Lines Matching refs:bpb
155 struct bpb {
178 struct bpb bpb;
225 static void getstdfmt(const char *, struct bpb *);
227 struct bpb *);
228 static void print_bpb(struct bpb *);
260 struct bpb bpb;
396 memset(&bpb, 0, sizeof(bpb));
398 getstdfmt(opt_f, &bpb);
399 bpb.bsec = bpb.sec;
400 bpb.sec = 0;
401 bpb.bspf = bpb.spf;
402 bpb.spf = 0;
405 bpb.hds = opt_h;
407 bpb.spt = opt_u;
409 bpb.bps = opt_S;
411 bpb.bsec = opt_s;
413 bpb.hid = opt_o;
416 getdiskinfo(fd, fname, dtype, oflag, &bpb);
418 bpb.bsec = opt_s;
420 bpb.bsec -= (opt_ofs / bpb.bps);
421 delta = bpb.bsec % bpb.spt;
424 (int)delta, bpb.bsec, bpb.spt);
425 bpb.bsec -= delta;
427 if (bpb.spc == 0) { /* set defaults */
428 if (bpb.bsec <= 6000) /* about 3MB -> 512 bytes */
429 bpb.spc = 1;
430 else if (bpb.bsec <= (1<<17)) /* 64M -> 4k */
431 bpb.spc = 8;
432 else if (bpb.bsec <= (1<<19)) /* 256M -> 8k */
433 bpb.spc = 16;
434 else if (bpb.bsec <= (1<<22)) /* 2G -> 16k, some versions of windows
436 bpb.spc = 32;
438 bpb.spc = 64; /* otherwise 32k */
441 if (!powerof2(bpb.bps))
442 errx(1, "bytes/sector (%u) is not a power of 2", bpb.bps);
443 if (bpb.bps < MINBPS)
445 bpb.bps, MINBPS);
457 bpb.rde = 0;
461 if (opt_b < bpb.bps)
463 opt_b, bpb.bps);
464 if (opt_b > bpb.bps * MAXSPC)
466 opt_b, bpb.bps * MAXSPC);
467 bpb.spc = opt_b / bpb.bps;
472 bpb.spc = opt_c;
475 bpb.res = opt_r;
480 bpb.nft = opt_n;
483 bpb.rde = opt_e;
487 bpb.mid = opt_m;
490 bpb.bspf = opt_a;
492 bpb.infs = opt_i;
494 bpb.bkbs = opt_k;
507 if (!S_ISREG(sb.st_mode) || sb.st_size % bpb.bps ||
508 sb.st_size < bpb.bps || sb.st_size > bpb.bps * MAXU16)
510 bss = sb.st_size / bpb.bps;
512 if (!bpb.nft)
513 bpb.nft = 2;
515 if (bpb.bsec < (bpb.res ? bpb.res : bss) +
516 howmany((RESFTE + (bpb.spc ? MINCLS16 : MAXCLS12 + 1)) *
517 ((bpb.spc ? 16 : 12) / BPN), bpb.bps * NPB) *
518 bpb.nft +
519 howmany(bpb.rde ? bpb.rde : DEFRDE,
520 bpb.bps / sizeof(struct de)) +
521 (bpb.spc ? MINCLS16 : MAXCLS12 + 1) *
522 (bpb.spc ? bpb.spc : howmany(DEFBLK, bpb.bps)))
524 else if (bpb.rde || bpb.bsec <
525 (bpb.res ? bpb.res : bss) +
526 howmany((RESFTE + MAXCLS16) * 2, bpb.bps) * bpb.nft +
527 howmany(DEFRDE, bpb.bps / sizeof(struct de)) +
529 (bpb.spc ? bpb.spc : howmany(8192, bpb.bps)))
536 if (!bpb.infs) {
537 if (x == MAXU16 || x == bpb.bkbs)
539 bpb.infs = x;
541 if (bpb.infs != MAXU16 && x <= bpb.infs)
542 x = bpb.infs + 1;
543 if (!bpb.bkbs) {
546 bpb.bkbs = x;
547 } else if (bpb.bkbs != MAXU16 && bpb.bkbs == bpb.infs)
549 if (bpb.bkbs != MAXU16 && x <= bpb.bkbs)
550 x = bpb.bkbs + 1;
552 if (!bpb.res)
553 bpb.res = fat == 32 ? MAX(x, MAX(16384 / bpb.bps, 4)) : x;
554 else if (bpb.res < x)
556 if (fat != 32 && !bpb.rde)
557 bpb.rde = DEFRDE;
558 rds = howmany(bpb.rde, bpb.bps / sizeof(struct de));
559 if (!bpb.spc)
560 for (bpb.spc = howmany(fat == 16 ? DEFBLK16 : DEFBLK, bpb.bps);
561 bpb.spc < MAXSPC &&
562 bpb.res +
564 bpb.bps * NPB) * bpb.nft +
566 (u_int64_t)(maxcls(fat) + 1) * bpb.spc <= bpb.bsec;
567 bpb.spc <<= 1);
568 if (fat != 32 && bpb.bspf > MAXU16)
570 x1 = bpb.res + rds;
571 x = bpb.bspf ? bpb.bspf : 1;
572 if (x1 + (u_int64_t)x * bpb.nft > bpb.bsec)
574 x1 += x * bpb.nft;
575 x = (u_int64_t)(bpb.bsec - x1) * bpb.bps * NPB /
576 (bpb.spc * bpb.bps * NPB + fat / BPN * bpb.nft);
578 bpb.bps * NPB);
579 if (!bpb.bspf) {
580 bpb.bspf = x2;
581 x1 += (bpb.bspf - 1) * bpb.nft;
583 cls = (bpb.bsec - x1) / bpb.spc;
584 x = (u_int64_t)bpb.bspf * bpb.bps * NPB / (fat / BPN) - RESFTE;
587 if (bpb.bspf < x2)
595 bpb.bsec = x1 + (cls + 1) * bpb.spc - 1;
597 bpb.bsec);
600 "(%u bytes/cluster)\n", fname, cls * bpb.spc,
601 cls * bpb.spc == 1 ? "" : "s", cls, fat,
602 cls == 1 ? "" : "s", bpb.bps * bpb.spc);
603 if (!bpb.mid)
604 bpb.mid = !bpb.hid ? 0xf0 : 0xf8;
606 bpb.rdcl = RESFTE;
607 if (bpb.hid + bpb.bsec <= MAXU16) {
608 bpb.sec = bpb.bsec;
609 bpb.bsec = 0;
612 bpb.spf = bpb.bspf;
613 bpb.bspf = 0;
615 print_bpb(&bpb);
620 if (!(img = malloc(bpb.bps)))
622 dir = bpb.res + (bpb.spf ? bpb.spf : bpb.bspf) * bpb.nft;
623 for (lsn = 0; lsn < dir + (fat == 32 ? bpb.spc : rds); lsn++) {
626 fat == 32 && bpb.bkbs != MAXU16 &&
627 bss <= bpb.bkbs && x >= bpb.bkbs) {
628 x -= bpb.bkbs;
633 if ((n = read(fd1, img, bpb.bps)) == -1)
635 if ((unsigned)n != bpb.bps)
638 memset(img, 0, bpb.bps);
640 (fat == 32 && bpb.bkbs != MAXU16 && lsn == bpb.bkbs)) {
643 mk2(bsbpb->bps, bpb.bps);
644 mk1(bsbpb->spc, bpb.spc);
645 mk2(bsbpb->res, bpb.res);
646 mk1(bsbpb->nft, bpb.nft);
647 mk2(bsbpb->rde, bpb.rde);
648 mk2(bsbpb->sec, bpb.sec);
649 mk1(bsbpb->mid, bpb.mid);
650 mk2(bsbpb->spf, bpb.spf);
651 mk2(bsbpb->spt, bpb.spt);
652 mk2(bsbpb->hds, bpb.hds);
653 mk4(bsbpb->hid, bpb.hid);
654 mk4(bsbpb->bsec, bpb.bsec);
658 mk4(bsxbpb->bspf, bpb.bspf);
661 mk4(bsxbpb->rdcl, bpb.rdcl);
662 mk2(bsxbpb->infs, bpb.infs);
663 mk2(bsxbpb->bkbs, bpb.bkbs);
693 } else if (fat == 32 && bpb.infs != MAXU16 &&
694 (lsn == bpb.infs ||
695 (bpb.bkbs != MAXU16 &&
696 lsn == bpb.bkbs + bpb.infs))) {
700 mk4(img + MINBPS - 20, bpb.rdcl);
702 } else if (lsn >= bpb.res && lsn < dir &&
703 !((lsn - bpb.res) %
704 (bpb.spf ? bpb.spf : bpb.bspf))) {
705 mk1(img[0], bpb.mid);
721 if ((n = write(fd, img, bpb.bps)) == -1)
723 if ((unsigned)n != bpb.bps) {
768 getstdfmt(const char *fmt, struct bpb *bpb)
776 *bpb = stdfmt[i].bpb;
786 struct bpb *bpb)
790 if (ioctl(fd, BLKSSZGET, &bpb->bps)) {
795 ckgeom(fname, bpb->bps, "bytes/sector");
797 if (ioctl(fd, BLKGETSIZE, &bpb->bsec)) {
818 bpb->spt = geom.sectors;
819 ckgeom(fname, bpb->spt, "sectors/track");
821 bpb->hds = geom.heads;
822 ckgeom(fname, bpb->hds, "drive heads");
829 struct bpb *bpb)
868 if (bpb->bps == 0 && ioctl(fd, DIOCGSECTORSIZE, &dlp.d_secsize) == -1)
871 /* XXX Should we use bpb->bps if it's set? */
874 if (bpb->spt == 0 && ioctl(fd, DIOCGFWSECTORS, &dlp.d_nsectors) == -1) {
878 if (bpb->hds == 0 && ioctl(fd, DIOCGFWHEADS, &dlp.d_ntracks) == -1) {
893 if (bpb->bps == 0)
894 bpb->bps = ckgeom(fname, lp->d_secsize, "bytes/sector");
895 if (bpb->spt == 0)
896 bpb->spt = ckgeom(fname, lp->d_nsectors, "sectors/track");
897 if (bpb->hds == 0)
898 bpb->hds = ckgeom(fname, lp->d_ntracks, "drive heads");
899 if (bpb->bsec == 0)
900 bpb->bsec = lp->d_secperunit;
901 if (bpb->hid == 0)
902 bpb->hid = hs;
907 * Print out BPB values.
910 print_bpb(struct bpb *bpb)
912 printf("bps=%u spc=%u res=%u nft=%u", bpb->bps, bpb->spc, bpb->res,
913 bpb->nft);
914 if (bpb->rde)
915 printf(" rde=%u", bpb->rde);
916 if (bpb->sec)
917 printf(" sec=%u", bpb->sec);
918 printf(" mid=%#x", bpb->mid);
919 if (bpb->spf)
920 printf(" spf=%u", bpb->spf);
921 printf(" spt=%u hds=%u hid=%u", bpb->spt, bpb->hds, bpb->hid);
922 if (bpb->bsec)
923 printf(" bsec=%u", bpb->bsec);
924 if (!bpb->spf) {
925 printf(" bspf=%u rdcl=%u", bpb->bspf, bpb->rdcl);
927 printf(bpb->infs == MAXU16 ? "%#x" : "%u", bpb->infs);
929 printf(bpb->bkbs == MAXU16 ? "%#x" : "%u", bpb->bkbs);
