在嵌入式设备当中,存储必不可少,常用的文件系统格式有 FAT,FAT 常用包括 FAT16、FAT32,这种不带有日志形式,在写数据时相对比较快,如果使用 EXT 带有日志文件系统格式,写入数据的同时也会写入日志信息,如果 SD 或者 U 盘的硬件写入速度不是太理想,这样相比之下可能影响系统效率。
当时由于 FAT 格式文件系统不带有日志,通常情况下,容易发生在写数据过程中突然掉电,此时如果正常更新 FAT 表信息,这样导致文件的结束块信息没有写入,这样下次读取这个文件时,没有结束标志,linux 系统遇到此种情况下,会将该文件的整个分区设为只读形式来自我保护,此时该分区无法写入数据,要解决这种问题必须重新格式化该分区才能消除这种情况,因为 FAT 表存在问题。虽然 linux 系统里面自带有 mkdos 部分源码,但是随着历史的发展要移植到嵌入式上来还是相对比较复杂,我在开源社区找到了 mkdos 的最初的版本源码,只有一个文件,支持 FAT16、FAT32 格式(注意 linux 下 FAT16 对应文件系统 ID 包括 0x04、0x06、0x0E, FAT32 对应文件系统 ID 包括 0x0B、0x0C), 在格式化前,必须有一个分区,如:在 linux 下,对于 U 盘而言,/dev/sda 是设备节点,里面包括 MBR、DPT 等信息,/dev/sda1 是一个分区,格式化只是针对 / dev/sda1,对于那种特殊没有分区只有 / dev/sda 设备节点的,不予以考虑,那种针对小容量才有,真正大容量的存储设备必须分区。
- #include < fcntl.h > #include < linux / hdreg.h > #include < linux / fs.h > #include < linux / fd.h > #include < endian.h > #include < mntent.h > #include < signal.h > #include < string.h > #include < stdio.h > #include < stdlib.h > #include < sys / ioctl.h > #include < sys / stat.h > #include < sys / types.h > #include < unistd.h > #include < time.h > #include < errno.h > #include < linux / version.h > #
- if LINUX_VERSION_CODE >= KERNEL_VERSION(2, 6, 0)#define __KERNEL__#include < asm / types.h > #undef __KERNEL__#endif#
- if __BYTE_ORDER == __BIG_ENDIAN#include < asm / byteorder.h > #ifdef __le16_to_cpu
- /* ++roman: 2.1 kernel headers define these function, they're probably more
- * efficient then coding the swaps machine-independently. */
- #define CF_LE_W __le16_to_cpu#define CF_LE_L __le32_to_cpu#define CT_LE_W __cpu_to_le16#define CT_LE_L __cpu_to_le32#
- else#define CF_LE_W(v)((((v) & 0xff) << 8) | (((v) >> 8) & 0xff))#define CF_LE_L(v)(((unsigned)(v) >> 24) | (((unsigned)(v) >> 8) & 0xff00) | \ (((unsigned)(v) << 8) & 0xff0000) | ((unsigned)(v) << 24))#define CT_LE_W(v) CF_LE_W(v)#define CT_LE_L(v) CF_LE_L(v)#endif
- /* defined(__le16_to_cpu) */
- #
- else#define CF_LE_W(v)(v)#define CF_LE_L(v)(v)#define CT_LE_W(v)(v)#define CT_LE_L(v)(v)#endif
- /* __BIG_ENDIAN */
- #define VERSION "2.11"#define VERSION_DATE "12 Mar 2005"
- /* In earlier versions, an own llseek() was used, but glibc lseek() is
- * sufficient (or even better :) for 64 bit offsets in the meantime */
- #define llseek lseek
- /* Constant definitions */
- #define TRUE 1
- /* Boolean constants */
- #define FALSE 0#define TEST_BUFFER_BLOCKS 16#define HARD_SECTOR_SIZE 512#define SECTORS_PER_BLOCK(BLOCK_SIZE / HARD_SECTOR_SIZE)
- /* Macro definitions */
- /* Report a failure message and return a failure error code */
- #define die(str) fatal_error("%s: "str "\n")
- /* Mark a cluster in the FAT as bad */
- #define mark_sector_bad(sector) mark_FAT_sector(sector, FAT_BAD)
- /* Compute ceil(a/b) */
- inline int cdiv(int a, int b) {
- return (a + b - 1) / b;
- }
- /* MS-DOS filesystem structures -- I included them here instead of
- including linux/msdos_fs.h since that doesn't include some fields we
- need */
- #define ATTR_RO 1
- /* read-only */
- #define ATTR_HIDDEN 2
- /* hidden */
- #define ATTR_SYS 4
- /* system */
- #define ATTR_VOLUME 8
- /* volume label */
- #define ATTR_DIR 16
- /* directory */
- #define ATTR_ARCH 32
- /* archived */
- #define ATTR_NONE 0
- /* no attribute bits */
- #define ATTR_UNUSED(ATTR_VOLUME | ATTR_ARCH | ATTR_SYS | ATTR_HIDDEN)
- /* attribute bits that are copied "as is" */
- /* FAT values */
- #define FAT_EOF(atari_format ? 0x0fffffff: 0x0ffffff8)#define FAT_BAD 0x0ffffff7#define MSDOS_EXT_SIGN 0x29
- /* extended boot sector signature */
- #define MSDOS_FAT12_SIGN "FAT12 "
- /* FAT12 filesystem signature */
- #define MSDOS_FAT16_SIGN "FAT16 "
- /* FAT16 filesystem signature */
- #define MSDOS_FAT32_SIGN "FAT32 "
- /* FAT32 filesystem signature */
- #define BOOT_SIGN 0xAA55
- /* Boot sector magic number */
- #define MAX_CLUST_12((1 << 12) - 16)#define MAX_CLUST_16((1 << 16) - 16)#define MIN_CLUST_32 65529
- /* M$ says the high 4 bits of a FAT32 FAT entry are reserved and don't belong
- * to the cluster number. So the max. cluster# is based on 2^28 */
- #define MAX_CLUST_32((1 << 28) - 16)#define FAT12_THRESHOLD 4085#define OLDGEMDOS_MAX_SECTORS 32765#define GEMDOS_MAX_SECTORS 65531#define GEMDOS_MAX_SECTOR_SIZE(16 * 1024)#define BOOTCODE_SIZE 448#define BOOTCODE_FAT32_SIZE 420
- /* __attribute__ ((packed)) is used on all structures to make gcc ignore any
- * alignments */
- struct msdos_volume_info {
- __u8 drive_number;
- /* BIOS drive number */
- __u8 RESERVED;
- /* Unused */
- __u8 ext_boot_sign;
- /* 0x29 if fields below exist (DOS 3.3+) */
- __u8 volume_id[4];
- /* Volume ID number */
- __u8 volume_label[11];
- /* Volume label */
- __u8 fs_type[8];
- /* Typically FAT12 or FAT16 */
- }
- __attribute__((packed));
- struct msdos_boot_sector {
- __u8 boot_jump[3];
- /* Boot strap short or near jump */
- __u8 system_id[8];
- /* Name - can be used to special case
- partition manager volumes */
- __u8 sector_size[2];
- /* bytes per logical sector */
- __u8 cluster_size;
- /* sectors/cluster */
- __u16 reserved;
- /* reserved sectors */
- __u8 fats;
- /* number of FATs */
- __u8 dir_entries[2];
- /* root directory entries */
- __u8 sectors[2];
- /* number of sectors */
- __u8 media;
- /* media code (unused) */
- __u16 fat_length;
- /* sectors/FAT */
- __u16 secs_track;
- /* sectors per track */
- __u16 heads;
- /* number of heads */
- __u32 hidden;
- /* hidden sectors (unused) */
- __u32 total_sect;
- /* number of sectors (if sectors == 0) */
- union {
- struct {
- struct msdos_volume_info vi;
- __u8 boot_code[BOOTCODE_SIZE];
- }
- __attribute__((packed)) _oldfat;
- struct {
- __u32 fat32_length;
- /* sectors/FAT */
- __u16 flags;
- /* bit 8: fat mirroring, low 4: active fat */
- __u8 version[2];
- /* major, minor filesystem version */
- __u32 root_cluster;
- /* first cluster in root directory */
- __u16 info_sector;
- /* filesystem info sector */
- __u16 backup_boot;
- /* backup boot sector */
- __u16 reserved2[6];
- /* Unused */
- struct msdos_volume_info vi;
- __u8 boot_code[BOOTCODE_FAT32_SIZE];
- }
- __attribute__((packed)) _fat32;
- }
- __attribute__((packed)) fstype;
- __u16 boot_sign;
- }
- __attribute__((packed));#define fat32 fstype._fat32#define oldfat fstype._oldfat struct fat32_fsinfo {
- __u32 reserved1;
- /* Nothing as far as I can tell */
- __u32 signature;
- /* 0x61417272L */
- __u32 free_clusters;
- /* Free cluster count. -1 if unknown */
- __u32 next_cluster;
- /* Most recently allocated cluster.
- * Unused under Linux. */
- __u32 reserved2[4];
- };
- struct msdos_dir_entry {
- char name[8],
- ext[3];
- /* name and extension */
- __u8 attr;
- /* attribute bits */
- __u8 lcase;
- /* Case for base and extension */
- __u8 ctime_ms;
- /* Creation time, milliseconds */
- __u16 ctime;
- /* Creation time */
- __u16 cdate;
- /* Creation date */
- __u16 adate;
- /* Last access date */
- __u16 starthi;
- /* high 16 bits of first cl. (FAT32) */
- __u16 time,
- date,
- start;
- /* time, date and first cluster */
- __u32 size;
- /* file size (in bytes) */
- }
- __attribute__((packed));
- /* The "boot code" we put into the filesystem... it writes a message and
- tells the user to try again */
- char dummy_boot_jump[3] = {
- 0xeb,
- 0x3c,
- 0x90
- };
- char dummy_boot_jump_m68k[2] = {
- 0x60,
- 0x1c
- };#define MSG_OFFSET_OFFSET 3 char dummy_boot_code[BOOTCODE_SIZE] = "\x0e"
- /* push cs */
- "\x1f"
- /* pop ds */
- "\xbe\x5b\x7c"
- /* mov si, offset message_txt */
- /* write_msg: */
- "\xac"
- /* lodsb */
- "\x22\xc0"
- /* and al, al */
- "\x74\x0b"
- /* jz key_press */
- "\x56"
- /* push si */
- "\xb4\x0e"
- /* mov ah, 0eh */
- "\xbb\x07\x00"
- /* mov bx, 0007h */
- "\xcd\x10"
- /* int 10h */
- "\x5e"
- /* pop si */
- "\xeb\xf0"
- /* jmp write_msg */
- /* key_press: */
- "\x32\xe4"
- /* xor ah, ah */
- "\xcd\x16"
- /* int 16h */
- "\xcd\x19"
- /* int 19h */
- "\xeb\xfe"
- /* foo: jmp foo */
- /* message_txt: */
- "This is not a bootable disk. Please insert a bootable floppy and\r\n""press any key to try again ... \r\n";#define MESSAGE_OFFSET 29
- /* Offset of message in above code */
- /* Global variables - the root of all evil :-) - see these and weep! */
- static const char * program_name = "mkdosfs";
- /* Name of the program */
- static const char * device_name = NULL;
- /* Name of the device on which to create the filesystem */
- static int atari_format = 0;
- /* Use Atari variation of MS-DOS FS format */
- static int check = FALSE;
- /* Default to no readablity checking */
- static int verbose = 0;
- /* Default to verbose mode off */
- static long volume_id;
- /* Volume ID number */
- static time_t create_time;
- /* Creation time */
- static char volume_name[] = " ";
- /* Volume name */
- static unsigned long long blocks;
- /* Number of blocks in filesystem */
- static int sector_size = 512;
- /* Size of a logical sector */
- static int sector_size_set = 0;
- /* User selected sector size */
- static int backup_boot = 0;
- /* Sector# of backup boot sector */
- static int reserved_sectors = 0;
- /* Number of reserved sectors */
- static int badblocks = 0;
- /* Number of bad blocks in the filesystem */
- static int nr_fats = 2;
- /* Default number of FATs to produce */
- static int size_fat = 0;
- /* Size in bits of FAT entries */
- static int size_fat_by_user = 0;
- /* 1 if FAT size user selected */
- static int dev = -1;
- /* FS block device file handle */
- static int ignore_full_disk = 0;
- /* Ignore warning about 'full' disk devices */
- static off_t currently_testing = 0;
- /* Block currently being tested (if autodetect bad blocks) */
- static struct msdos_boot_sector bs;
- /* Boot sector data */
- static int start_data_sector;
- /* Sector number for the start of the data area */
- static int start_data_block;
- /* Block number for the start of the data area */
- static unsigned char * fat;
- /* File allocation table */
- static unsigned char * info_sector;
- /* FAT32 info sector */
- static struct msdos_dir_entry * root_dir;
- /* Root directory */
- static int size_root_dir;
- /* Size of the root directory in bytes */
- static int sectors_per_cluster = 0;
- /* Number of sectors per disk cluster */
- static int root_dir_entries = 0;
- /* Number of root directory entries */
- static char * blank_sector;
- /* Blank sector - all zeros */
- static int hidden_sectors = 0;
- /* Number of hidden sectors */
- /* Function prototype definitions */
- static void fatal_error(const char * fmt_string);
- static void mark_FAT_cluster(int cluster, unsigned int value);
- static void mark_FAT_sector(int sector, unsigned int value);
- static long do_check(char * buffer, int try1, off_t current_block);
- static void alarm_intr(int alnum);
- static void check_blocks(void);
- static void get_list_blocks(char * filename);
- static int valid_offset(int fd, loff_t offset);
- static unsigned long long count_blocks(char * filename);
- static void check_mount(char * device_name);
- static int establish_params(int device_num, int size);
- static int setup_tables(void);
- static int write_tables(void);
- /* The function implementations */
- /* Handle the reporting of fatal errors. Volatile to let gcc know that this doesn't return */
- static void fatal_error(const char * fmt_string) {
- fprintf(stderr, fmt_string, program_name, device_name);
- //exit (1); /* The error exit code is 1! */
- }
- //add by lightd, 2014-05-13
- #define print_error_info(err_str)\do {\fprintf(stderr, "Err:%s:%d: %s.\n", __FUNCTION__, __LINE__, (const char * ) err_str);\
- } while ( 0 )
- /* Mark the specified cluster as having a particular value */
- static void mark_FAT_cluster(int cluster, unsigned int value) {
- switch (size_fat) {
- case 12:
- value &= 0x0fff;
- if (((cluster * 3) & 0x1) == 0) {
- fat[3 * cluster / 2] = (unsigned char)(value & 0x00ff);
- fat[(3 * cluster / 2) + 1] = (unsigned char)((fat[(3 * cluster / 2) + 1] & 0x00f0) | ((value & 0x0f00) >> 8));
- } else {
- fat[3 * cluster / 2] = (unsigned char)((fat[3 * cluster / 2] & 0x000f) | ((value & 0x000f) << 4));
- fat[(3 * cluster / 2) + 1] = (unsigned char)((value & 0x0ff0) >> 4);
- }
- break;
- case 16:
- value &= 0xffff;
- fat[2 * cluster] = (unsigned char)(value & 0x00ff);
- fat[(2 * cluster) + 1] = (unsigned char)(value >> 8);
- break;
- case 32:
- value &= 0xfffffff;
- fat[4 * cluster] = (unsigned char)(value & 0x000000ff);
- fat[(4 * cluster) + 1] = (unsigned char)((value & 0x0000ff00) >> 8);
- fat[(4 * cluster) + 2] = (unsigned char)((value & 0x00ff0000) >> 16);
- fat[(4 * cluster) + 3] = (unsigned char)((value & 0xff000000) >> 24);
- break;
- default:
- die("Bad FAT size (not 12, 16, or 32)");
- }
- }
- /* Mark a specified sector as having a particular value in it's FAT entry */
- static void mark_FAT_sector(int sector, unsigned int value) {
- int cluster;
- if (0 == (bs.cluster_size)) {
- printf("mark_FAT_sector :: bs.cluster_size = 0 \n");
- return;
- }
- cluster = (sector - start_data_sector) / (int)(bs.cluster_size) / (sector_size / HARD_SECTOR_SIZE);
- if (cluster < 0) die("Invalid cluster number in mark_FAT_sector: probably bug!");
- mark_FAT_cluster(cluster, value);
- }
- /* Perform a test on a block. Return the number of blocks that could be read successfully */
- static long do_check(char * buffer, int try1, off_t current_block) {
- long got;
- if (llseek(dev, current_block * BLOCK_SIZE, SEEK_SET)
- /* Seek to the correct location */
- != current_block * BLOCK_SIZE) die("seek failed during testing for blocks");
- got = read(dev, buffer, try1 * BLOCK_SIZE);
- /* Try reading! */
- if (got < 0) got = 0;
- if (got & (BLOCK_SIZE - 1)) printf("Unexpected values in do_check: probably bugs\n");
- got /= BLOCK_SIZE;
- return got;
- }
- /* Alarm clock handler - display the status of the quest for bad blocks! Then retrigger the alarm for five senconds
- later (so we can come here again) */
- static void alarm_intr(int alnum) {
- if ((unsigned long) currently_testing >= blocks) return;
- signal(SIGALRM, alarm_intr);
- alarm(5);
- if (!currently_testing) return;
- printf("%lld... ", (unsigned long long) currently_testing);
- fflush(stdout);
- }
- static void check_blocks(void) {
- int try1,
- got;
- int i;
- static char blkbuf[BLOCK_SIZE * TEST_BUFFER_BLOCKS];
- if (verbose) {
- printf("Searching for bad blocks ");
- fflush(stdout);
- }
- currently_testing = 0;
- if (verbose) {
- signal(SIGALRM, alarm_intr);
- alarm(5);
- }
- try1 = TEST_BUFFER_BLOCKS;
- while ((unsigned long) currently_testing < blocks) {
- if ((unsigned long)(currently_testing + try1) > blocks) try1 = blocks - currently_testing;
- got = do_check(blkbuf, try1, currently_testing);
- currently_testing += got;
- if (got == try1) {
- try1 = TEST_BUFFER_BLOCKS;
- continue;
- } else try1 = 1;
- if (currently_testing < start_data_block) die("bad blocks before data-area: cannot make fs");
- for (i = 0; i < SECTORS_PER_BLOCK; i++)
- /* Mark all of the sectors in the block as bad */
- mark_sector_bad(currently_testing * SECTORS_PER_BLOCK + i);
- badblocks++;
- currently_testing++;
- }
- if (verbose) printf("\n");
- if (badblocks) printf("%d bad block%s\n", badblocks, (badblocks > 1) ? "s": "");
- }
- static void get_list_blocks(char * filename) {
- int i;
- FILE * listfile;
- unsigned long blockno;
- listfile = fopen(filename, "r");
- if (listfile == (FILE * ) NULL) {
- die("Can't open file of bad blocks");
- return;
- }
- while (!feof(listfile)) {
- fscanf(listfile, "%lu", &blockno);
- for (i = 0; i < SECTORS_PER_BLOCK; i++)
- /* Mark all of the sectors in the block as bad */
- {
- mark_sector_bad(blockno * SECTORS_PER_BLOCK + i);
- }
- badblocks++;
- }
- fclose(listfile);
- if (badblocks) printf("%d bad block%s\n", badblocks, (badblocks > 1) ? "s": "");
- }
- /* Given a file descriptor and an offset, check whether the offset is a valid offset for the file - return FALSE if it
- isn't valid or TRUE if it is */
- static int valid_offset(int fd, loff_t offset) {
- char ch;
- if (llseek(fd, offset, SEEK_SET) < 0) return FALSE;
- if (read(fd, &ch, 1) < 1) return FALSE;
- return TRUE;
- }
- /* Given a filename, look to see how many blocks of BLOCK_SIZE are present, returning the answer */
- static unsigned long long count_blocks(char * filename) {
- off_t high,
- low;
- int fd;
- if ((fd = open(filename, O_RDONLY)) < 0) {
- perror(filename);
- exit(1);
- }
- /* first try SEEK_END, which should work on most devices nowadays */
- if ((low = llseek(fd, 0, SEEK_END)) <= 0) {
- low = 0;
- for (high = 1; valid_offset(fd, high); high *= 2) low = high;
- while (low < high - 1) {
- const loff_t mid = (low + high) / 2;
- if (valid_offset(fd, mid)) low = mid;
- else high = mid;
- }++low;
- }
- close(fd);
- return low / BLOCK_SIZE;
- }
- /* Check to see if the specified device is currently mounted - abort if it is */
- static void check_mount(char * device_name) {
- FILE * f;
- struct mntent * mnt;
- if ((f = setmntent(MOUNTED, "r")) == NULL) return;
- while ((mnt = getmntent(f)) != NULL) if (strcmp(device_name, mnt - >mnt_fsname) == 0) die("%s contains a mounted file system.");
- endmntent(f);
- }
- /* Establish the geometry and media parameters for the device */
- static int establish_params(int device_num, int size) {
- long loop_size;
- struct hd_geometry geometry;
- struct floppy_struct param;
- /* file image or floppy disk */
- if ((0 == device_num) || ((device_num & 0xff00) == 0x0200)) {
- if (0 == device_num) {
- param.size = size / 512;
- switch (param.size) {
- case 720:
- {
- param.sect = 9;
- param.head = 2;
- }
- break;
- case 1440:
- {
- param.sect = 9;
- param.head = 2;
- }
- break;
- case 2400:
- {
- param.sect = 15;
- param.head = 2;
- }
- break;
- case 2880:
- {
- param.sect = 18;
- param.head = 2;
- }
- break;
- case 5760:
- {
- param.sect = 36;
- param.head = 2;
- }
- break;
- default:
- /* fake values */
- {
- param.sect = 32;
- param.head = 64;
- }
- break;
- }
- } else
- /* is a floppy diskette */
- {
- if (ioctl(dev, FDGETPRM, ¶m))
- /* Can we get the diskette geometry? */
- {
- print_error_info("unable to get diskette geometry for '%s'");
- return - 1;
- }
- }
- bs.secs_track = CT_LE_W(param.sect);
- /* Set up the geometry information */
- bs.heads = CT_LE_W(param.head);
- switch (param.size)
- /* Set up the media descriptor byte */
- {
- case 720:
- /* 5.25", 2, 9, 40 - 360K */
- bs.media = (char) 0xfd;
- bs.cluster_size = (char) 2;
- bs.dir_entries[0] = (char) 112;
- bs.dir_entries[1] = (char) 0;
- break;
- case 1440:
- /* 3.5", 2, 9, 80 - 720K */
- bs.media = (char) 0xf9;
- bs.cluster_size = (char) 2;
- bs.dir_entries[0] = (char) 112;
- bs.dir_entries[1] = (char) 0;
- break;
- case 2400:
- /* 5.25", 2, 15, 80 - 1200K */
- bs.media = (char) 0xf9;
- bs.cluster_size = (char)(atari_format ? 2 : 1);
- bs.dir_entries[0] = (char) 224;
- bs.dir_entries[1] = (char) 0;
- break;
- case 5760:
- /* 3.5", 2, 36, 80 - 2880K */
- bs.media = (char) 0xf0;
- bs.cluster_size = (char) 2;
- bs.dir_entries[0] = (char) 224;
- bs.dir_entries[1] = (char) 0;
- break;
- case 2880:
- /* 3.5", 2, 18, 80 - 1440K */
- floppy_default:
- bs.media = (char) 0xf0;
- bs.cluster_size = (char)(atari_format ? 2 : 1);
- bs.dir_entries[0] = (char) 224;
- bs.dir_entries[1] = (char) 0;
- break;
- default:
- /* Anything else */
- if (0 == device_num) {
- goto def_hd_params;
- } else {
- goto floppy_default;
- }
- }
- } else if ((device_num & 0xff00) == 0x0700)
- /* This is a loop device */
- {
- if (ioctl(dev, BLKGETSIZE, &loop_size)) {
- print_error_info("unable to get loop device size");
- return - 2;
- }
- switch (loop_size)
- /* Assuming the loop device -> floppy later */
- {
- case 720:
- /* 5.25", 2, 9, 40 - 360K */
- bs.secs_track = CF_LE_W(9);
- bs.heads = CF_LE_W(2);
- bs.media = (char) 0xfd;
- bs.cluster_size = (char) 2;
- bs.dir_entries[0] = (char) 112;
- bs.dir_entries[1] = (char) 0;
- break;
- case 1440:
- /* 3.5", 2, 9, 80 - 720K */
- bs.secs_track = CF_LE_W(9);
- bs.heads = CF_LE_W(2);
- bs.media = (char) 0xf9;
- bs.cluster_size = (char) 2;
- bs.dir_entries[0] = (char) 112;
- bs.dir_entries[1] = (char) 0;
- break;
- case 2400:
- /* 5.25", 2, 15, 80 - 1200K */
- bs.secs_track = CF_LE_W(15);
- bs.heads = CF_LE_W(2);
- bs.media = (char) 0xf9;
- bs.cluster_size = (char)(atari_format ? 2 : 1);
- bs.dir_entries[0] = (char) 224;
- bs.dir_entries[1] = (char) 0;
- break;
- case 5760:
- /* 3.5", 2, 36, 80 - 2880K */
- bs.secs_track = CF_LE_W(36);
- bs.heads = CF_LE_W(2);
- bs.media = (char) 0xf0;
- bs.cluster_size = (char) 2;
- bs.dir_entries[0] = (char) 224;
- bs.dir_entries[1] = (char) 0;
- break;
- case 2880:
- /* 3.5", 2, 18, 80 - 1440K */
- bs.secs_track = CF_LE_W(18);
- bs.heads = CF_LE_W(2);
- bs.media = (char) 0xf0;
- bs.cluster_size = (char)(atari_format ? 2 : 1);
- bs.dir_entries[0] = (char) 224;
- bs.dir_entries[1] = (char) 0;
- break;
- default:
- /* Anything else: default hd setup */
- printf("Loop device does not match a floppy size, using ""default hd params\n");
- bs.secs_track = CT_LE_W(32);
- /* these are fake values... */
- bs.heads = CT_LE_W(64);
- goto def_hd_params;
- }
- } else
- /* Must be a hard disk then! */
- {
- /* Can we get the drive geometry? (Note I'm not too sure about */
- /* whether to use HDIO_GETGEO or HDIO_REQ) */
- if (ioctl(dev, HDIO_GETGEO, &geometry)) {
- printf("unable to get drive geometry, using default 255/63");
- bs.secs_track = CT_LE_W(63);
- bs.heads = CT_LE_W(255);
- } else {
- bs.secs_track = CT_LE_W(geometry.sectors);
- /* Set up the geometry information */
- bs.heads = CT_LE_W(geometry.heads);
- }
- def_hd_params: bs.media = (char) 0xf8;
- /* Set up the media descriptor for a hard drive */
- bs.dir_entries[0] = (char) 0;
- /* Default to 512 entries */
- bs.dir_entries[1] = (char) 2;
- if (!size_fat && blocks * SECTORS_PER_BLOCK > 1064960) {
- if (verbose) {
- printf("Auto-selecting FAT32 for large filesystem\n");
- }
- size_fat = 32;
- }
- if (size_fat == 32) {
- /* For FAT32, try to do the same as M$'s format command:
- * fs size < 256M: 0.5k clusters
- * fs size < 8G: 4k clusters
- * fs size < 16G: 8k clusters
- * fs size >= 16G: 16k clusters
- */
- unsigned long sz_mb = (blocks + (1 << (20 - BLOCK_SIZE_BITS)) - 1) >> (20 - BLOCK_SIZE_BITS);
- bs.cluster_size = (sz_mb >= 16 * 1024) ? (32) : (sz_mb >= 8 * 1024 ? 16 : (sz_mb >= 256 ? 8 : 1));
- } else {
- /* FAT12 and FAT16: start at 4 sectors per cluster */
- bs.cluster_size = (char) 4;
- }
- }
- return 0;
- }
- /* Create the filesystem data tables */
- static int setup_tables(void) {
- unsigned num_sectors;
- unsigned cluster_count = 0;
- unsigned fat_length;
- unsigned fatdata;
- /* Sectors for FATs + data area */
- struct tm * ctime;
- struct msdos_volume_info * vi = (size_fat == 32 ? &bs.fat32.vi: &bs.oldfat.vi);
- if (atari_format) {
- /* On Atari, the first few bytes of the boot sector are assigned
- * differently: The jump code is only 2 bytes (and m68k machine code
- * :-), then 6 bytes filler (ignored), then 3 byte serial number. */
- strncpy((char * )(bs.system_id - 1), "mkdosf", 6);
- } else {
- strcpy((char * ) bs.system_id, "mkdosfs");
- }
- if (sectors_per_cluster) {
- bs.cluster_size = (char) sectors_per_cluster;
- }
- if (size_fat == 32) {
- /* Under FAT32, the root dir is in a cluster chain, and this is
- * signalled by bs.dir_entries being 0. */
- bs.dir_entries[0] = bs.dir_entries[1] = (char) 0;
- root_dir_entries = 0;
- } else if (root_dir_entries) {
- /* Override default from establish_params() */
- bs.dir_entries[0] = (char)(root_dir_entries & 0x00ff);
- bs.dir_entries[1] = (char)((root_dir_entries & 0xff00) >> 8);
- } else {
- root_dir_entries = bs.dir_entries[0] + (bs.dir_entries[1] << 8);
- }
- if (atari_format) {
- bs.system_id[5] = (unsigned char)(volume_id & 0x000000ff);
- bs.system_id[6] = (unsigned char)((volume_id & 0x0000ff00) >> 8);
- bs.system_id[7] = (unsigned char)((volume_id & 0x00ff0000) >> 16);
- } else {
- vi - >volume_id[0] = (unsigned char)(volume_id & 0x000000ff);
- vi - >volume_id[1] = (unsigned char)((volume_id & 0x0000ff00) >> 8);
- vi - >volume_id[2] = (unsigned char)((volume_id & 0x00ff0000) >> 16);
- vi - >volume_id[3] = (unsigned char)(volume_id >> 24);
- }
- if (!atari_format) {
- memcpy(vi - >volume_label, volume_name, 11);
- memcpy(bs.boot_jump, dummy_boot_jump, 3);
- /* Patch in the correct offset to the boot code */
- bs.boot_jump[1] = ((size_fat == 32 ? (char * ) & bs.fat32.boot_code: (char * ) & bs.oldfat.boot_code) - (char * ) & bs) - 2;
- if (size_fat == 32) {
- int offset = (char * ) & bs.fat32.boot_code - (char * ) & bs + MESSAGE_OFFSET + 0x7c00;
- if (dummy_boot_code[BOOTCODE_FAT32_SIZE - 1]) {
- printf("Warning: message too long; truncated\n");
- }
- dummy_boot_code[BOOTCODE_FAT32_SIZE - 1] = 0;
- memcpy(bs.fat32.boot_code, dummy_boot_code, BOOTCODE_FAT32_SIZE);
- bs.fat32.boot_code[MSG_OFFSET_OFFSET] = offset & 0xff;
- bs.fat32.boot_code[MSG_OFFSET_OFFSET + 1] = offset >> 8;
- } else {
- memcpy(bs.oldfat.boot_code, dummy_boot_code, BOOTCODE_SIZE);
- }
- bs.boot_sign = CT_LE_W(BOOT_SIGN);
- } else {
- memcpy(bs.boot_jump, dummy_boot_jump_m68k, 2);
- }
- if (verbose >= 2) {
- printf("Boot jump code is %02x %02x\n", bs.boot_jump[0], bs.boot_jump[1]);
- }
- if (!reserved_sectors) {
- reserved_sectors = (size_fat == 32) ? 32 : 1;
- } else {
- if (size_fat == 32 && reserved_sectors < 2) {
- print_error_info("On FAT32 at least 2 reserved sectors are needed.");
- return - 1;
- }
- }
- bs.reserved = CT_LE_W(reserved_sectors);
- if (verbose >= 2) {
- printf("Using %d reserved sectors\n", reserved_sectors);
- }
- bs.fats = (char) nr_fats;
- if (!atari_format || size_fat == 32) {
- bs.hidden = CT_LE_L(hidden_sectors);
- } else {
- /* In Atari format, hidden is a 16 bit field */
- __u16 hidden = CT_LE_W(hidden_sectors);
- if (hidden_sectors & ~0xffff) {
- print_error_info("#hidden doesn't fit in 16bit field of Atari format\n");
- return - 2;
- }
- memcpy( & bs.hidden, &hidden, 2);
- }
- num_sectors = (long long)(blocks) * BLOCK_SIZE / sector_size;
- if (!atari_format) {
- unsigned fatlength12,
- fatlength16,
- fatlength32;
- unsigned maxclust12,
- maxclust16,
- maxclust32;
- unsigned clust12,
- clust16,
- clust32;
- int maxclustsize;
- fatdata = num_sectors - cdiv(root_dir_entries * 32, sector_size) - reserved_sectors;
- if (sectors_per_cluster) {
- bs.cluster_size = maxclustsize = sectors_per_cluster;
- } else {
- /* An initial guess for bs.cluster_size should already be set */
- maxclustsize = 128;
- }
- if (verbose >= 2) {
- printf("%u sectors for FAT+data, starting with %d sectors/cluster\n", fatdata, bs.cluster_size);
- }
- do {
- if (verbose >= 2) {
- printf("Trying with %d sectors/cluster:\n", bs.cluster_size);
- }
- /* The factor 2 below avoids cut-off errors for nr_fats == 1.
- * The "nr_fats*3" is for the reserved first two FAT entries */
- clust12 = 2 * ((long long) fatdata * sector_size + nr_fats * 3) / (2 * (int) bs.cluster_size * sector_size + nr_fats * 3);
- fatlength12 = cdiv(((clust12 + 2) * 3 + 1) >> 1, sector_size);
- /* Need to recalculate number of clusters, since the unused parts of the
- * FATS and data area together could make up space for an additional,
- * not really present cluster. */
- clust12 = (fatdata - nr_fats * fatlength12) / bs.cluster_size;
- maxclust12 = (fatlength12 * 2 * sector_size) / 3;
- if (maxclust12 > MAX_CLUST_12) {
- maxclust12 = MAX_CLUST_12;
- }
- if (verbose >= 2) {
- printf("FAT12: #clu=%u, fatlen=%u, maxclu=%u, limit=%u\n", clust12, fatlength12, maxclust12, MAX_CLUST_12);
- }
- if (clust12 > maxclust12 - 2) {
- clust12 = 0;
- if (verbose >= 2) {
- printf("FAT12: too much clusters\n");
- }
- }
- clust16 = ((long long) fatdata * sector_size + nr_fats * 4) / ((int) bs.cluster_size * sector_size + nr_fats * 2);
- fatlength16 = cdiv((clust16 + 2) * 2, sector_size);
- /* Need to recalculate number of clusters, since the unused parts of the
- * FATS and data area together could make up space for an additional,
- * not really present cluster. */
- clust16 = (fatdata - nr_fats * fatlength16) / bs.cluster_size;
- maxclust16 = (fatlength16 * sector_size) / 2;
- if (maxclust16 > MAX_CLUST_16) {
- maxclust16 = MAX_CLUST_16;
- }
- if (verbose >= 2) {
- printf("FAT16: #clu=%u, fatlen=%u, maxclu=%u, limit=%u\n", clust16, fatlength16, maxclust16, MAX_CLUST_16);
- }
- if (clust16 > maxclust16 - 2) {
- if (verbose >= 2) {
- printf("FAT16: too much clusters\n");
- }
- clust16 = 0;
- }
- /* The < 4078 avoids that the filesystem will be misdetected as having a
- * 12 bit FAT. */
- if (clust16 < FAT12_THRESHOLD && !(size_fat_by_user && size_fat == 16)) {
- if (verbose >= 2) {
- printf(clust16 < FAT12_THRESHOLD ? "FAT16: would be misdetected as FAT12\n": "FAT16: too much clusters\n");
- }
- clust16 = 0;
- }
- clust32 = ((long long) fatdata * sector_size + nr_fats * 8) / ((int) bs.cluster_size * sector_size + nr_fats * 4);
- fatlength32 = cdiv((clust32 + 2) * 4, sector_size);
- /* Need to recalculate number of clusters, since the unused parts of the
- * FATS and data area together could make up space for an additional,
- * not really present cluster. */
- clust32 = (fatdata - nr_fats * fatlength32) / bs.cluster_size;
- maxclust32 = (fatlength32 * sector_size) / 4;
- if (maxclust32 > MAX_CLUST_32) {
- maxclust32 = MAX_CLUST_32;
- }
- if (clust32 && clust32 < MIN_CLUST_32 && !(size_fat_by_user && size_fat == 32)) {
- clust32 = 0;
- if (verbose >= 2) {
- printf("FAT32: not enough clusters (%d)\n", MIN_CLUST_32);
- }
- }
- if (verbose >= 2) {
- printf("FAT32: #clu=%u, fatlen=%u, maxclu=%u, limit=%u\n", clust32, fatlength32, maxclust32, MAX_CLUST_32);
- }
- if (clust32 > maxclust32) {
- clust32 = 0;
- if (verbose >= 2) {
- printf("FAT32: too much clusters\n");
- }
- }
- if ((clust12 && (size_fat == 0 || size_fat == 12)) || (clust16 && (size_fat == 0 || size_fat == 16)) || (clust32 && size_fat == 32)) {
- break;
- }
- bs.cluster_size <<= 1;
- } while ( bs . cluster_size && ( bs . cluster_size <= maxclustsize ));
- /* Use the optimal FAT size if not specified;
- * FAT32 is (not yet) choosen automatically */
- if (!size_fat) {
- size_fat = (clust16 > clust12) ? 16 : 12;
- if (verbose >= 2) {
- printf("Choosing %d bits for FAT\n", size_fat);
- }
- }
- switch (size_fat) {
- case 12:
- {
- cluster_count = clust12;
- fat_length = fatlength12;
- bs.fat_length = CT_LE_W(fatlength12);
- memcpy(vi - >fs_type, MSDOS_FAT12_SIGN, 8);
- }
- break;
- case 16:
- {
- if (clust16 < FAT12_THRESHOLD) {
- if (size_fat_by_user) {
- fprintf(stderr, "WARNING: Not enough clusters for a ""16 bit FAT! The filesystem will be\n""misinterpreted as having a 12 bit FAT without ""mount option \"fat=16\".\n");
- } else {
- fprintf(stderr, "This filesystem has an unfortunate size. ""A 12 bit FAT cannot provide\n""enough clusters, but a 16 bit FAT takes up a little ""bit more space so that\n""the total number of clusters becomes less than the ""threshold value for\n""distinction between 12 and 16 bit FATs.\n");
- print_error_info("Make the file system a bit smaller manually.");
- return - 3;
- }
- }
- cluster_count = clust16;
- fat_length = fatlength16;
- bs.fat_length = CT_LE_W(fatlength16);
- memcpy(vi - >fs_type, MSDOS_FAT16_SIGN, 8);
- }
- break;
- case 32:
- {
- cluster_count = clust32;
- fat_length = fatlength32;
- bs.fat_length = CT_LE_W(0);
- bs.fat32.fat32_length = CT_LE_L(fatlength32);
- memcpy(vi - >fs_type, MSDOS_FAT32_SIGN, 8);
- }
- break;
- default:
- {
- print_error_info("FAT not 12, 16 or 32 bits");
- return - 4;
- }
- break;
- }
- } else {
- unsigned clusters,
- maxclust;
- /* GEMDOS always uses a 12 bit FAT on floppies, and always a 16 bit FAT on
- * hard disks. So use 12 bit if the size of the file system suggests that
- * this fs is for a floppy disk, if the user hasn't explicitly requested a
- * size.
- */
- if (!size_fat) {
- size_fat = (num_sectors == 1440 || num_sectors == 2400 || num_sectors == 2880 || num_sectors == 5760) ? 12 : 16;
- }
- if (verbose >= 2) {
- printf("Choosing %d bits for FAT\n", size_fat);
- }
- /* Atari format: cluster size should be 2, except explicitly requested by
- * the user, since GEMDOS doesn't like other cluster sizes very much.
- * Instead, tune the sector size for the FS to fit.
- */
- bs.cluster_size = sectors_per_cluster ? sectors_per_cluster: 2;
- if (!sector_size_set) {
- while (num_sectors > GEMDOS_MAX_SECTORS) {
- num_sectors >>= 1;
- sector_size <<= 1;
- }
- }
- if (verbose >= 2) {
- printf("Sector size must be %d to have less than %d log. sectors\n", sector_size, GEMDOS_MAX_SECTORS);
- }
- /* Check if there are enough FAT indices for how much clusters we have */
- do {
- fatdata = (num_sectors - cdiv(root_dir_entries * 32, sector_size) - reserved_sectors);
- /* The factor 2 below avoids cut-off errors for nr_fats == 1 and
- * size_fat == 12
- * The "2*nr_fats*size_fat/8" is for the reserved first two FAT entries
- */
- clusters = (2 * ((long long) fatdata * sector_size - 2 * nr_fats * size_fat / 8)) / (2 * ((int) bs.cluster_size * sector_size + nr_fats * size_fat / 8));
- fat_length = cdiv((clusters + 2) * size_fat / 8, sector_size);
- /* Need to recalculate number of clusters, since the unused parts of the
- * FATS and data area together could make up space for an additional,
- * not really present cluster. */
- clusters = (fatdata - nr_fats * fat_length) / bs.cluster_size;
- maxclust = (fat_length * sector_size * 8) / size_fat;
- if (verbose >= 2) {
- printf("ss=%d: #clu=%u, fat_len=%u, maxclu=%u\n", sector_size, clusters, fat_length, maxclust);
- }
- /* last 10 cluster numbers are special (except FAT32: 4 high bits rsvd);
- * first two numbers are reserved */
- if (maxclust <= (unsigned)(size_fat == 32 ? MAX_CLUST_32: (1 << size_fat) - 0x10) && clusters <= maxclust - 2) {
- break;
- }
- if (verbose >= 2) {
- printf(clusters > maxclust - 2 ? "Too many clusters\n": "FAT too big\n");
- }
- /* need to increment sector_size once more to */
- if (sector_size_set) {
- print_error_info("With this sector size, the maximum number of FAT entries ""would be exceeded.");
- return - 5;
- }
- num_sectors >>= 1;
- sector_size <<= 1;
- } while ( sector_size <= GEMDOS_MAX_SECTOR_SIZE );
- if (sector_size > GEMDOS_MAX_SECTOR_SIZE) {
- print_error_info("Would need a sector size > 16k, which GEMDOS can't work with");
- return - 6;
- }
- cluster_count = clusters;
- if (size_fat != 32) {
- bs.fat_length = CT_LE_W(fat_length);
- } else {
- bs.fat_length = 0;
- bs.fat32.fat32_length = CT_LE_L(fat_length);
- }
- }
- bs.sector_size[0] = (char)(sector_size & 0x00ff);
- bs.sector_size[1] = (char)((sector_size & 0xff00) >> 8);
- if (size_fat == 32) {
- /* set up additional FAT32 fields */
- bs.fat32.flags = CT_LE_W(0);
- bs.fat32.version[0] = 0;
- bs.fat32.version[1] = 0;
- bs.fat32.root_cluster = CT_LE_L(2);
- bs.fat32.info_sector = CT_LE_W(1);
- if (!backup_boot) {
- backup_boot = (reserved_sectors >= 7) ? (6) : ((reserved_sectors >= 2) ? (reserved_sectors - 1) : 0);
- } else {
- if (backup_boot == 1) {
- print_error_info("Backup boot sector must be after sector 1");
- return - 7;
- } else if (backup_boot >= reserved_sectors) {
- print_error_info("Backup boot sector must be a reserved sector");
- return - 8;
- }
- }
- if (verbose >= 2) {
- printf("Using sector %d as backup boot sector (0 = none)\n", backup_boot);
- }
- bs.fat32.backup_boot = CT_LE_W(backup_boot);
- memset( & bs.fat32.reserved2, 0, sizeof(bs.fat32.reserved2));
- }
- if (atari_format) {
- /* Just some consistency checks */
- if (num_sectors >= GEMDOS_MAX_SECTORS) {
- print_error_info("GEMDOS can't handle more than 65531 sectors");
- return - 9;
- } else if (num_sectors >= OLDGEMDOS_MAX_SECTORS) {
- printf("Warning: More than 32765 sector need TOS 1.04 ""or higher.\n");
- }
- }
- if (num_sectors >= 65536) {
- bs.sectors[0] = (char) 0;
- bs.sectors[1] = (char) 0;
- bs.total_sect = CT_LE_L(num_sectors);
- } else {
- bs.sectors[0] = (char)(num_sectors & 0x00ff);
- bs.sectors[1] = (char)((num_sectors & 0xff00) >> 8);
- if (!atari_format) bs.total_sect = CT_LE_L(0);
- }
- if (!atari_format) {
- vi - >ext_boot_sign = MSDOS_EXT_SIGN;
- }
- if (!cluster_count) {
- if (sectors_per_cluster)
- /* If yes, die if we'd spec'd sectors per cluster */
- {
- print_error_info("Too many clusters for file system - try more sectors per cluster");
- return - 10;
- } else {
- print_error_info("Attempting to create a too large file system");
- return - 11;
- }
- }
- /* The two following vars are in hard sectors, i.e. 512 byte sectors! */
- start_data_sector = (reserved_sectors + nr_fats * fat_length) * (sector_size / HARD_SECTOR_SIZE);
- start_data_block = (start_data_sector + SECTORS_PER_BLOCK - 1) / SECTORS_PER_BLOCK;
- if (blocks < (unsigned int)(start_data_block + 32))
- /* Arbitrary undersize file system! */
- {
- print_error_info("Too few blocks for viable file system");
- return - 12;
- }
- if (verbose) {
- printf("%s has %d head%s and %d sector%s per track,\n", device_name, \CF_LE_W(bs.heads), \ (CF_LE_W(bs.heads) != 1) ? "s": "", \CF_LE_W(bs.secs_track), \ (CF_LE_W(bs.secs_track) != 1) ? "s": "");
- printf("logical sector size is %d,\n", sector_size);
- printf("using 0x%02x media descriptor, with %u sectors;\n", (int)(bs.media), num_sectors);
- printf("file system has %d %d-bit FAT%s and %d sector%s per cluster.\n", (int)(bs.fats), \size_fat, (bs.fats != 1) ? "s": "", (int)(bs.cluster_size), \ (bs.cluster_size != 1) ? "s": "");
- printf("FAT size is %u sector%s, and provides %u cluster%s.\n", fat_length, \ (fat_length != 1) ? "s": "", cluster_count, (cluster_count != 1) ? "s": "");
- if (size_fat != 32) {
- printf("Root directory contains %d slots.\n", (int)(bs.dir_entries[0]) + (int)(bs.dir_entries[1]) * 256);
- }
- printf("Volume ID is %08lx, ", volume_id & (atari_format ? 0x00ffffff: 0xffffffff));
- if (strcmp(volume_name, " ")) {
- printf("volume label %s.\n", volume_name);
- } else {
- printf("no volume label.\n");
- }
- }
- /* Make the file allocation tables! */
- if ((fat = (unsigned char * ) malloc(fat_length * sector_size)) == NULL) {
- print_error_info("unable to allocate space for FAT image in memory");
- return - 13;
- }
- memset(fat, 0, fat_length * sector_size);
- mark_FAT_cluster(0, 0xffffffff);
- /* Initial fat entries */
- mark_FAT_cluster(1, 0xffffffff);
- fat[0] = (unsigned char) bs.media;
- /* Put media type in first byte! */
- if (size_fat == 32) {
- /* Mark cluster 2 as EOF (used for root dir) */
- mark_FAT_cluster(2, FAT_EOF);
- }
- /* Make the root directory entries */
- size_root_dir = (size_fat == 32) ? \bs.cluster_size * sector_size: \ (((int) bs.dir_entries[1] * 256 + (int) bs.dir_entries[0]) * sizeof(struct msdos_dir_entry));
- if ((root_dir = (struct msdos_dir_entry * ) malloc(size_root_dir)) == NULL) {
- if (fat) {
- free(fat);
- /* Tidy up before we die! */
- fat = NULL;
- }
- print_error_info("unable to allocate space for root directory in memory");
- return - 14;
- }
- memset(root_dir, 0, size_root_dir);
- if (memcmp(volume_name, " ", 11)) {
- struct msdos_dir_entry * de = &root_dir[0];
- memcpy(de - >name, volume_name, 8);
- de - >attr = ATTR_VOLUME;
- ctime = localtime( & create_time);
- de - >time = CT_LE_W((unsigned short)((ctime - >tm_sec >> 1) + (ctime - >tm_min << 5) + (ctime - >tm_hour << 11)));
- de - >date = CT_LE_W((unsigned short)(ctime - >tm_mday + ((ctime - >tm_mon + 1) << 5) + ((ctime - >tm_year - 80) << 9)));
- de - >ctime_ms = 0;
- de - >ctime = de - >time;
- de - >cdate = de - >date;
- de - >adate = de - >date;
- de - >starthi = CT_LE_W(0);
- de - >start = CT_LE_W(0);
- de - >size = CT_LE_L(0);
- }
- if (size_fat == 32) {
- /* For FAT32, create an info sector */
- struct fat32_fsinfo * info;
- if (! (info_sector = (unsigned char * ) malloc(sector_size))) {
- print_error_info("Out of memory");
- return - 15;
- }
- memset(info_sector, 0, sector_size);
- /* fsinfo structure is at offset 0x1e0 in info sector by observation */
- info = (struct fat32_fsinfo * )(info_sector + 0x1e0);
- /* Info sector magic */
- info_sector[0] = 'R';
- info_sector[1] = 'R';
- info_sector[2] = 'a';
- info_sector[3] = 'A';
- /* Magic for fsinfo structure */
- info - >signature = CT_LE_L(0x61417272);
- /* We've allocated cluster 2 for the root dir. */
- info - >free_clusters = CT_LE_L(cluster_count - 1);
- info - >next_cluster = CT_LE_L(2);
- /* Info sector also must have boot sign */
- * (__u16 * )(info_sector + 0x1fe) = CT_LE_W(BOOT_SIGN);
- }
- if (! (blank_sector = (char * ) malloc(sector_size))) {
- print_error_info("Out of memory");
- return - 16;
- }
- memset(blank_sector, 0, sector_size);
- return 0;
- }
- /* Write the new filesystem's data tables to wherever they're going to end up! */
- //modify by lightd, forbid kill main process
- //new line connect symbol '\', must be need it, or occur warning(in c100 project, that equal errors) - noted by lightd
- #define error(err_str, errno)\do {\free(fat);\
- if (info_sector)\ {\free(info_sector);\
- }\free(root_dir);\print_error_info(err_str);\
- return (errno);\
- } while ( 0 )#define seekto(pos, errstr, errno)\do {\loff_t __pos = (pos);\
- if (llseek(dev, __pos, SEEK_SET) != __pos)\ {\error("seek to "errstr " failed whilst writing tables", errno);\
- }\
- } while ( 0 )#define writebuf(buf, size, errstr, errno)\do {\int __size = (size);\
- if (write(dev, buf, __size) != __size)\ {\error("failed whilst writing "errstr, errno);\
- }\
- } while ( 0 ) static int write_tables(void) {
- int x;
- int fat_length;
- fat_length = (size_fat == 32) ? CF_LE_L(bs.fat32.fat32_length) : CF_LE_W(bs.fat_length);
- seekto(0, "start of device", -1);
- /* clear all reserved sectors */
- for (x = 0; x < reserved_sectors; ++x) {
- writebuf(blank_sector, sector_size, "reserved sector", -2);
- }
- /* seek back to sector 0 and write the boot sector */
- seekto(0, "boot sector", -3);
- writebuf((char * ) & bs, sizeof(struct msdos_boot_sector), "boot sector", -4);
- /* on FAT32, write the info sector and backup boot sector */
- if (size_fat == 32) {
- seekto(CF_LE_W(bs.fat32.info_sector) * sector_size, "info sector", -5);
- writebuf(info_sector, 512, "info sector", -6);
- if (backup_boot != 0) {
- seekto(backup_boot * sector_size, "backup boot sector", -7);
- writebuf((char * ) & bs, sizeof(struct msdos_boot_sector), "backup boot sector", -8);
- }
- }
- /* seek to start of FATS and write them all */
- seekto(reserved_sectors * sector_size, "first FAT", -9);
- for (x = 1; x <= nr_fats; x++) {
- writebuf(fat, fat_length * sector_size, "FAT", -10);
- }
- /* Write the root directory directly after the last FAT. This is the root
- * dir area on FAT12/16, and the first cluster on FAT32. */
- writebuf((char * ) root_dir, size_root_dir, "root directory", -11);
- if (blank_sector) {
- free(blank_sector);
- blank_sector = NULL;
- }
- if (info_sector) {
- free(info_sector);
- info_sector = NULL;
- }
- free(root_dir);
- /* Free up the root directory space from setup_tables */
- free(fat);
- /* Free up the fat table space reserved during setup_tables */
- return 0;
- }
- /* Report the command usage and return a failure error code */
- void usage(void) {
- fprintf(stderr, "\
- Usage: mkdosfs [-A] [-c] [-C] [-v] [-I] [-l bad-block-file] [-b backup-boot-sector]\n\
- [-m boot-msg-file] [-n volume-name] [-i volume-id]\n\
- [-s sectors-per-cluster] [-S logical-sector-size] [-f number-of-FATs]\n\
- [-h hidden-sectors] [-F fat-size] [-r root-dir-entries] [-R reserved-sectors]\n\
- /dev/name [blocks]\n");
- }
- /*
- * ++roman: On m68k, check if this is an Atari; if yes, turn on Atari variant
- * of MS-DOS filesystem by default.
- */
- static void check_atari(void) {#ifdef __mc68000__ FILE * f;
- char line[128];
- char * p = NULL;
- if (! (f = fopen("/proc/hardware", "r"))) {
- perror("/proc/hardware");
- return;
- }
- while (fgets(line, sizeof(line), f)) {
- if (strncmp(line, "Model:", 6) == 0) {
- p = line + 6;
- p += strspn(p, " \t");
- if (strncmp(p, "Atari ", 6) == 0) {
- atari_format = 1;
- }
- break;
- }
- }
- fclose(f);#endif
- }
- /* The "main" entry point into the utility - we pick up the options and attempt to process them in some sort of sensible
- way. In the event that some/all of the options are invalid we need to tell the user so that something can be done! */
- int main(int argc, char * *argv) {
- char * tmp;
- char * listfile = NULL;
- int i = 0;
- int pos;
- int ch;
- int create = 0;
- int c;
- int ret;
- unsigned long long cblocks = 0;
- FILE * msgfile;
- struct stat statbuf;
- if (argc && *argv)
- /* What's the program name? */
- {
- char * p = NULL;
- program_name = *argv;
- if ((p = strrchr(program_name, '/'))) program_name = p + 1;
- }
- time( & create_time);
- volume_id = (long) create_time;
- /* Default volume ID = creation time */
- check_atari();
- printf("%s "VERSION " ("VERSION_DATE ")\n", program_name);
- /* Scan the command line for options */
- while ((c = getopt(argc, argv, "AbcCf:F:Ii:l:m:n:r:R:s:S:h:v")) != EOF) {
- switch (c) {
- case 'A':
- /* toggle Atari format */
- {
- atari_format = !atari_format;
- }
- break;
- case 'b':
- /* b : location of backup boot sector */
- {
- backup_boot = (int) strtol(optarg, &tmp, 0);
- if ( * tmp || backup_boot < 2 || backup_boot > 0xffff) {
- printf("Bad location for backup boot sector : %s\n", optarg);
- usage();
- return - 1;
- }
- }
- break;
- case 'c':
- /* c : Check FS as we build it */
- {
- check = TRUE;
- }
- break;
- case 'C':
- /* C : Create a new file */
- {
- create = TRUE;
- }
- break;
- case 'f':
- /* f : Choose number of FATs */
- {
- nr_fats = (int) strtol(optarg, &tmp, 0);
- if ( * tmp || nr_fats < 1 || nr_fats > 4) {
- printf("Bad number of FATs : %s\n", optarg);
- usage();
- return - 2;
- }
- }
- break;
- case 'F':
- /* F : Choose FAT size */
- {
- size_fat = (int) strtol(optarg, &tmp, 0);
- if ( * tmp || (size_fat != 12 && size_fat != 16 && size_fat != 32)) {
- printf("Bad FAT type : %s\n", optarg);
- usage();
- return - 3;
- }
- size_fat_by_user = 1;
- }
- break;
- case 'h':
- /* h : number of hidden sectors */
- {
- hidden_sectors = (int) strtol(optarg, &tmp, 0);
- if ( * tmp || hidden_sectors < 0) {
- printf("Bad number of hidden sectors : %s\n", optarg);
- usage();
- return - 4;
- }
- }
- break;
- case 'I':
- {
- ignore_full_disk = 1;
- }
- break;
- case 'i':
- /* i : specify volume ID */
- {
- volume_id = strtoul(optarg, &tmp, 16);
- if ( * tmp) {
- printf("Volume ID must be a hexadecimal number\n");
- usage();
- return - 5;
- }
- }
- break;
- case 'l':
- /* l : Bad block filename */
- {
- listfile = optarg;
- }
- break;
- case 'm':
- /* m : Set boot message */
- {
- if (strcmp(optarg, "-")) {
- msgfile = fopen(optarg, "r");
- if (!msgfile) {
- perror(optarg);
- }
- } else {
- msgfile = stdin;
- }
- if (msgfile) {
- /* The boot code ends at offset 448 and needs a null terminator */
- i = MESSAGE_OFFSET;
- pos = 0;
- /* We are at beginning of line */
- do {
- ch = getc(msgfile);
- switch (ch) {
- case '\r':
- /* Ignore CRs */
- case '\0':
- /* and nulls */
- break;
- case '\n':
- /* LF -> CR+LF if necessary */
- if (pos)
- /* If not at beginning of line */
- {
- dummy_boot_code[i++] = '\r';
- pos = 0;
- }
- dummy_boot_code[i++] = '\n';
- break;
- case '\t':
- /* Expand tabs */
- do {
- dummy_boot_code[i++] = ' ';
- pos++;
- } while ( pos % 8 && i < BOOTCODE_SIZE - 1 );
- break;
- case EOF:
- dummy_boot_code[i++] = '\0';
- /* Null terminator */
- break;
- default:
- dummy_boot_code[i++] = ch;
- /* Store character */
- pos++;
- /* Advance position */
- break;
- }
- } while ( ch != EOF && i < BOOTCODE_SIZE - 1 );
- /* Fill up with zeros */
- while (i < BOOTCODE_SIZE - 1) {
- dummy_boot_code[i++] = '\0';
- }
- dummy_boot_code[BOOTCODE_SIZE - 1] = '\0';
- /* Just in case */
- if (ch != EOF) {
- printf("Warning: message too long; truncated\n");
- }
- if (msgfile != stdin) {
- fclose(msgfile);
- }
- }
- }
- break;
- case 'n':
- /* n : Volume name */
- {
- sprintf(volume_name, "%-11.11s", optarg);
- }
- break;
- case 'r':
- /* r : Root directory entries */
- {
- root_dir_entries = (int) strtol(optarg, &tmp, 0);
- if ( * tmp || root_dir_entries < 16 || root_dir_entries > 32768) {
- printf("Bad number of root directory entries : %s\n", optarg);
- usage();
- return - 6;
- }
- }
- break;
- case 'R':
- /* R : number of reserved sectors */
- {
- reserved_sectors = (int) strtol(optarg, &tmp, 0);
- if ( * tmp || reserved_sectors < 1 || reserved_sectors > 0xffff) {
- printf("Bad number of reserved sectors : %s\n", optarg);
- usage();
- return - 7;
- }
- }
- break;
- case 's':
- /* s : Sectors per cluster */
- {
- sectors_per_cluster = (int) strtol(optarg, &tmp, 0);
- if ( * tmp || (sectors_per_cluster != 1 && sectors_per_cluster != 2 && sectors_per_cluster != 4 && sectors_per_cluster != 8 && sectors_per_cluster != 16 && sectors_per_cluster != 32 && sectors_per_cluster != 64 && sectors_per_cluster != 128)) {
- printf("Bad number of sectors per cluster : %s\n", optarg);
- usage();
- return - 8;
- }
- }
- break;
- case 'S':
- /* S : Sector size */
- {
- sector_size = (int) strtol(optarg, &tmp, 0);
- if ( * tmp || (sector_size != 512 && sector_size != 1024 && sector_size != 2048 && sector_size != 4096 && sector_size != 8192 && sector_size != 16384 && sector_size != 32768)) {
- printf("Bad logical sector size : %s\n", optarg);
- usage();
- return - 9;
- }
- sector_size_set = 1;
- }
- break;
- case 'v':
- /* v : Verbose execution */
- {++verbose;
- }
- break;
- default:
- {
- printf("Unknown option: %c\n", c);
- usage();
- return - 10;
- }
- break;
- }
- }
- if (optind < argc) {
- device_name = argv[optind];
- /* Determine the number of blocks in the FS */
- if (!create) {
- cblocks = count_blocks((char * ) device_name);
- /* Have a look and see! */
- }
- }
- if (optind == argc - 2)
- /* Either check the user specified number */
- {
- blocks = strtoull(argv[optind + 1], &tmp, 0);
- if (!create && blocks != cblocks) {
- fprintf(stderr, "Warning: block count mismatch: ");
- fprintf(stderr, "found %llu but assuming %llu.\n", cblocks, blocks);
- }
- } else if (optind == argc - 1)
- /* Or use value found */
- {
- if (create) {
- print_error_info("Need intended size with -C.\n");
- return - 11;
- }
- blocks = cblocks;
- tmp = (char * )"";
- } else {
- print_error_info("No device specified!\n");
- usage();
- return - 11;
- }
- if ( * tmp) {
- fprintf(stderr, "Bad block count : %s\n", argv[optind + 1]);
- usage();
- return - 12;
- }
- if (check && listfile)
- /* Auto and specified bad block handling are mutually */
- {
- print_error_info("-c and -l are incompatible\n");
- /* exclusive of each other! */
- return - 13;
- }
- if (!create) {
- check_mount((char * ) device_name);
- /* Is the device already mounted? */
- dev = open(device_name, O_RDWR);
- /* Is it a suitable device to build the FS on? */
- if (dev < 0) {
- print_error_info("unable to open %s\n");
- return - 14;
- }
- } else {
- off_t offset = blocks * BLOCK_SIZE - 1;
- char null = 0;
- /* create the file */
- dev = open(device_name, O_RDWR | O_CREAT | O_TRUNC, 0666);
- if (dev < 0) {
- print_error_info("unable to create %s\n");
- return - 15;
- }
- /* seek to the intended end-1, and write one byte. this creates a
- * sparse-as-possible file of appropriate size. */
- if (llseek(dev, offset, SEEK_SET) != offset) {
- print_error_info("seek failed.\n");
- return - 16;
- }
- if (write(dev, &null, 1) < 0) {
- print_error_info("write failed");
- return - 17;
- }
- if (llseek(dev, 0, SEEK_SET) != 0) {
- print_error_info("seek failed");
- return - 18;
- }
- }
- if (fstat(dev, &statbuf) < 0) {
- print_error_info("unable to stat %s");
- return - 19;
- }
- if (!S_ISBLK(statbuf.st_mode)) {
- statbuf.st_rdev = 0;
- check = 0;
- } else if (!ignore_full_disk && ((statbuf.st_rdev & 0xff3f) == 0x0300 ||
- /* hda, hdb */
- (statbuf.st_rdev & 0xff0f) == 0x0800 ||
- /* sd */
- (statbuf.st_rdev & 0xff3f) == 0x0d00 ||
- /* xd */
- (statbuf.st_rdev & 0xff3f) == 0x1600)
- /* hdc, hdd */
- ) {
- /*
- * Ignore any 'full' fixed disk devices, if -I is not given.
- * On a MO-disk one doesn't need partitions. The filesytem can go
- * directly to the whole disk. Under other OSes this is known as
- * the 'superfloppy' format. As I don't know how to find out if
- * this is a MO disk I introduce a -I (ignore) switch. -Joey
- */
- print_error_info("Will not try to make filesystem on full-disk device '%s' (use -I if wanted)");
- return - 20;
- }
- ret = establish_params(statbuf.st_rdev, statbuf.st_size);
- /* Establish the media parameters */
- if (ret != 0) {
- print_error_info("call function \"establish_params\" error");
- return - 21;
- }
- ret = setup_tables();
- /* Establish the file system tables */
- if (ret != 0) {
- print_error_info("call function \"setup_tables\" error");
- return - 22;
- }
- if (check)
- /* Determine any bad block locations and mark them */
- {
- check_blocks();
- } else if (listfile) {
- get_list_blocks(listfile);
- }
- ret = write_tables();
- /* Write the file system tables away! */
- if (ret != 0) {
- print_error_info("call function \"write_tables\" error");
- return - 23;
- }
- printf("--mkdosfs execute over--\n");
- //exit (0); /* Terminate with no errors! */
- close(dev);
- return 0;
- }
- /* That's All Folks */
- /* Local Variables: */
- /* tab-width: 8 */
- /* End: */
来源: http://lib.csdn.net/article/embeddeddevelopment/49837