util-linux/mkfs_vfat.c

   1 /* vi: set sw=4 ts=4: */
   2 /*
   3  * mkfs_vfat: utility to create FAT32 filesystem
   4  * inspired by dosfstools
   5  *
   6  * Busybox'ed (2009) by Vladimir Dronnikov <dronnikov@gmail.com>
   7  *
   8  * Licensed under GPLv2, see file LICENSE in this tarball for details.
   9  */
  10 #include "libbb.h"
  11 #include "volume_id/volume_id_internal.h"
  12
  13 #include <linux/hdreg.h> /* HDIO_GETGEO */
  14 #include <linux/fd.h>    /* FDGETPRM */
  15 //#include <linux/msdos_fs.h>
  16
  17 #define SECTOR_SIZE             512
  18
  19 #define SECTORS_PER_BLOCK       (BLOCK_SIZE / SECTOR_SIZE)
  20
  21 // M$ says the high 4 bits of a FAT32 FAT entry are reserved
  22 #define EOF_FAT32       0x0FFFFFF8
  23 #define BAD_FAT32       0x0FFFFFF7
  24 #define MAX_CLUST_32    0x0FFFFFF0
  25
  26 #define ATTR_VOLUME     8
  27
  28 #define NUM_FATS        2
  29
  30 /* FAT32 filesystem looks like this:
  31  * sector -nn...-1: "hidden" sectors, all sectors before this partition
  32  * (-h hidden-sectors sets it. Useful only for boot loaders,
  33  *  they need to know _disk_ offset in order to be able to correctly
  34  *  address sectors relative to start of disk)
  35  * sector 0: boot sector
  36  * sector 1: info sector
  37  * sector 2: set aside for boot code which didn't fit into sector 0
  38  * ...(zero-filled sectors)...
  39  * sector B: backup copy of sector 0 [B set by -b backup-boot-sector]
  40  * sector B+1: backup copy of sector 1
  41  * sector B+2: backup copy of sector 2
  42  * ...(zero-filled sectors)...
  43  * sector R: FAT#1 [R set by -R reserved-sectors]
  44  * ...(FAT#1)...
  45  * sector R+fat_size: FAT#2
  46  * ...(FAT#2)...
  47  * sector R+fat_size*2: cluster #2
  48  * ...(cluster #2)...
  49  * sector R+fat_size*2+clust_size: cluster #3
  50  * ...(the rest is filled by clusters till the end)...
  51  */
  52
  53 enum {
  54 // Perhaps this should remain constant
  55         info_sector_number = 1,
  56 // TODO: make these cmdline options
  57 // dont forget sanity check: backup_boot_sector + 3 <= reserved_sect
  58         backup_boot_sector = 3,
  59         reserved_sect      = 6,
  60 };
  61
  62 // how many blocks we try to read while testing
  63 #define TEST_BUFFER_BLOCKS      16
  64
  65 struct msdos_dir_entry {
  66         char     name[11];       /* 000 name and extension */
  67         uint8_t  attr;           /* 00b attribute bits */
  68         uint8_t  lcase;          /* 00c case for base and extension */
  69         uint8_t  ctime_cs;       /* 00d creation time, centiseconds (0-199) */
  70         uint16_t ctime;          /* 00e creation time */
  71         uint16_t cdate;          /* 010 creation date */
  72         uint16_t adate;          /* 012 last access date */
  73         uint16_t starthi;        /* 014 high 16 bits of cluster in FAT32 */
  74         uint16_t time;           /* 016 time */
  75         uint16_t date;           /* 018 date */
  76         uint16_t start;          /* 01a first cluster */
  77         uint32_t size;           /* 01c file size in bytes */
  78 } __attribute__ ((packed));
  79
  80 /* Example of boot sector's beginning:
  81 0000  eb 58 90 4d 53 57 49 4e  34 2e 31 00 02 08 26 00  |...MSWIN4.1...&.|
  82 0010  02 00 00 00 00 f8 00 00  3f 00 ff 00 3f 00 00 00  |........?...?...|
  83 0020  54 9b d0 00 0d 34 00 00  00 00 00 00 02 00 00 00  |T....4..........|
  84 0030  01 00 06 00 00 00 00 00  00 00 00 00 00 00 00 00  |................|
  85 0040  80 00 29 71 df 51 e0 4e  4f 20 4e 41 4d 45 20 20  |..)q.Q.NO NAME  |
  86 0050  20 20 46 41 54 33 32 20  20 20 33 c9 8e d1 bc f4  |  FAT32   3.....|
  87 */
  88 struct msdos_volume_info { /* (offsets are relative to start of boot sector) */
  89         uint8_t  drive_number;    /* 040 BIOS drive number */
  90         uint8_t  reserved;        /* 041 unused */
  91         uint8_t  ext_boot_sign;   /* 042 0x29 if fields below exist (DOS 3.3+) */
  92         uint32_t volume_id32;     /* 043 volume ID number */
  93         char     volume_label[11];/* 047 volume label */
  94         char     fs_type[8];      /* 052 typically "FATnn" */
  95 } __attribute__ ((packed));       /* 05a end. Total size 26 (0x1a) bytes */
  96
  97 struct msdos_boot_sector {
  98         char     boot_jump[3];       /* 000 short or near jump instruction */
  99         char     system_id[8];       /* 003 name - can be used to special case partition manager volumes */
 100         uint16_t bytes_per_sect;     /* 00b bytes per logical sector */
 101         uint8_t  sect_per_clust;     /* 00d sectors/cluster */
 102         uint16_t reserved_sect;      /* 00e reserved sectors (sector offset of 1st FAT relative to volume start) */
 103         uint8_t  fats;               /* 010 number of FATs */
 104         uint16_t dir_entries;        /* 011 root directory entries */
 105         uint16_t volume_size_sect;   /* 013 volume size in sectors */
 106         uint8_t  media_byte;         /* 015 media code */
 107         uint16_t sect_per_fat;       /* 016 sectors/FAT */
 108         uint16_t sect_per_track;     /* 018 sectors per track */
 109         uint16_t heads;              /* 01a number of heads */
 110         uint32_t hidden;             /* 01c hidden sectors (sector offset of volume within physical disk) */
 111         uint32_t fat32_volume_size_sect; /* 020 volume size in sectors (if volume_size_sect == 0) */
 112         uint32_t fat32_sect_per_fat; /* 024 sectors/FAT */
 113         uint16_t fat32_flags;        /* 028 bit 8: fat mirroring, low 4: active fat */
 114         uint8_t  fat32_version[2];   /* 02a major, minor filesystem version (I see 0,0) */
 115         uint32_t fat32_root_cluster; /* 02c first cluster in root directory */
 116         uint16_t fat32_info_sector;  /* 030 filesystem info sector (usually 1) */
 117         uint16_t fat32_backup_boot;  /* 032 backup boot sector (usually 6) */
 118         uint32_t reserved2[3];       /* 034 unused */
 119         struct msdos_volume_info vi; /* 040 */
 120         char     boot_code[0x200 - 0x5a - 2]; /* 05a */
 121 #define BOOT_SIGN 0xAA55
 122         uint16_t boot_sign;          /* 1fe */
 123 } __attribute__ ((packed));
 124
 125 #define FAT_FSINFO_SIG1 0x41615252
 126 #define FAT_FSINFO_SIG2 0x61417272
 127 struct fat32_fsinfo {
 128         uint32_t signature1;         /* 0x52,0x52,0x41,0x61, "RRaA" */
 129         uint32_t reserved1[128 - 8];
 130         uint32_t signature2;         /* 0x72,0x72,0x61,0x41, "rrAa" */
 131         uint32_t free_clusters;      /* free cluster count.  -1 if unknown */
 132         uint32_t next_cluster;       /* most recently allocated cluster */
 133         uint32_t reserved2[3];
 134         uint16_t reserved3;          /* 1fc */
 135         uint16_t boot_sign;          /* 1fe */
 136 } __attribute__ ((packed));
 137
 138 struct bug_check {
 139         char BUG1[sizeof(struct msdos_dir_entry  ) == 0x20 ? 1 : -1];
 140         char BUG2[sizeof(struct msdos_volume_info) == 0x1a ? 1 : -1];
 141         char BUG3[sizeof(struct msdos_boot_sector) == 0x200 ? 1 : -1];
 142         char BUG4[sizeof(struct fat32_fsinfo     ) == 0x200 ? 1 : -1];
 143 };
 144
 145 static const char boot_code[] ALIGN1 =
 146         "\x0e"          /* 05a:         push  cs */
 147         "\x1f"          /* 05b:         pop   ds */
 148         "\xbe\x77\x7c"  /*  write_msg:  mov   si, offset message_txt */
 149         "\xac"          /* 05f:         lodsb */
 150         "\x22\xc0"      /* 060:         and   al, al */
 151         "\x74\x0b"      /* 062:         jz    key_press */
 152         "\x56"          /* 064:         push  si */
 153         "\xb4\x0e"      /* 065:         mov   ah, 0eh */
 154         "\xbb\x07\x00"  /* 067:         mov   bx, 0007h */
 155         "\xcd\x10"      /* 06a:         int   10h */
 156         "\x5e"          /* 06c:         pop   si */
 157         "\xeb\xf0"      /* 06d:         jmp   write_msg */
 158         "\x32\xe4"      /*  key_press:  xor   ah, ah */
 159         "\xcd\x16"      /* 071:         int   16h */
 160         "\xcd\x19"      /* 073:         int   19h */
 161         "\xeb\xfe"      /*  foo:        jmp   foo */
 162         /* 077: message_txt: */
 163         "This is not a bootable disk\r\n";
 164
 165
 166 #define MARK_CLUSTER(cluster, value) \
 167         ((uint32_t *)fat)[cluster] = cpu_to_le32(value)
 168
 169 void BUG_unsupported_field_size(void);
 170 #define STORE_LE(field, value) \
 171 do { \
 172         if (sizeof(field) == 4) \
 173                 field = cpu_to_le32(value); \
 174         else if (sizeof(field) == 2) \
 175                 field = cpu_to_le16(value); \
 176         else if (sizeof(field) == 1) \
 177                 field = (value); \
 178         else \
 179                 BUG_unsupported_field_size(); \
 180 } while (0)
 181
 182 /* compat:
 183  * mkdosfs 2.11 (12 Mar 2005)
 184  * Usage: mkdosfs [-A] [-c] [-C] [-v] [-I] [-l bad-block-file]
 185  *        [-b backup-boot-sector]
 186  *        [-m boot-msg-file] [-n volume-name] [-i volume-id]
 187  *        [-s sectors-per-cluster] [-S logical-sector-size]
 188  *        [-f number-of-FATs]
 189  *        [-h hidden-sectors] [-F fat-size] [-r root-dir-entries]
 190  *        [-R reserved-sectors]
 191  *        /dev/name [blocks]
 192  */
 193 int mkfs_vfat_main(int argc, char **argv) MAIN_EXTERNALLY_VISIBLE;
 194 int mkfs_vfat_main(int argc UNUSED_PARAM, char **argv)
 195 {
 196         struct stat st;
 197         const char *volume_label = "";
 198         char *buf;
 199         char *device_name;
 200         uoff_t volume_size_bytes;
 201         uoff_t volume_size_blocks;
 202         uoff_t volume_size_sect;
 203         uint32_t total_clust;
 204         uint32_t volume_id;
 205         int dev;
 206         unsigned bytes_per_sect;
 207         unsigned sect_per_fat;
 208         unsigned opts;
 209         uint16_t sect_per_track;
 210         uint8_t media_byte;
 211         uint8_t sect_per_clust;
 212         uint8_t heads;
 213         enum {
 214                 OPT_A = 1 << 0,  // [IGNORED] atari format
 215                 OPT_b = 1 << 1,  // [IGNORED] location of backup boot sector
 216                 OPT_c = 1 << 2,  // [IGNORED] check filesystem
 217                 OPT_C = 1 << 3,  // [IGNORED] create a new file
 218                 OPT_f = 1 << 4,  // [IGNORED] number of FATs
 219                 OPT_F = 1 << 5,  // [IGNORED, implied 32] choose FAT size
 220                 OPT_h = 1 << 6,  // [IGNORED] number of hidden sectors
 221                 OPT_I = 1 << 7,  // [IGNORED] don't bark at entire disk devices
 222                 OPT_i = 1 << 8,  // [IGNORED] volume ID
 223                 OPT_l = 1 << 9,  // [IGNORED] bad block filename
 224                 OPT_m = 1 << 10, // [IGNORED] message file
 225                 OPT_n = 1 << 11, // volume label
 226                 OPT_r = 1 << 12, // [IGNORED] root directory entries
 227                 OPT_R = 1 << 13, // [IGNORED] number of reserved sectors
 228                 OPT_s = 1 << 14, // [IGNORED] sectors per cluster
 229                 OPT_S = 1 << 15, // [IGNORED] sector size
 230                 OPT_v = 1 << 16, // verbose
 231         };
 232
 233         opt_complementary = "-1";//:b+:f+:F+:h+:r+:R+:s+:S+:vv:c--l:l--c";
 234         opts = getopt32(argv, "Ab:cCf:F:h:Ii:l:m:n:r:R:s:S:v",
 235                 NULL, NULL, NULL, NULL, NULL,
 236                 NULL, NULL, &volume_label, NULL, NULL, NULL, NULL);
 237         argv += optind;
 238
 239         // cache device name
 240         device_name = argv[0];
 241         // default volume ID = creation time
 242         volume_id = time(NULL);
 243
 244         dev = xopen(device_name, O_EXCL | O_RDWR);
 245         if (fstat(dev, &st) < 0)
 246                 bb_simple_perror_msg_and_die(device_name);
 247
 248         //
 249         // Get image size and sector size
 250         //
 251         bytes_per_sect = SECTOR_SIZE;
 252         volume_size_bytes = st.st_size;
 253         if (!S_ISBLK(st.st_mode)) {
 254                 if (!S_ISREG(st.st_mode)) {
 255                         if (!argv[1])
 256                                 bb_error_msg_and_die("image size must be specified");
 257                 }
 258                 // not a block device, skip bad sectors check
 259                 opts &= ~OPT_c;
 260         } else {
 261                 int min_bytes_per_sect;
 262
 263                 // more portable than BLKGETSIZE[64]
 264                 volume_size_bytes = xlseek(dev, 0, SEEK_END);
 265                 xlseek(dev, 0, SEEK_SET);
 266 #if 0
 267                 unsigned device_num;
 268                 // for true block devices we do check sanity
 269                 device_num = st.st_rdev & 0xff3f;
 270                 // do we allow to format the whole disk device?
 271                 if (!(opts & OPT_I) && (
 272                         device_num == 0x0300 || // hda, hdb
 273                         (device_num & 0xff0f) == 0x0800 || // sd
 274                         device_num == 0x0d00 || // xd
 275                         device_num == 0x1600 )  // hdc, hdd
 276                 )
 277                         bb_error_msg_and_die("Will not try to make filesystem on full-disk device (use -I if wanted)");
 278                 // can't work on mounted filesystems
 279                 if (find_mount_point(device_name, NULL))
 280                         bb_error_msg_and_die("Can't format mounted filesystem");
 281 #endif
 282                 // get true sector size
 283                 // (parameter must be int*, not long* or size_t*)
 284                 xioctl(dev, BLKSSZGET, &min_bytes_per_sect);
 285                 if (min_bytes_per_sect > SECTOR_SIZE) {
 286                         bytes_per_sect = min_bytes_per_sect;
 287                         bb_error_msg("for this device sector size is %u", min_bytes_per_sect);
 288                 }
 289         }
 290         if (argv[1]) {
 291                 volume_size_bytes = XATOOFF(argv[1]);
 292                 if (volume_size_bytes >= MAXINT(off_t) / 1024)
 293                         bb_error_msg_and_die("image size is too big");
 294                 volume_size_bytes *= 1024;
 295         }
 296         volume_size_blocks = (volume_size_bytes >> BLOCK_SIZE_BITS);
 297         volume_size_sect = volume_size_bytes / bytes_per_sect;
 298
 299         //
 300         // Find out or guess media parameters
 301         //
 302         media_byte = 0xf8;
 303         heads = 255;
 304         sect_per_track = 63;
 305         sect_per_clust = 1;
 306         {
 307                 struct hd_geometry geometry;
 308                 // size (in sectors), sect (per track), head
 309                 struct floppy_struct param;
 310
 311                 // N.B. whether to use HDIO_GETGEO or HDIO_REQ?
 312                 if (ioctl(dev, HDIO_GETGEO, &geometry) == 0
 313                  && geometry.sectors
 314                  && geometry.heads
 315                 ) {
 316                         // hard drive
 317                         sect_per_track = geometry.sectors;
 318                         heads = geometry.heads;
 319
 320  set_cluster_size:
 321                         /* For FAT32, try to do the same as M$'s format command
 322                          * (see http://www.win.tue.nl/~aeb/linux/fs/fat/fatgen103.pdf p. 20):
 323                          * fs size <= 260M: 0.5k clusters
 324                          * fs size <=   8G: 4k clusters
 325                          * fs size <=  16G: 8k clusters
 326                          * fs size >   16G: 16k clusters
 327                          */
 328                         sect_per_clust = volume_size_bytes > ((off_t)16)*1024*1024*1024 ? 32 :
 329                                         volume_size_bytes > ((off_t)8)*1024*1024*1024 ? 16 :
 330                                         volume_size_bytes >        260*1024*1024 ? 8 : 1;
 331                 } else {
 332                         int not_floppy = ioctl(dev, FDGETPRM, &param);
 333                         if (not_floppy == 0) {
 334                                 // floppy disk
 335                                 sect_per_track = param.sect;
 336                                 heads = param.head;
 337                                 volume_size_sect = param.size;
 338                                 volume_size_bytes = param.size * SECTOR_SIZE;
 339                         }
 340                         // setup the media descriptor byte
 341                         switch (volume_size_sect) {
 342                         case 2*360:     // 5.25", 2, 9, 40 - 360K
 343                                 media_byte = 0xfd;
 344                                 break;
 345                         case 2*720:     // 3.5", 2, 9, 80 - 720K
 346                         case 2*1200:    // 5.25", 2, 15, 80 - 1200K
 347                                 media_byte = 0xf9;
 348                                 break;
 349                         default:        // anything else
 350                                 if (not_floppy)
 351                                         goto set_cluster_size;
 352                         case 2*1440:    // 3.5", 2, 18, 80 - 1440K
 353                         case 2*2880:    // 3.5", 2, 36, 80 - 2880K
 354                                 media_byte = 0xf0;
 355                                 break;
 356                         }
 357                         // not floppy, but size matches floppy exactly.
 358                         // perhaps it is a floppy image.
 359                         // we already set media_byte as if it is a floppy,
 360                         // now set sect_per_track and heads.
 361                         heads = 2;
 362                         sect_per_track = (unsigned)volume_size_sect / 160;
 363                         if (sect_per_track < 9)
 364                                 sect_per_track = 9;
 365                 }
 366         }
 367
 368         //
 369         // Calculate number of clusters, sectors/cluster, sectors/FAT
 370         // (an initial guess for sect_per_clust should already be set)
 371         //
 372         if ((off_t)(volume_size_sect - reserved_sect) < 16) // arbitrary limit
 373                 bb_error_msg_and_die("the image is too small for FAT32");
 374         sect_per_fat = 1;
 375         while (1) {
 376                 while (1) {
 377                         unsigned spf;
 378                         off_t tcl = (volume_size_sect - reserved_sect - NUM_FATS * sect_per_fat) / sect_per_clust;
 379                         // tcl may be > MAX_CLUST_32 here, but it may be
 380                         // because sect_per_fat is underestimated,
 381                         // and with increased sect_per_fat it still may become
 382                         // <= MAX_CLUST_32. Therefore, we do not check
 383                         // against MAX_CLUST_32, but against a bigger const:
 384                         if (tcl > 0x7fffffff)
 385                                 goto next;
 386                         total_clust = tcl; // fits in uint32_t
 387                         spf = ((total_clust + 2) * 4 + bytes_per_sect - 1) / bytes_per_sect;
 388                         if (spf <= sect_per_fat) {
 389                                 // do not need to adjust sect_per_fat.
 390                                 // so, was total_clust too big after all?
 391                                 if (total_clust <= MAX_CLUST_32)
 392                                         goto found_total_clust; // no
 393                                 // yes, total_clust is _a bit_ too big
 394                                 goto next;
 395                         }
 396                         // adjust sect_per_fat, go back and recalc total_clust
 397                         sect_per_fat = spf;
 398                 }
 399  next:
 400                 if (sect_per_clust == 128)
 401                         bb_error_msg_and_die("can't make FAT32 with >128 sectors/cluster");
 402                 sect_per_clust *= 2;
 403                 sect_per_fat = (sect_per_fat / 2) | 1;
 404         }
 405  found_total_clust:
 406
 407         //
 408         // Print info
 409         //
 410         if (opts & OPT_v) {
 411                 fprintf(stderr,
 412                         "Device '%s':\n"
 413                         "heads:%u, sectors/track:%u, bytes/sector:%u\n"
 414                         "media descriptor:0x%02x\n"
 415                         "total sectors:%"OFF_FMT"u, clusters:%u, sectors/cluster:%u\n"
 416                         "FATs:2, sectors/FAT:%u\n"
 417                         "volumeID:%08x, label:'%s'\n",
 418                         device_name,
 419                         heads, sect_per_track, bytes_per_sect,
 420                         (int)media_byte,
 421                         volume_size_sect, (int)total_clust, (int)sect_per_clust,
 422                         sect_per_fat,
 423                         (int)volume_id, volume_label
 424                 );
 425         }
 426
 427         //
 428         // Write filesystem image sequentially (no seeking)
 429         //
 430         {
 431                 // (a | b) is poor man's max(a, b)
 432                 unsigned bufsize = reserved_sect;
 433                 //bufsize |= sect_per_fat; // can be quite large
 434                 bufsize |= 2; // use this instead
 435                 bufsize |= sect_per_clust;
 436                 buf = xzalloc(bufsize * bytes_per_sect);
 437         }
 438
 439         { // boot and fsinfo sectors, and their copies
 440                 struct msdos_boot_sector *boot_blk = (void*)buf;
 441                 struct fat32_fsinfo *info = (void*)(buf + bytes_per_sect);
 442
 443                 strcpy(boot_blk->boot_jump, "\xeb\x58\x90" "mkdosfs"); // system_id[8] included :)
 444                 STORE_LE(boot_blk->bytes_per_sect, bytes_per_sect);
 445                 STORE_LE(boot_blk->sect_per_clust, sect_per_clust);
 446                 STORE_LE(boot_blk->reserved_sect, reserved_sect);
 447                 STORE_LE(boot_blk->fats, 2);
 448                 //STORE_LE(boot_blk->dir_entries, 0); // for FAT32, stays 0
 449                 if (volume_size_sect <= 0xffff)
 450                         STORE_LE(boot_blk->volume_size_sect, volume_size_sect);
 451                 STORE_LE(boot_blk->media_byte, media_byte);
 452                 // wrong: this would make Linux think that it's fat12/16:
 453                 //if (sect_per_fat <= 0xffff)
 454                 //      STORE_LE(boot_blk->sect_per_fat, sect_per_fat);
 455                 // works:
 456                 //STORE_LE(boot_blk->sect_per_fat, 0);
 457                 STORE_LE(boot_blk->sect_per_track, sect_per_track);
 458                 STORE_LE(boot_blk->heads, heads);
 459                 //STORE_LE(boot_blk->hidden, 0);
 460                 STORE_LE(boot_blk->fat32_volume_size_sect, volume_size_sect);
 461                 STORE_LE(boot_blk->fat32_sect_per_fat, sect_per_fat);
 462                 //STORE_LE(boot_blk->fat32_flags, 0);
 463                 //STORE_LE(boot_blk->fat32_version[2], 0,0);
 464                 STORE_LE(boot_blk->fat32_root_cluster, 2);
 465                 STORE_LE(boot_blk->fat32_info_sector, info_sector_number);
 466                 STORE_LE(boot_blk->fat32_backup_boot, backup_boot_sector);
 467                 //STORE_LE(boot_blk->reserved2[3], 0,0,0);
 468                 STORE_LE(boot_blk->vi.ext_boot_sign, 0x29);
 469                 STORE_LE(boot_blk->vi.volume_id32, volume_id);
 470                 strncpy(boot_blk->vi.fs_type, "FAT32   ", sizeof(boot_blk->vi.fs_type));
 471                 strncpy(boot_blk->vi.volume_label, volume_label, sizeof(boot_blk->vi.volume_label));
 472                 memcpy(boot_blk->boot_code, boot_code, sizeof(boot_code));
 473                 STORE_LE(boot_blk->boot_sign, BOOT_SIGN);
 474
 475                 STORE_LE(info->signature1, FAT_FSINFO_SIG1);
 476                 STORE_LE(info->signature2, FAT_FSINFO_SIG2);
 477                 // we've allocated cluster 2 for the root dir
 478                 STORE_LE(info->free_clusters, (total_clust - 1));
 479                 STORE_LE(info->next_cluster, 2);
 480                 STORE_LE(info->boot_sign, BOOT_SIGN);
 481
 482                 // 1st copy
 483                 xwrite(dev, buf, bytes_per_sect * backup_boot_sector);
 484                 // 2nd copy and possibly zero sectors
 485                 xwrite(dev, buf, bytes_per_sect * (reserved_sect - backup_boot_sector));
 486         }
 487
 488         { // file allocation tables
 489                 unsigned i,j;
 490                 unsigned char *fat = (void*)buf;
 491
 492                 memset(buf, 0, bytes_per_sect * 2);
 493                 // initial FAT entries
 494                 MARK_CLUSTER(0, 0x0fffff00 | media_byte);
 495                 MARK_CLUSTER(1, 0xffffffff);
 496                 // mark cluster 2 as EOF (used for root dir)
 497                 MARK_CLUSTER(2, EOF_FAT32);
 498                 for (i = 0; i < NUM_FATS; i++) {
 499                         xwrite(dev, buf, bytes_per_sect);
 500                         for (j = 1; j < sect_per_fat; j++)
 501                                 xwrite(dev, buf + bytes_per_sect, bytes_per_sect);
 502                 }
 503         }
 504
 505         // root directory
 506         // empty directory is just a set of zero bytes
 507         memset(buf, 0, sect_per_clust * bytes_per_sect);
 508         if (volume_label[0]) {
 509                 // create dir entry for volume_label
 510                 struct msdos_dir_entry *de;
 511 #if 0
 512                 struct tm tm;
 513                 uint16_t t, d;
 514 #endif
 515                 de = (void*)buf;
 516                 strncpy(de->name, volume_label, sizeof(de->name));
 517                 STORE_LE(de->attr, ATTR_VOLUME);
 518 #if 0
 519                 localtime_r(&create_time, &tm);
 520                 t = (tm.tm_sec >> 1) + (tm.tm_min << 5) + (tm.tm_hour << 11);
 521                 d = tm.tm_mday + ((tm.tm_mon+1) << 5) + ((tm.tm_year-80) << 9);
 522                 STORE_LE(de->time, t);
 523                 STORE_LE(de->date, d);
 524                 //STORE_LE(de->ctime_cs, 0);
 525                 de->ctime = de->time;
 526                 de->cdate = de->date;
 527                 de->adate = de->date;
 528 #endif
 529         }
 530         xwrite(dev, buf, sect_per_clust * bytes_per_sect);
 531
 532 #if 0
 533         if (opts & OPT_c) {
 534                 unsigned start_data_sector;
 535                 unsigned start_data_block;
 536                 unsigned badblocks = 0;
 537                 int try, got;
 538                 off_t currently_testing;
 539                 char *blkbuf = xmalloc(BLOCK_SIZE * TEST_BUFFER_BLOCKS);
 540
 541                 // N.B. the two following vars are in hard sectors, i.e. SECTOR_SIZE byte sectors!
 542                 start_data_sector = (reserved_sect + NUM_FATS * sect_per_fat) * (bytes_per_sect / SECTOR_SIZE);
 543                 start_data_block = (start_data_sector + SECTORS_PER_BLOCK - 1) / SECTORS_PER_BLOCK;
 544
 545                 bb_info_msg("Searching for bad blocks ");
 546                 currently_testing = 0;
 547                 try = TEST_BUFFER_BLOCKS;
 548                 while (currently_testing < volume_size_blocks) {
 549                         if (currently_testing + try > volume_size_blocks)
 550                                 try = volume_size_blocks - currently_testing;
 551                         // perform a test on a block. return the number of blocks
 552                         // that could be read successfully.
 553                         // seek to the correct location
 554                         xlseek(dev, currently_testing * BLOCK_SIZE, SEEK_SET);
 555                         // try reading
 556                         got = read(dev, blkbuf, try * BLOCK_SIZE);
 557                         if (got < 0)
 558                                 got = 0;
 559                         if (got & (BLOCK_SIZE - 1))
 560                                 bb_error_msg("Unexpected values in do_check: probably bugs");
 561                         got /= BLOCK_SIZE;
 562                         currently_testing += got;
 563                         if (got == try) {
 564                                 try = TEST_BUFFER_BLOCKS;
 565                                 continue;
 566                         }
 567                         try = 1;
 568                         if (currently_testing < start_data_block)
 569                                 bb_error_msg_and_die("bad blocks before data-area: cannot make fs");
 570
 571                         // mark all of the sectors in the block as bad
 572                         for (i = 0; i < SECTORS_PER_BLOCK; i++) {
 573                                 int cluster = (currently_testing * SECTORS_PER_BLOCK + i - start_data_sector) / (int) (sect_per_clust) / (bytes_per_sect / SECTOR_SIZE);
 574                                 if (cluster < 0)
 575                                         bb_error_msg_and_die("Invalid cluster number in mark_sector: probably bug!");
 576                                 MARK_CLUSTER(cluster, BAD_FAT32);
 577                         }
 578                         badblocks++;
 579                         currently_testing++;
 580                 }
 581                 free(blkbuf);
 582                 if (badblocks)
 583                         bb_info_msg("%d bad block(s)", badblocks);
 584         }
 585 #endif
 586
 587         // cleanup
 588         if (ENABLE_FEATURE_CLEAN_UP) {
 589                 free(buf);
 590                 close(dev);
 591         }
 592
 593         return 0;
 594 }