diff options
| -rw-r--r-- | include/applets.h | 2 | ||||
| -rw-r--r-- | include/libbb.h | 4 | ||||
| -rw-r--r-- | include/usage.h | 16 | ||||
| -rw-r--r-- | util-linux/Config.in | 6 | ||||
| -rw-r--r-- | util-linux/Kbuild | 1 | ||||
| -rw-r--r-- | util-linux/mkfs_vfat.c | 593 |
6 files changed, 622 insertions, 0 deletions
diff --git a/include/applets.h b/include/applets.h index becb14066..1d932589b 100644 --- a/include/applets.h +++ b/include/applets.h @@ -250,11 +250,13 @@ USE_MDEV(APPLET(mdev, _BB_DIR_SBIN, _BB_SUID_NEVER)) USE_MESG(APPLET(mesg, _BB_DIR_USR_BIN, _BB_SUID_NEVER)) USE_MICROCOM(APPLET(microcom, _BB_DIR_USR_BIN, _BB_SUID_NEVER)) USE_MKDIR(APPLET_NOFORK(mkdir, mkdir, _BB_DIR_BIN, _BB_SUID_NEVER, mkdir)) +USE_MKFS_VFAT(APPLET_ODDNAME(mkdosfs, mkfs_vfat, _BB_DIR_SBIN, _BB_SUID_NEVER, mkfs_vfat)) //USE_MKE2FS(APPLET(mke2fs, _BB_DIR_SBIN, _BB_SUID_NEVER)) USE_MKFIFO(APPLET(mkfifo, _BB_DIR_USR_BIN, _BB_SUID_NEVER)) //USE_MKE2FS(APPLET_ODDNAME(mkfs.ext2, mke2fs, _BB_DIR_SBIN, _BB_SUID_NEVER, mkfs_ext2)) //USE_MKE2FS(APPLET_ODDNAME(mkfs.ext3, mke2fs, _BB_DIR_SBIN, _BB_SUID_NEVER, mkfs_ext3)) USE_MKFS_MINIX(APPLET_ODDNAME(mkfs.minix, mkfs_minix, _BB_DIR_SBIN, _BB_SUID_NEVER, mkfs_minix)) +USE_MKFS_VFAT(APPLET_ODDNAME(mkfs.vfat, mkfs_vfat, _BB_DIR_SBIN, _BB_SUID_NEVER, mkfs_vfat)) USE_MKNOD(APPLET(mknod, _BB_DIR_BIN, _BB_SUID_NEVER)) USE_CRYPTPW(APPLET_ODDNAME(mkpasswd, cryptpw, _BB_DIR_USR_BIN, _BB_SUID_NEVER, mkpasswd)) USE_MKSWAP(APPLET(mkswap, _BB_DIR_SBIN, _BB_SUID_NEVER)) diff --git a/include/libbb.h b/include/libbb.h index 015374b4a..c2e034447 100644 --- a/include/libbb.h +++ b/include/libbb.h @@ -150,6 +150,7 @@ int sysinfo(struct sysinfo* info); /* CONFIG_LFS is on */ # if ULONG_MAX > 0xffffffff /* "long" is long enough on this system */ +typedef unsigned long uoff_t; # define XATOOFF(a) xatoul_range(a, 0, LONG_MAX) /* usage: sz = BB_STRTOOFF(s, NULL, 10); if (errno || sz < 0) die(); */ # define BB_STRTOOFF bb_strtoul @@ -158,6 +159,7 @@ int sysinfo(struct sysinfo* info); # define OFF_FMT "l" # else /* "long" is too short, need "long long" */ +typedef unsigned long long uoff_t; # define XATOOFF(a) xatoull_range(a, 0, LLONG_MAX) # define BB_STRTOOFF bb_strtoull # define STRTOOFF strtoull @@ -168,11 +170,13 @@ int sysinfo(struct sysinfo* info); # if UINT_MAX == 0xffffffff /* While sizeof(off_t) == sizeof(int), off_t is typedef'ed to long anyway. * gcc will throw warnings on printf("%d", off_t). Crap... */ +typedef unsigned long uoff_t; # define XATOOFF(a) xatoi_u(a) # define BB_STRTOOFF bb_strtou # define STRTOOFF strtol # define OFF_FMT "l" # else +typedef unsigned long uoff_t; # define XATOOFF(a) xatoul_range(a, 0, LONG_MAX) # define BB_STRTOOFF bb_strtoul # define STRTOOFF strtol diff --git a/include/usage.h b/include/usage.h index 2b5d34ea6..16d5eec9f 100644 --- a/include/usage.h +++ b/include/usage.h @@ -2670,6 +2670,22 @@ "\n -l FILENAME Read bad blocks list from FILENAME" \ "\n -v Make version 2 filesystem" \ +#define mkfs_vfat_trivial_usage \ + "[-v] [-n LABEL] FILE_OR_DEVICE [SIZE_IN_KB]" +/* Accepted but ignored: + "[-c] [-C] [-I] [-l bad-block-file] [-b backup-boot-sector] " + "[-m boot-msg-file] [-i volume-id] " + "[-s sectors-per-cluster] [-S logical-sector-size] [-f number-of-FATs] " + "[-h hidden-sectors] [-F fat-size] [-r root-dir-entries] [-R reserved-sectors] " +*/ +#define mkfs_vfat_full_usage "\n\n" \ + "Make a FAT32 filesystem\n" \ + "\nOptions:" \ +/* "\n -c Check device for bad blocks" */ \ + "\n -v Verbose" \ +/* "\n -I Allow to use entire disk device (e.g. /dev/hda)" */ \ + "\n -n LBL Volume label" \ + #define mknod_trivial_usage \ "[OPTIONS] NAME TYPE MAJOR MINOR" #define mknod_full_usage "\n\n" \ diff --git a/util-linux/Config.in b/util-linux/Config.in index 3bba2e26d..e5c053fcf 100644 --- a/util-linux/Config.in +++ b/util-linux/Config.in @@ -233,6 +233,12 @@ config FEATURE_MINIX2 this. If you enabled 'mkfs_minix' then you almost certainly want to be using the version 2 filesystem support. +config MKFS_VFAT + bool "mkfs_vfat" + default n + help + Utility to create FAT32 filesystems. + config GETOPT bool "getopt" default n diff --git a/util-linux/Kbuild b/util-linux/Kbuild index 842afb756..ac071c620 100644 --- a/util-linux/Kbuild +++ b/util-linux/Kbuild @@ -23,6 +23,7 @@ lib-$(CONFIG_IPCS) += ipcs.o lib-$(CONFIG_LOSETUP) += losetup.o lib-$(CONFIG_MDEV) += mdev.o lib-$(CONFIG_MKFS_MINIX) += mkfs_minix.o +lib-$(CONFIG_MKFS_VFAT) += mkfs_vfat.o lib-$(CONFIG_MKSWAP) += mkswap.o lib-$(CONFIG_MORE) += more.o lib-$(CONFIG_MOUNT) += mount.o diff --git a/util-linux/mkfs_vfat.c b/util-linux/mkfs_vfat.c new file mode 100644 index 000000000..930fd45cc --- /dev/null +++ b/util-linux/mkfs_vfat.c @@ -0,0 +1,593 @@ +/* vi: set sw=4 ts=4: */ +/* + * mkfs_vfat: utility to create FAT32 filesystem + * inspired by dosfstools + * + * Busybox'ed (2009) by Vladimir Dronnikov <dronnikov@gmail.com> + * + * Licensed under GPLv2, see file LICENSE in this tarball for details. + */ +#include "libbb.h" +#include "volume_id/volume_id_internal.h" + +#include <linux/hdreg.h> /* HDIO_GETGEO */ +#include <linux/fd.h> /* FDGETPRM */ +//#include <linux/msdos_fs.h> + +#define SECTOR_SIZE 512 + +#define SECTORS_PER_BLOCK (BLOCK_SIZE / SECTOR_SIZE) + +// M$ says the high 4 bits of a FAT32 FAT entry are reserved +#define EOF_FAT32 0x0FFFFFF8 +#define BAD_FAT32 0x0FFFFFF7 +#define MAX_CLUST_32 0x0FFFFFF0 + +#define ATTR_VOLUME 8 + +#define NUM_FATS 2 + +/* FAT32 filesystem looks like this: + * sector -nn...-1: "hidden" sectors, all sectors before this partition + * (-h hidden-sectors sets it. Useful only for boot loaders, + * they need to know _disk_ offset in order to be able to correctly + * address sectors relative to start of disk) + * sector 0: boot sector + * sector 1: info sector + * sector 2: set aside for boot code which didn't fit into sector 0 + * ...(zero-filled sectors)... + * sector B: backup copy of sector 0 [B set by -b backup-boot-sector] + * sector B+1: backup copy of sector 1 + * sector B+2: backup copy of sector 2 + * ...(zero-filled sectors)... + * sector R: FAT#1 [R set by -R reserved-sectors] + * ...(FAT#1)... + * sector R+fat_size: FAT#2 + * ...(FAT#2)... + * sector R+fat_size*2: cluster #2 + * ...(cluster #2)... + * sector R+fat_size*2+clust_size: cluster #3 + * ...(the rest is filled by clusters till the end)... + */ + +enum { +// Perhaps this should remain constant + info_sector_number = 1, +// TODO: make these cmdline options +// dont forget sanity check: backup_boot_sector + 3 <= reserved_sect + backup_boot_sector = 3, + reserved_sect = 6, +}; + +// how many blocks we try to read while testing +#define TEST_BUFFER_BLOCKS 16 + +struct msdos_dir_entry { + char name[11]; /* 000 name and extension */ + uint8_t attr; /* 00b attribute bits */ + uint8_t lcase; /* 00c case for base and extension */ + uint8_t ctime_cs; /* 00d creation time, centiseconds (0-199) */ + uint16_t ctime; /* 00e creation time */ + uint16_t cdate; /* 010 creation date */ + uint16_t adate; /* 012 last access date */ + uint16_t starthi; /* 014 high 16 bits of cluster in FAT32 */ + uint16_t time; /* 016 time */ + uint16_t date; /* 018 date */ + uint16_t start; /* 01a first cluster */ + uint32_t size; /* 01c file size in bytes */ +} __attribute__ ((packed)); + +/* Example of boot sector's beginning: +0000 eb 58 90 4d 53 57 49 4e 34 2e 31 00 02 08 26 00 |...MSWIN4.1...&.| +0010 02 00 00 00 00 f8 00 00 3f 00 ff 00 3f 00 00 00 |........?...?...| +0020 54 9b d0 00 0d 34 00 00 00 00 00 00 02 00 00 00 |T....4..........| +0030 01 00 06 00 00 00 00 00 00 00 00 00 00 00 00 00 |................| +0040 80 00 29 71 df 51 e0 4e 4f 20 4e 41 4d 45 20 20 |..)q.Q.NO NAME | +0050 20 20 46 41 54 33 32 20 20 20 33 c9 8e d1 bc f4 | FAT32 3.....| +*/ +struct msdos_volume_info { /* (offsets are relative to start of boot sector) */ + uint8_t drive_number; /* 040 BIOS drive number */ + uint8_t reserved; /* 041 unused */ + uint8_t ext_boot_sign; /* 042 0x29 if fields below exist (DOS 3.3+) */ + uint32_t volume_id32; /* 043 volume ID number */ + char volume_label[11];/* 047 volume label */ + char fs_type[8]; /* 052 typically "FATnn" */ +} __attribute__ ((packed)); /* 05a end. Total size 26 (0x1a) bytes */ + +struct msdos_boot_sector { + char boot_jump[3]; /* 000 short or near jump instruction */ + char system_id[8]; /* 003 name - can be used to special case partition manager volumes */ + uint16_t bytes_per_sect; /* 00b bytes per logical sector */ + uint8_t sect_per_clust; /* 00d sectors/cluster */ + uint16_t reserved_sect; /* 00e reserved sectors (sector offset of 1st FAT relative to volume start) */ + uint8_t fats; /* 010 number of FATs */ + uint16_t dir_entries; /* 011 root directory entries */ + uint16_t volume_size_sect; /* 013 volume size in sectors */ + uint8_t media_byte; /* 015 media code */ + uint16_t sect_per_fat; /* 016 sectors/FAT */ + uint16_t sect_per_track; /* 018 sectors per track */ + uint16_t heads; /* 01a number of heads */ + uint32_t hidden; /* 01c hidden sectors (sector offset of volume within physical disk) */ + uint32_t fat32_volume_size_sect; /* 020 volume size in sectors (if volume_size_sect == 0) */ + uint32_t fat32_sect_per_fat; /* 024 sectors/FAT */ + uint16_t fat32_flags; /* 028 bit 8: fat mirroring, low 4: active fat */ + uint8_t fat32_version[2]; /* 02a major, minor filesystem version (I see 0,0) */ + uint32_t fat32_root_cluster; /* 02c first cluster in root directory */ + uint16_t fat32_info_sector; /* 030 filesystem info sector (usually 1) */ + uint16_t fat32_backup_boot; /* 032 backup boot sector (usually 6) */ + uint32_t reserved2[3]; /* 034 unused */ + struct msdos_volume_info vi; /* 040 */ + char boot_code[0x200 - 0x5a - 2]; /* 05a */ +#define BOOT_SIGN 0xAA55 + uint16_t boot_sign; /* 1fe */ +} __attribute__ ((packed)); + +#define FAT_FSINFO_SIG1 0x41615252 +#define FAT_FSINFO_SIG2 0x61417272 +struct fat32_fsinfo { + uint32_t signature1; /* 0x52,0x52,0x41,0x61, "RRaA" */ + uint32_t reserved1[128 - 8]; + uint32_t signature2; /* 0x72,0x72,0x61,0x41, "rrAa" */ + uint32_t free_clusters; /* free cluster count. -1 if unknown */ + uint32_t next_cluster; /* most recently allocated cluster */ + uint32_t reserved2[3]; + uint16_t reserved3; /* 1fc */ + uint16_t boot_sign; /* 1fe */ +} __attribute__ ((packed)); + +struct bug_check { + char BUG1[sizeof(struct msdos_dir_entry ) == 0x20 ? 1 : -1]; + char BUG2[sizeof(struct msdos_volume_info) == 0x1a ? 1 : -1]; + char BUG3[sizeof(struct msdos_boot_sector) == 0x200 ? 1 : -1]; + char BUG4[sizeof(struct fat32_fsinfo ) == 0x200 ? 1 : -1]; +}; + +static const char boot_code[] ALIGN1 = + "\x0e" /* 05a: push cs */ + "\x1f" /* 05b: pop ds */ + "\xbe\x77\x7c" /* write_msg: mov si, offset message_txt */ + "\xac" /* 05f: lodsb */ + "\x22\xc0" /* 060: and al, al */ + "\x74\x0b" /* 062: jz key_press */ + "\x56" /* 064: push si */ + "\xb4\x0e" /* 065: mov ah, 0eh */ + "\xbb\x07\x00" /* 067: mov bx, 0007h */ + "\xcd\x10" /* 06a: int 10h */ + "\x5e" /* 06c: pop si */ + "\xeb\xf0" /* 06d: jmp write_msg */ + "\x32\xe4" /* key_press: xor ah, ah */ + "\xcd\x16" /* 071: int 16h */ + "\xcd\x19" /* 073: int 19h */ + "\xeb\xfe" /* foo: jmp foo */ + /* 077: message_txt: */ + "This is not a bootable disk\r\n"; + + +// mark specified cluster as having a particular value +#define mark_cluster(cluster, value) \ + ((uint32_t *)fat)[cluster] = cpu_to_le32(value) + +void BUG_unsupported_field_size(void); +#define STORE_LE(field, value) \ +do { \ + if (sizeof(field) == 4) \ + field = cpu_to_le32(value); \ + else if (sizeof(field) == 2) \ + field = cpu_to_le16(value); \ + else if (sizeof(field) == 1) \ + field = (value); \ + else \ + BUG_unsupported_field_size(); \ +} while (0) + +/* compat: + * mkdosfs 2.11 (12 Mar 2005) + * Usage: mkdosfs [-A] [-c] [-C] [-v] [-I] [-l bad-block-file] + * [-b backup-boot-sector] + * [-m boot-msg-file] [-n volume-name] [-i volume-id] + * [-s sectors-per-cluster] [-S logical-sector-size] + * [-f number-of-FATs] + * [-h hidden-sectors] [-F fat-size] [-r root-dir-entries] + * [-R reserved-sectors] + * /dev/name [blocks] + */ +int mkfs_vfat_main(int argc, char **argv) MAIN_EXTERNALLY_VISIBLE; +int mkfs_vfat_main(int argc UNUSED_PARAM, char **argv) +{ + struct stat st; + const char *volume_label = ""; + char *buf; + char *device_name; + uoff_t volume_size_bytes; + uoff_t volume_size_blocks; + uoff_t volume_size_sect; + uint32_t total_clust; + uint32_t volume_id; + int dev; + unsigned bytes_per_sect; + unsigned sect_per_fat; + unsigned opts; + uint16_t sect_per_track; + uint8_t media_byte; + uint8_t sect_per_clust; + uint8_t heads; + enum { + OPT_A = 1 << 0, // [IGNORED] atari format + OPT_b = 1 << 1, // [IGNORED] location of backup boot sector + OPT_c = 1 << 2, // [IGNORED] check filesystem + OPT_C = 1 << 3, // [IGNORED] create a new file + OPT_f = 1 << 4, // [IGNORED] number of FATs + OPT_F = 1 << 5, // [IGNORED, implied 32] choose FAT size + OPT_h = 1 << 6, // [IGNORED] number of hidden sectors + OPT_I = 1 << 7, // [IGNORED] don't bark at entire disk devices + OPT_i = 1 << 8, // [IGNORED] volume ID + OPT_l = 1 << 9, // [IGNORED] bad block filename + OPT_m = 1 << 10, // [IGNORED] message file + OPT_n = 1 << 11, // volume label + OPT_r = 1 << 12, // [IGNORED] root directory entries + OPT_R = 1 << 13, // [IGNORED] number of reserved sectors + OPT_s = 1 << 14, // [IGNORED] sectors per cluster + OPT_S = 1 << 15, // [IGNORED] sector size + OPT_v = 1 << 16, // verbose + }; + + opt_complementary = "-1";//:b+:f+:F+:h+:r+:R+:s+:S+:vv:c--l:l--c"; + opts = getopt32(argv, "Ab:cCf:F:h:Ii:l:m:n:r:R:s:S:v", + NULL, NULL, NULL, NULL, NULL, + NULL, NULL, &volume_label, NULL, NULL, NULL, NULL); + argv += optind; + + // cache device name + device_name = argv[0]; + // default volume ID = creation time + volume_id = time(NULL); + + dev = xopen(device_name, O_EXCL | O_RDWR); + if (fstat(dev, &st) < 0) + bb_simple_perror_msg_and_die(device_name); + + // + // Get image size and sector size + // + bytes_per_sect = SECTOR_SIZE; + volume_size_bytes = st.st_size; + if (!S_ISBLK(st.st_mode)) { + if (!S_ISREG(st.st_mode)) { + if (!argv[1]) + bb_error_msg_and_die("image size must be specified"); + } + // not a block device, skip bad sectors check + opts &= ~OPT_c; + } else { + int min_bytes_per_sect; + + // more portable than BLKGETSIZE[64] + volume_size_bytes = xlseek(dev, 0, SEEK_END); + xlseek(dev, 0, SEEK_SET); +#if 0 + unsigned device_num; + // for true block devices we do check sanity + device_num = st.st_rdev & 0xff3f; + // do we allow to format the whole disk device? + if (!(opts & OPT_I) && ( + device_num == 0x0300 || // hda, hdb + (device_num & 0xff0f) == 0x0800 || // sd + device_num == 0x0d00 || // xd + device_num == 0x1600 ) // hdc, hdd + ) + bb_error_msg_and_die("Will not try to make filesystem on full-disk device (use -I if wanted)"); + // can't work on mounted filesystems + if (find_mount_point(device_name, NULL)) + bb_error_msg_and_die("Can't format mounted filesystem"); +#endif + // get true sector size + // (parameter must be int*, not long* or size_t*) + xioctl(dev, BLKSSZGET, &min_bytes_per_sect); + if (min_bytes_per_sect > SECTOR_SIZE) { + bytes_per_sect = min_bytes_per_sect; + bb_error_msg("for this device sector size is %u", min_bytes_per_sect); + } + } + if (argv[1]) { + volume_size_bytes = XATOOFF(argv[1]); + if (volume_size_bytes >= MAXINT(off_t) / 1024) + bb_error_msg_and_die("image size is too big"); + volume_size_bytes *= 1024; + } + volume_size_blocks = (volume_size_bytes >> BLOCK_SIZE_BITS); + volume_size_sect = volume_size_bytes / bytes_per_sect; + + // + // Find out or guess media parameters + // + media_byte = 0xf8; + heads = 255; + sect_per_track = 63; + sect_per_clust = 1; + { + struct hd_geometry geometry; + // size (in sectors), sect (per track), head + struct floppy_struct param; + + // N.B. whether to use HDIO_GETGEO or HDIO_REQ? + if (ioctl(dev, HDIO_GETGEO, &geometry) == 0 + && geometry.sectors + && geometry.heads + ) { + // hard drive + sect_per_track = geometry.sectors; + heads = geometry.heads; + + set_cluster_size: + /* For FAT32, try to do the same as M$'s format command + * (see http://www.win.tue.nl/~aeb/linux/fs/fat/fatgen103.pdf p. 20): + * fs size <= 260M: 0.5k clusters + * fs size <= 8G: 4k clusters + * fs size <= 16G: 8k clusters + * fs size > 16G: 16k clusters + */ + sect_per_clust = volume_size_bytes > ((off_t)16)*1024*1024*1024 ? 32 : + volume_size_bytes > ((off_t)8)*1024*1024*1024 ? 16 : + volume_size_bytes > 260*1024*1024 ? 8 : 1; + } else { + int not_floppy = ioctl(dev, FDGETPRM, ¶m); + if (not_floppy == 0) { + // floppy disk + sect_per_track = param.sect; + heads = param.head; + volume_size_sect = param.size; + volume_size_bytes = param.size * SECTOR_SIZE; + } + // setup the media descriptor byte + switch (volume_size_sect) { + case 2*360: // 5.25", 2, 9, 40 - 360K + media_byte = 0xfd; + break; + case 2*720: // 3.5", 2, 9, 80 - 720K + case 2*1200: // 5.25", 2, 15, 80 - 1200K + media_byte = 0xf9; + break; + default: // anything else + if (not_floppy) + goto set_cluster_size; + case 2*1440: // 3.5", 2, 18, 80 - 1440K + case 2*2880: // 3.5", 2, 36, 80 - 2880K + media_byte = 0xf0; + break; + } + // not floppy, but size matches floppy exactly. + // perhaps it is a floppy image. + // we already set media_byte as if it is a floppy, + // now set sect_per_track and heads. + heads = 2; + sect_per_track = (unsigned)volume_size_sect / 160; + if (sect_per_track < 9) + sect_per_track = 9; + } + } + + // + // Calculate number of clusters, sectors/cluster, sectors/FAT + // (an initial guess for sect_per_clust should already be set) + // + if ((off_t)(volume_size_sect - reserved_sect) < 16) // arbitrary limit + bb_error_msg_and_die("the image is too small for FAT32"); + sect_per_fat = 1; + while (1) { + while (1) { + unsigned spf; + off_t tcl = (volume_size_sect - reserved_sect - NUM_FATS * sect_per_fat) / sect_per_clust; + // tcl may be > MAX_CLUST_32 here, but it may be + // because sect_per_fat is underestimated, + // and with increased sect_per_fat it still may become + // <= MAX_CLUST_32. Therefore, we do not check + // against MAX_CLUST_32, but against a bigger const: + if (tcl > 0x7fffffff) + goto next; + total_clust = tcl; // fits in uint32_t + spf = ((total_clust + 2) * 4 + bytes_per_sect - 1) / bytes_per_sect; + if (spf <= sect_per_fat) { + // do not need to adjust sect_per_fat. + // so, was total_clust too big after all? + if (total_clust <= MAX_CLUST_32) + goto found_total_clust; // no + // yes, total_clust is _a bit_ too big + goto next; + } + // adjust sect_per_fat, go back and recalc total_clust + sect_per_fat = spf; + } + next: + if (sect_per_clust == 128) + bb_error_msg_and_die("can't make FAT32 with >128 sectors/cluster"); + sect_per_clust *= 2; + sect_per_fat = (sect_per_fat / 2) | 1; + } + found_total_clust: + + // + // Print info + // + if (opts & OPT_v) { + fprintf(stderr, + "Device '%s':\n" + "heads:%u, sectors/track:%u, bytes/sector:%u\n" + "media descriptor:0x%02x\n" + "total sectors:%"OFF_FMT"u, clusters:%u, sectors/cluster:%u\n" + "FATs:2, sectors/FAT:%u\n" + "volumeID:%08x, label:'%s'\n", + device_name, + heads, sect_per_track, bytes_per_sect, + (int)media_byte, + volume_size_sect, (int)total_clust, (int)sect_per_clust, + sect_per_fat, + (int)volume_id, volume_label + ); + } + + // + // Write filesystem image sequentially (no seeking) + // + { + unsigned bufsize = reserved_sect; + //bufsize |= sect_per_fat; // can be quite large + bufsize |= 2; // use this instead + bufsize |= sect_per_clust; + buf = xzalloc(bufsize * bytes_per_sect); + } + + { // boot, fsinfo sectors and their copies + struct msdos_boot_sector *boot_blk = (void*)buf; + struct fat32_fsinfo *info = (void*)(buf + bytes_per_sect); + + strcpy(boot_blk->boot_jump, "\xeb\x58\x90" "mkdosfs"); // system_id[8] included :) + STORE_LE(boot_blk->bytes_per_sect, bytes_per_sect); + STORE_LE(boot_blk->sect_per_clust, sect_per_clust); + STORE_LE(boot_blk->reserved_sect, reserved_sect); + STORE_LE(boot_blk->fats, 2); + //STORE_LE(boot_blk->dir_entries, 0); // for FAT32, stays 0 + if (volume_size_sect <= 0xffff) + STORE_LE(boot_blk->volume_size_sect, volume_size_sect); + STORE_LE(boot_blk->media_byte, media_byte); + // Bad: this would make Linux to think that it's fat12/16 + //if (sect_per_fat <= 0xffff) + // STORE_LE(boot_blk->sect_per_fat, sect_per_fat); + //STORE_LE(boot_blk->sect_per_fat, 0); + STORE_LE(boot_blk->sect_per_track, sect_per_track); + STORE_LE(boot_blk->heads, heads); + //STORE_LE(boot_blk->hidden, 0); + STORE_LE(boot_blk->fat32_volume_size_sect, volume_size_sect); + STORE_LE(boot_blk->fat32_sect_per_fat, sect_per_fat); + //STORE_LE(boot_blk->fat32_flags, 0); + //STORE_LE(boot_blk->fat32_version[2], 0,0); + STORE_LE(boot_blk->fat32_root_cluster, 2); + STORE_LE(boot_blk->fat32_info_sector, info_sector_number); + STORE_LE(boot_blk->fat32_backup_boot, backup_boot_sector); + //STORE_LE(boot_blk->reserved2[3], 0,0,0); + STORE_LE(boot_blk->vi.ext_boot_sign, 0x29); + STORE_LE(boot_blk->vi.volume_id32, volume_id); + strncpy(boot_blk->vi.fs_type, "FAT32 ", sizeof(boot_blk->vi.fs_type)); + strncpy(boot_blk->vi.volume_label, volume_label, sizeof(boot_blk->vi.volume_label)); + memcpy(boot_blk->boot_code, boot_code, sizeof(boot_code)); + STORE_LE(boot_blk->boot_sign, BOOT_SIGN); + + STORE_LE(info->signature1, FAT_FSINFO_SIG1); + STORE_LE(info->signature2, FAT_FSINFO_SIG2); + // we've allocated cluster 2 for the root dir + STORE_LE(info->free_clusters, (total_clust - 1)); + STORE_LE(info->next_cluster, 2); + STORE_LE(info->boot_sign, BOOT_SIGN); + + // 1st copy + xwrite(dev, buf, bytes_per_sect * backup_boot_sector); + // 2nd copy and possibly zero sectors + xwrite(dev, buf, bytes_per_sect * (reserved_sect - backup_boot_sector)); + } + + { // file allocation tables + unsigned i,j; + unsigned char *fat = (void*)buf; + + memset(buf, 0, bytes_per_sect * 2); + // initial FAT entries + mark_cluster(0, 0x0fffff00 | media_byte); + mark_cluster(1, 0xffffffff); + // mark cluster 2 as EOF (used for root dir) + mark_cluster(2, EOF_FAT32); + for (i = 0; i < NUM_FATS; i++) { + xwrite(dev, buf, bytes_per_sect); + for (j = 1; j < sect_per_fat; j++) + xwrite(dev, buf + bytes_per_sect, bytes_per_sect); + } + } + + // root directory + // empty directory is just a set of zero bytes + memset(buf, 0, sect_per_clust * bytes_per_sect); + if (volume_label[0]) { + // create dir entry for volume_label + struct msdos_dir_entry *de; +#if 0 + struct tm tm; + uint16_t t, d; +#endif + de = (void*)buf; + strncpy(de->name, volume_label, sizeof(de->name)); + STORE_LE(de->attr, ATTR_VOLUME); +#if 0 + localtime_r(&create_time, &tm); + t = (tm.tm_sec >> 1) + (tm.tm_min << 5) + (tm.tm_hour << 11); + d = tm.tm_mday + ((tm.tm_mon+1) << 5) + ((tm.tm_year-80) << 9); + STORE_LE(de->time, t); + STORE_LE(de->date, d); + //STORE_LE(de->ctime_cs, 0); + de->ctime = de->time; + de->cdate = de->date; + de->adate = de->date; +#endif + } + xwrite(dev, buf, sect_per_clust * bytes_per_sect); + +#if 0 + if (opts & OPT_c) { + unsigned start_data_sector; + unsigned start_data_block; + unsigned badblocks = 0; + int try, got; + off_t currently_testing; + char *blkbuf = xmalloc(BLOCK_SIZE * TEST_BUFFER_BLOCKS); + + // N.B. the two following vars are in hard sectors, i.e. SECTOR_SIZE byte sectors! + start_data_sector = (reserved_sect + NUM_FATS * sect_per_fat) * (bytes_per_sect / SECTOR_SIZE); + start_data_block = (start_data_sector + SECTORS_PER_BLOCK - 1) / SECTORS_PER_BLOCK; + + bb_info_msg("Searching for bad blocks "); + currently_testing = 0; + try = TEST_BUFFER_BLOCKS; + while (currently_testing < volume_size_blocks) { + if (currently_testing + try > volume_size_blocks) + try = volume_size_blocks - currently_testing; + // perform a test on a block. return the number of blocks + // that could be read successfully. + // seek to the correct location + xlseek(dev, currently_testing * BLOCK_SIZE, SEEK_SET); + // try reading + got = read(dev, blkbuf, try * BLOCK_SIZE); + if (got < 0) + got = 0; + if (got & (BLOCK_SIZE - 1)) + bb_error_msg("Unexpected values in do_check: probably bugs"); + got /= BLOCK_SIZE; + currently_testing += got; + if (got == try) { + try = TEST_BUFFER_BLOCKS; + continue; + } + try = 1; + if (currently_testing < start_data_block) + bb_error_msg_and_die("bad blocks before data-area: cannot make fs"); + + // mark all of the sectors in the block as bad + for (i = 0; i < SECTORS_PER_BLOCK; i++) { + int cluster = (currently_testing * SECTORS_PER_BLOCK + i - start_data_sector) / (int) (sect_per_clust) / (bytes_per_sect / SECTOR_SIZE); + if (cluster < 0) + bb_error_msg_and_die("Invalid cluster number in mark_sector: probably bug!"); + mark_cluster(cluster, BAD_FAT32); + } + badblocks++; + currently_testing++; + } + free(blkbuf); + if (badblocks) + bb_info_msg("%d bad block(s)", badblocks); + } +#endif + + // cleanup + if (ENABLE_FEATURE_CLEAN_UP) { + free(buf); + close(dev); + } + + return 0; +} |