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