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