hardenedbsd/HardenedBSD
1
0
Fork 0
mirror of https://git.hardenedbsd.org/hardenedbsd/HardenedBSD.git synced 2024-11-27 03:11:52 +01:00
Code Issues Actions Packages Projects Releases Wiki Activity

Many style fixes.

Browse Source 
Remove C99 initializers: they don't help in this case.
Set errno to 0 before strtoll() (from NetBSD).

PR:		151850
Suggested by:	bde
Approved by:	jhb (Mentor)
MFC after:	2 weeks
This commit is contained in:
Pedro F. Giffuni 2011-12-20 15:50:54 +00:00
parent 8f72e930c1
commit 1ac4aa743c
Notes: svn2git 2020-12-20 02:59:44 +00:00 
svn path=/head/; revision=228740
2 changed files with 97 additions and 77 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

36
sbin/newfs_msdos/newfs_msdos.8
View File

@ -180,27 +180,27 @@ For reference purposes, this structure is presented
below. below.
.Bd -literal .Bd -literal
struct bsbpb { struct bsbpb {
u_int16_t bps; /* [-S] bytes per sector */ u_int16_t bpbBytesPerSec; /* [-S] bytes per sector */
u_int8_t spc; /* [-c] sectors per cluster */ u_int8_t bpbSecPerClust; /* [-c] sectors per cluster */
u_int16_t res; /* [-r] reserved sectors */ u_int16_t bpbResSectors; /* [-r] reserved sectors */
u_int8_t nft; /* [-n] number of FATs */ u_int8_t bpbFATs; /* [-n] number of FATs */
u_int16_t rde; /* [-e] root directory entries */ u_int16_t bpbRootDirEnts; /* [-e] root directory entries */
u_int16_t sec; /* [-s] total sectors */ u_int16_t bpbSectors; /* [-s] total sectors */
u_int8_t mid; /* [-m] media descriptor */ u_int8_t bpbMedia; /* [-m] media descriptor */
u_int16_t spf; /* [-a] sectors per FAT */ u_int16_t bpbFATsecs; /* [-a] sectors per FAT */
u_int16_t spt; /* [-u] sectors per track */ u_int16_t bpbSecPerTrack; /* [-u] sectors per track */
u_int16_t hds; /* [-h] drive heads */ u_int16_t bpbHeads; /* [-h] drive heads */
u_int32_t hid; /* [-o] hidden sectors */ u_int32_t bpbHiddenSecs; /* [-o] hidden sectors */
u_int32_t bsec; /* [-s] big total sectors */ u_int32_t bpbHugeSectors; /* [-s] big total sectors */
}; };
/* FAT32 extensions */ /* FAT32 extensions */
struct bsxbpb { struct bsxbpb {
u_int32_t bspf; /* [-a] big sectors per FAT */ u_int32_t bpbBigFATsecs; /* [-a] big sectors per FAT */
u_int16_t xflg; /* control flags */ u_int16_t bpbExtFlags; /* control flags */
u_int16_t vers; /* file system version */ u_int16_t bpbFSVers; /* file system version */
u_int32_t rdcl; /* root directory start cluster */ u_int32_t bpbRootClust; /* root directory start cluster */
u_int16_t infs; /* [-i] file system info sector */ u_int16_t bpbFSInfo; /* [-i] file system info sector */
u_int16_t bkbs; /* [-k] backup boot sector */ u_int16_t bpbBackup; /* [-k] backup boot sector */
}; };
.Ed .Ed
.Sh LIMITATION .Sh LIMITATION

94
sbin/newfs_msdos/newfs_msdos.c
View File

@ -166,23 +166,20 @@ struct bpb {
#define BPBGAP 0, 0, 0, 0, 0, 0 #define BPBGAP 0, 0, 0, 0, 0, 0
#define INIT(a, b, c, d, e, f, g, h, i, j) \
{ .bpbBytesPerSec = a, .bpbSecPerClust = b, .bpbResSectors = c, .bpbFATs = d, .bpbRootDirEnts = e, \
.bpbSectors = f, .bpbMedia = g, .bpbFATsecs = h, .bpbSecPerTrack = i, .bpbHeads = j, }
static struct { static struct {
const char *name; const char *name;
struct bpb bpb; struct bpb bpb;
} const stdfmt[] = { } const stdfmt[] = {
{"160", INIT(512, 1, 1, 2, 64, 320, 0xfe, 1, 8, 1)}, {"160", {512, 1, 1, 2, 64, 320, 0xfe, 1, 8, 1, BPBGAP}},
{"180", INIT(512, 1, 1, 2, 64, 360, 0xfc, 2, 9, 1)}, {"180", {512, 1, 1, 2, 64, 360, 0xfc, 2, 9, 1, BPBGAP}},
{"320", INIT(512, 2, 1, 2, 112, 640, 0xff, 1, 8, 2)}, {"320", {512, 2, 1, 2, 112, 640, 0xff, 1, 8, 2, BPBGAP}},
{"360", INIT(512, 2, 1, 2, 112, 720, 0xfd, 2, 9, 2)}, {"360", {512, 2, 1, 2, 112, 720, 0xfd, 2, 9, 2, BPBGAP}},
{"640", INIT(512, 2, 1, 2, 112, 1280, 0xfb, 2, 8, 2)}, {"640", {512, 2, 1, 2, 112, 1280, 0xfb, 2, 8, 2, BPBGAP}},
{"720", INIT(512, 2, 1, 2, 112, 1440, 0xf9, 3, 9, 2)}, {"720", {512, 2, 1, 2, 112, 1440, 0xf9, 3, 9, 2, BPBGAP}},
{"1200", INIT(512, 1, 1, 2, 224, 2400, 0xf9, 7, 15, 2)}, {"1200", {512, 1, 1, 2, 224, 2400, 0xf9, 7, 15, 2, BPBGAP}},
{"1232", INIT(1024,1, 1, 2, 192, 1232, 0xfe, 2, 8, 2)}, {"1232", {1024,1, 1, 2, 192, 1232, 0xfe, 2, 8, 2, BPBGAP}},
{"1440", INIT(512, 1, 1, 2, 224, 2880, 0xf0, 9, 18, 2)}, {"1440", {512, 1, 1, 2, 224, 2880, 0xf0, 9, 18, 2, BPBGAP}},
{"2880", INIT(512, 2, 1, 2, 240, 5760, 0xf0, 9, 36, 2)} {"2880", {512, 2, 1, 2, 240, 5760, 0xf0, 9, 36, 2, BPBGAP}}
}; };
static const u_int8_t bootcode[] = { static const u_int8_t bootcode[] = {
@ -494,7 +491,8 @@ main(int argc, char *argv[])
if ((fd1 = open(bname, O_RDONLY)) == -1 || fstat(fd1, &sb)) if ((fd1 = open(bname, O_RDONLY)) == -1 || fstat(fd1, &sb))
err(1, "%s", bname); err(1, "%s", bname);
if (!S_ISREG(sb.st_mode) || sb.st_size % bpb.bpbBytesPerSec || if (!S_ISREG(sb.st_mode) || sb.st_size % bpb.bpbBytesPerSec ||
sb.st_size < bpb.bpbBytesPerSec || sb.st_size > bpb.bpbBytesPerSec * MAXU16) sb.st_size < bpb.bpbBytesPerSec ||
sb.st_size > bpb.bpbBytesPerSec * MAXU16)
errx(1, "%s: inappropriate file type or format", bname); errx(1, "%s: inappropriate file type or format", bname);
bss = sb.st_size / bpb.bpbBytesPerSec; bss = sb.st_size / bpb.bpbBytesPerSec;
} }
@ -503,19 +501,23 @@ main(int argc, char *argv[])
if (!fat) { if (!fat) {
if (bpb.bpbHugeSectors < (bpb.bpbResSectors ? bpb.bpbResSectors : bss) + if (bpb.bpbHugeSectors < (bpb.bpbResSectors ? bpb.bpbResSectors : bss) +
howmany((RESFTE + (bpb.bpbSecPerClust ? MINCLS16 : MAXCLS12 + 1)) * howmany((RESFTE + (bpb.bpbSecPerClust ? MINCLS16 : MAXCLS12 + 1)) *
((bpb.bpbSecPerClust ? 16 : 12) / BPN), bpb.bpbBytesPerSec * NPB) * (bpb.bpbSecPerClust ? 16 : 12) / BPN,
bpb.bpbBytesPerSec * NPB) *
bpb.bpbFATs + bpb.bpbFATs +
howmany(bpb.bpbRootDirEnts ? bpb.bpbRootDirEnts : DEFRDE, howmany(bpb.bpbRootDirEnts ? bpb.bpbRootDirEnts : DEFRDE,
bpb.bpbBytesPerSec / sizeof(struct de)) + bpb.bpbBytesPerSec / sizeof(struct de)) +
(bpb.bpbSecPerClust ? MINCLS16 : MAXCLS12 + 1) * (bpb.bpbSecPerClust ? MINCLS16 : MAXCLS12 + 1) *
(bpb.bpbSecPerClust ? bpb.bpbSecPerClust : howmany(DEFBLK, bpb.bpbBytesPerSec))) (bpb.bpbSecPerClust ? bpb.bpbSecPerClust :
howmany(DEFBLK, bpb.bpbBytesPerSec)))
fat = 12; fat = 12;
else if (bpb.bpbRootDirEnts || bpb.bpbHugeSectors < else if (bpb.bpbRootDirEnts || bpb.bpbHugeSectors <
(bpb.bpbResSectors ? bpb.bpbResSectors : bss) + (bpb.bpbResSectors ? bpb.bpbResSectors : bss) +
howmany((RESFTE + MAXCLS16) * 2, bpb.bpbBytesPerSec) * bpb.bpbFATs + howmany((RESFTE + MAXCLS16) * 2, bpb.bpbBytesPerSec) *
bpb.bpbFATs +
howmany(DEFRDE, bpb.bpbBytesPerSec / sizeof(struct de)) + howmany(DEFRDE, bpb.bpbBytesPerSec / sizeof(struct de)) +
(MAXCLS16 + 1) * (MAXCLS16 + 1) *
(bpb.bpbSecPerClust ? bpb.bpbSecPerClust : howmany(8192, bpb.bpbBytesPerSec))) (bpb.bpbSecPerClust ? bpb.bpbSecPerClust :
howmany(8192, bpb.bpbBytesPerSec)))
fat = 16; fat = 16;
else else
fat = 32; fat = 32;
@ -539,21 +541,27 @@ main(int argc, char *argv[])
x = bpb.bpbBackup + 1; x = bpb.bpbBackup + 1;
} }
if (!bpb.bpbResSectors) if (!bpb.bpbResSectors)
bpb.bpbResSectors = fat == 32 ? MAX(x, MAX(16384 / bpb.bpbBytesPerSec, 4)) : x; bpb.bpbResSectors = fat == 32 ?
MAX(x, MAX(16384 / bpb.bpbBytesPerSec, 4)) : x;
else if (bpb.bpbResSectors < x) else if (bpb.bpbResSectors < x)
errx(1, "too few reserved sectors (need %d have %d)", x, bpb.bpbResSectors); errx(1, "too few reserved sectors (need %d have %d)", x,
bpb.bpbResSectors);
if (fat != 32 && !bpb.bpbRootDirEnts) if (fat != 32 && !bpb.bpbRootDirEnts)
bpb.bpbRootDirEnts = DEFRDE; bpb.bpbRootDirEnts = DEFRDE;
rds = howmany(bpb.bpbRootDirEnts, bpb.bpbBytesPerSec / sizeof(struct de)); rds = howmany(bpb.bpbRootDirEnts, bpb.bpbBytesPerSec / sizeof(struct de));
if (!bpb.bpbSecPerClust) if (!bpb.bpbSecPerClust)
for (bpb.bpbSecPerClust = howmany(fat == 16 ? DEFBLK16 : DEFBLK, bpb.bpbBytesPerSec); for (bpb.bpbSecPerClust = howmany(fat == 16 ? DEFBLK16 :
DEFBLK, bpb.bpbBytesPerSec);
bpb.bpbSecPerClust < MAXSPC && bpb.bpbSecPerClust < MAXSPC &&
bpb.bpbResSectors + bpb.bpbResSectors +
howmany((RESFTE + maxcls(fat)) * (fat / BPN), howmany((RESFTE + maxcls(fat)) * (fat / BPN),
bpb.bpbBytesPerSec * NPB) * bpb.bpbFATs + bpb.bpbBytesPerSec * NPB) *
bpb.bpbFATs +
rds + rds +
(u_int64_t)(maxcls(fat) + 1) * bpb.bpbSecPerClust <= bpb.bpbHugeSectors; (u_int64_t) (maxcls(fat) + 1) *
bpb.bpbSecPerClust <<= 1); bpb.bpbSecPerClust <= bpb.bpbHugeSectors;
bpb.bpbSecPerClust <<= 1)
continue;
if (fat != 32 && bpb.bpbBigFATsecs > MAXU16) if (fat != 32 && bpb.bpbBigFATsecs > MAXU16)
errx(1, "too many sectors/FAT for FAT12/16"); errx(1, "too many sectors/FAT for FAT12/16");
x1 = bpb.bpbResSectors + rds; x1 = bpb.bpbResSectors + rds;
@ -562,7 +570,8 @@ main(int argc, char *argv[])
errx(1, "meta data exceeds file system size"); errx(1, "meta data exceeds file system size");
x1 += x * bpb.bpbFATs; x1 += x * bpb.bpbFATs;
x = (u_int64_t)(bpb.bpbHugeSectors - x1) * bpb.bpbBytesPerSec * NPB / x = (u_int64_t)(bpb.bpbHugeSectors - x1) * bpb.bpbBytesPerSec * NPB /
(bpb.bpbSecPerClust * bpb.bpbBytesPerSec * NPB + fat / BPN * bpb.bpbFATs); (bpb.bpbSecPerClust * bpb.bpbBytesPerSec * NPB + fat /
BPN * bpb.bpbFATs);
x2 = howmany((RESFTE + MIN(x, maxcls(fat))) * (fat / BPN), x2 = howmany((RESFTE + MIN(x, maxcls(fat))) * (fat / BPN),
bpb.bpbBytesPerSec * NPB); bpb.bpbBytesPerSec * NPB);
if (!bpb.bpbBigFATsecs) { if (!bpb.bpbBigFATsecs) {
@ -570,7 +579,8 @@ main(int argc, char *argv[])
x1 += (bpb.bpbBigFATsecs - 1) * bpb.bpbFATs; x1 += (bpb.bpbBigFATsecs - 1) * bpb.bpbFATs;
} }
cls = (bpb.bpbHugeSectors - x1) / bpb.bpbSecPerClust; cls = (bpb.bpbHugeSectors - x1) / bpb.bpbSecPerClust;
x = (u_int64_t)bpb.bpbBigFATsecs * bpb.bpbBytesPerSec * NPB / (fat / BPN) - RESFTE; x = (u_int64_t)bpb.bpbBigFATsecs * bpb.bpbBytesPerSec * NPB / (fat / BPN) -
RESFTE;
if (cls > x) if (cls > x)
cls = x; cls = x;
if (bpb.bpbBigFATsecs < x2) if (bpb.bpbBigFATsecs < x2)
@ -608,7 +618,8 @@ main(int argc, char *argv[])
tm = localtime(&now); tm = localtime(&now);
if (!(img = malloc(bpb.bpbBytesPerSec))) if (!(img = malloc(bpb.bpbBytesPerSec)))
err(1, NULL); err(1, NULL);
dir = bpb.bpbResSectors + (bpb.bpbFATsecs ? bpb.bpbFATsecs : bpb.bpbBigFATsecs) * bpb.bpbFATs; dir = bpb.bpbResSectors + (bpb.bpbFATsecs ? bpb.bpbFATsecs :
bpb.bpbBigFATsecs) * bpb.bpbFATs;
memset(&si_sa, 0, sizeof(si_sa)); memset(&si_sa, 0, sizeof(si_sa));
si_sa.sa_handler = infohandler; si_sa.sa_handler = infohandler;
if (sigaction(SIGINFO, &si_sa, NULL) == -1) if (sigaction(SIGINFO, &si_sa, NULL) == -1)
@ -638,7 +649,8 @@ main(int argc, char *argv[])
} else } else
memset(img, 0, bpb.bpbBytesPerSec); memset(img, 0, bpb.bpbBytesPerSec);
if (!lsn || if (!lsn ||
(fat == 32 && bpb.bpbBackup != MAXU16 && lsn == bpb.bpbBackup)) { (fat == 32 && bpb.bpbBackup != MAXU16 &&
lsn == bpb.bpbBackup)) {
x1 = sizeof(struct bs); x1 = sizeof(struct bs);
bsbpb = (struct bsbpb *)(img + x1); bsbpb = (struct bsbpb *)(img + x1);
mk2(bsbpb->bpbBytesPerSec, bpb.bpbBytesPerSec); mk2(bsbpb->bpbBytesPerSec, bpb.bpbBytesPerSec);
@ -702,7 +714,8 @@ main(int argc, char *argv[])
mk2(img + MINBPS - 2, DOSMAGIC); mk2(img + MINBPS - 2, DOSMAGIC);
} else if (lsn >= bpb.bpbResSectors && lsn < dir && } else if (lsn >= bpb.bpbResSectors && lsn < dir &&
!((lsn - bpb.bpbResSectors) % !((lsn - bpb.bpbResSectors) %
(bpb.bpbFATsecs ? bpb.bpbFATsecs : bpb.bpbBigFATsecs))) { (bpb.bpbFATsecs ? bpb.bpbFATsecs :
bpb.bpbBigFATsecs))) {
mk1(img[0], bpb.bpbMedia); mk1(img[0], bpb.bpbMedia);
for (x = 1; x < fat * (fat == 32 ? 3 : 2) / 8; x++) for (x = 1; x < fat * (fat == 32 ? 3 : 2) / 8; x++)
mk1(img[x], fat == 32 && x % 4 == 3 ? 0x0f : 0xff); mk1(img[x], fat == 32 && x % 4 == 3 ? 0x0f : 0xff);
@ -817,16 +830,19 @@ getdiskinfo(int fd, const char *fname, const char *dtype, __unused int oflag,
if (bpb->bpbBytesPerSec) if (bpb->bpbBytesPerSec)
dlp.d_secsize = bpb->bpbBytesPerSec; dlp.d_secsize = bpb->bpbBytesPerSec;
if (ioctl(fd, DIOCGDINFO, &dlp) == -1) { if (ioctl(fd, DIOCGDINFO, &dlp) == -1) {
if (bpb->bpbBytesPerSec == 0 && ioctl(fd, DIOCGSECTORSIZE, &dlp.d_secsize) == -1) if (bpb->bpbBytesPerSec == 0 && ioctl(fd, DIOCGSECTORSIZE,
&dlp.d_secsize) == -1)
errx(1, "Cannot get sector size, %s", strerror(errno)); errx(1, "Cannot get sector size, %s", strerror(errno));
dlp.d_secperunit = ms / dlp.d_secsize; dlp.d_secperunit = ms / dlp.d_secsize;
if (bpb->bpbSecPerTrack == 0 && ioctl(fd, DIOCGFWSECTORS, &dlp.d_nsectors) == -1) { if (bpb->bpbSecPerTrack == 0 && ioctl(fd, DIOCGFWSECTORS,
&dlp.d_nsectors) == -1) {
warnx("Cannot get number of sectors per track, %s", strerror(errno)); warnx("Cannot get number of sectors per track, %s", strerror(errno));
dlp.d_nsectors = 63; dlp.d_nsectors = 63;
} }
if (bpb->bpbHeads == 0 && ioctl(fd, DIOCGFWHEADS, &dlp.d_ntracks) == -1) { if (bpb->bpbHeads == 0 &&
ioctl(fd, DIOCGFWHEADS, &dlp.d_ntracks) == -1) {
warnx("Cannot get number of heads, %s", strerror(errno)); warnx("Cannot get number of heads, %s", strerror(errno));
if (dlp.d_secperunit <= 63*1*1024) if (dlp.d_secperunit <= 63*1*1024)
dlp.d_ntracks = 1; dlp.d_ntracks = 1;
@ -859,7 +875,8 @@ getdiskinfo(int fd, const char *fname, const char *dtype, __unused int oflag,
static void static void
print_bpb(struct bpb *bpb) print_bpb(struct bpb *bpb)
{ {
printf("BytesPerSec=%u SecPerClust=%u ResSectors=%u FATs=%u", bpb->bpbBytesPerSec, bpb->bpbSecPerClust, bpb->bpbResSectors, printf("BytesPerSec=%u SecPerClust=%u ResSectors=%u FATs=%u",
bpb->bpbBytesPerSec, bpb->bpbSecPerClust, bpb->bpbResSectors,
bpb->bpbFATs); bpb->bpbFATs);
if (bpb->bpbRootDirEnts) if (bpb->bpbRootDirEnts)
printf(" RootDirEnts=%u", bpb->bpbRootDirEnts); printf(" RootDirEnts=%u", bpb->bpbRootDirEnts);
@ -868,11 +885,13 @@ print_bpb(struct bpb *bpb)
printf(" Media=%#x", bpb->bpbMedia); printf(" Media=%#x", bpb->bpbMedia);
if (bpb->bpbFATsecs) if (bpb->bpbFATsecs)
printf(" FATsecs=%u", bpb->bpbFATsecs); printf(" FATsecs=%u", bpb->bpbFATsecs);
printf(" SecPerTrack=%u Heads=%u HiddenSecs=%u", bpb->bpbSecPerTrack, bpb->bpbHeads, bpb->bpbHiddenSecs); printf(" SecPerTrack=%u Heads=%u HiddenSecs=%u", bpb->bpbSecPerTrack,
bpb->bpbHeads, bpb->bpbHiddenSecs);
if (bpb->bpbHugeSectors) if (bpb->bpbHugeSectors)
printf(" HugeSectors=%u", bpb->bpbHugeSectors); printf(" HugeSectors=%u", bpb->bpbHugeSectors);
if (!bpb->bpbFATsecs) { if (!bpb->bpbFATsecs) {
printf(" FATsecs=%u RootCluster=%u", bpb->bpbBigFATsecs, bpb->bpbRootClust); printf(" FATsecs=%u RootCluster=%u", bpb->bpbBigFATsecs,
bpb->bpbRootClust);
printf(" FSInfo="); printf(" FSInfo=");
printf(bpb->bpbFSInfo == MAXU16 ? "%#x" : "%u", bpb->bpbFSInfo); printf(bpb->bpbFSInfo == MAXU16 ? "%#x" : "%u", bpb->bpbFSInfo);
printf(" Backup="); printf(" Backup=");
@ -919,6 +938,7 @@ argtooff(const char *arg, const char *msg)
char *s; char *s;
off_t x; off_t x;
errno = 0;
x = strtoll(arg, &s, 0); x = strtoll(arg, &s, 0);
/* allow at most one extra char */ /* allow at most one extra char */
if (errno || x < 0 || (s[0] && s[1]) ) if (errno || x < 0 || (s[0] && s[1]) )
@ -950,9 +970,9 @@ argtooff(const char *arg, const char *msg)
break; break;
case 'p': /* partition start */ case 'p': /* partition start */
case 'P': /* partition start */ case 'P':
case 'l': /* partition length */ case 'l': /* partition length */
case 'L': /* partition length */ case 'L':
errx(1, "%s: not supported yet %s", arg, msg); errx(1, "%s: not supported yet %s", arg, msg);
/* notreached */ /* notreached */
} }