Lines Matching refs:bpb
148 struct bpb {
171 struct bpb bpb;
222 static int getstdfmt(const char *, struct bpb *);
223 static int getdiskinfo(int, const char *, const char *, int, struct bpb *);
224 static void print_bpb(struct bpb *);
237 struct bpb bpb;
304 memset(&bpb, 0, sizeof(bpb));
306 if (getstdfmt(o.floppy, &bpb) == -1)
308 bpb.bpbHugeSectors = bpb.bpbSectors;
309 bpb.bpbSectors = 0;
310 bpb.bpbBigFATsecs = bpb.bpbFATsecs;
311 bpb.bpbFATsecs = 0;
314 bpb.bpbHeads = o.drive_heads;
316 bpb.bpbSecPerTrack = o.sectors_per_track;
318 bpb.bpbBytesPerSec = o.bytes_per_sector;
320 bpb.bpbHugeSectors = o.size;
322 bpb.bpbHiddenSecs = o.hidden_sectors;
325 if (getdiskinfo(fd, fname, dtype, o.hidden_sectors_set, &bpb) == -1)
327 bpb.bpbHugeSectors -= (o.offset / bpb.bpbBytesPerSec);
328 if (bpb.bpbSecPerClust == 0) { /* set defaults */
329 if (bpb.bpbHugeSectors <= 6000) /* about 3MB -> 512 bytes */
330 bpb.bpbSecPerClust = 1;
331 else if (bpb.bpbHugeSectors <= (1<<17)) /* 64M -> 4k */
332 bpb.bpbSecPerClust = 8;
333 else if (bpb.bpbHugeSectors <= (1<<19)) /* 256M -> 8k */
334 bpb.bpbSecPerClust = 16;
335 else if (bpb.bpbHugeSectors <= (1<<21)) /* 1G -> 16k */
336 bpb.bpbSecPerClust = 32;
338 bpb.bpbSecPerClust = 64; /* otherwise 32k */
341 if (bpb.bpbBytesPerSec < MINBPS ||
342 bpb.bpbBytesPerSec > MAXBPS ||
343 !powerof2(bpb.bpbBytesPerSec)) {
345 bpb.bpbBytesPerSec);
366 bpb.bpbRootDirEnts = 0;
377 if (o.block_size < bpb.bpbBytesPerSec) {
379 o.block_size, bpb.bpbBytesPerSec);
382 if (o.block_size > bpb.bpbBytesPerSec * MAXSPC) {
384 o.block_size, bpb.bpbBytesPerSec * MAXSPC);
387 bpb.bpbSecPerClust = o.block_size / bpb.bpbBytesPerSec;
395 bpb.bpbSecPerClust = o.sectors_per_cluster;
398 bpb.bpbResSectors = o.reserved_sectors;
405 bpb.bpbFATs = o.num_FAT;
408 bpb.bpbRootDirEnts = o.directory_entries;
414 bpb.bpbMedia = o.media_descriptor;
417 bpb.bpbBigFATsecs = o.sectors_per_fat;
419 bpb.bpbFSInfo = o.info_sector;
421 bpb.bpbBackup = o.backup_sector;
435 if (!S_ISREG(sb.st_mode) || sb.st_size % bpb.bpbBytesPerSec ||
436 sb.st_size < bpb.bpbBytesPerSec ||
437 sb.st_size > bpb.bpbBytesPerSec * MAXU16) {
441 bss = sb.st_size / bpb.bpbBytesPerSec;
443 if (!bpb.bpbFATs)
444 bpb.bpbFATs = 2;
446 if (bpb.bpbHugeSectors < (bpb.bpbResSectors ? bpb.bpbResSectors : bss) +
447 howmany((RESFTE + (bpb.bpbSecPerClust ? MINCLS16 : MAXCLS12 + 1)) *
448 (bpb.bpbSecPerClust ? 16 : 12) / BPN,
449 bpb.bpbBytesPerSec * NPB) *
450 bpb.bpbFATs +
451 howmany(bpb.bpbRootDirEnts ? bpb.bpbRootDirEnts : DEFRDE,
452 bpb.bpbBytesPerSec / sizeof(struct de)) +
453 (bpb.bpbSecPerClust ? MINCLS16 : MAXCLS12 + 1) *
454 (bpb.bpbSecPerClust ? bpb.bpbSecPerClust :
455 howmany(DEFBLK, bpb.bpbBytesPerSec)))
457 else if (bpb.bpbRootDirEnts || bpb.bpbHugeSectors <
458 (bpb.bpbResSectors ? bpb.bpbResSectors : bss) +
459 howmany((RESFTE + MAXCLS16) * 2, bpb.bpbBytesPerSec) *
460 bpb.bpbFATs +
461 howmany(DEFRDE, bpb.bpbBytesPerSec / sizeof(struct de)) +
463 (bpb.bpbSecPerClust ? bpb.bpbSecPerClust :
464 howmany(8192, bpb.bpbBytesPerSec)))
471 if (!bpb.bpbFSInfo) {
472 if (x == MAXU16 || x == bpb.bpbBackup) {
476 bpb.bpbFSInfo = x;
478 if (bpb.bpbFSInfo != MAXU16 && x <= bpb.bpbFSInfo)
479 x = bpb.bpbFSInfo + 1;
480 if (!bpb.bpbBackup) {
485 bpb.bpbBackup = x;
486 } else if (bpb.bpbBackup != MAXU16 && bpb.bpbBackup == bpb.bpbFSInfo) {
490 if (bpb.bpbBackup != MAXU16 && x <= bpb.bpbBackup)
491 x = bpb.bpbBackup + 1;
496 set_res = (bpb.bpbResSectors == 0);
497 set_spf = (bpb.bpbBigFATsecs == 0);
498 set_spc = (bpb.bpbSecPerClust == 0);
513 bpb.bpbResSectors = ((fat == 32) ?
514 MAX(x, MAX(16384 / bpb.bpbBytesPerSec, 4)) : x) + extra_res;
515 else if (bpb.bpbResSectors < x) {
517 bpb.bpbResSectors);
520 if (fat != 32 && !bpb.bpbRootDirEnts)
521 bpb.bpbRootDirEnts = DEFRDE;
522 rds = howmany(bpb.bpbRootDirEnts,
523 bpb.bpbBytesPerSec / sizeof(struct de));
525 for (bpb.bpbSecPerClust = howmany(fat == 16 ? DEFBLK16 :
526 DEFBLK, bpb.bpbBytesPerSec);
527 bpb.bpbSecPerClust < MAXSPC && (bpb.bpbResSectors +
529 bpb.bpbBytesPerSec * NPB) * bpb.bpbFATs +
531 (u_int64_t) (maxcls(fat) + 1) * bpb.bpbSecPerClust) <=
532 bpb.bpbHugeSectors;
533 bpb.bpbSecPerClust <<= 1)
537 if (fat != 32 && bpb.bpbBigFATsecs > MAXU16) {
541 x1 = bpb.bpbResSectors + rds;
542 x = bpb.bpbBigFATsecs ? bpb.bpbBigFATsecs : 1;
543 if (x1 + (u_int64_t)x * bpb.bpbFATs > bpb.bpbHugeSectors) {
547 x1 += x * bpb.bpbFATs;
548 x = (u_int64_t)(bpb.bpbHugeSectors - x1) * bpb.bpbBytesPerSec * NPB /
549 (bpb.bpbSecPerClust * bpb.bpbBytesPerSec * NPB +
550 fat / BPN * bpb.bpbFATs);
552 bpb.bpbBytesPerSec * NPB);
554 if (bpb.bpbBigFATsecs == 0)
555 bpb.bpbBigFATsecs = x2;
556 x1 += (bpb.bpbBigFATsecs - 1) * bpb.bpbFATs;
560 alignment = (bpb.bpbResSectors + bpb.bpbBigFATsecs * bpb.bpbFATs) %
561 bpb.bpbSecPerClust;
563 extra_res += bpb.bpbSecPerClust - alignment;
570 cls = (bpb.bpbHugeSectors - x1) / bpb.bpbSecPerClust;
571 x = (u_int64_t)bpb.bpbBigFATsecs * bpb.bpbBytesPerSec * NPB / (fat / BPN) -
575 if (bpb.bpbBigFATsecs < x2)
585 bpb.bpbHugeSectors = x1 + (cls + 1) * bpb.bpbSecPerClust - 1;
587 bpb.bpbHugeSectors);
590 "(%u bytes/cluster)\n", fname, cls * bpb.bpbSecPerClust,
591 cls * bpb.bpbSecPerClust == 1 ? "" : "s", cls, fat,
592 cls == 1 ? "" : "s", bpb.bpbBytesPerSec * bpb.bpbSecPerClust);
593 if (!bpb.bpbMedia)
594 bpb.bpbMedia = !bpb.bpbHiddenSecs ? 0xf0 : 0xf8;
596 bpb.bpbRootClust = RESFTE;
597 if (bpb.bpbHugeSectors <= MAXU16) {
598 bpb.bpbSectors = bpb.bpbHugeSectors;
599 bpb.bpbHugeSectors = 0;
602 bpb.bpbFATsecs = bpb.bpbBigFATsecs;
603 bpb.bpbBigFATsecs = 0;
605 print_bpb(&bpb);
626 dir = bpb.bpbResSectors + (bpb.bpbFATsecs ? bpb.bpbFATsecs :
627 bpb.bpbBigFATsecs) * bpb.bpbFATs;
634 for (lsn = 0; lsn < dir + (fat == 32 ? bpb.bpbSecPerClust : rds); lsn++) {
638 (dir + (fat == 32 ? bpb.bpbSecPerClust: rds)),
640 (fat == 32 ? bpb.bpbSecPerClust: rds)));
645 fat == 32 && bpb.bpbBackup != MAXU16 &&
646 bss <= bpb.bpbBackup && x >= bpb.bpbBackup) {
647 x -= bpb.bpbBackup;
654 if ((n = read(fd1, img, bpb.bpbBytesPerSec)) == -1) {
658 if ((unsigned)n != bpb.bpbBytesPerSec) {
663 memset(img, 0, bpb.bpbBytesPerSec);
665 (fat == 32 && bpb.bpbBackup != MAXU16 &&
666 lsn == bpb.bpbBackup)) {
669 mk2(bsbpb->bpbBytesPerSec, bpb.bpbBytesPerSec);
670 mk1(bsbpb->bpbSecPerClust, bpb.bpbSecPerClust);
671 mk2(bsbpb->bpbResSectors, bpb.bpbResSectors);
672 mk1(bsbpb->bpbFATs, bpb.bpbFATs);
673 mk2(bsbpb->bpbRootDirEnts, bpb.bpbRootDirEnts);
674 mk2(bsbpb->bpbSectors, bpb.bpbSectors);
675 mk1(bsbpb->bpbMedia, bpb.bpbMedia);
676 mk2(bsbpb->bpbFATsecs, bpb.bpbFATsecs);
677 mk2(bsbpb->bpbSecPerTrack, bpb.bpbSecPerTrack);
678 mk2(bsbpb->bpbHeads, bpb.bpbHeads);
679 mk4(bsbpb->bpbHiddenSecs, bpb.bpbHiddenSecs);
680 mk4(bsbpb->bpbHugeSectors, bpb.bpbHugeSectors);
684 mk4(bsxbpb->bpbBigFATsecs, bpb.bpbBigFATsecs);
687 mk4(bsxbpb->bpbRootClust, bpb.bpbRootClust);
688 mk2(bsxbpb->bpbFSInfo, bpb.bpbFSInfo);
689 mk2(bsxbpb->bpbBackup, bpb.bpbBackup);
719 } else if (fat == 32 && bpb.bpbFSInfo != MAXU16 &&
720 (lsn == bpb.bpbFSInfo ||
721 (bpb.bpbBackup != MAXU16 &&
722 lsn == bpb.bpbBackup + bpb.bpbFSInfo))) {
728 } else if (lsn >= bpb.bpbResSectors && lsn < dir &&
729 !((lsn - bpb.bpbResSectors) %
730 (bpb.bpbFATsecs ? bpb.bpbFATsecs :
731 bpb.bpbBigFATsecs))) {
732 mk1(img[0], bpb.bpbMedia);
752 img += bpb.bpbBytesPerSec;
865 getstdfmt(const char *fmt, struct bpb *bpb)
875 *bpb = stdfmt[i].bpb;
884 struct bpb *bpb)
922 if (bpb->bpbBytesPerSec)
923 dlp.d_secsize = bpb->bpbBytesPerSec;
924 if (bpb->bpbBytesPerSec == 0 && ioctl(fd, DIOCGSECTORSIZE,
930 if (bpb->bpbSecPerTrack == 0 && ioctl(fd, DIOCGFWSECTORS,
935 if (bpb->bpbHeads == 0 &&
950 if (bpb->bpbBytesPerSec == 0) {
953 bpb->bpbBytesPerSec = lp->d_secsize;
955 if (bpb->bpbSecPerTrack == 0) {
958 bpb->bpbSecPerTrack = lp->d_nsectors;
960 if (bpb->bpbHeads == 0) {
963 bpb->bpbHeads = lp->d_ntracks;
965 if (bpb->bpbHugeSectors == 0)
966 bpb->bpbHugeSectors = lp->d_secperunit;
967 if (bpb->bpbHiddenSecs == 0)
968 bpb->bpbHiddenSecs = hs;
976 print_bpb(struct bpb *bpb)
979 bpb->bpbBytesPerSec, bpb->bpbSecPerClust, bpb->bpbResSectors,
980 bpb->bpbFATs);
981 if (bpb->bpbRootDirEnts)
982 printf(" RootDirEnts=%u", bpb->bpbRootDirEnts);
983 if (bpb->bpbSectors)
984 printf(" Sectors=%u", bpb->bpbSectors);
985 printf(" Media=%#x", bpb->bpbMedia);
986 if (bpb->bpbFATsecs)
987 printf(" FATsecs=%u", bpb->bpbFATsecs);
988 printf(" SecPerTrack=%u Heads=%u HiddenSecs=%u", bpb->bpbSecPerTrack,
989 bpb->bpbHeads, bpb->bpbHiddenSecs);
990 if (bpb->bpbHugeSectors)
991 printf(" HugeSectors=%u", bpb->bpbHugeSectors);
992 if (!bpb->bpbFATsecs) {
993 printf(" FATsecs=%u RootCluster=%u", bpb->bpbBigFATsecs,
994 bpb->bpbRootClust);
996 printf(bpb->bpbFSInfo == MAXU16 ? "%#x" : "%u", bpb->bpbFSInfo);
998 printf(bpb->bpbBackup == MAXU16 ? "%#x" : "%u", bpb->bpbBackup);