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