xref: /illumos-gate/usr/src/boot/common/disk.c (revision 22028508)
1922a2a16SToomas Soome /*
2199767f8SToomas Soome  * Copyright (c) 1998 Michael Smith <msmith@freebsd.org>
3199767f8SToomas Soome  * Copyright (c) 2012 Andrey V. Elsukov <ae@FreeBSD.org>
4199767f8SToomas Soome  * All rights reserved.
5199767f8SToomas Soome  *
6199767f8SToomas Soome  * Redistribution and use in source and binary forms, with or without
7199767f8SToomas Soome  * modification, are permitted provided that the following conditions
8199767f8SToomas Soome  * are met:
9199767f8SToomas Soome  * 1. Redistributions of source code must retain the above copyright
10199767f8SToomas Soome  *    notice, this list of conditions and the following disclaimer.
11199767f8SToomas Soome  * 2. Redistributions in binary form must reproduce the above copyright
12199767f8SToomas Soome  *    notice, this list of conditions and the following disclaimer in the
13199767f8SToomas Soome  *    documentation and/or other materials provided with the distribution.
14199767f8SToomas Soome  *
15199767f8SToomas Soome  * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND
16199767f8SToomas Soome  * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
17199767f8SToomas Soome  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
18199767f8SToomas Soome  * ARE DISCLAIMED.  IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE
19199767f8SToomas Soome  * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
20199767f8SToomas Soome  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
21199767f8SToomas Soome  * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
22199767f8SToomas Soome  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
23199767f8SToomas Soome  * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
24199767f8SToomas Soome  * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
25199767f8SToomas Soome  * SUCH DAMAGE.
26199767f8SToomas Soome  */
27199767f8SToomas Soome 
28199767f8SToomas Soome #include <sys/cdefs.h>
29199767f8SToomas Soome #include <sys/disk.h>
30199767f8SToomas Soome #include <sys/queue.h>
31199767f8SToomas Soome #include <stand.h>
32199767f8SToomas Soome #include <stdarg.h>
334da7ed37SToomas Soome #include <inttypes.h>
34199767f8SToomas Soome #include <bootstrap.h>
35199767f8SToomas Soome #include <part.h>
36199767f8SToomas Soome 
37199767f8SToomas Soome #include "disk.h"
38199767f8SToomas Soome 
39199767f8SToomas Soome #ifdef DISK_DEBUG
407efc4ab5SToomas Soome #define	DPRINTF(fmt, args...)	printf("%s: " fmt "\n", __func__, ## args)
41199767f8SToomas Soome #else
427efc4ab5SToomas Soome #define	DPRINTF(fmt, args...)	((void)0)
43199767f8SToomas Soome #endif
44199767f8SToomas Soome 
45199767f8SToomas Soome struct open_disk {
46199767f8SToomas Soome 	struct ptable		*table;
47252244c3SToomas Soome 	uint64_t		mediasize;
48252244c3SToomas Soome 	uint64_t		entrysize;
49922a2a16SToomas Soome 	uint_t			sectorsize;
50199767f8SToomas Soome };
51199767f8SToomas Soome 
52199767f8SToomas Soome struct print_args {
53199767f8SToomas Soome 	struct disk_devdesc	*dev;
54199767f8SToomas Soome 	const char		*prefix;
55199767f8SToomas Soome 	int			verbose;
56199767f8SToomas Soome };
57199767f8SToomas Soome 
58199767f8SToomas Soome /* Convert size to a human-readable number. */
59199767f8SToomas Soome static char *
display_size(uint64_t size,uint_t sectorsize)60922a2a16SToomas Soome display_size(uint64_t size, uint_t sectorsize)
61199767f8SToomas Soome {
62199767f8SToomas Soome 	static char buf[80];
63199767f8SToomas Soome 	char unit;
64199767f8SToomas Soome 
65199767f8SToomas Soome 	size = size * sectorsize / 1024;
66199767f8SToomas Soome 	unit = 'K';
67199767f8SToomas Soome 	if (size >= 10485760000LL) {
68199767f8SToomas Soome 		size /= 1073741824;
69199767f8SToomas Soome 		unit = 'T';
70199767f8SToomas Soome 	} else if (size >= 10240000) {
71199767f8SToomas Soome 		size /= 1048576;
72199767f8SToomas Soome 		unit = 'G';
73199767f8SToomas Soome 	} else if (size >= 10000) {
74199767f8SToomas Soome 		size /= 1024;
75199767f8SToomas Soome 		unit = 'M';
76199767f8SToomas Soome 	}
7718d216a4SToomas Soome 	snprintf(buf, sizeof (buf), "%4" PRIu64 "%cB", size, unit);
78199767f8SToomas Soome 	return (buf);
79199767f8SToomas Soome }
80199767f8SToomas Soome 
81199767f8SToomas Soome static int
ptblread(void * d,void * buf,size_t blocks,uint64_t offset)8279bea51bSToomas Soome ptblread(void *d, void *buf, size_t blocks, uint64_t offset)
83199767f8SToomas Soome {
84199767f8SToomas Soome 	struct disk_devdesc *dev;
85199767f8SToomas Soome 	struct open_disk *od;
86199767f8SToomas Soome 
87199767f8SToomas Soome 	dev = (struct disk_devdesc *)d;
8876b35943SToomas Soome 	od = (struct open_disk *)dev->dd.d_opendata;
893dab2501SToomas Soome 
9013a5079aSToomas Soome 	/*
9113a5079aSToomas Soome 	 * The strategy function assumes the offset is in units of 512 byte
9213a5079aSToomas Soome 	 * sectors. For larger sector sizes, we need to adjust the offset to
9313a5079aSToomas Soome 	 * match the actual sector size.
9413a5079aSToomas Soome 	 */
9513a5079aSToomas Soome 	offset *= (od->sectorsize / 512);
963dab2501SToomas Soome 	/*
973dab2501SToomas Soome 	 * As the GPT backup partition is located at the end of the disk,
983dab2501SToomas Soome 	 * to avoid reading past disk end, flag bcache not to use RA.
993dab2501SToomas Soome 	 */
100922a2a16SToomas Soome 	return (dev->dd.d_dev->dv_strategy(dev, F_READ | F_NORA, offset,
101199767f8SToomas Soome 	    blocks * od->sectorsize, (char *)buf, NULL));
102199767f8SToomas Soome }
103199767f8SToomas Soome 
104199767f8SToomas Soome static int
ptable_print(void * arg,const char * pname,const struct ptable_entry * part)105199767f8SToomas Soome ptable_print(void *arg, const char *pname, const struct ptable_entry *part)
106199767f8SToomas Soome {
1070eec6d64SToomas Soome 	struct disk_devdesc dev;
108199767f8SToomas Soome 	struct print_args *pa, bsd;
109199767f8SToomas Soome 	struct open_disk *od;
110199767f8SToomas Soome 	struct ptable *table;
111199767f8SToomas Soome 	char line[80];
11218d216a4SToomas Soome 	int res;
11318d216a4SToomas Soome 	uint_t sectsize;
11418d216a4SToomas Soome 	uint64_t partsize;
115199767f8SToomas Soome 
116199767f8SToomas Soome 	pa = (struct print_args *)arg;
11776b35943SToomas Soome 	od = (struct open_disk *)pa->dev->dd.d_opendata;
11818d216a4SToomas Soome 	sectsize = od->sectorsize;
11918d216a4SToomas Soome 	partsize = part->end - part->start + 1;
12018d216a4SToomas Soome 	snprintf(line, sizeof (line), "  %s%s: %s", pa->prefix, pname,
121199767f8SToomas Soome 	    parttype2str(part->type));
12218d216a4SToomas Soome 	if (pager_output(line))
12318d216a4SToomas Soome 		return (1);
12418d216a4SToomas Soome 
12518d216a4SToomas Soome 	if (pa->verbose) {
12618d216a4SToomas Soome 		/* Emit extra tab when the line is shorter than 3 tab stops */
12718d216a4SToomas Soome 		if (strlen(line) < 24)
12818d216a4SToomas Soome 			(void) pager_output("\t");
12918d216a4SToomas Soome 
13018d216a4SToomas Soome 		snprintf(line, sizeof (line), "\t%s",
13118d216a4SToomas Soome 		    display_size(partsize, sectsize));
13218d216a4SToomas Soome 		if (pager_output(line))
13318d216a4SToomas Soome 			return (1);
13418d216a4SToomas Soome 	}
13518d216a4SToomas Soome 	if (pager_output("\n"))
13618d216a4SToomas Soome 		return (1);
13718d216a4SToomas Soome 	res = 0;
138199767f8SToomas Soome 	if (part->type == PART_FREEBSD || part->type == PART_SOLARIS2) {
139199767f8SToomas Soome 		/* Open slice with BSD or VTOC label */
14076b35943SToomas Soome 		dev.dd.d_dev = pa->dev->dd.d_dev;
14176b35943SToomas Soome 		dev.dd.d_unit = pa->dev->dd.d_unit;
1420eec6d64SToomas Soome 		dev.d_slice = part->index;
1439a34674dSToomas Soome 		dev.d_partition = D_PARTNONE;
14418d216a4SToomas Soome 		if (disk_open(&dev, partsize, sectsize) == 0) {
14518d216a4SToomas Soome 			table = ptable_open(&dev, partsize, sectsize, ptblread);
14618d216a4SToomas Soome 			if (table != NULL) {
14718d216a4SToomas Soome 				snprintf(line, sizeof (line), "  %s%s",
14818d216a4SToomas Soome 				    pa->prefix, pname);
1490eec6d64SToomas Soome 				bsd.dev = &dev;
1500eec6d64SToomas Soome 				bsd.prefix = line;
1510eec6d64SToomas Soome 				bsd.verbose = pa->verbose;
15218d216a4SToomas Soome 				res = ptable_iterate(table, &bsd, ptable_print);
15318d216a4SToomas Soome 				ptable_close(table);
1540eec6d64SToomas Soome 			}
1550eec6d64SToomas Soome 			disk_close(&dev);
1560eec6d64SToomas Soome 		}
157199767f8SToomas Soome 	}
15818d216a4SToomas Soome 
15918d216a4SToomas Soome 	return (res);
160199767f8SToomas Soome }
161199767f8SToomas Soome 
162199767f8SToomas Soome int
disk_print(struct disk_devdesc * dev,char * prefix,int verbose)163199767f8SToomas Soome disk_print(struct disk_devdesc *dev, char *prefix, int verbose)
164199767f8SToomas Soome {
165199767f8SToomas Soome 	struct open_disk *od;
166199767f8SToomas Soome 	struct print_args pa;
167199767f8SToomas Soome 
168199767f8SToomas Soome 	/* Disk should be opened */
16976b35943SToomas Soome 	od = (struct open_disk *)dev->dd.d_opendata;
170199767f8SToomas Soome 	pa.dev = dev;
171199767f8SToomas Soome 	pa.prefix = prefix;
172199767f8SToomas Soome 	pa.verbose = verbose;
173199767f8SToomas Soome 	return (ptable_iterate(od->table, &pa, ptable_print));
174199767f8SToomas Soome }
175199767f8SToomas Soome 
176199767f8SToomas Soome int
disk_read(struct disk_devdesc * dev,void * buf,uint64_t offset,uint_t blocks)177922a2a16SToomas Soome disk_read(struct disk_devdesc *dev, void *buf, uint64_t offset, uint_t blocks)
178199767f8SToomas Soome {
179199767f8SToomas Soome 	struct open_disk *od;
180199767f8SToomas Soome 	int ret;
181199767f8SToomas Soome 
18276b35943SToomas Soome 	od = (struct open_disk *)dev->dd.d_opendata;
18376b35943SToomas Soome 	ret = dev->dd.d_dev->dv_strategy(dev, F_READ, dev->d_offset + offset,
184199767f8SToomas Soome 	    blocks * od->sectorsize, buf, NULL);
185199767f8SToomas Soome 
186199767f8SToomas Soome 	return (ret);
187199767f8SToomas Soome }
188199767f8SToomas Soome 
189199767f8SToomas Soome int
disk_write(struct disk_devdesc * dev,void * buf,uint64_t offset,uint_t blocks)190922a2a16SToomas Soome disk_write(struct disk_devdesc *dev, void *buf, uint64_t offset, uint_t blocks)
191199767f8SToomas Soome {
192199767f8SToomas Soome 	struct open_disk *od;
193199767f8SToomas Soome 	int ret;
194199767f8SToomas Soome 
19576b35943SToomas Soome 	od = (struct open_disk *)dev->dd.d_opendata;
19676b35943SToomas Soome 	ret = dev->dd.d_dev->dv_strategy(dev, F_WRITE, dev->d_offset + offset,
197199767f8SToomas Soome 	    blocks * od->sectorsize, buf, NULL);
198199767f8SToomas Soome 
199199767f8SToomas Soome 	return (ret);
200199767f8SToomas Soome }
201199767f8SToomas Soome 
202199767f8SToomas Soome int
disk_ioctl(struct disk_devdesc * dev,unsigned long cmd,void * data)203922a2a16SToomas Soome disk_ioctl(struct disk_devdesc *dev, unsigned long cmd, void *data)
204199767f8SToomas Soome {
20576b35943SToomas Soome 	struct open_disk *od = dev->dd.d_opendata;
206252244c3SToomas Soome 
207252244c3SToomas Soome 	if (od == NULL)
208252244c3SToomas Soome 		return (ENOTTY);
209252244c3SToomas Soome 
210252244c3SToomas Soome 	switch (cmd) {
211252244c3SToomas Soome 	case DIOCGSECTORSIZE:
212922a2a16SToomas Soome 		*(uint_t *)data = od->sectorsize;
213252244c3SToomas Soome 		break;
214252244c3SToomas Soome 	case DIOCGMEDIASIZE:
215252244c3SToomas Soome 		if (dev->d_offset == 0)
216252244c3SToomas Soome 			*(uint64_t *)data = od->mediasize;
217252244c3SToomas Soome 		else
218252244c3SToomas Soome 			*(uint64_t *)data = od->entrysize * od->sectorsize;
219252244c3SToomas Soome 		break;
220252244c3SToomas Soome 	default:
221252244c3SToomas Soome 		return (ENOTTY);
222252244c3SToomas Soome 	}
223199767f8SToomas Soome 
224252244c3SToomas Soome 	return (0);
225199767f8SToomas Soome }
226199767f8SToomas Soome 
227199767f8SToomas Soome int
disk_open(struct disk_devdesc * dev,uint64_t mediasize,uint_t sectorsize)228922a2a16SToomas Soome disk_open(struct disk_devdesc *dev, uint64_t mediasize, uint_t sectorsize)
229199767f8SToomas Soome {
2309a34674dSToomas Soome 	struct disk_devdesc partdev;
231199767f8SToomas Soome 	struct open_disk *od;
232199767f8SToomas Soome 	struct ptable *table;
233199767f8SToomas Soome 	struct ptable_entry part;
234199767f8SToomas Soome 	int rc, slice, partition;
235199767f8SToomas Soome 
23680954523SToomas Soome 	if (sectorsize == 0) {
2377efc4ab5SToomas Soome 		DPRINTF("unknown sector size");
23880954523SToomas Soome 		return (ENXIO);
23980954523SToomas Soome 	}
240199767f8SToomas Soome 	rc = 0;
241922a2a16SToomas Soome 	od = (struct open_disk *)malloc(sizeof (struct open_disk));
24274207d1dSToomas Soome 	if (od == NULL) {
2437efc4ab5SToomas Soome 		DPRINTF("no memory");
24474207d1dSToomas Soome 		return (ENOMEM);
245199767f8SToomas Soome 	}
24676b35943SToomas Soome 	dev->dd.d_opendata = od;
24774207d1dSToomas Soome 	od->entrysize = 0;
248199767f8SToomas Soome 	od->mediasize = mediasize;
249199767f8SToomas Soome 	od->sectorsize = sectorsize;
2509a34674dSToomas Soome 	/*
2519a34674dSToomas Soome 	 * While we are reading disk metadata, make sure we do it relative
2529a34674dSToomas Soome 	 * to the start of the disk
2539a34674dSToomas Soome 	 */
2549a34674dSToomas Soome 	memcpy(&partdev, dev, sizeof(partdev));
2559a34674dSToomas Soome 	partdev.d_offset = 0;
2569a34674dSToomas Soome 	partdev.d_slice = D_SLICENONE;
2579a34674dSToomas Soome 	partdev.d_partition = D_PARTNONE;
2589a34674dSToomas Soome 
2599a34674dSToomas Soome 	dev->d_offset = 0;
2609a34674dSToomas Soome 	table = NULL;
2619a34674dSToomas Soome 	slice = dev->d_slice;
2629a34674dSToomas Soome 	partition = dev->d_partition;
2639a34674dSToomas Soome 
2647efc4ab5SToomas Soome 	DPRINTF("%s unit %d, slice %d, partition %d => %p", disk_fmtdev(dev),
2654da7ed37SToomas Soome 	    dev->dd.d_unit, dev->d_slice, dev->d_partition, od);
266199767f8SToomas Soome 
267199767f8SToomas Soome 	/* Determine disk layout. */
2689a34674dSToomas Soome 	od->table = ptable_open(&partdev, mediasize / sectorsize, sectorsize,
269199767f8SToomas Soome 	    ptblread);
270199767f8SToomas Soome 	if (od->table == NULL) {
2717efc4ab5SToomas Soome 		DPRINTF("Can't read partition table");
272199767f8SToomas Soome 		rc = ENXIO;
273199767f8SToomas Soome 		goto out;
274199767f8SToomas Soome 	}
275252244c3SToomas Soome 
276252244c3SToomas Soome 	if (ptable_getsize(od->table, &mediasize) != 0) {
277252244c3SToomas Soome 		rc = ENXIO;
278252244c3SToomas Soome 		goto out;
279252244c3SToomas Soome 	}
280124619e5SToomas Soome 	od->mediasize = mediasize;
28174207d1dSToomas Soome 
2829a34674dSToomas Soome 	if ((ptable_gettype(od->table) == PTABLE_BSD ||
2839a34674dSToomas Soome 	    ptable_gettype(od->table) == PTABLE_VTOC) &&
284199767f8SToomas Soome 	    partition >= 0) {
285199767f8SToomas Soome 		/* It doesn't matter what value has d_slice */
286199767f8SToomas Soome 		rc = ptable_getpart(od->table, &part, partition);
287252244c3SToomas Soome 		if (rc == 0) {
288199767f8SToomas Soome 			dev->d_offset = part.start;
289252244c3SToomas Soome 			od->entrysize = part.end - part.start + 1;
290252244c3SToomas Soome 		}
291922a2a16SToomas Soome 	} else if (ptable_gettype(od->table) == PTABLE_ISO9660) {
292922a2a16SToomas Soome 		dev->d_offset = 0;
293922a2a16SToomas Soome 		od->entrysize = mediasize;
294199767f8SToomas Soome 	} else if (slice >= 0) {
295199767f8SToomas Soome 		/* Try to get information about partition */
296199767f8SToomas Soome 		if (slice == 0)
297199767f8SToomas Soome 			rc = ptable_getbestpart(od->table, &part);
298199767f8SToomas Soome 		else
299199767f8SToomas Soome 			rc = ptable_getpart(od->table, &part, slice);
300199767f8SToomas Soome 		if (rc != 0) /* Partition doesn't exist */
301199767f8SToomas Soome 			goto out;
302199767f8SToomas Soome 		dev->d_offset = part.start;
303252244c3SToomas Soome 		od->entrysize = part.end - part.start + 1;
304199767f8SToomas Soome 		slice = part.index;
305199767f8SToomas Soome 		if (ptable_gettype(od->table) == PTABLE_GPT) {
3069a34674dSToomas Soome 			partition = D_PARTISGPT;
307199767f8SToomas Soome 			goto out; /* Nothing more to do */
3089a34674dSToomas Soome 		} else if (partition == D_PARTISGPT) {
309199767f8SToomas Soome 			/*
310199767f8SToomas Soome 			 * When we try to open GPT partition, but partition
3119a34674dSToomas Soome 			 * table isn't GPT, reset partition value to
3129a34674dSToomas Soome 			 * D_PARTWILD and try to autodetect appropriate value.
313199767f8SToomas Soome 			 */
3149a34674dSToomas Soome 			partition = D_PARTWILD;
315199767f8SToomas Soome 		}
3169a34674dSToomas Soome 
317199767f8SToomas Soome 		/*
3189a34674dSToomas Soome 		 * If partition is D_PARTNONE, then disk_open() was called
3199a34674dSToomas Soome 		 * to open raw MBR slice.
320199767f8SToomas Soome 		 */
3219a34674dSToomas Soome 		if (partition == D_PARTNONE)
322199767f8SToomas Soome 			goto out;
3239a34674dSToomas Soome 
3249a34674dSToomas Soome 		/*
3259a34674dSToomas Soome 		 * If partition is D_PARTWILD and we are looking at a
3269a34674dSToomas Soome 		 * BSD/VTOC slice, then try to read label, otherwise return
3279a34674dSToomas Soome 		 * the whole MBR slice.
3289a34674dSToomas Soome 		 */
3299a34674dSToomas Soome 		if (partition == D_PARTWILD) {
3309a34674dSToomas Soome 			switch (part.type) {
3319a34674dSToomas Soome 			case PART_FREEBSD:
3329a34674dSToomas Soome 			case PART_SOLARIS2:
3339a34674dSToomas Soome 				break;
3349a34674dSToomas Soome 			default:
3359a34674dSToomas Soome 				goto out;
3369a34674dSToomas Soome 			}
3379a34674dSToomas Soome 		}
338199767f8SToomas Soome 		/* Try to read label */
339199767f8SToomas Soome 		table = ptable_open(dev, part.end - part.start + 1,
340199767f8SToomas Soome 		    od->sectorsize, ptblread);
341199767f8SToomas Soome 		if (table == NULL) {
3427efc4ab5SToomas Soome 			DPRINTF("Can't read BSD/VTOC label");
343199767f8SToomas Soome 			rc = ENXIO;
344199767f8SToomas Soome 			goto out;
345199767f8SToomas Soome 		}
346199767f8SToomas Soome 		/*
3479a34674dSToomas Soome 		 * If slice contains BSD/VTOC label and partition < 0, then
348199767f8SToomas Soome 		 * assume the 'a' partition. Otherwise just return the
349199767f8SToomas Soome 		 * whole MBR slice, because it can contain ZFS.
350199767f8SToomas Soome 		 */
351199767f8SToomas Soome 		if (partition < 0) {
3529a34674dSToomas Soome 			if (ptable_gettype(table) != PTABLE_BSD &&
353199767f8SToomas Soome 			    ptable_gettype(table) != PTABLE_VTOC)
354199767f8SToomas Soome 				goto out;
355199767f8SToomas Soome 			partition = 0;
356199767f8SToomas Soome 		}
357199767f8SToomas Soome 		rc = ptable_getpart(table, &part, partition);
358199767f8SToomas Soome 		if (rc != 0)
359199767f8SToomas Soome 			goto out;
360199767f8SToomas Soome 		dev->d_offset += part.start;
361252244c3SToomas Soome 		od->entrysize = part.end - part.start + 1;
362199767f8SToomas Soome 	}
363199767f8SToomas Soome out:
364199767f8SToomas Soome 	if (table != NULL)
365199767f8SToomas Soome 		ptable_close(table);
366199767f8SToomas Soome 
367199767f8SToomas Soome 	if (rc != 0) {
36874207d1dSToomas Soome 		if (od->table != NULL)
36974207d1dSToomas Soome 			ptable_close(od->table);
37074207d1dSToomas Soome 		free(od);
3717efc4ab5SToomas Soome 		DPRINTF("%s could not open", disk_fmtdev(dev));
372199767f8SToomas Soome 	} else {
373199767f8SToomas Soome 		/* Save the slice and partition number to the dev */
374199767f8SToomas Soome 		dev->d_slice = slice;
375199767f8SToomas Soome 		dev->d_partition = partition;
3767efc4ab5SToomas Soome 		DPRINTF("%s offset %" PRIu64 " => %p", disk_fmtdev(dev),
3774da7ed37SToomas Soome 		    dev->d_offset, od);
378199767f8SToomas Soome 	}
379199767f8SToomas Soome 	return (rc);
380199767f8SToomas Soome }
381199767f8SToomas Soome 
382199767f8SToomas Soome int
disk_close(struct disk_devdesc * dev)383199767f8SToomas Soome disk_close(struct disk_devdesc *dev)
384199767f8SToomas Soome {
385199767f8SToomas Soome 	struct open_disk *od;
386199767f8SToomas Soome 
38776b35943SToomas Soome 	od = (struct open_disk *)dev->dd.d_opendata;
3887efc4ab5SToomas Soome 	DPRINTF("%s closed => %p", disk_fmtdev(dev), od);
38974207d1dSToomas Soome 	ptable_close(od->table);
39074207d1dSToomas Soome 	free(od);
391199767f8SToomas Soome 	return (0);
392199767f8SToomas Soome }
393199767f8SToomas Soome 
394922a2a16SToomas Soome char *
disk_fmtdev(struct disk_devdesc * dev)395199767f8SToomas Soome disk_fmtdev(struct disk_devdesc *dev)
396199767f8SToomas Soome {
397199767f8SToomas Soome 	static char buf[128];
398199767f8SToomas Soome 	char *cp;
399199767f8SToomas Soome 
40076b35943SToomas Soome 	cp = buf + sprintf(buf, "%s%d", dev->dd.d_dev->dv_name, dev->dd.d_unit);
4019a34674dSToomas Soome 	if (dev->d_slice > D_SLICENONE) {
402199767f8SToomas Soome #ifdef LOADER_GPT_SUPPORT
4039a34674dSToomas Soome 		if (dev->d_partition == D_PARTISGPT) {
404199767f8SToomas Soome 			sprintf(cp, "p%d:", dev->d_slice);
405199767f8SToomas Soome 			return (buf);
406199767f8SToomas Soome 		} else
407199767f8SToomas Soome #endif
408199767f8SToomas Soome #ifdef LOADER_MBR_SUPPORT
409199767f8SToomas Soome 			cp += sprintf(cp, "s%d", dev->d_slice);
410199767f8SToomas Soome #endif
411199767f8SToomas Soome 	}
4129a34674dSToomas Soome 	if (dev->d_partition > D_PARTNONE)
413199767f8SToomas Soome 		cp += sprintf(cp, "%c", dev->d_partition + 'a');
414199767f8SToomas Soome 	strcat(cp, ":");
415199767f8SToomas Soome 	return (buf);
416199767f8SToomas Soome }
417199767f8SToomas Soome 
418199767f8SToomas Soome int
disk_parsedev(struct disk_devdesc * dev,const char * devspec,const char ** path)419199767f8SToomas Soome disk_parsedev(struct disk_devdesc *dev, const char *devspec, const char **path)
420199767f8SToomas Soome {
421199767f8SToomas Soome 	int unit, slice, partition;
422199767f8SToomas Soome 	const char *np;
423199767f8SToomas Soome 	char *cp;
424199767f8SToomas Soome 
425199767f8SToomas Soome 	np = devspec;
4269a34674dSToomas Soome 	unit = -1;
4279a34674dSToomas Soome 	/*
4289a34674dSToomas Soome 	 * If there is path/file info after the device info, then any missing
4299a34674dSToomas Soome 	 * slice or partition info should be considered a request to search for
4309a34674dSToomas Soome 	 * an appropriate partition.  Otherwise we want to open the raw device
4319a34674dSToomas Soome 	 * itself and not try to fill in missing info by searching.
4329a34674dSToomas Soome 	 */
4339a34674dSToomas Soome 	if ((cp = strchr(np, ':')) != NULL && cp[1] != '\0') {
4349a34674dSToomas Soome 		slice = D_SLICEWILD;
4359a34674dSToomas Soome 		partition = D_PARTWILD;
4369a34674dSToomas Soome 	} else {
4379a34674dSToomas Soome 		slice = D_SLICENONE;
4389a34674dSToomas Soome 		partition = D_PARTNONE;
4399a34674dSToomas Soome 	}
4409a34674dSToomas Soome 
441199767f8SToomas Soome 	if (*np != '\0' && *np != ':') {
442199767f8SToomas Soome 		unit = strtol(np, &cp, 10);
443199767f8SToomas Soome 		if (cp == np)
444199767f8SToomas Soome 			return (EUNIT);
445199767f8SToomas Soome #ifdef LOADER_GPT_SUPPORT
446199767f8SToomas Soome 		if (*cp == 'p') {
447199767f8SToomas Soome 			np = cp + 1;
448199767f8SToomas Soome 			slice = strtol(np, &cp, 10);
449199767f8SToomas Soome 			if (np == cp)
450199767f8SToomas Soome 				return (ESLICE);
451199767f8SToomas Soome 			/* we don't support nested partitions on GPT */
452199767f8SToomas Soome 			if (*cp != '\0' && *cp != ':')
453199767f8SToomas Soome 				return (EINVAL);
4549a34674dSToomas Soome 			partition = D_PARTISGPT;
455199767f8SToomas Soome 		} else
456199767f8SToomas Soome #endif
457199767f8SToomas Soome #ifdef LOADER_MBR_SUPPORT
458199767f8SToomas Soome 		if (*cp == 's') {
459199767f8SToomas Soome 			np = cp + 1;
460199767f8SToomas Soome 			slice = strtol(np, &cp, 10);
461199767f8SToomas Soome 			if (np == cp)
462199767f8SToomas Soome 				return (ESLICE);
463199767f8SToomas Soome 		}
464199767f8SToomas Soome #endif
465199767f8SToomas Soome 		if (*cp != '\0' && *cp != ':') {
466199767f8SToomas Soome 			partition = *cp - 'a';
467199767f8SToomas Soome 			if (partition < 0)
468199767f8SToomas Soome 				return (EPART);
469199767f8SToomas Soome 			cp++;
470199767f8SToomas Soome 		}
471199767f8SToomas Soome 	} else
472199767f8SToomas Soome 		return (EINVAL);
473199767f8SToomas Soome 
474199767f8SToomas Soome 	if (*cp != '\0' && *cp != ':')
475199767f8SToomas Soome 		return (EINVAL);
47676b35943SToomas Soome 	dev->dd.d_unit = unit;
477199767f8SToomas Soome 	dev->d_slice = slice;
478199767f8SToomas Soome 	dev->d_partition = partition;
479199767f8SToomas Soome 	if (path != NULL)
480199767f8SToomas Soome 		*path = (*cp == '\0') ? cp: cp + 1;
481199767f8SToomas Soome 	return (0);
482199767f8SToomas Soome }
483