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