1 /* $NetBSD: mkfs_msdos.c,v 1.15 2019/10/12 09:42:38 martin Exp $ */
2
3 /*
4 * Copyright (c) 1998 Robert Nordier
5 * All rights reserved.
6 *
7 * Redistribution and use in source and binary forms, with or without
8 * modification, are permitted provided that the following conditions
9 * are met:
10 * 1. Redistributions of source code must retain the above copyright
11 * notice, this list of conditions and the following disclaimer.
12 * 2. Redistributions in binary form must reproduce the above copyright
13 * notice, this list of conditions and the following disclaimer in
14 * the documentation and/or other materials provided with the
15 * distribution.
16 *
17 * THIS SOFTWARE IS PROVIDED BY THE AUTHOR(S) ``AS IS'' AND ANY EXPRESS
18 * OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
19 * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
20 * ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR(S) BE LIABLE FOR ANY
21 * DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
22 * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE
23 * GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
24 * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER
25 * IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR
26 * OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN
27 * IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
28 */
29
30 #if HAVE_NBTOOL_CONFIG_H
31 #include "nbtool_config.h"
32 #endif
33
34 #include <sys/cdefs.h>
35 #ifndef lint
36 #if 0
37 static const char rcsid[] =
38 "$FreeBSD: src/sbin/newfs_msdos/newfs_msdos.c,v 1.15 2000/10/10 01:49:37 wollman Exp $";
39 #else
40 __RCSID("$NetBSD: mkfs_msdos.c,v 1.15 2019/10/12 09:42:38 martin Exp $");
41 #endif
42 #endif /* not lint */
43
44 #include <sys/types.h>
45 #include <sys/param.h>
46 #include <sys/stat.h>
47 #include <sys/time.h>
48 #ifndef MAKEFS
49 #include <sys/mount.h>
50 #include <sys/disk.h>
51 #endif
52
53 #include <ctype.h>
54 #include <err.h>
55 #include <errno.h>
56 #include <fcntl.h>
57 #include <paths.h>
58 #include <stdio.h>
59 #include <stdlib.h>
60 #include <string.h>
61 #include <time.h>
62 #include <unistd.h>
63 #include <signal.h>
64
65 #include <util.h>
66 #include <disktab.h>
67
68 #ifndef MAKEFS
69 #include "partutil.h"
70 #endif
71 #include "mkfs_msdos.h"
72
73 #define MAXU16 0xffff /* maximum unsigned 16-bit quantity */
74 #define BPN 4 /* bits per nibble */
75 #define NPB 2 /* nibbles per byte */
76
77 #define DOSMAGIC 0xaa55 /* DOS magic number */
78 #define MINBPS 512 /* minimum bytes per sector */
79 #define MAXSPC 128 /* maximum sectors per cluster */
80 #define MAXNFT 16 /* maximum number of FATs */
81 #define DEFBLK 4096 /* default block size */
82 #define DEFBLK16 2048 /* default block size FAT16 */
83 #define DEFRDE 512 /* default root directory entries */
84 #define RESFTE 2 /* reserved FAT entries */
85 #define MINCLS12 1 /* minimum FAT12 clusters */
86 #define MINCLS16 0xff5 /* minimum FAT16 clusters */
87 #define MINCLS32 0xfff5 /* minimum FAT32 clusters */
88 #define MAXCLS12 0xff4 /* maximum FAT12 clusters */
89 #define MAXCLS16 0xfff4 /* maximum FAT16 clusters */
90 #define MAXCLS32 0xffffff4 /* maximum FAT32 clusters */
91
92 #define mincls(fat_type) ((fat_type) == 12 ? MINCLS12 : \
93 (fat_type) == 16 ? MINCLS16 : \
94 MINCLS32)
95
96 #define maxcls(fat_type) ((fat_type) == 12 ? MAXCLS12 : \
97 (fat_type) == 16 ? MAXCLS16 : \
98 MAXCLS32)
99
100 #define mk1(p, x) \
101 (p) = (u_int8_t)(x)
102
103 #define mk2(p, x) \
104 (p)[0] = (u_int8_t)(x), \
105 (p)[1] = (u_int8_t)((x) >> 010)
106
107 #define mk4(p, x) \
108 (p)[0] = (u_int8_t)(x), \
109 (p)[1] = (u_int8_t)((x) >> 010), \
110 (p)[2] = (u_int8_t)((x) >> 020), \
111 (p)[3] = (u_int8_t)((x) >> 030)
112
113 struct bs {
114 u_int8_t jmp[3]; /* bootstrap entry point */
115 u_int8_t oem[8]; /* OEM name and version */
116 };
117
118 struct bsbpb {
119 u_int8_t bps[2]; /* bytes per sector */
120 u_int8_t spc; /* sectors per cluster */
121 u_int8_t res[2]; /* reserved sectors */
122 u_int8_t nft; /* number of FATs */
123 u_int8_t rde[2]; /* root directory entries */
124 u_int8_t sec[2]; /* total sectors */
125 u_int8_t mid; /* media descriptor */
126 u_int8_t spf[2]; /* sectors per FAT */
127 u_int8_t spt[2]; /* sectors per track */
128 u_int8_t hds[2]; /* drive heads */
129 u_int8_t hid[4]; /* hidden sectors */
130 u_int8_t bsec[4]; /* big total sectors */
131 };
132
133 struct bsxbpb {
134 u_int8_t bspf[4]; /* big sectors per FAT */
135 u_int8_t xflg[2]; /* FAT control flags */
136 u_int8_t vers[2]; /* file system version */
137 u_int8_t rdcl[4]; /* root directory start cluster */
138 u_int8_t infs[2]; /* file system info sector */
139 u_int8_t bkbs[2]; /* backup boot sector */
140 u_int8_t rsvd[12]; /* reserved */
141 };
142
143 struct bsx {
144 u_int8_t drv; /* drive number */
145 u_int8_t rsvd; /* reserved */
146 u_int8_t sig; /* extended boot signature */
147 u_int8_t volid[4]; /* volume ID number */
148 u_int8_t label[11]; /* volume label */
149 u_int8_t type[8]; /* file system type */
150 };
151
152 struct de {
153 u_int8_t namext[11]; /* name and extension */
154 u_int8_t attr; /* attributes */
155 u_int8_t rsvd[10]; /* reserved */
156 u_int8_t time[2]; /* creation time */
157 u_int8_t date[2]; /* creation date */
158 u_int8_t clus[2]; /* starting cluster */
159 u_int8_t size[4]; /* size */
160 };
161
162 struct bpb {
163 u_int bps; /* bytes per sector */
164 u_int spc; /* sectors per cluster */
165 u_int res; /* reserved sectors */
166 u_int nft; /* number of FATs */
167 u_int rde; /* root directory entries */
168 u_int sec; /* total sectors */
169 u_int mid; /* media descriptor */
170 u_int spf; /* sectors per FAT */
171 u_int spt; /* sectors per track */
172 u_int hds; /* drive heads */
173 u_int hid; /* hidden sectors */
174 u_int bsec; /* big total sectors */
175 u_int bspf; /* big sectors per FAT */
176 u_int rdcl; /* root directory start cluster */
177 u_int infs; /* file system info sector */
178 u_int bkbs; /* backup boot sector */
179 };
180
181 #define INIT(a, b, c, d, e, f, g, h, i, j) \
182 { .bps = a, .spc = b, .res = c, .nft = d, .rde = e, \
183 .sec = f, .mid = g, .spf = h, .spt = i, .hds = j, }
184 static struct {
185 const char *name;
186 struct bpb bpb;
187 } stdfmt[] = {
188 {"160", INIT(512, 1, 1, 2, 64, 320, 0xfe, 1, 8, 1)},
189 {"180", INIT(512, 1, 1, 2, 64, 360, 0xfc, 2, 9, 1)},
190 {"320", INIT(512, 2, 1, 2, 112, 640, 0xff, 1, 8, 2)},
191 {"360", INIT(512, 2, 1, 2, 112, 720, 0xfd, 2, 9, 2)},
192 {"640", INIT(512, 2, 1, 2, 112, 1280, 0xfb, 2, 8, 2)},
193 {"720", INIT(512, 2, 1, 2, 112, 1440, 0xf9, 3, 9, 2)},
194 {"1200", INIT(512, 1, 1, 2, 224, 2400, 0xf9, 7, 15, 2)},
195 {"1232", INIT(1024,1, 1, 2, 192, 1232, 0xfe, 2, 8, 2)},
196 {"1440", INIT(512, 1, 1, 2, 224, 2880, 0xf0, 9, 18, 2)},
197 {"2880", INIT(512, 2, 1, 2, 240, 5760, 0xf0, 9, 36, 2)}
198 };
199
200 static u_int8_t bootcode[] = {
201 0xfa, /* cli */
202 0x31, 0xc0, /* xor ax,ax */
203 0x8e, 0xd0, /* mov ss,ax */
204 0xbc, 0x00, 0x7c, /* mov sp,7c00h */
205 0xfb, /* sti */
206 0x8e, 0xd8, /* mov ds,ax */
207 0xe8, 0x00, 0x00, /* call $ + 3 */
208 0x5e, /* pop si */
209 0x83, 0xc6, 0x19, /* add si,+19h */
210 0xbb, 0x07, 0x00, /* mov bx,0007h */
211 0xfc, /* cld */
212 0xac, /* lodsb */
213 0x84, 0xc0, /* test al,al */
214 0x74, 0x06, /* jz $ + 8 */
215 0xb4, 0x0e, /* mov ah,0eh */
216 0xcd, 0x10, /* int 10h */
217 0xeb, 0xf5, /* jmp $ - 9 */
218 0x30, 0xe4, /* xor ah,ah */
219 0xcd, 0x16, /* int 16h */
220 0xcd, 0x19, /* int 19h */
221 0x0d, 0x0a,
222 'N', 'o', 'n', '-', 's', 'y', 's', 't',
223 'e', 'm', ' ', 'd', 'i', 's', 'k',
224 0x0d, 0x0a,
225 'P', 'r', 'e', 's', 's', ' ', 'a', 'n',
226 'y', ' ', 'k', 'e', 'y', ' ', 't', 'o',
227 ' ', 'r', 'e', 'b', 'o', 'o', 't',
228 0x0d, 0x0a,
229 0
230 };
231
232 static int got_siginfo = 0; /* received a SIGINFO */
233
234 #ifndef MAKEFS
235 static int check_mounted(const char *, mode_t);
236 #endif
237 static int getstdfmt(const char *, struct bpb *);
238 static int getbpbinfo(int, const char *, const char *, int, struct bpb *, off_t);
239 static void print_bpb(struct bpb *);
240 static int ckgeom(const char *, u_int, const char *);
241 static int oklabel(const char *);
242 static void mklabel(u_int8_t *, const char *);
243 static void setstr(u_int8_t *, const char *, size_t);
244 static void infohandler(int sig);
245
246 int
mkfs_msdos(const char * fname,const char * dtype,const struct msdos_options * op)247 mkfs_msdos(const char *fname, const char *dtype, const struct msdos_options *op)
248 {
249 char buf[MAXPATHLEN];
250 struct stat sb;
251 struct timeval tv;
252 struct bpb bpb;
253 struct tm *tm;
254 struct bs *bs;
255 struct bsbpb *bsbpb;
256 struct bsxbpb *bsxbpb;
257 struct bsx *bsx;
258 struct de *de;
259 u_int8_t *img;
260 const char *bname;
261 ssize_t n;
262 time_t now;
263 u_int bss, rds, cls, dir, lsn, x, x1, x2;
264 int ch, fd, fd1;
265 struct msdos_options o = *op;
266 int oflags = O_RDWR | O_CREAT;
267 bool bspf_is_calculated;
268
269 again:
270 bspf_is_calculated = false;
271 if (o.block_size && o.sectors_per_cluster) {
272 warnx("Cannot specify both block size and sectors per cluster");
273 return -1;
274 }
275 if (o.OEM_string && strlen(o.OEM_string) > 8) {
276 warnx("%s: bad OEM string", o.OEM_string);
277 return -1;
278 }
279 if (o.create_size) {
280 if (o.no_create) {
281 warnx("create (-C) is incompatible with -N");
282 return -1;
283 }
284 if (o.offset == 0)
285 oflags |= O_TRUNC;
286 fd = open(fname, oflags, 0644);
287 if (fd == -1) {
288 warnx("failed to create %s", fname);
289 return -1;
290 }
291 (void)lseek(fd, o.create_size - 1, SEEK_SET);
292 if (write(fd, "\0", 1) != 1) {
293 warn("failed to set file size");
294 return -1;
295 }
296 (void)lseek(fd, 0, SEEK_SET);
297 } else if ((fd = open(fname, o.no_create ? O_RDONLY : O_RDWR)) == -1 ||
298 fstat(fd, &sb)) {
299 warn("%s", fname);
300 return -1;
301 }
302 #ifndef MAKEFS
303 if (!o.no_create)
304 if (check_mounted(fname, sb.st_mode) == -1)
305 return -1;
306 #endif
307 if (!S_ISCHR(sb.st_mode) && !o.create_size) {
308 warnx("warning, %s is not a character device", fname);
309 return -1;
310 }
311 if (o.offset && o.offset != lseek(fd, o.offset, SEEK_SET)) {
312 warnx("cannot seek to %jd", (intmax_t)o.offset);
313 return -1;
314 }
315 memset(&bpb, 0, sizeof(bpb));
316 if (o.floppy) {
317 if (getstdfmt(o.floppy, &bpb) == -1)
318 return -1;
319 bpb.bsec = bpb.sec;
320 bpb.sec = 0;
321 bpb.bspf = bpb.spf;
322 bpb.spf = 0;
323 }
324 if (o.drive_heads)
325 bpb.hds = o.drive_heads;
326 if (o.sectors_per_track)
327 bpb.spt = o.sectors_per_track;
328 if (o.bytes_per_sector)
329 bpb.bps = o.bytes_per_sector;
330 if (o.size)
331 bpb.bsec = o.size;
332 if (o.hidden_sectors_set)
333 bpb.hid = o.hidden_sectors;
334 if (!(o.floppy || (o.drive_heads && o.sectors_per_track &&
335 o.bytes_per_sector && o.size && o.hidden_sectors_set))) {
336 if (getbpbinfo(fd, fname, dtype, o.hidden_sectors_set, &bpb,
337 o.create_size) == -1)
338 return -1;
339 bpb.bsec -= (o.offset / bpb.bps);
340 if (bpb.spc == 0) { /* set defaults */
341 /* minimum cluster size */
342 switch (o.fat_type) {
343 case 12:
344 bpb.spc = 1; /* use 512 bytes */
345 x = 2; /* up to 2MB */
346 break;
347 case 16:
348 bpb.spc = 1; /* use 512 bytes */
349 x = 32; /* up to 32MB */
350 break;
351 default:
352 bpb.spc = 8; /* use 4k */
353 x = 8192; /* up to 8GB */
354 break;
355 }
356 x1 = howmany(bpb.bsec, (1048576 / 512)); /* -> MB */
357 while (bpb.spc < 128 && x < x1) {
358 x *= 2;
359 bpb.spc *= 2;
360 }
361 }
362 }
363
364 if (o.volume_label && !oklabel(o.volume_label)) {
365 warnx("%s: bad volume label", o.volume_label);
366 return -1;
367 }
368
369 switch (o.fat_type) {
370 case 0:
371 if (o.floppy)
372 o.fat_type = 12;
373 else if (!o.directory_entries && (o.info_sector || o.backup_sector))
374 o.fat_type = 32;
375 break;
376 case 12:
377 case 16:
378 if (o.info_sector) {
379 warnx("Cannot specify info sector with FAT%u", o.fat_type);
380 return -1;
381 }
382 if (o.backup_sector) {
383 warnx("Cannot specify backup sector with FAT%u", o.fat_type);
384 return -1;
385 }
386 break;
387 case 32:
388 if (o.directory_entries) {
389 warnx("Cannot specify directory entries with FAT32");
390 return -1;
391 }
392 break;
393 default:
394 warnx("%d: bad FAT type", o.fat_type);
395 return -1;
396 }
397 if (!powerof2(bpb.bps)) {
398 warnx("bytes/sector (%u) is not a power of 2", bpb.bps);
399 return -1;
400 }
401 if (bpb.bps < MINBPS) {
402 warnx("bytes/sector (%u) is too small; minimum is %u",
403 bpb.bps, MINBPS);
404 return -1;
405 }
406
407 if (o.floppy && o.fat_type == 32)
408 bpb.rde = 0;
409 if (o.block_size) {
410 if (!powerof2(o.block_size)) {
411 warnx("block size (%u) is not a power of 2", o.block_size);
412 return -1;
413 }
414 if (o.block_size < bpb.bps) {
415 warnx("block size (%u) is too small; minimum is %u",
416 o.block_size, bpb.bps);
417 return -1;
418 }
419 if (o.block_size > bpb.bps * MAXSPC) {
420 warnx("block size (%u) is too large; maximum is %u",
421 o.block_size, bpb.bps * MAXSPC);
422 return -1;
423 }
424 bpb.spc = o.block_size / bpb.bps;
425 }
426 if (o.sectors_per_cluster) {
427 if (!powerof2(o.sectors_per_cluster)) {
428 warnx("sectors/cluster (%u) is not a power of 2",
429 o.sectors_per_cluster);
430 return -1;
431 }
432 bpb.spc = o.sectors_per_cluster;
433 }
434 if (o.reserved_sectors)
435 bpb.res = o.reserved_sectors;
436 if (o.num_FAT) {
437 if (o.num_FAT > MAXNFT) {
438 warnx("number of FATs (%u) is too large; maximum is %u",
439 o.num_FAT, MAXNFT);
440 return -1;
441 }
442 bpb.nft = o.num_FAT;
443 }
444 if (o.directory_entries)
445 bpb.rde = o.directory_entries;
446 if (o.media_descriptor_set) {
447 if (o.media_descriptor < 0xf0) {
448 warnx("illegal media descriptor (%#x)", o.media_descriptor);
449 return -1;
450 }
451 bpb.mid = o.media_descriptor;
452 }
453 if (o.sectors_per_fat)
454 bpb.bspf = o.sectors_per_fat;
455 if (o.info_sector)
456 bpb.infs = o.info_sector;
457 if (o.backup_sector)
458 bpb.bkbs = o.backup_sector;
459 bss = 1;
460 bname = NULL;
461 fd1 = -1;
462 if (o.bootstrap) {
463 bname = o.bootstrap;
464 if (!strchr(bname, '/')) {
465 snprintf(buf, sizeof(buf), "/boot/%s", bname);
466 if (!(bname = strdup(buf))) {
467 warn(NULL);
468 return -1;
469 }
470 }
471 if ((fd1 = open(bname, O_RDONLY)) == -1 || fstat(fd1, &sb)) {
472 warn("%s", bname);
473 return -1;
474 }
475 if (!S_ISREG(sb.st_mode) || sb.st_size % bpb.bps ||
476 sb.st_size < bpb.bps || sb.st_size > bpb.bps * MAXU16) {
477 warnx("%s: inappropriate file type or format", bname);
478 return -1;
479 }
480 bss = sb.st_size / bpb.bps;
481 }
482 if (!bpb.nft)
483 bpb.nft = 2;
484 if (!o.fat_type) {
485 if (bpb.bsec < (bpb.res ? bpb.res : bss) +
486 howmany((RESFTE + (bpb.spc ? MINCLS16 : MAXCLS12 + 1)) *
487 ((bpb.spc ? 16 : 12) / BPN), bpb.bps * NPB) *
488 bpb.nft +
489 howmany(bpb.rde ? bpb.rde : DEFRDE,
490 bpb.bps / sizeof(struct de)) +
491 (bpb.spc ? MINCLS16 : MAXCLS12 + 1) *
492 (bpb.spc ? bpb.spc : howmany(DEFBLK, bpb.bps)))
493 o.fat_type = 12;
494 else if (bpb.rde || bpb.bsec <
495 (bpb.res ? bpb.res : bss) +
496 howmany((RESFTE + MAXCLS16) * 2, bpb.bps) * bpb.nft +
497 howmany(DEFRDE, bpb.bps / sizeof(struct de)) +
498 (MAXCLS16 + 1) *
499 (bpb.spc ? bpb.spc : howmany(8192, bpb.bps)))
500 o.fat_type = 16;
501 else
502 o.fat_type = 32;
503 }
504 x = bss;
505 if (o.fat_type == 32) {
506 if (!bpb.infs) {
507 if (x == MAXU16 || x == bpb.bkbs) {
508 warnx("no room for info sector");
509 return -1;
510 }
511 bpb.infs = x;
512 }
513 if (bpb.infs != MAXU16 && x <= bpb.infs)
514 x = bpb.infs + 1;
515 if (!bpb.bkbs) {
516 if (x == MAXU16) {
517 warnx("no room for backup sector");
518 return -1;
519 }
520 bpb.bkbs = x;
521 } else if (bpb.bkbs != MAXU16 && bpb.bkbs == bpb.infs) {
522 warnx("backup sector would overwrite info sector");
523 return -1;
524 }
525 if (bpb.bkbs != MAXU16 && x <= bpb.bkbs)
526 x = bpb.bkbs + 1;
527 }
528 if (!bpb.res)
529 bpb.res = o.fat_type == 32 ? MAX(x, MAX(16384 / bpb.bps, 4)) : x;
530 else if (bpb.res < x) {
531 warnx("too few reserved sectors (need %d have %d)", x, bpb.res);
532 return -1;
533 }
534 if (o.fat_type != 32 && !bpb.rde)
535 bpb.rde = DEFRDE;
536 rds = howmany(bpb.rde, bpb.bps / sizeof(struct de));
537 if (!bpb.spc)
538 for (bpb.spc = howmany(o.fat_type == 16 ? DEFBLK16 : DEFBLK, bpb.bps);
539 bpb.spc < MAXSPC &&
540 bpb.res +
541 howmany((RESFTE + maxcls(o.fat_type)) * (o.fat_type / BPN),
542 bpb.bps * NPB) * bpb.nft +
543 rds +
544 (u_int64_t)(maxcls(o.fat_type) + 1) * bpb.spc <= bpb.bsec;
545 bpb.spc <<= 1);
546 if (o.fat_type != 32 && bpb.bspf > MAXU16) {
547 warnx("too many sectors/FAT for FAT12/16");
548 return -1;
549 }
550 x1 = bpb.res + rds;
551 x = bpb.bspf ? bpb.bspf : 1;
552 if (x1 + (u_int64_t)x * bpb.nft > bpb.bsec) {
553 warnx("meta data exceeds file system size");
554 return -1;
555 }
556 x1 += x * bpb.nft;
557 x = (u_int64_t)(bpb.bsec - x1) * bpb.bps * NPB /
558 (bpb.spc * bpb.bps * NPB + o.fat_type / BPN * bpb.nft);
559 x2 = howmany((RESFTE + MIN(x, maxcls(o.fat_type))) * (o.fat_type / BPN),
560 bpb.bps * NPB);
561 if (!bpb.bspf) {
562 bspf_is_calculated = true;
563 bpb.bspf = x2;
564 x1 += (bpb.bspf - 1) * bpb.nft;
565 }
566 cls = (bpb.bsec - x1) / bpb.spc;
567 x = (u_int64_t)bpb.bspf * bpb.bps * NPB / (o.fat_type / BPN) - RESFTE;
568 if (cls > x)
569 cls = x;
570 if (bpb.bspf < x2) {
571 warnx("warning: sectors/FAT limits file system to %u clusters",
572 cls);
573 return -1;
574 }
575 if (cls < mincls(o.fat_type)) {
576 if (bspf_is_calculated && o.sectors_per_cluster == 0 && bpb.spc > 2) {
577 /* retry with smaller cluster size */
578 o.sectors_per_cluster = 2;
579 goto again;
580 }
581 warnx("%u clusters too few clusters for FAT%u, need %u", cls,
582 o.fat_type, mincls(o.fat_type));
583 return -1;
584 }
585 if (cls > maxcls(o.fat_type)) {
586 cls = maxcls(o.fat_type);
587 bpb.bsec = x1 + (cls + 1) * bpb.spc - 1;
588 warnx("warning: FAT type limits file system to %u sectors",
589 bpb.bsec);
590 return -1;
591 }
592 printf("%s: %u sector%s in %u FAT%u cluster%s "
593 "(%u bytes/cluster)\n", fname, cls * bpb.spc,
594 cls * bpb.spc == 1 ? "" : "s", cls, o.fat_type,
595 cls == 1 ? "" : "s", bpb.bps * bpb.spc);
596 if (!bpb.mid)
597 bpb.mid = !bpb.hid ? 0xf0 : 0xf8;
598 if (o.fat_type == 32)
599 bpb.rdcl = RESFTE;
600 if (bpb.hid + bpb.bsec <= MAXU16) {
601 bpb.sec = bpb.bsec;
602 bpb.bsec = 0;
603 }
604 if (o.fat_type != 32) {
605 bpb.spf = bpb.bspf;
606 bpb.bspf = 0;
607 }
608 ch = 0;
609 if (o.fat_type == 12)
610 ch = 1; /* 001 Primary DOS with 12 bit FAT */
611 else if (o.fat_type == 16) {
612 if (bpb.bsec == 0)
613 ch = 4; /* 004 Primary DOS with 16 bit FAT <32M */
614 else
615 ch = 6; /* 006 Primary 'big' DOS, 16-bit FAT (> 32MB) */
616 /*
617 * XXX: what about:
618 * 014 DOS (16-bit FAT) - LBA
619 * ?
620 */
621 } else if (o.fat_type == 32) {
622 ch = 11; /* 011 Primary DOS with 32 bit FAT */
623 /*
624 * XXX: what about:
625 * 012 Primary DOS with 32 bit FAT - LBA
626 * ?
627 */
628 }
629 if (ch != 0)
630 printf("MBR type: %d\n", ch);
631 print_bpb(&bpb);
632 if (!o.no_create) {
633 if (o.timestamp_set) {
634 tv.tv_sec = now = o.timestamp;
635 tv.tv_usec = 0;
636 tm = gmtime(&now);
637 } else {
638 gettimeofday(&tv, NULL);
639 now = tv.tv_sec;
640 tm = localtime(&now);
641 }
642 if (!(img = malloc(bpb.bps)))
643 err(1, NULL);
644 dir = bpb.res + (bpb.spf ? bpb.spf : bpb.bspf) * bpb.nft;
645 #ifdef SIGINFO
646 signal(SIGINFO, infohandler);
647 #endif
648 for (lsn = 0; lsn < dir + (o.fat_type == 32 ? bpb.spc : rds); lsn++) {
649 if (got_siginfo) {
650 fprintf(stderr,"%s: writing sector %u of %u (%u%%)\n",
651 fname,lsn,(dir + (o.fat_type == 32 ? bpb.spc : rds)),
652 (lsn*100)/(dir + (o.fat_type == 32 ? bpb.spc : rds)));
653 got_siginfo = 0;
654 }
655 x = lsn;
656 if (o.bootstrap &&
657 o.fat_type == 32 && bpb.bkbs != MAXU16 &&
658 bss <= bpb.bkbs && x >= bpb.bkbs) {
659 x -= bpb.bkbs;
660 if (!x && lseek(fd1, o.offset, SEEK_SET)) {
661 warn("%s", bname);
662 return -1;
663 }
664 }
665 if (o.bootstrap && x < bss) {
666 if ((n = read(fd1, img, bpb.bps)) == -1) {
667 warn("%s", bname);
668 return -1;
669 }
670 if ((size_t)n != bpb.bps) {
671 warnx("%s: can't read sector %u", bname, x);
672 return -1;
673 }
674 } else
675 memset(img, 0, bpb.bps);
676 if (!lsn ||
677 (o.fat_type == 32 && bpb.bkbs != MAXU16 && lsn == bpb.bkbs)) {
678 x1 = sizeof(struct bs);
679 bsbpb = (struct bsbpb *)(img + x1);
680 mk2(bsbpb->bps, bpb.bps);
681 mk1(bsbpb->spc, bpb.spc);
682 mk2(bsbpb->res, bpb.res);
683 mk1(bsbpb->nft, bpb.nft);
684 mk2(bsbpb->rde, bpb.rde);
685 mk2(bsbpb->sec, bpb.sec);
686 mk1(bsbpb->mid, bpb.mid);
687 mk2(bsbpb->spf, bpb.spf);
688 mk2(bsbpb->spt, bpb.spt);
689 mk2(bsbpb->hds, bpb.hds);
690 mk4(bsbpb->hid, bpb.hid);
691 mk4(bsbpb->bsec, bpb.bsec);
692 x1 += sizeof(struct bsbpb);
693 if (o.fat_type == 32) {
694 bsxbpb = (struct bsxbpb *)(img + x1);
695 mk4(bsxbpb->bspf, bpb.bspf);
696 mk2(bsxbpb->xflg, 0);
697 mk2(bsxbpb->vers, 0);
698 mk4(bsxbpb->rdcl, bpb.rdcl);
699 mk2(bsxbpb->infs, bpb.infs);
700 mk2(bsxbpb->bkbs, bpb.bkbs);
701 x1 += sizeof(struct bsxbpb);
702 }
703 bsx = (struct bsx *)(img + x1);
704 mk1(bsx->sig, 0x29);
705 if (o.volume_id_set)
706 x = o.volume_id;
707 else
708 x = (((u_int)(1 + tm->tm_mon) << 8 |
709 (u_int)tm->tm_mday) +
710 ((u_int)tm->tm_sec << 8 |
711 (u_int)(tv.tv_usec / 10))) << 16 |
712 ((u_int)(1900 + tm->tm_year) +
713 ((u_int)tm->tm_hour << 8 |
714 (u_int)tm->tm_min));
715 mk4(bsx->volid, x);
716 mklabel(bsx->label, o.volume_label ? o.volume_label : "NO NAME");
717 snprintf(buf, sizeof(buf), "FAT%u", o.fat_type);
718 setstr(bsx->type, buf, sizeof(bsx->type));
719 if (!o.bootstrap) {
720 x1 += sizeof(struct bsx);
721 bs = (struct bs *)img;
722 mk1(bs->jmp[0], 0xeb);
723 mk1(bs->jmp[1], x1 - 2);
724 mk1(bs->jmp[2], 0x90);
725 setstr(bs->oem, o.OEM_string ? o.OEM_string : "NetBSD",
726 sizeof(bs->oem));
727 memcpy(img + x1, bootcode, sizeof(bootcode));
728 mk2(img + MINBPS - 2, DOSMAGIC);
729 }
730 } else if (o.fat_type == 32 && bpb.infs != MAXU16 &&
731 (lsn == bpb.infs ||
732 (bpb.bkbs != MAXU16 &&
733 lsn == bpb.bkbs + bpb.infs))) {
734 mk4(img, 0x41615252);
735 mk4(img + MINBPS - 28, 0x61417272);
736 mk4(img + MINBPS - 24, 0xffffffff);
737 mk4(img + MINBPS - 20, 0xffffffff);
738 mk2(img + MINBPS - 2, DOSMAGIC);
739 } else if (lsn >= bpb.res && lsn < dir &&
740 !((lsn - bpb.res) %
741 (bpb.spf ? bpb.spf : bpb.bspf))) {
742 mk1(img[0], bpb.mid);
743 for (x = 1; x < o.fat_type * (o.fat_type == 32 ? 3U : 2U) / 8U; x++)
744 mk1(img[x], o.fat_type == 32 && x % 4 == 3 ? 0x0f : 0xff);
745 } else if (lsn == dir && o.volume_label) {
746 de = (struct de *)img;
747 mklabel(de->namext, o.volume_label);
748 mk1(de->attr, 050);
749 x = (u_int)tm->tm_hour << 11 |
750 (u_int)tm->tm_min << 5 |
751 (u_int)tm->tm_sec >> 1;
752 mk2(de->time, x);
753 x = (u_int)(tm->tm_year - 80) << 9 |
754 (u_int)(tm->tm_mon + 1) << 5 |
755 (u_int)tm->tm_mday;
756 mk2(de->date, x);
757 }
758 if ((n = write(fd, img, bpb.bps)) == -1) {
759 warn("%s", fname);
760 return -1;
761 }
762 if ((size_t)n != bpb.bps) {
763 warnx("%s: can't write sector %u", fname, lsn);
764 return -1;
765 }
766 }
767 }
768 return 0;
769 }
770
771 #ifndef MAKEFS
772 /*
773 * return -1 with error if file system is mounted.
774 */
775 static int
check_mounted(const char * fname,mode_t mode)776 check_mounted(const char *fname, mode_t mode)
777 {
778 struct statvfs *mp;
779 const char *s1, *s2;
780 size_t len;
781 int n, r;
782
783 if (!(n = getmntinfo(&mp, MNT_NOWAIT))) {
784 warn("getmntinfo");
785 return -1;
786 }
787 len = strlen(_PATH_DEV);
788 s1 = fname;
789 if (!strncmp(s1, _PATH_DEV, len))
790 s1 += len;
791 r = S_ISCHR(mode) && s1 != fname && *s1 == 'r';
792 for (; n--; mp++) {
793 s2 = mp->f_mntfromname;
794 if (!strncmp(s2, _PATH_DEV, len))
795 s2 += len;
796 if ((r && s2 != mp->f_mntfromname && !strcmp(s1 + 1, s2)) ||
797 !strcmp(s1, s2)) {
798 warnx("%s is mounted on %s", fname, mp->f_mntonname);
799 return -1;
800 }
801 }
802 return 0;
803 }
804 #endif
805
806 /*
807 * Get a standard format.
808 */
809 static int
getstdfmt(const char * fmt,struct bpb * bpb)810 getstdfmt(const char *fmt, struct bpb *bpb)
811 {
812 u_int x, i;
813
814 x = sizeof(stdfmt) / sizeof(stdfmt[0]);
815 for (i = 0; i < x && strcmp(fmt, stdfmt[i].name); i++);
816 if (i == x) {
817 warnx("%s: unknown standard format", fmt);
818 return -1;
819 }
820 *bpb = stdfmt[i].bpb;
821 return 0;
822 }
823
824 /*
825 * Get disk slice, partition, and geometry information.
826 */
827 static int
getbpbinfo(int fd,const char * fname,const char * dtype,int iflag,struct bpb * bpb,off_t create_size)828 getbpbinfo(int fd, const char *fname, const char *dtype, int iflag,
829 struct bpb *bpb, off_t create_size)
830 {
831 const char *s1, *s2;
832 int part;
833
834 part = -1;
835 s1 = fname;
836 if ((s2 = strrchr(s1, '/')))
837 s1 = s2 + 1;
838 for (s2 = s1; *s2 && !isdigit((unsigned char)*s2); s2++);
839 if (!*s2 || s2 == s1)
840 s2 = NULL;
841 else
842 while (isdigit((unsigned char)*++s2));
843 s1 = s2;
844
845 #ifndef MAKEFS
846 int maxpartitions = getmaxpartitions();
847 struct disk_geom geo;
848 struct dkwedge_info dkw;
849
850 // XXX: Does not work with wedges
851 if (s2 && *s2 >= 'a' && *s2 <= 'a' + maxpartitions - 1) {
852 part = *s2++ - 'a';
853 }
854 #endif
855
856 if (!(((part != -1) && ((!iflag && part != -1) || !bpb->bsec)) ||
857 !bpb->bps || !bpb->spt || !bpb->hds)) {
858 return 0;
859 }
860
861 u_int sector_size = 512;
862 u_int nsectors = 63;
863 u_int ntracks = 255;
864 u_int size;
865
866 if (create_size == 0) {
867 #ifndef MAKEFS
868 if (getdiskinfo(fname, fd, NULL, &geo, &dkw) != -1) {
869 sector_size = geo.dg_secsize;
870 nsectors = geo.dg_nsectors;
871 ntracks = geo.dg_ntracks;
872 size = dkw.dkw_size;
873 } else
874 #endif
875 {
876 struct stat st;
877
878 if (fstat(fd, &st) == -1) {
879 warnx("Can't get disk size for `%s'", fname);
880 return -1;
881 }
882 size = st.st_size / sector_size;
883 }
884 } else {
885 size = create_size / sector_size;
886 }
887
888 if (!bpb->bps) {
889 if (ckgeom(fname, sector_size, "bytes/sector") == -1)
890 return -1;
891 bpb->bps = sector_size;
892 }
893
894 if (nsectors > 63) {
895 /*
896 * The kernel doesn't accept BPB with spt > 63.
897 * (see sys/fs/msdosfs/msdosfs_vfsops.c:msdosfs_mountfs())
898 * If values taken from disklabel don't match these
899 * restrictions, use popular BIOS default values instead.
900 */
901 nsectors = 63;
902 }
903 if (!bpb->spt) {
904 if (ckgeom(fname, nsectors, "sectors/track") == -1)
905 return -1;
906 bpb->spt = nsectors;
907 }
908 if (!bpb->hds) {
909 if (ckgeom(fname, ntracks, "drive heads") == -1)
910 return -1;
911 bpb->hds = ntracks;
912 }
913 if (!bpb->bsec)
914 bpb->bsec = size;
915
916 return 0;
917 }
918
919 /*
920 * Print out BPB values.
921 */
922 static void
print_bpb(struct bpb * bpb)923 print_bpb(struct bpb *bpb)
924 {
925 printf("bps=%u spc=%u res=%u nft=%u", bpb->bps, bpb->spc, bpb->res,
926 bpb->nft);
927 if (bpb->rde)
928 printf(" rde=%u", bpb->rde);
929 if (bpb->sec)
930 printf(" sec=%u", bpb->sec);
931 printf(" mid=%#x", bpb->mid);
932 if (bpb->spf)
933 printf(" spf=%u", bpb->spf);
934 printf(" spt=%u hds=%u hid=%u", bpb->spt, bpb->hds, bpb->hid);
935 if (bpb->bsec)
936 printf(" bsec=%u", bpb->bsec);
937 if (!bpb->spf) {
938 printf(" bspf=%u rdcl=%u", bpb->bspf, bpb->rdcl);
939 printf(" infs=");
940 printf(bpb->infs == MAXU16 ? "%#x" : "%u", bpb->infs);
941 printf(" bkbs=");
942 printf(bpb->bkbs == MAXU16 ? "%#x" : "%u", bpb->bkbs);
943 }
944 printf("\n");
945 }
946
947 /*
948 * Check a disk geometry value.
949 */
950 static int
ckgeom(const char * fname,u_int val,const char * msg)951 ckgeom(const char *fname, u_int val, const char *msg)
952 {
953 if (!val) {
954 warnx("%s: no default %s", fname, msg);
955 return -1;
956 }
957 if (val > MAXU16) {
958 warnx("%s: illegal %s", fname, msg);
959 return -1;
960 }
961 return 0;
962 }
963 /*
964 * Check a volume label.
965 */
966 static int
oklabel(const char * src)967 oklabel(const char *src)
968 {
969 int c, i;
970
971 for (i = 0; i <= 11; i++) {
972 c = (u_char)*src++;
973 if (c < ' ' + !i || strchr("\"*+,./:;<=>?[\\]|", c))
974 break;
975 }
976 return i && !c;
977 }
978
979 /*
980 * Make a volume label.
981 */
982 static void
mklabel(u_int8_t * dest,const char * src)983 mklabel(u_int8_t *dest, const char *src)
984 {
985 int c, i;
986
987 for (i = 0; i < 11; i++) {
988 c = *src ? toupper((unsigned char)*src++) : ' ';
989 *dest++ = !i && c == '\xe5' ? 5 : c;
990 }
991 }
992
993 /*
994 * Copy string, padding with spaces.
995 */
996 static void
setstr(u_int8_t * dest,const char * src,size_t len)997 setstr(u_int8_t *dest, const char *src, size_t len)
998 {
999 while (len--)
1000 *dest++ = *src ? *src++ : ' ';
1001 }
1002
1003 static void
infohandler(int sig)1004 infohandler(int sig)
1005 {
1006 got_siginfo = 1;
1007 }
1008