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