LXR busybox/util-linux/mkfs

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