xref: /freebsd/stand/common/disk.c (revision de04d704a98a7d2e9e57ebd83d2dd7a19fc11dab)
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
41ca987d46SWarner Losh # define DEBUG(fmt, args...)	printf("%s: " fmt "\n" , __func__ , ## args)
42ca987d46SWarner Losh #else
43ca987d46SWarner Losh # define DEBUG(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 	}
78ca987d46SWarner Losh 	sprintf(buf, "%ld%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;
89*de04d704SWarner 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 	 */
101*de04d704SWarner 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 #define	PWIDTH	35
106ca987d46SWarner Losh static int
107ca987d46SWarner Losh ptable_print(void *arg, const char *pname, const struct ptable_entry *part)
108ca987d46SWarner Losh {
109ca987d46SWarner Losh 	struct disk_devdesc dev;
110ca987d46SWarner Losh 	struct print_args *pa, bsd;
111ca987d46SWarner Losh 	struct open_disk *od;
112ca987d46SWarner Losh 	struct ptable *table;
113ca987d46SWarner Losh 	char line[80];
114ca987d46SWarner Losh 	int res;
115ca987d46SWarner Losh 
116ca987d46SWarner Losh 	pa = (struct print_args *)arg;
117*de04d704SWarner Losh 	od = (struct open_disk *)pa->dev->dd.d_opendata;
118ca987d46SWarner Losh 	sprintf(line, "  %s%s: %s", pa->prefix, pname,
119ca987d46SWarner Losh 	    parttype2str(part->type));
120ca987d46SWarner Losh 	if (pa->verbose)
121ca987d46SWarner Losh 		sprintf(line, "%-*s%s", PWIDTH, line,
122ca987d46SWarner Losh 		    display_size(part->end - part->start + 1,
123ca987d46SWarner Losh 		    od->sectorsize));
124ca987d46SWarner Losh 	strcat(line, "\n");
125ca987d46SWarner Losh 	if (pager_output(line))
126ca987d46SWarner Losh 		return 1;
127ca987d46SWarner Losh 	res = 0;
128ca987d46SWarner Losh 	if (part->type == PART_FREEBSD) {
129ca987d46SWarner Losh 		/* Open slice with BSD label */
130*de04d704SWarner Losh 		dev.dd.d_dev = pa->dev->dd.d_dev;
131*de04d704SWarner Losh 		dev.dd.d_unit = pa->dev->dd.d_unit;
132ca987d46SWarner Losh 		dev.d_slice = part->index;
133ca987d46SWarner Losh 		dev.d_partition = -1;
134ca987d46SWarner Losh 		if (disk_open(&dev, part->end - part->start + 1,
135ca987d46SWarner Losh 		    od->sectorsize) == 0) {
136ca987d46SWarner Losh 			table = ptable_open(&dev, part->end - part->start + 1,
137ca987d46SWarner Losh 			    od->sectorsize, ptblread);
138ca987d46SWarner Losh 			if (table != NULL) {
139ca987d46SWarner Losh 				sprintf(line, "  %s%s", pa->prefix, pname);
140ca987d46SWarner Losh 				bsd.dev = pa->dev;
141ca987d46SWarner Losh 				bsd.prefix = line;
142ca987d46SWarner Losh 				bsd.verbose = pa->verbose;
143ca987d46SWarner Losh 				res = ptable_iterate(table, &bsd, ptable_print);
144ca987d46SWarner Losh 				ptable_close(table);
145ca987d46SWarner Losh 			}
146ca987d46SWarner Losh 			disk_close(&dev);
147ca987d46SWarner Losh 		}
148ca987d46SWarner Losh 	}
149ca987d46SWarner Losh 
150ca987d46SWarner Losh 	return (res);
151ca987d46SWarner Losh }
152ca987d46SWarner Losh #undef PWIDTH
153ca987d46SWarner Losh 
154ca987d46SWarner Losh int
155ca987d46SWarner Losh disk_print(struct disk_devdesc *dev, char *prefix, int verbose)
156ca987d46SWarner Losh {
157ca987d46SWarner Losh 	struct open_disk *od;
158ca987d46SWarner Losh 	struct print_args pa;
159ca987d46SWarner Losh 
160ca987d46SWarner Losh 	/* Disk should be opened */
161*de04d704SWarner Losh 	od = (struct open_disk *)dev->dd.d_opendata;
162ca987d46SWarner Losh 	pa.dev = dev;
163ca987d46SWarner Losh 	pa.prefix = prefix;
164ca987d46SWarner Losh 	pa.verbose = verbose;
165ca987d46SWarner Losh 	return (ptable_iterate(od->table, &pa, ptable_print));
166ca987d46SWarner Losh }
167ca987d46SWarner Losh 
168ca987d46SWarner Losh int
169ca987d46SWarner Losh disk_read(struct disk_devdesc *dev, void *buf, uint64_t offset, u_int blocks)
170ca987d46SWarner Losh {
171ca987d46SWarner Losh 	struct open_disk *od;
172ca987d46SWarner Losh 	int ret;
173ca987d46SWarner Losh 
174*de04d704SWarner Losh 	od = (struct open_disk *)dev->dd.d_opendata;
175*de04d704SWarner Losh 	ret = dev->dd.d_dev->dv_strategy(dev, F_READ, dev->d_offset + offset,
176ca987d46SWarner Losh 	    blocks * od->sectorsize, buf, NULL);
177ca987d46SWarner Losh 
178ca987d46SWarner Losh 	return (ret);
179ca987d46SWarner Losh }
180ca987d46SWarner Losh 
181ca987d46SWarner Losh int
182ca987d46SWarner Losh disk_write(struct disk_devdesc *dev, void *buf, uint64_t offset, u_int blocks)
183ca987d46SWarner Losh {
184ca987d46SWarner Losh 	struct open_disk *od;
185ca987d46SWarner Losh 	int ret;
186ca987d46SWarner Losh 
187*de04d704SWarner Losh 	od = (struct open_disk *)dev->dd.d_opendata;
188*de04d704SWarner Losh 	ret = dev->dd.d_dev->dv_strategy(dev, F_WRITE, dev->d_offset + offset,
189ca987d46SWarner Losh 	    blocks * od->sectorsize, buf, NULL);
190ca987d46SWarner Losh 
191ca987d46SWarner Losh 	return (ret);
192ca987d46SWarner Losh }
193ca987d46SWarner Losh 
194ca987d46SWarner Losh int
195ca987d46SWarner Losh disk_ioctl(struct disk_devdesc *dev, u_long cmd, void *data)
196ca987d46SWarner Losh {
197*de04d704SWarner Losh 	struct open_disk *od = dev->dd.d_opendata;
198ca987d46SWarner Losh 
199ca987d46SWarner Losh 	if (od == NULL)
200ca987d46SWarner Losh 		return (ENOTTY);
201ca987d46SWarner Losh 
202ca987d46SWarner Losh 	switch (cmd) {
203ca987d46SWarner Losh 	case DIOCGSECTORSIZE:
204ca987d46SWarner Losh 		*(u_int *)data = od->sectorsize;
205ca987d46SWarner Losh 		break;
206ca987d46SWarner Losh 	case DIOCGMEDIASIZE:
207ca987d46SWarner Losh 		if (dev->d_offset == 0)
208ca987d46SWarner Losh 			*(uint64_t *)data = od->mediasize;
209ca987d46SWarner Losh 		else
210ca987d46SWarner Losh 			*(uint64_t *)data = od->entrysize * od->sectorsize;
211ca987d46SWarner Losh 		break;
212ca987d46SWarner Losh 	default:
213ca987d46SWarner Losh 		return (ENOTTY);
214ca987d46SWarner Losh 	}
215ca987d46SWarner Losh 
216ca987d46SWarner Losh 	return (0);
217ca987d46SWarner Losh }
218ca987d46SWarner Losh 
219ca987d46SWarner Losh int
220ca987d46SWarner Losh disk_open(struct disk_devdesc *dev, uint64_t mediasize, u_int sectorsize)
221ca987d46SWarner Losh {
222ca987d46SWarner Losh 	struct open_disk *od;
223ca987d46SWarner Losh 	struct ptable *table;
224ca987d46SWarner Losh 	struct ptable_entry part;
225ca987d46SWarner Losh 	int rc, slice, partition;
226ca987d46SWarner Losh 
227ca987d46SWarner Losh 	rc = 0;
228ca987d46SWarner Losh 	/*
229ca987d46SWarner Losh 	 * While we are reading disk metadata, make sure we do it relative
230ca987d46SWarner Losh 	 * to the start of the disk
231ca987d46SWarner Losh 	 */
232ca987d46SWarner Losh 	dev->d_offset = 0;
233ca987d46SWarner Losh 	table = NULL;
234ca987d46SWarner Losh 	slice = dev->d_slice;
235ca987d46SWarner Losh 	partition = dev->d_partition;
236ca987d46SWarner Losh 	od = (struct open_disk *)malloc(sizeof(struct open_disk));
237ca987d46SWarner Losh 	if (od == NULL) {
238ca987d46SWarner Losh 		DEBUG("no memory");
239ca987d46SWarner Losh 		return (ENOMEM);
240ca987d46SWarner Losh 	}
241*de04d704SWarner Losh 	dev->dd.d_opendata = od;
242ca987d46SWarner Losh 	od->entrysize = 0;
243ca987d46SWarner Losh 	od->mediasize = mediasize;
244ca987d46SWarner Losh 	od->sectorsize = sectorsize;
245ca987d46SWarner Losh 	DEBUG("%s unit %d, slice %d, partition %d => %p",
246ca987d46SWarner Losh 	    disk_fmtdev(dev), dev->d_unit, dev->d_slice, dev->d_partition, od);
247ca987d46SWarner Losh 
248ca987d46SWarner Losh 	/* Determine disk layout. */
249ca987d46SWarner Losh 	od->table = ptable_open(dev, mediasize / sectorsize, sectorsize,
250ca987d46SWarner Losh 	    ptblread);
251ca987d46SWarner Losh 	if (od->table == NULL) {
252ca987d46SWarner Losh 		DEBUG("Can't read partition table");
253ca987d46SWarner Losh 		rc = ENXIO;
254ca987d46SWarner Losh 		goto out;
255ca987d46SWarner Losh 	}
256ca987d46SWarner Losh 
257ca987d46SWarner Losh 	if (ptable_getsize(od->table, &mediasize) != 0) {
258ca987d46SWarner Losh 		rc = ENXIO;
259ca987d46SWarner Losh 		goto out;
260ca987d46SWarner Losh 	}
261ca987d46SWarner Losh 	if (mediasize > od->mediasize) {
262ca987d46SWarner Losh 		od->mediasize = mediasize;
263ca987d46SWarner Losh 	}
264ca987d46SWarner Losh 
265ca987d46SWarner Losh 	if (ptable_gettype(od->table) == PTABLE_BSD &&
266ca987d46SWarner Losh 	    partition >= 0) {
267ca987d46SWarner Losh 		/* It doesn't matter what value has d_slice */
268ca987d46SWarner Losh 		rc = ptable_getpart(od->table, &part, partition);
269ca987d46SWarner Losh 		if (rc == 0) {
270ca987d46SWarner Losh 			dev->d_offset = part.start;
271ca987d46SWarner Losh 			od->entrysize = part.end - part.start + 1;
272ca987d46SWarner Losh 		}
273ca987d46SWarner Losh 	} else if (slice >= 0) {
274ca987d46SWarner Losh 		/* Try to get information about partition */
275ca987d46SWarner Losh 		if (slice == 0)
276ca987d46SWarner Losh 			rc = ptable_getbestpart(od->table, &part);
277ca987d46SWarner Losh 		else
278ca987d46SWarner Losh 			rc = ptable_getpart(od->table, &part, slice);
279ca987d46SWarner Losh 		if (rc != 0) /* Partition doesn't exist */
280ca987d46SWarner Losh 			goto out;
281ca987d46SWarner Losh 		dev->d_offset = part.start;
282ca987d46SWarner Losh 		od->entrysize = part.end - part.start + 1;
283ca987d46SWarner Losh 		slice = part.index;
284ca987d46SWarner Losh 		if (ptable_gettype(od->table) == PTABLE_GPT) {
285ca987d46SWarner Losh 			partition = 255;
286ca987d46SWarner Losh 			goto out; /* Nothing more to do */
287ca987d46SWarner Losh 		} else if (partition == 255) {
288ca987d46SWarner Losh 			/*
289ca987d46SWarner Losh 			 * When we try to open GPT partition, but partition
290ca987d46SWarner Losh 			 * table isn't GPT, reset d_partition value to -1
291ca987d46SWarner Losh 			 * and try to autodetect appropriate value.
292ca987d46SWarner Losh 			 */
293ca987d46SWarner Losh 			partition = -1;
294ca987d46SWarner Losh 		}
295ca987d46SWarner Losh 		/*
296ca987d46SWarner Losh 		 * If d_partition < 0 and we are looking at a BSD slice,
297ca987d46SWarner Losh 		 * then try to read BSD label, otherwise return the
298ca987d46SWarner Losh 		 * whole MBR slice.
299ca987d46SWarner Losh 		 */
300ca987d46SWarner Losh 		if (partition == -1 &&
301ca987d46SWarner Losh 		    part.type != PART_FREEBSD)
302ca987d46SWarner Losh 			goto out;
303ca987d46SWarner Losh 		/* Try to read BSD label */
304ca987d46SWarner Losh 		table = ptable_open(dev, part.end - part.start + 1,
305ca987d46SWarner Losh 		    od->sectorsize, ptblread);
306ca987d46SWarner Losh 		if (table == NULL) {
307ca987d46SWarner Losh 			DEBUG("Can't read BSD label");
308ca987d46SWarner Losh 			rc = ENXIO;
309ca987d46SWarner Losh 			goto out;
310ca987d46SWarner Losh 		}
311ca987d46SWarner Losh 		/*
312ca987d46SWarner Losh 		 * If slice contains BSD label and d_partition < 0, then
313ca987d46SWarner Losh 		 * assume the 'a' partition. Otherwise just return the
314ca987d46SWarner Losh 		 * whole MBR slice, because it can contain ZFS.
315ca987d46SWarner Losh 		 */
316ca987d46SWarner Losh 		if (partition < 0) {
317ca987d46SWarner Losh 			if (ptable_gettype(table) != PTABLE_BSD)
318ca987d46SWarner Losh 				goto out;
319ca987d46SWarner Losh 			partition = 0;
320ca987d46SWarner Losh 		}
321ca987d46SWarner Losh 		rc = ptable_getpart(table, &part, partition);
322ca987d46SWarner Losh 		if (rc != 0)
323ca987d46SWarner Losh 			goto out;
324ca987d46SWarner Losh 		dev->d_offset += part.start;
325ca987d46SWarner Losh 		od->entrysize = part.end - part.start + 1;
326ca987d46SWarner Losh 	}
327ca987d46SWarner Losh out:
328ca987d46SWarner Losh 	if (table != NULL)
329ca987d46SWarner Losh 		ptable_close(table);
330ca987d46SWarner Losh 
331ca987d46SWarner Losh 	if (rc != 0) {
332ca987d46SWarner Losh 		if (od->table != NULL)
333ca987d46SWarner Losh 			ptable_close(od->table);
334ca987d46SWarner Losh 		free(od);
335ca987d46SWarner Losh 		DEBUG("%s could not open", disk_fmtdev(dev));
336ca987d46SWarner Losh 	} else {
337ca987d46SWarner Losh 		/* Save the slice and partition number to the dev */
338ca987d46SWarner Losh 		dev->d_slice = slice;
339ca987d46SWarner Losh 		dev->d_partition = partition;
340ca987d46SWarner Losh 		DEBUG("%s offset %lld => %p", disk_fmtdev(dev),
341ca987d46SWarner Losh 		    (long long)dev->d_offset, od);
342ca987d46SWarner Losh 	}
343ca987d46SWarner Losh 	return (rc);
344ca987d46SWarner Losh }
345ca987d46SWarner Losh 
346ca987d46SWarner Losh int
347ca987d46SWarner Losh disk_close(struct disk_devdesc *dev)
348ca987d46SWarner Losh {
349ca987d46SWarner Losh 	struct open_disk *od;
350ca987d46SWarner Losh 
351*de04d704SWarner Losh 	od = (struct open_disk *)dev->dd.d_opendata;
352ca987d46SWarner Losh 	DEBUG("%s closed => %p", disk_fmtdev(dev), od);
353ca987d46SWarner Losh 	ptable_close(od->table);
354ca987d46SWarner Losh 	free(od);
355ca987d46SWarner Losh 	return (0);
356ca987d46SWarner Losh }
357ca987d46SWarner Losh 
358ca987d46SWarner Losh char*
359ca987d46SWarner Losh disk_fmtdev(struct disk_devdesc *dev)
360ca987d46SWarner Losh {
361ca987d46SWarner Losh 	static char buf[128];
362ca987d46SWarner Losh 	char *cp;
363ca987d46SWarner Losh 
364*de04d704SWarner Losh 	cp = buf + sprintf(buf, "%s%d", dev->dd.d_dev->dv_name, dev->dd.d_unit);
365ca987d46SWarner Losh 	if (dev->d_slice >= 0) {
366ca987d46SWarner Losh #ifdef LOADER_GPT_SUPPORT
367ca987d46SWarner Losh 		if (dev->d_partition == 255) {
368ca987d46SWarner Losh 			sprintf(cp, "p%d:", dev->d_slice);
369ca987d46SWarner Losh 			return (buf);
370ca987d46SWarner Losh 		} else
371ca987d46SWarner Losh #endif
372ca987d46SWarner Losh #ifdef LOADER_MBR_SUPPORT
373ca987d46SWarner Losh 			cp += sprintf(cp, "s%d", dev->d_slice);
374ca987d46SWarner Losh #endif
375ca987d46SWarner Losh 	}
376ca987d46SWarner Losh 	if (dev->d_partition >= 0)
377ca987d46SWarner Losh 		cp += sprintf(cp, "%c", dev->d_partition + 'a');
378ca987d46SWarner Losh 	strcat(cp, ":");
379ca987d46SWarner Losh 	return (buf);
380ca987d46SWarner Losh }
381ca987d46SWarner Losh 
382ca987d46SWarner Losh int
383ca987d46SWarner Losh disk_parsedev(struct disk_devdesc *dev, const char *devspec, const char **path)
384ca987d46SWarner Losh {
385ca987d46SWarner Losh 	int unit, slice, partition;
386ca987d46SWarner Losh 	const char *np;
387ca987d46SWarner Losh 	char *cp;
388ca987d46SWarner Losh 
389ca987d46SWarner Losh 	np = devspec;
390ca987d46SWarner Losh 	unit = slice = partition = -1;
391ca987d46SWarner Losh 	if (*np != '\0' && *np != ':') {
392ca987d46SWarner Losh 		unit = strtol(np, &cp, 10);
393ca987d46SWarner Losh 		if (cp == np)
394ca987d46SWarner Losh 			return (EUNIT);
395ca987d46SWarner Losh #ifdef LOADER_GPT_SUPPORT
396ca987d46SWarner Losh 		if (*cp == 'p') {
397ca987d46SWarner Losh 			np = cp + 1;
398ca987d46SWarner Losh 			slice = strtol(np, &cp, 10);
399ca987d46SWarner Losh 			if (np == cp)
400ca987d46SWarner Losh 				return (ESLICE);
401ca987d46SWarner Losh 			/* we don't support nested partitions on GPT */
402ca987d46SWarner Losh 			if (*cp != '\0' && *cp != ':')
403ca987d46SWarner Losh 				return (EINVAL);
404ca987d46SWarner Losh 			partition = 255;
405ca987d46SWarner Losh 		} else
406ca987d46SWarner Losh #endif
407ca987d46SWarner Losh #ifdef LOADER_MBR_SUPPORT
408ca987d46SWarner Losh 		if (*cp == 's') {
409ca987d46SWarner Losh 			np = cp + 1;
410ca987d46SWarner Losh 			slice = strtol(np, &cp, 10);
411ca987d46SWarner Losh 			if (np == cp)
412ca987d46SWarner Losh 				return (ESLICE);
413ca987d46SWarner Losh 		}
414ca987d46SWarner Losh #endif
415ca987d46SWarner Losh 		if (*cp != '\0' && *cp != ':') {
416ca987d46SWarner Losh 			partition = *cp - 'a';
417ca987d46SWarner Losh 			if (partition < 0)
418ca987d46SWarner Losh 				return (EPART);
419ca987d46SWarner Losh 			cp++;
420ca987d46SWarner Losh 		}
421ca987d46SWarner Losh 	} else
422ca987d46SWarner Losh 		return (EINVAL);
423ca987d46SWarner Losh 
424ca987d46SWarner Losh 	if (*cp != '\0' && *cp != ':')
425ca987d46SWarner Losh 		return (EINVAL);
426*de04d704SWarner Losh 	dev->dd.d_unit = unit;
427ca987d46SWarner Losh 	dev->d_slice = slice;
428ca987d46SWarner Losh 	dev->d_partition = partition;
429ca987d46SWarner Losh 	if (path != NULL)
430ca987d46SWarner Losh 		*path = (*cp == '\0') ? cp: cp + 1;
431ca987d46SWarner Losh 	return (0);
432ca987d46SWarner Losh }
433