xref: /freebsd/stand/common/disk.c (revision 41a1c642e4f5630bbc74c13192d0fca6face6af9)
1ca987d46SWarner Losh /*-
2ca987d46SWarner Losh  * Copyright (c) 1998 Michael Smith <msmith@freebsd.org>
3ca987d46SWarner Losh  * Copyright (c) 2012 Andrey V. Elsukov <ae@FreeBSD.org>
4ca987d46SWarner Losh  * All rights reserved.
5ca987d46SWarner Losh  *
6ca987d46SWarner Losh  * Redistribution and use in source and binary forms, with or without
7ca987d46SWarner Losh  * modification, are permitted provided that the following conditions
8ca987d46SWarner Losh  * are met:
9ca987d46SWarner Losh  * 1. Redistributions of source code must retain the above copyright
10ca987d46SWarner Losh  *    notice, this list of conditions and the following disclaimer.
11ca987d46SWarner Losh  * 2. Redistributions in binary form must reproduce the above copyright
12ca987d46SWarner Losh  *    notice, this list of conditions and the following disclaimer in the
13ca987d46SWarner Losh  *    documentation and/or other materials provided with the distribution.
14ca987d46SWarner Losh  *
15ca987d46SWarner Losh  * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND
16ca987d46SWarner Losh  * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
17ca987d46SWarner Losh  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
18ca987d46SWarner Losh  * ARE DISCLAIMED.  IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE
19ca987d46SWarner Losh  * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
20ca987d46SWarner Losh  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
21ca987d46SWarner Losh  * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
22ca987d46SWarner Losh  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
23ca987d46SWarner Losh  * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
24ca987d46SWarner Losh  * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
25ca987d46SWarner Losh  * SUCH DAMAGE.
26ca987d46SWarner Losh  */
27ca987d46SWarner Losh 
28ca987d46SWarner Losh #include <sys/cdefs.h>
29ca987d46SWarner Losh __FBSDID("$FreeBSD$");
30ca987d46SWarner Losh 
31ca987d46SWarner Losh #include <sys/disk.h>
32ca987d46SWarner Losh #include <sys/queue.h>
33ca987d46SWarner Losh #include <stand.h>
34ca987d46SWarner Losh #include <stdarg.h>
35ca987d46SWarner Losh #include <bootstrap.h>
36ca987d46SWarner Losh #include <part.h>
37ca987d46SWarner Losh 
38ca987d46SWarner Losh #include "disk.h"
39ca987d46SWarner Losh 
40ca987d46SWarner Losh #ifdef DISK_DEBUG
417325df02SKyle Evans # define DPRINTF(fmt, args...)	printf("%s: " fmt "\n" , __func__ , ## args)
42ca987d46SWarner Losh #else
437325df02SKyle Evans # define DPRINTF(fmt, args...)
44ca987d46SWarner Losh #endif
45ca987d46SWarner Losh 
46ca987d46SWarner Losh struct open_disk {
47ca987d46SWarner Losh 	struct ptable		*table;
48ca987d46SWarner Losh 	uint64_t		mediasize;
49ca987d46SWarner Losh 	uint64_t		entrysize;
50ca987d46SWarner Losh 	u_int			sectorsize;
51ca987d46SWarner Losh };
52ca987d46SWarner Losh 
53ca987d46SWarner Losh struct print_args {
54ca987d46SWarner Losh 	struct disk_devdesc	*dev;
55ca987d46SWarner Losh 	const char		*prefix;
56ca987d46SWarner Losh 	int			verbose;
57ca987d46SWarner Losh };
58ca987d46SWarner Losh 
59ca987d46SWarner Losh /* Convert size to a human-readable number. */
60ca987d46SWarner Losh static char *
61ca987d46SWarner Losh display_size(uint64_t size, u_int sectorsize)
62ca987d46SWarner Losh {
63ca987d46SWarner Losh 	static char buf[80];
64ca987d46SWarner Losh 	char unit;
65ca987d46SWarner Losh 
66ca987d46SWarner Losh 	size = size * sectorsize / 1024;
67ca987d46SWarner Losh 	unit = 'K';
68ca987d46SWarner Losh 	if (size >= 10485760000LL) {
69ca987d46SWarner Losh 		size /= 1073741824;
70ca987d46SWarner Losh 		unit = 'T';
71ca987d46SWarner Losh 	} else if (size >= 10240000) {
72ca987d46SWarner Losh 		size /= 1048576;
73ca987d46SWarner Losh 		unit = 'G';
74ca987d46SWarner Losh 	} else if (size >= 10000) {
75ca987d46SWarner Losh 		size /= 1024;
76ca987d46SWarner Losh 		unit = 'M';
77ca987d46SWarner Losh 	}
78*41a1c642SToomas Soome 	snprintf(buf, sizeof(buf), "%4ld%cB", (long)size, unit);
79ca987d46SWarner Losh 	return (buf);
80ca987d46SWarner Losh }
81ca987d46SWarner Losh 
82ca987d46SWarner Losh int
83ca987d46SWarner Losh ptblread(void *d, void *buf, size_t blocks, uint64_t offset)
84ca987d46SWarner Losh {
85ca987d46SWarner Losh 	struct disk_devdesc *dev;
86ca987d46SWarner Losh 	struct open_disk *od;
87ca987d46SWarner Losh 
88ca987d46SWarner Losh 	dev = (struct disk_devdesc *)d;
89de04d704SWarner Losh 	od = (struct open_disk *)dev->dd.d_opendata;
90ca987d46SWarner Losh 
91ca987d46SWarner Losh 	/*
92ca987d46SWarner Losh 	 * The strategy function assumes the offset is in units of 512 byte
93ca987d46SWarner Losh 	 * sectors. For larger sector sizes, we need to adjust the offset to
94ca987d46SWarner Losh 	 * match the actual sector size.
95ca987d46SWarner Losh 	 */
96ca987d46SWarner Losh 	offset *= (od->sectorsize / 512);
97ca987d46SWarner Losh 	/*
98ca987d46SWarner Losh 	 * As the GPT backup partition is located at the end of the disk,
99ca987d46SWarner Losh 	 * to avoid reading past disk end, flag bcache not to use RA.
100ca987d46SWarner Losh 	 */
101de04d704SWarner Losh 	return (dev->dd.d_dev->dv_strategy(dev, F_READ | F_NORA, offset,
102ca987d46SWarner Losh 	    blocks * od->sectorsize, (char *)buf, NULL));
103ca987d46SWarner Losh }
104ca987d46SWarner Losh 
105ca987d46SWarner Losh static int
106ca987d46SWarner Losh ptable_print(void *arg, const char *pname, const struct ptable_entry *part)
107ca987d46SWarner Losh {
108ca987d46SWarner Losh 	struct disk_devdesc dev;
109ca987d46SWarner Losh 	struct print_args *pa, bsd;
110ca987d46SWarner Losh 	struct open_disk *od;
111ca987d46SWarner Losh 	struct ptable *table;
112ca987d46SWarner Losh 	char line[80];
113ca987d46SWarner Losh 	int res;
11471c96defSIan Lepore 	u_int sectsize;
11571c96defSIan Lepore 	uint64_t partsize;
116ca987d46SWarner Losh 
117ca987d46SWarner Losh 	pa = (struct print_args *)arg;
118de04d704SWarner Losh 	od = (struct open_disk *)pa->dev->dd.d_opendata;
11971c96defSIan Lepore 	sectsize = od->sectorsize;
12071c96defSIan Lepore 	partsize = part->end - part->start + 1;
121*41a1c642SToomas Soome 	snprintf(line, sizeof(line), "  %s%s: %s", pa->prefix, pname,
122*41a1c642SToomas Soome 	    parttype2str(part->type));
123ca987d46SWarner Losh 	if (pager_output(line))
124*41a1c642SToomas Soome 		return (1);
125*41a1c642SToomas Soome 
126*41a1c642SToomas Soome 	if (pa->verbose) {
127*41a1c642SToomas Soome 		/* Emit extra tab when the line is shorter than 3 tab stops */
128*41a1c642SToomas Soome 		if (strlen(line) < 24)
129*41a1c642SToomas Soome 			(void) pager_output("\t");
130*41a1c642SToomas Soome 
131*41a1c642SToomas Soome 		snprintf(line, sizeof(line), "\t%s",
132*41a1c642SToomas Soome 		    display_size(partsize, sectsize));
133*41a1c642SToomas Soome 		if (pager_output(line))
134*41a1c642SToomas Soome 			return (1);
135*41a1c642SToomas Soome 	}
136*41a1c642SToomas Soome 	if (pager_output("\n"))
137*41a1c642SToomas Soome 		return (1);
138*41a1c642SToomas Soome 
139ca987d46SWarner Losh 	res = 0;
140ca987d46SWarner Losh 	if (part->type == PART_FREEBSD) {
141ca987d46SWarner Losh 		/* Open slice with BSD label */
142de04d704SWarner Losh 		dev.dd.d_dev = pa->dev->dd.d_dev;
143de04d704SWarner Losh 		dev.dd.d_unit = pa->dev->dd.d_unit;
144ca987d46SWarner Losh 		dev.d_slice = part->index;
14514243f8dSIan Lepore 		dev.d_partition = D_PARTNONE;
14671c96defSIan Lepore 		if (disk_open(&dev, partsize, sectsize) == 0) {
14771c96defSIan Lepore 			table = ptable_open(&dev, partsize, sectsize, ptblread);
148ca987d46SWarner Losh 			if (table != NULL) {
149*41a1c642SToomas Soome 				snprintf(line, sizeof(line), "  %s%s",
150*41a1c642SToomas Soome 				    pa->prefix, pname);
151ca987d46SWarner Losh 				bsd.dev = pa->dev;
152ca987d46SWarner Losh 				bsd.prefix = line;
153ca987d46SWarner Losh 				bsd.verbose = pa->verbose;
154ca987d46SWarner Losh 				res = ptable_iterate(table, &bsd, ptable_print);
155ca987d46SWarner Losh 				ptable_close(table);
156ca987d46SWarner Losh 			}
157ca987d46SWarner Losh 			disk_close(&dev);
158ca987d46SWarner Losh 		}
159ca987d46SWarner Losh 	}
160ca987d46SWarner Losh 
161ca987d46SWarner Losh 	return (res);
162ca987d46SWarner Losh }
163ca987d46SWarner Losh 
164ca987d46SWarner Losh int
165ca987d46SWarner Losh disk_print(struct disk_devdesc *dev, char *prefix, int verbose)
166ca987d46SWarner Losh {
167ca987d46SWarner Losh 	struct open_disk *od;
168ca987d46SWarner Losh 	struct print_args pa;
169ca987d46SWarner Losh 
170ca987d46SWarner Losh 	/* Disk should be opened */
171de04d704SWarner Losh 	od = (struct open_disk *)dev->dd.d_opendata;
172ca987d46SWarner Losh 	pa.dev = dev;
173ca987d46SWarner Losh 	pa.prefix = prefix;
174ca987d46SWarner Losh 	pa.verbose = verbose;
175ca987d46SWarner Losh 	return (ptable_iterate(od->table, &pa, ptable_print));
176ca987d46SWarner Losh }
177ca987d46SWarner Losh 
178ca987d46SWarner Losh int
179ca987d46SWarner Losh disk_read(struct disk_devdesc *dev, void *buf, uint64_t offset, u_int blocks)
180ca987d46SWarner Losh {
181ca987d46SWarner Losh 	struct open_disk *od;
182ca987d46SWarner Losh 	int ret;
183ca987d46SWarner Losh 
184de04d704SWarner Losh 	od = (struct open_disk *)dev->dd.d_opendata;
185de04d704SWarner Losh 	ret = dev->dd.d_dev->dv_strategy(dev, F_READ, dev->d_offset + offset,
186ca987d46SWarner Losh 	    blocks * od->sectorsize, buf, NULL);
187ca987d46SWarner Losh 
188ca987d46SWarner Losh 	return (ret);
189ca987d46SWarner Losh }
190ca987d46SWarner Losh 
191ca987d46SWarner Losh int
192ca987d46SWarner Losh disk_write(struct disk_devdesc *dev, void *buf, uint64_t offset, u_int blocks)
193ca987d46SWarner Losh {
194ca987d46SWarner Losh 	struct open_disk *od;
195ca987d46SWarner Losh 	int ret;
196ca987d46SWarner Losh 
197de04d704SWarner Losh 	od = (struct open_disk *)dev->dd.d_opendata;
198de04d704SWarner Losh 	ret = dev->dd.d_dev->dv_strategy(dev, F_WRITE, dev->d_offset + offset,
199ca987d46SWarner Losh 	    blocks * od->sectorsize, buf, NULL);
200ca987d46SWarner Losh 
201ca987d46SWarner Losh 	return (ret);
202ca987d46SWarner Losh }
203ca987d46SWarner Losh 
204ca987d46SWarner Losh int
205ca987d46SWarner Losh disk_ioctl(struct disk_devdesc *dev, u_long cmd, void *data)
206ca987d46SWarner Losh {
207de04d704SWarner Losh 	struct open_disk *od = dev->dd.d_opendata;
208ca987d46SWarner Losh 
209ca987d46SWarner Losh 	if (od == NULL)
210ca987d46SWarner Losh 		return (ENOTTY);
211ca987d46SWarner Losh 
212ca987d46SWarner Losh 	switch (cmd) {
213ca987d46SWarner Losh 	case DIOCGSECTORSIZE:
214ca987d46SWarner Losh 		*(u_int *)data = od->sectorsize;
215ca987d46SWarner Losh 		break;
216ca987d46SWarner Losh 	case DIOCGMEDIASIZE:
217ca987d46SWarner Losh 		if (dev->d_offset == 0)
218ca987d46SWarner Losh 			*(uint64_t *)data = od->mediasize;
219ca987d46SWarner Losh 		else
220ca987d46SWarner Losh 			*(uint64_t *)data = od->entrysize * od->sectorsize;
221ca987d46SWarner Losh 		break;
222ca987d46SWarner Losh 	default:
223ca987d46SWarner Losh 		return (ENOTTY);
224ca987d46SWarner Losh 	}
225ca987d46SWarner Losh 
226ca987d46SWarner Losh 	return (0);
227ca987d46SWarner Losh }
228ca987d46SWarner Losh 
229ca987d46SWarner Losh int
230ca987d46SWarner Losh disk_open(struct disk_devdesc *dev, uint64_t mediasize, u_int sectorsize)
231ca987d46SWarner Losh {
23232c52b48SAllan Jude 	struct disk_devdesc partdev;
233ca987d46SWarner Losh 	struct open_disk *od;
234ca987d46SWarner Losh 	struct ptable *table;
235ca987d46SWarner Losh 	struct ptable_entry part;
236ca987d46SWarner Losh 	int rc, slice, partition;
237ca987d46SWarner Losh 
23815f5e297SToomas Soome 	if (sectorsize == 0) {
23915f5e297SToomas Soome 		DPRINTF("unknown sector size");
24015f5e297SToomas Soome 		return (ENXIO);
24115f5e297SToomas Soome 	}
242ca987d46SWarner Losh 	rc = 0;
243ca987d46SWarner Losh 	od = (struct open_disk *)malloc(sizeof(struct open_disk));
244ca987d46SWarner Losh 	if (od == NULL) {
2457325df02SKyle Evans 		DPRINTF("no memory");
246ca987d46SWarner Losh 		return (ENOMEM);
247ca987d46SWarner Losh 	}
248de04d704SWarner Losh 	dev->dd.d_opendata = od;
249ca987d46SWarner Losh 	od->entrysize = 0;
250ca987d46SWarner Losh 	od->mediasize = mediasize;
251ca987d46SWarner Losh 	od->sectorsize = sectorsize;
25232c52b48SAllan Jude 	/*
25332c52b48SAllan Jude 	 * While we are reading disk metadata, make sure we do it relative
25432c52b48SAllan Jude 	 * to the start of the disk
25532c52b48SAllan Jude 	 */
25632c52b48SAllan Jude 	memcpy(&partdev, dev, sizeof(partdev));
25732c52b48SAllan Jude 	partdev.d_offset = 0;
25814243f8dSIan Lepore 	partdev.d_slice = D_SLICENONE;
25914243f8dSIan Lepore 	partdev.d_partition = D_PARTNONE;
26032c52b48SAllan Jude 
261436dbc42SAllan Jude 	dev->d_offset = 0;
26232c52b48SAllan Jude 	table = NULL;
26332c52b48SAllan Jude 	slice = dev->d_slice;
26432c52b48SAllan Jude 	partition = dev->d_partition;
26532c52b48SAllan Jude 
2667325df02SKyle Evans 	DPRINTF("%s unit %d, slice %d, partition %d => %p",
267d48c0a68SAllan Jude 	    disk_fmtdev(dev), dev->dd.d_unit, dev->d_slice, dev->d_partition, od);
268ca987d46SWarner Losh 
269ca987d46SWarner Losh 	/* Determine disk layout. */
27032c52b48SAllan Jude 	od->table = ptable_open(&partdev, mediasize / sectorsize, sectorsize,
271ca987d46SWarner Losh 	    ptblread);
272ca987d46SWarner Losh 	if (od->table == NULL) {
2737325df02SKyle Evans 		DPRINTF("Can't read partition table");
274ca987d46SWarner Losh 		rc = ENXIO;
275ca987d46SWarner Losh 		goto out;
276ca987d46SWarner Losh 	}
277ca987d46SWarner Losh 
278ca987d46SWarner Losh 	if (ptable_getsize(od->table, &mediasize) != 0) {
279ca987d46SWarner Losh 		rc = ENXIO;
280ca987d46SWarner Losh 		goto out;
281ca987d46SWarner Losh 	}
282ca987d46SWarner Losh 	od->mediasize = mediasize;
283ca987d46SWarner Losh 
284ca987d46SWarner Losh 	if (ptable_gettype(od->table) == PTABLE_BSD &&
285ca987d46SWarner Losh 	    partition >= 0) {
286ca987d46SWarner Losh 		/* It doesn't matter what value has d_slice */
287ca987d46SWarner Losh 		rc = ptable_getpart(od->table, &part, partition);
288ca987d46SWarner Losh 		if (rc == 0) {
289ca987d46SWarner Losh 			dev->d_offset = part.start;
290ca987d46SWarner Losh 			od->entrysize = part.end - part.start + 1;
291ca987d46SWarner Losh 		}
29248990fceSBenno Rice 	} else if (ptable_gettype(od->table) == PTABLE_ISO9660) {
29348990fceSBenno Rice 		dev->d_offset = 0;
29448990fceSBenno Rice 		od->entrysize = mediasize;
295ca987d46SWarner Losh 	} else if (slice >= 0) {
296ca987d46SWarner Losh 		/* Try to get information about partition */
297ca987d46SWarner Losh 		if (slice == 0)
298ca987d46SWarner Losh 			rc = ptable_getbestpart(od->table, &part);
299ca987d46SWarner Losh 		else
300ca987d46SWarner Losh 			rc = ptable_getpart(od->table, &part, slice);
301ca987d46SWarner Losh 		if (rc != 0) /* Partition doesn't exist */
302ca987d46SWarner Losh 			goto out;
303ca987d46SWarner Losh 		dev->d_offset = part.start;
304ca987d46SWarner Losh 		od->entrysize = part.end - part.start + 1;
305ca987d46SWarner Losh 		slice = part.index;
306ca987d46SWarner Losh 		if (ptable_gettype(od->table) == PTABLE_GPT) {
307fa4b8179SWarner Losh 			partition = D_PARTISGPT;
308ca987d46SWarner Losh 			goto out; /* Nothing more to do */
309fa4b8179SWarner Losh 		} else if (partition == D_PARTISGPT) {
310ca987d46SWarner Losh 			/*
311ca987d46SWarner Losh 			 * When we try to open GPT partition, but partition
312ca987d46SWarner Losh 			 * table isn't GPT, reset d_partition value to -1
313ca987d46SWarner Losh 			 * and try to autodetect appropriate value.
314ca987d46SWarner Losh 			 */
315ca987d46SWarner Losh 			partition = -1;
316ca987d46SWarner Losh 		}
317ca987d46SWarner Losh 		/*
318ca987d46SWarner Losh 		 * If d_partition < 0 and we are looking at a BSD slice,
319ca987d46SWarner Losh 		 * then try to read BSD label, otherwise return the
320ca987d46SWarner Losh 		 * whole MBR slice.
321ca987d46SWarner Losh 		 */
322ca987d46SWarner Losh 		if (partition == -1 &&
323ca987d46SWarner Losh 		    part.type != PART_FREEBSD)
324ca987d46SWarner Losh 			goto out;
325ca987d46SWarner Losh 		/* Try to read BSD label */
326ca987d46SWarner Losh 		table = ptable_open(dev, part.end - part.start + 1,
327ca987d46SWarner Losh 		    od->sectorsize, ptblread);
328ca987d46SWarner Losh 		if (table == NULL) {
3297325df02SKyle Evans 			DPRINTF("Can't read BSD label");
330ca987d46SWarner Losh 			rc = ENXIO;
331ca987d46SWarner Losh 			goto out;
332ca987d46SWarner Losh 		}
333ca987d46SWarner Losh 		/*
334ca987d46SWarner Losh 		 * If slice contains BSD label and d_partition < 0, then
335ca987d46SWarner Losh 		 * assume the 'a' partition. Otherwise just return the
336ca987d46SWarner Losh 		 * whole MBR slice, because it can contain ZFS.
337ca987d46SWarner Losh 		 */
338ca987d46SWarner Losh 		if (partition < 0) {
339ca987d46SWarner Losh 			if (ptable_gettype(table) != PTABLE_BSD)
340ca987d46SWarner Losh 				goto out;
341ca987d46SWarner Losh 			partition = 0;
342ca987d46SWarner Losh 		}
343ca987d46SWarner Losh 		rc = ptable_getpart(table, &part, partition);
344ca987d46SWarner Losh 		if (rc != 0)
345ca987d46SWarner Losh 			goto out;
346ca987d46SWarner Losh 		dev->d_offset += part.start;
347ca987d46SWarner Losh 		od->entrysize = part.end - part.start + 1;
348ca987d46SWarner Losh 	}
349ca987d46SWarner Losh out:
350ca987d46SWarner Losh 	if (table != NULL)
351ca987d46SWarner Losh 		ptable_close(table);
352ca987d46SWarner Losh 
353ca987d46SWarner Losh 	if (rc != 0) {
354ca987d46SWarner Losh 		if (od->table != NULL)
355ca987d46SWarner Losh 			ptable_close(od->table);
356ca987d46SWarner Losh 		free(od);
3577325df02SKyle Evans 		DPRINTF("%s could not open", disk_fmtdev(dev));
358ca987d46SWarner Losh 	} else {
359ca987d46SWarner Losh 		/* Save the slice and partition number to the dev */
360ca987d46SWarner Losh 		dev->d_slice = slice;
361ca987d46SWarner Losh 		dev->d_partition = partition;
3627325df02SKyle Evans 		DPRINTF("%s offset %lld => %p", disk_fmtdev(dev),
363ca987d46SWarner Losh 		    (long long)dev->d_offset, od);
364ca987d46SWarner Losh 	}
365ca987d46SWarner Losh 	return (rc);
366ca987d46SWarner Losh }
367ca987d46SWarner Losh 
368ca987d46SWarner Losh int
369ca987d46SWarner Losh disk_close(struct disk_devdesc *dev)
370ca987d46SWarner Losh {
371ca987d46SWarner Losh 	struct open_disk *od;
372ca987d46SWarner Losh 
373de04d704SWarner Losh 	od = (struct open_disk *)dev->dd.d_opendata;
3747325df02SKyle Evans 	DPRINTF("%s closed => %p", disk_fmtdev(dev), od);
375ca987d46SWarner Losh 	ptable_close(od->table);
376ca987d46SWarner Losh 	free(od);
377ca987d46SWarner Losh 	return (0);
378ca987d46SWarner Losh }
379ca987d46SWarner Losh 
380ca987d46SWarner Losh char*
381ca987d46SWarner Losh disk_fmtdev(struct disk_devdesc *dev)
382ca987d46SWarner Losh {
383ca987d46SWarner Losh 	static char buf[128];
384ca987d46SWarner Losh 	char *cp;
385ca987d46SWarner Losh 
386de04d704SWarner Losh 	cp = buf + sprintf(buf, "%s%d", dev->dd.d_dev->dv_name, dev->dd.d_unit);
38714243f8dSIan Lepore 	if (dev->d_slice > D_SLICENONE) {
388ca987d46SWarner Losh #ifdef LOADER_GPT_SUPPORT
38914243f8dSIan Lepore 		if (dev->d_partition == D_PARTISGPT) {
390ca987d46SWarner Losh 			sprintf(cp, "p%d:", dev->d_slice);
391ca987d46SWarner Losh 			return (buf);
392ca987d46SWarner Losh 		} else
393ca987d46SWarner Losh #endif
394ca987d46SWarner Losh #ifdef LOADER_MBR_SUPPORT
395ca987d46SWarner Losh 			cp += sprintf(cp, "s%d", dev->d_slice);
396ca987d46SWarner Losh #endif
397ca987d46SWarner Losh 	}
39814243f8dSIan Lepore 	if (dev->d_partition > D_PARTNONE)
399ca987d46SWarner Losh 		cp += sprintf(cp, "%c", dev->d_partition + 'a');
400ca987d46SWarner Losh 	strcat(cp, ":");
401ca987d46SWarner Losh 	return (buf);
402ca987d46SWarner Losh }
403ca987d46SWarner Losh 
404ca987d46SWarner Losh int
405ca987d46SWarner Losh disk_parsedev(struct disk_devdesc *dev, const char *devspec, const char **path)
406ca987d46SWarner Losh {
407ca987d46SWarner Losh 	int unit, slice, partition;
408ca987d46SWarner Losh 	const char *np;
409ca987d46SWarner Losh 	char *cp;
410ca987d46SWarner Losh 
411ca987d46SWarner Losh 	np = devspec;
41214243f8dSIan Lepore 	unit = -1;
413e77f4eb2SIan Lepore 	/*
414e77f4eb2SIan Lepore 	 * If there is path/file info after the device info, then any missing
415e77f4eb2SIan Lepore 	 * slice or partition info should be considered a request to search for
416e77f4eb2SIan Lepore 	 * an appropriate partition.  Otherwise we want to open the raw device
417e77f4eb2SIan Lepore 	 * itself and not try to fill in missing info by searching.
418e77f4eb2SIan Lepore 	 */
419e77f4eb2SIan Lepore 	if ((cp = strchr(np, ':')) != NULL && cp[1] != '\0') {
42014243f8dSIan Lepore 		slice = D_SLICEWILD;
42114243f8dSIan Lepore 		partition = D_PARTWILD;
422e77f4eb2SIan Lepore 	} else {
423e77f4eb2SIan Lepore 		slice = D_SLICENONE;
424e77f4eb2SIan Lepore 		partition = D_PARTNONE;
425e77f4eb2SIan Lepore 	}
426e77f4eb2SIan Lepore 
427ca987d46SWarner Losh 	if (*np != '\0' && *np != ':') {
428ca987d46SWarner Losh 		unit = strtol(np, &cp, 10);
429ca987d46SWarner Losh 		if (cp == np)
430ca987d46SWarner Losh 			return (EUNIT);
431ca987d46SWarner Losh #ifdef LOADER_GPT_SUPPORT
432ca987d46SWarner Losh 		if (*cp == 'p') {
433ca987d46SWarner Losh 			np = cp + 1;
434ca987d46SWarner Losh 			slice = strtol(np, &cp, 10);
435ca987d46SWarner Losh 			if (np == cp)
436ca987d46SWarner Losh 				return (ESLICE);
437ca987d46SWarner Losh 			/* we don't support nested partitions on GPT */
438ca987d46SWarner Losh 			if (*cp != '\0' && *cp != ':')
439ca987d46SWarner Losh 				return (EINVAL);
440fa4b8179SWarner Losh 			partition = D_PARTISGPT;
441ca987d46SWarner Losh 		} else
442ca987d46SWarner Losh #endif
443ca987d46SWarner Losh #ifdef LOADER_MBR_SUPPORT
444ca987d46SWarner Losh 		if (*cp == 's') {
445ca987d46SWarner Losh 			np = cp + 1;
446ca987d46SWarner Losh 			slice = strtol(np, &cp, 10);
447ca987d46SWarner Losh 			if (np == cp)
448ca987d46SWarner Losh 				return (ESLICE);
449ca987d46SWarner Losh 		}
450ca987d46SWarner Losh #endif
451ca987d46SWarner Losh 		if (*cp != '\0' && *cp != ':') {
452ca987d46SWarner Losh 			partition = *cp - 'a';
453ca987d46SWarner Losh 			if (partition < 0)
454ca987d46SWarner Losh 				return (EPART);
455ca987d46SWarner Losh 			cp++;
456ca987d46SWarner Losh 		}
457ca987d46SWarner Losh 	} else
458ca987d46SWarner Losh 		return (EINVAL);
459ca987d46SWarner Losh 
460ca987d46SWarner Losh 	if (*cp != '\0' && *cp != ':')
461ca987d46SWarner Losh 		return (EINVAL);
462de04d704SWarner Losh 	dev->dd.d_unit = unit;
463ca987d46SWarner Losh 	dev->d_slice = slice;
464ca987d46SWarner Losh 	dev->d_partition = partition;
465ca987d46SWarner Losh 	if (path != NULL)
466ca987d46SWarner Losh 		*path = (*cp == '\0') ? cp: cp + 1;
467ca987d46SWarner Losh 	return (0);
468ca987d46SWarner Losh }
469