mkdosfs (aka mkfs.vfat): new applet by Vladimir
text data bss dec hex filename 821202 476 7616 829294 ca76e busybox_old 823577 476 7616 831669 cb0b5 busybox_unstripped
This commit is contained in:
Denis Vlasenko
parent
4d3a812b71
commit
9d04b6b630
@ -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))
|
||||
|
||||
@ -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
|
||||
|
||||
@ -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" \
|
||||
|
||||
@ -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
|
||||
|
||||
@ -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
|
||||
|
||||
593
util-linux/mkfs_vfat.c
Normal file
593
util-linux/mkfs_vfat.c
Normal file
@ -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;
|
||||
}
|
||||
Loading…
Reference in New Issue
Block a user