1 /* $NetBSD: efiblock.c,v 1.20 2023/06/14 00:52:25 rin Exp $ */ 2 3 /*- 4 * Copyright (c) 2016 Kimihiro Nonaka <nonaka (at) netbsd.org> 5 * Copyright (c) 2018 Jared McNeill <jmcneill (at) invisible.ca> 6 * All rights reserved. 7 * 8 * Redistribution and use in source and binary forms, with or without 9 * modification, are permitted provided that the following conditions 10 * are met: 11 * 1. Redistributions of source code must retain the above copyright 12 * notice, this list of conditions and the following disclaimer. 13 * 2. Redistributions in binary form must reproduce the above copyright 14 * notice, this list of conditions and the following disclaimer in the 15 * documentation and/or other materials provided with the distribution. 16 * 17 * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND 18 * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE 19 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE 20 * ARE DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE 21 * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL 22 * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS 23 * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) 24 * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT 25 * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY 26 * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF 27 * SUCH DAMAGE. 28 */ 29 30 #define FSTYPENAMES 31 32 #include <sys/param.h> 33 #include <sys/md5.h> 34 #include <sys/uuid.h> 35 36 #include <fs/cd9660/iso.h> 37 38 #include "efiboot.h" 39 #include "efiblock.h" 40 41 #define EFI_BLOCK_READAHEAD (64 * 1024) 42 #define EFI_BLOCK_TIMEOUT 120 43 #define EFI_BLOCK_TIMEOUT_CODE 0x810c0000 44 45 /* 46 * The raidframe support is basic. Ideally, it should be expanded to 47 * consider raid volumes a first-class citizen like the x86 efiboot does, 48 * but for now, we simply assume each RAID is potentially bootable. 49 */ 50 #define RF_PROTECTED_SECTORS 64 /* XXX refer to <.../rf_optnames.h> */ 51 52 static EFI_HANDLE *efi_block; 53 static UINTN efi_nblock; 54 static struct efi_block_part *efi_block_booted = NULL; 55 56 static bool efi_ra_enable = false; 57 static UINT8 *efi_ra_buffer = NULL; 58 static UINT32 efi_ra_media_id; 59 static UINT64 efi_ra_start = 0; 60 static UINT64 efi_ra_length = 0; 61 62 static TAILQ_HEAD(, efi_block_dev) efi_block_devs = TAILQ_HEAD_INITIALIZER(efi_block_devs); 63 64 static int 65 efi_block_parse(const char *fname, struct efi_block_part **pbpart, char **pfile) 66 { 67 struct efi_block_dev *bdev; 68 struct efi_block_part *bpart; 69 char pathbuf[PATH_MAX], *default_device, *ep = NULL; 70 const char *full_path; 71 intmax_t dev; 72 int part; 73 74 default_device = get_default_device(); 75 if (strchr(fname, ':') == NULL) { 76 if (strlen(default_device) > 0) { 77 snprintf(pathbuf, sizeof(pathbuf), "%s:%s", default_device, fname); 78 full_path = pathbuf; 79 *pfile = __UNCONST(fname); 80 } else { 81 return EINVAL; 82 } 83 } else { 84 full_path = fname; 85 *pfile = strchr(fname, ':') + 1; 86 } 87 88 if (*pfile[0] == '\0') { 89 *pfile = __UNCONST("/"); 90 } 91 92 if (strncasecmp(full_path, "hd", 2) != 0) 93 return EINVAL; 94 dev = strtoimax(full_path + 2, &ep, 10); 95 if (dev < 0 || dev >= efi_nblock) 96 return ENXIO; 97 if (ep[0] < 'a' || ep[0] >= 'a' + MAXPARTITIONS || ep[1] != ':') 98 return EINVAL; 99 part = ep[0] - 'a'; 100 TAILQ_FOREACH(bdev, &efi_block_devs, entries) { 101 if (bdev->index == dev) { 102 TAILQ_FOREACH(bpart, &bdev->partitions, entries) { 103 if (bpart->index == part) { 104 *pbpart = bpart; 105 return 0; 106 } 107 } 108 } 109 } 110 111 return ENOENT; 112 } 113 114 static void 115 efi_block_generate_hash_mbr(struct efi_block_part *bpart, struct mbr_sector *mbr) 116 { 117 MD5_CTX md5ctx; 118 119 MD5Init(&md5ctx); 120 MD5Update(&md5ctx, (void *)mbr, sizeof(*mbr)); 121 MD5Final(bpart->hash, &md5ctx); 122 } 123 124 static EFI_STATUS 125 efi_block_do_read_blockio(struct efi_block_dev *bdev, UINT64 off, void *buf, 126 UINTN bufsize) 127 { 128 UINT8 *blkbuf, *blkbuf_start; 129 EFI_STATUS status; 130 EFI_LBA lba_start, lba_end; 131 UINT64 blkbuf_offset; 132 UINT64 blkbuf_size, alloc_size; 133 134 lba_start = off / bdev->bio->Media->BlockSize; 135 lba_end = (off + bufsize - 1) / bdev->bio->Media->BlockSize; 136 blkbuf_offset = off % bdev->bio->Media->BlockSize; 137 blkbuf_size = (lba_end - lba_start + 1) * bdev->bio->Media->BlockSize; 138 139 alloc_size = blkbuf_size; 140 if (bdev->bio->Media->IoAlign > 1) { 141 alloc_size = (blkbuf_size + bdev->bio->Media->IoAlign - 1) / 142 bdev->bio->Media->IoAlign * 143 bdev->bio->Media->IoAlign; 144 } 145 146 blkbuf = AllocatePool(alloc_size); 147 if (blkbuf == NULL) { 148 return EFI_OUT_OF_RESOURCES; 149 } 150 151 if (bdev->bio->Media->IoAlign > 1) { 152 blkbuf_start = (void *)roundup2((intptr_t)blkbuf, 153 bdev->bio->Media->IoAlign); 154 } else { 155 blkbuf_start = blkbuf; 156 } 157 158 status = uefi_call_wrapper(bdev->bio->ReadBlocks, 5, bdev->bio, 159 bdev->media_id, lba_start, blkbuf_size, blkbuf_start); 160 if (EFI_ERROR(status)) { 161 goto done; 162 } 163 164 memcpy(buf, blkbuf_start + blkbuf_offset, bufsize); 165 166 done: 167 FreePool(blkbuf); 168 return status; 169 } 170 171 static EFI_STATUS 172 efi_block_do_read_diskio(struct efi_block_dev *bdev, UINT64 off, void *buf, 173 UINTN bufsize) 174 { 175 return uefi_call_wrapper(bdev->dio->ReadDisk, 5, bdev->dio, 176 bdev->media_id, off, bufsize, buf); 177 } 178 179 static EFI_STATUS 180 efi_block_do_read(struct efi_block_dev *bdev, UINT64 off, void *buf, 181 UINTN bufsize) 182 { 183 /* 184 * Perform read access using EFI_DISK_IO_PROTOCOL if available, 185 * otherwise use EFI_BLOCK_IO_PROTOCOL. 186 */ 187 if (bdev->dio != NULL) { 188 return efi_block_do_read_diskio(bdev, off, buf, bufsize); 189 } else { 190 return efi_block_do_read_blockio(bdev, off, buf, bufsize); 191 } 192 } 193 194 static EFI_STATUS 195 efi_block_readahead(struct efi_block_dev *bdev, UINT64 off, void *buf, 196 UINTN bufsize) 197 { 198 EFI_STATUS status; 199 UINT64 mediasize, len; 200 201 if (efi_ra_buffer == NULL) { 202 efi_ra_buffer = AllocatePool(EFI_BLOCK_READAHEAD); 203 if (efi_ra_buffer == NULL) { 204 return EFI_OUT_OF_RESOURCES; 205 } 206 } 207 208 if (bdev->media_id != efi_ra_media_id || 209 off < efi_ra_start || 210 off + bufsize > efi_ra_start + efi_ra_length) { 211 mediasize = bdev->bio->Media->BlockSize * 212 (bdev->bio->Media->LastBlock + 1); 213 len = EFI_BLOCK_READAHEAD; 214 if (len > mediasize - off) { 215 len = mediasize - off; 216 } 217 status = efi_block_do_read(bdev, off, efi_ra_buffer, len); 218 if (EFI_ERROR(status)) { 219 efi_ra_start = efi_ra_length = 0; 220 return status; 221 } 222 efi_ra_start = off; 223 efi_ra_length = len; 224 efi_ra_media_id = bdev->media_id; 225 } 226 227 memcpy(buf, &efi_ra_buffer[off - efi_ra_start], bufsize); 228 return EFI_SUCCESS; 229 } 230 231 static EFI_STATUS 232 efi_block_read(struct efi_block_dev *bdev, UINT64 off, void *buf, 233 UINTN bufsize) 234 { 235 if (efi_ra_enable) { 236 return efi_block_readahead(bdev, off, buf, bufsize); 237 } 238 239 return efi_block_do_read(bdev, off, buf, bufsize); 240 } 241 242 static int 243 efi_block_find_partitions_cd9660(struct efi_block_dev *bdev) 244 { 245 struct efi_block_part *bpart; 246 struct iso_primary_descriptor vd; 247 EFI_STATUS status; 248 EFI_LBA lba; 249 250 for (lba = 16;; lba++) { 251 status = efi_block_read(bdev, 252 lba * ISO_DEFAULT_BLOCK_SIZE, &vd, sizeof(vd)); 253 if (EFI_ERROR(status)) { 254 goto io_error; 255 } 256 257 if (memcmp(vd.id, ISO_STANDARD_ID, sizeof vd.id) != 0) { 258 goto io_error; 259 } 260 if (isonum_711(vd.type) == ISO_VD_END) { 261 goto io_error; 262 } 263 if (isonum_711(vd.type) == ISO_VD_PRIMARY) { 264 break; 265 } 266 } 267 268 if (isonum_723(vd.logical_block_size) != ISO_DEFAULT_BLOCK_SIZE) { 269 goto io_error; 270 } 271 272 bpart = alloc(sizeof(*bpart)); 273 bpart->index = 0; 274 bpart->bdev = bdev; 275 bpart->type = EFI_BLOCK_PART_CD9660; 276 TAILQ_INSERT_TAIL(&bdev->partitions, bpart, entries); 277 278 return 0; 279 280 io_error: 281 return EIO; 282 } 283 284 static int 285 efi_block_find_partitions_disklabel(struct efi_block_dev *bdev, 286 struct mbr_sector *mbr, uint32_t start, uint32_t size) 287 { 288 struct efi_block_part *bpart; 289 char buf[DEV_BSIZE]; /* XXX, arbitrary size >= struct disklabel */ 290 struct disklabel d; 291 struct partition *p; 292 EFI_STATUS status; 293 int n; 294 295 status = efi_block_read(bdev, 296 ((EFI_LBA)start + LABELSECTOR) * bdev->bio->Media->BlockSize, buf, sizeof(buf)); 297 if (EFI_ERROR(status) || getdisklabel(buf, &d) != NULL) 298 return EIO; 299 300 if (le32toh(d.d_magic) != DISKMAGIC || le32toh(d.d_magic2) != DISKMAGIC) 301 return EINVAL; 302 if (le16toh(d.d_npartitions) > MAXPARTITIONS) 303 return EINVAL; 304 305 for (n = 0; n < le16toh(d.d_npartitions); n++) { 306 p = &d.d_partitions[n]; 307 switch (p->p_fstype) { 308 case FS_BSDFFS: 309 case FS_MSDOS: 310 case FS_BSDLFS: 311 break; 312 case FS_RAID: 313 p->p_size -= RF_PROTECTED_SECTORS; 314 p->p_offset += RF_PROTECTED_SECTORS; 315 break; 316 default: 317 continue; 318 } 319 320 bpart = alloc(sizeof(*bpart)); 321 bpart->index = n; 322 bpart->bdev = bdev; 323 bpart->type = EFI_BLOCK_PART_DISKLABEL; 324 bpart->disklabel.secsize = d.d_secsize; 325 bpart->disklabel.part = *p; 326 efi_block_generate_hash_mbr(bpart, mbr); 327 TAILQ_INSERT_TAIL(&bdev->partitions, bpart, entries); 328 } 329 330 return 0; 331 } 332 333 static int 334 efi_block_find_partitions_mbr(struct efi_block_dev *bdev) 335 { 336 struct mbr_sector mbr; 337 struct mbr_partition *mbr_part; 338 EFI_STATUS status; 339 int n; 340 341 status = efi_block_read(bdev, 0, &mbr, sizeof(mbr)); 342 if (EFI_ERROR(status)) 343 return EIO; 344 345 if (le32toh(mbr.mbr_magic) != MBR_MAGIC) 346 return ENOENT; 347 348 for (n = 0; n < MBR_PART_COUNT; n++) { 349 mbr_part = &mbr.mbr_parts[n]; 350 if (le32toh(mbr_part->mbrp_size) == 0) 351 continue; 352 if (mbr_part->mbrp_type == MBR_PTYPE_NETBSD) { 353 efi_block_find_partitions_disklabel(bdev, &mbr, 354 le32toh(mbr_part->mbrp_start), 355 le32toh(mbr_part->mbrp_size)); 356 break; 357 } 358 } 359 360 return 0; 361 } 362 363 static const struct { 364 struct uuid guid; 365 uint8_t fstype; 366 } gpt_guid_to_str[] = { 367 { GPT_ENT_TYPE_NETBSD_FFS, FS_BSDFFS }, 368 { GPT_ENT_TYPE_NETBSD_LFS, FS_BSDLFS }, 369 { GPT_ENT_TYPE_NETBSD_RAIDFRAME, FS_RAID }, 370 { GPT_ENT_TYPE_NETBSD_CCD, FS_CCD }, 371 { GPT_ENT_TYPE_NETBSD_CGD, FS_CGD }, 372 { GPT_ENT_TYPE_MS_BASIC_DATA, FS_MSDOS }, /* or NTFS? ambiguous */ 373 { GPT_ENT_TYPE_EFI, FS_MSDOS }, 374 }; 375 376 static int 377 efi_block_find_partitions_gpt_entry(struct efi_block_dev *bdev, 378 struct gpt_hdr *hdr, struct gpt_ent *ent, UINT32 index) 379 { 380 struct efi_block_part *bpart; 381 uint8_t fstype = FS_UNUSED; 382 struct uuid uuid; 383 int n; 384 385 memcpy(&uuid, ent->ent_type, sizeof(uuid)); 386 for (n = 0; n < __arraycount(gpt_guid_to_str); n++) 387 if (memcmp(ent->ent_type, &gpt_guid_to_str[n].guid, 388 sizeof(ent->ent_type)) == 0) { 389 fstype = gpt_guid_to_str[n].fstype; 390 break; 391 } 392 if (fstype == FS_UNUSED) 393 return 0; 394 395 bpart = alloc(sizeof(*bpart)); 396 bpart->index = index; 397 bpart->bdev = bdev; 398 bpart->type = EFI_BLOCK_PART_GPT; 399 bpart->gpt.fstype = fstype; 400 bpart->gpt.ent = *ent; 401 if (fstype == FS_RAID) { 402 bpart->gpt.ent.ent_lba_start += RF_PROTECTED_SECTORS; 403 bpart->gpt.ent.ent_lba_end -= RF_PROTECTED_SECTORS; 404 } 405 memcpy(bpart->hash, ent->ent_guid, sizeof(bpart->hash)); 406 TAILQ_INSERT_TAIL(&bdev->partitions, bpart, entries); 407 408 return 0; 409 } 410 411 static int 412 efi_block_find_partitions_gpt(struct efi_block_dev *bdev) 413 { 414 struct gpt_hdr hdr; 415 struct gpt_ent ent; 416 EFI_STATUS status; 417 UINT32 entry; 418 void *buf; 419 UINTN sz; 420 421 status = efi_block_read(bdev, (EFI_LBA)GPT_HDR_BLKNO * bdev->bio->Media->BlockSize, &hdr, 422 sizeof(hdr)); 423 if (EFI_ERROR(status)) { 424 return EIO; 425 } 426 427 if (memcmp(hdr.hdr_sig, GPT_HDR_SIG, sizeof(hdr.hdr_sig)) != 0) 428 return ENOENT; 429 if (le32toh(hdr.hdr_entsz) < sizeof(ent)) 430 return EINVAL; 431 432 sz = le32toh(hdr.hdr_entsz) * le32toh(hdr.hdr_entries); 433 buf = AllocatePool(sz); 434 if (buf == NULL) 435 return ENOMEM; 436 437 status = efi_block_read(bdev, 438 le64toh(hdr.hdr_lba_table) * bdev->bio->Media->BlockSize, buf, sz); 439 if (EFI_ERROR(status)) { 440 FreePool(buf); 441 return EIO; 442 } 443 444 for (entry = 0; entry < le32toh(hdr.hdr_entries); entry++) { 445 memcpy(&ent, (UINT8 *)buf + (entry * le32toh(hdr.hdr_entsz)), 446 sizeof(ent)); 447 efi_block_find_partitions_gpt_entry(bdev, &hdr, &ent, entry); 448 } 449 450 FreePool(buf); 451 452 return 0; 453 } 454 455 static int 456 efi_block_find_partitions(struct efi_block_dev *bdev) 457 { 458 int error; 459 460 error = efi_block_find_partitions_gpt(bdev); 461 if (error) 462 error = efi_block_find_partitions_mbr(bdev); 463 if (error) 464 error = efi_block_find_partitions_cd9660(bdev); 465 466 return error; 467 } 468 469 void 470 efi_block_probe(void) 471 { 472 struct efi_block_dev *bdev; 473 struct efi_block_part *bpart; 474 EFI_BLOCK_IO *bio; 475 EFI_DISK_IO *dio; 476 EFI_STATUS status; 477 uint16_t devindex = 0; 478 int depth = -1; 479 int n; 480 481 status = LibLocateHandle(ByProtocol, &BlockIoProtocol, NULL, &efi_nblock, &efi_block); 482 if (EFI_ERROR(status)) 483 return; 484 485 if (efi_bootdp) { 486 depth = efi_device_path_depth(efi_bootdp, MEDIA_DEVICE_PATH); 487 if (depth == 0) 488 depth = 1; 489 else if (depth == -1) 490 depth = 2; 491 } 492 493 for (n = 0; n < efi_nblock; n++) { 494 /* EFI_BLOCK_IO_PROTOCOL is required */ 495 status = uefi_call_wrapper(BS->HandleProtocol, 3, efi_block[n], 496 &BlockIoProtocol, (void **)&bio); 497 if (EFI_ERROR(status) || !bio->Media->MediaPresent) 498 continue; 499 500 /* Ignore logical partitions (we do our own partition discovery) */ 501 if (bio->Media->LogicalPartition) 502 continue; 503 504 /* EFI_DISK_IO_PROTOCOL is optional */ 505 status = uefi_call_wrapper(BS->HandleProtocol, 3, efi_block[n], 506 &DiskIoProtocol, (void **)&dio); 507 if (EFI_ERROR(status)) { 508 dio = NULL; 509 } 510 511 bdev = alloc(sizeof(*bdev)); 512 bdev->index = devindex++; 513 bdev->bio = bio; 514 bdev->dio = dio; 515 bdev->media_id = bio->Media->MediaId; 516 bdev->path = DevicePathFromHandle(efi_block[n]); 517 TAILQ_INIT(&bdev->partitions); 518 TAILQ_INSERT_TAIL(&efi_block_devs, bdev, entries); 519 520 efi_block_find_partitions(bdev); 521 522 if (depth > 0 && efi_device_path_ncmp(efi_bootdp, DevicePathFromHandle(efi_block[n]), depth) == 0) { 523 TAILQ_FOREACH(bpart, &bdev->partitions, entries) { 524 uint8_t fstype = FS_UNUSED; 525 switch (bpart->type) { 526 case EFI_BLOCK_PART_DISKLABEL: 527 fstype = bpart->disklabel.part.p_fstype; 528 break; 529 case EFI_BLOCK_PART_GPT: 530 fstype = bpart->gpt.fstype; 531 break; 532 case EFI_BLOCK_PART_CD9660: 533 fstype = FS_ISO9660; 534 break; 535 } 536 if (fstype == FS_BSDFFS || fstype == FS_ISO9660 || fstype == FS_RAID) { 537 char devname[9]; 538 snprintf(devname, sizeof(devname), "hd%u%c", bdev->index, bpart->index + 'a'); 539 set_default_device(devname); 540 set_default_fstype(fstype); 541 break; 542 } 543 } 544 } 545 } 546 } 547 548 static void 549 print_guid(const uint8_t *guid) 550 { 551 const int index[] = { 3, 2, 1, 0, 5, 4, 7, 6, 8, 9, 10, 11, 12, 13, 14, 15 }; 552 int i; 553 554 for (i = 0; i < 16; i++) { 555 printf("%02x", guid[index[i]]); 556 if (i == 3 || i == 5 || i == 7 || i == 9) 557 printf("-"); 558 } 559 } 560 561 void 562 efi_block_show(void) 563 { 564 struct efi_block_dev *bdev; 565 struct efi_block_part *bpart; 566 uint64_t size; 567 CHAR16 *path; 568 569 TAILQ_FOREACH(bdev, &efi_block_devs, entries) { 570 printf("hd%u (", bdev->index); 571 572 /* Size in MB */ 573 size = ((bdev->bio->Media->LastBlock + 1) * bdev->bio->Media->BlockSize) / (1024 * 1024); 574 if (size >= 10000) 575 printf("%"PRIu64" GB", size / 1024); 576 else 577 printf("%"PRIu64" MB", size); 578 printf("): "); 579 580 path = DevicePathToStr(bdev->path); 581 Print(L"%s", path); 582 FreePool(path); 583 584 printf("\n"); 585 586 TAILQ_FOREACH(bpart, &bdev->partitions, entries) { 587 switch (bpart->type) { 588 case EFI_BLOCK_PART_DISKLABEL: 589 printf(" hd%u%c (", bdev->index, bpart->index + 'a'); 590 591 /* Size in MB */ 592 size = ((uint64_t)bpart->disklabel.secsize * bpart->disklabel.part.p_size) / (1024 * 1024); 593 if (size >= 10000) 594 printf("%"PRIu64" GB", size / 1024); 595 else 596 printf("%"PRIu64" MB", size); 597 printf("): "); 598 599 printf("%s\n", fstypenames[bpart->disklabel.part.p_fstype]); 600 break; 601 case EFI_BLOCK_PART_GPT: 602 printf(" hd%u%c ", bdev->index, bpart->index + 'a'); 603 604 if (bpart->gpt.ent.ent_name[0] == 0x0000) { 605 printf("\""); 606 print_guid(bpart->gpt.ent.ent_guid); 607 printf("\""); 608 } else { 609 Print(L"\"%s\"", bpart->gpt.ent.ent_name); 610 } 611 612 /* Size in MB */ 613 size = (le64toh(bpart->gpt.ent.ent_lba_end) - le64toh(bpart->gpt.ent.ent_lba_start)) * bdev->bio->Media->BlockSize; 614 size /= (1024 * 1024); 615 if (size >= 10000) 616 printf(" (%"PRIu64" GB): ", size / 1024); 617 else 618 printf(" (%"PRIu64" MB): ", size); 619 620 printf("%s\n", fstypenames[bpart->gpt.fstype]); 621 break; 622 case EFI_BLOCK_PART_CD9660: 623 printf(" hd%u%c %s\n", bdev->index, bpart->index + 'a', fstypenames[FS_ISO9660]); 624 break; 625 default: 626 break; 627 } 628 } 629 } 630 } 631 632 struct efi_block_part * 633 efi_block_boot_part(void) 634 { 635 return efi_block_booted; 636 } 637 638 int 639 efi_block_open(struct open_file *f, ...) 640 { 641 struct efi_block_part *bpart; 642 const char *fname; 643 char **file; 644 char *path; 645 va_list ap; 646 int rv, n; 647 648 va_start(ap, f); 649 fname = va_arg(ap, const char *); 650 file = va_arg(ap, char **); 651 va_end(ap); 652 653 rv = efi_block_parse(fname, &bpart, &path); 654 if (rv != 0) 655 return rv; 656 657 for (n = 0; n < ndevs; n++) 658 if (strcmp(DEV_NAME(&devsw[n]), "efiblock") == 0) { 659 f->f_dev = &devsw[n]; 660 break; 661 } 662 if (n == ndevs) 663 return ENXIO; 664 665 f->f_devdata = bpart; 666 667 *file = path; 668 669 efi_block_booted = bpart; 670 671 return 0; 672 } 673 674 int 675 efi_block_close(struct open_file *f) 676 { 677 return 0; 678 } 679 680 int 681 efi_block_strategy(void *devdata, int rw, daddr_t dblk, size_t size, void *buf, size_t *rsize) 682 { 683 struct efi_block_part *bpart = devdata; 684 struct efi_block_dev *bdev = bpart->bdev; 685 EFI_STATUS status; 686 UINT64 off; 687 688 if (rw != F_READ) 689 return EROFS; 690 691 efi_set_watchdog(EFI_BLOCK_TIMEOUT, EFI_BLOCK_TIMEOUT_CODE); 692 693 switch (bpart->type) { 694 case EFI_BLOCK_PART_DISKLABEL: 695 off = ((EFI_LBA)dblk + bpart->disklabel.part.p_offset) * bdev->bio->Media->BlockSize; 696 break; 697 case EFI_BLOCK_PART_GPT: 698 off = ((EFI_LBA)dblk + le64toh(bpart->gpt.ent.ent_lba_start)) * bdev->bio->Media->BlockSize; 699 break; 700 case EFI_BLOCK_PART_CD9660: 701 off = (EFI_LBA)dblk * ISO_DEFAULT_BLOCK_SIZE; 702 break; 703 default: 704 return EINVAL; 705 } 706 707 status = efi_block_read(bpart->bdev, off, buf, size); 708 if (EFI_ERROR(status)) 709 return EIO; 710 711 *rsize = size; 712 713 return 0; 714 } 715 716 void 717 efi_block_set_readahead(bool onoff) 718 { 719 efi_ra_enable = onoff; 720 } 721 722 int 723 efi_block_ioctl(struct open_file *f, u_long cmd, void *data) 724 { 725 struct efi_block_part *bpart = f->f_devdata; 726 struct efi_block_dev *bdev = bpart->bdev; 727 int error = 0; 728 729 switch (cmd) { 730 case SAIOSECSIZE: 731 *(u_int *)data = bdev->bio->Media->BlockSize; 732 break; 733 default: 734 error = ENOTTY; 735 break; 736 } 737 738 return error; 739 } 740
Indexes created Sat Sep 20 22:09:52 GMT 2025