mkdosfs 建立硬盘启动扇区参数 （bs结构体 二)
/* Create the filesystem data tables */
static void setup_tables(void)
{
unsigned num_sectors;
unsigned cluster_count = 0, fat_length;
struct tm *ctime;
struct msdos_volume_info *vi =
(size_fat == 32 ? &bs.fat32.vi : &bs.oldfat.vi); //设置vi指针
if (atari_format) //atari_format = 0
/* 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. */
memcpy(bs.system_id - 1, "mkdosf", 6);
else
strcpy((char *)bs.system_id, "mkdosfs");
if (sectors_per_cluster) // 每簇扇区数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. */
root_dir_entries = 0;
}
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);
printf("volume_id = 0x%08lx,,vi->volume_id[0] = 0x%02x,vi->volume_id[1] = 0x%02x,vi->volume_id[2] = 0x%02x,vi->volume_id[3] = 0x%02x\n",volume_id,vi->volume_id[0],vi->volume_id[1],vi->volume_id[2],vi->volume_id[3]);
//volume_id = 0x0fee11bb,,vi->volume_id[0] = 0xbb,vi->volume_id[1] = 0x11,vi->volume_id[2] = 0xee,vi->volume_id[3] = 0x0f //volume_id 是一个随机值．
}
if (!atari_format) {
memcpy(vi->volume_label, volume_name, 11);
printf("volume_name = [%s]\n",volume_name);//volume_name = [ ]
memcpy(bs.boot_jump,dummy_boot_jump, 3); //char dummy_boot_jump[3] = { 0xeb, 0x3c, 0x90 }; 这三个字节是汇编跳转指令．
/* 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); //BOOTCODE_FAT32_SIZE = 420 ,将默认的启动代码dummy_boot_code拷到bs.fat32.boot_code里．
printf("dummy_boot_code:%s\n",dummy_boot_code);
bs.fat32.boot_code[MSG_OFFSET_OFFSET] = offset & 0xff; //MSG_OFFSET_OFFSET = 3
bs.fat32.boot_code[MSG_OFFSET_OFFSET + 1] = offset>> 8; //将默认启动代码的前４２０字节，计算好了的偏移量，赋给bs.fat32.boot_code的第３第４个字节进行更改．
} else {
memcpy(bs.oldfat.boot_code, dummy_boot_code, BOOTCODE_SIZE);
}
bs.boot_sign = CT_LE_W(BOOT_SIGN); //0xAA55 结束，启动扇区标记忆 ．小端存储变成 55 AA.
} 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) //未通过mkdosfs -R 设置．reserved_sectors = 0
reserved_sectors= (size_fat == 32) ? 32 : 1; //保留扇区数为３２
else {
if (size_fat == 32 && reserved_sectors < 2)
die("On FAT32 at least 2 reserved sectors are needed.");
}
bs.reserved = CT_LE_W(reserved_sectors);
if (verbose >= 2)
printf("Using %d reserved sectors\n", reserved_sectors);
bs.fats = (char)nr_fats; //nr_fats 未通过mkdosfs -f 设置．默认为２. bs.fats = 2 个fats表．
if (!atari_format || size_fat == 32)
bs.hidden = CT_LE_L(hidden_sectors); //隐藏扇区 未通过mkdosfs -h设置．默认为０.
else {
/* In Atari format, hidden is a 16 bit field */
__u16 hidden = CT_LE_W(hidden_sectors);
if (hidden_sectors & ~0xffff)
die("#hidden doesn't fit in 16bit field of Atari format\n");
memcpy(&bs.hidden, &hidden, 2);
}
num_sectors = (long long)(blocks *BLOCK_SIZE / sector_size)+orphaned_sectors; //总扇区数 ＝ 总块数＊1024／512 ＋ 最后一块未能包含一扇区数．
if (!atari_format) {
unsigned fatdata1216; /* Sectors for FATs + data area (FAT12/16) */
unsigned fatdata32; /* Sectors for FATs + data area (FAT32) */
unsigned fatlength12, fatlength16, fatlength32;
unsigned maxclust12, maxclust16, maxclust32;
unsigned clust12, clust16, clust32;
int maxclustsize;
unsigned root_dir_sectors = cdiv(root_dir_entries * 32, sector_size);
/*
* If the filesystem is 8192 sectors or less (4 MB with 512-byte
* sectors, i.e. floppy size), don't align the data structures.
*/
if (num_sectors <= 8192) { //扇区数小于8192 ,就不进行对齐．
if (align_structures && verbose >= 2)
printf("Disabling alignment due to tiny filesystem\n");
align_structures= FALSE;
}
if (sectors_per_cluster) //sectors_per_cluster 每簇的扇区数未通过mkdosfs -s设置，默认为０．
bs.cluster_size = maxclustsize = sectors_per_cluster;
else
/* An initial guess for bs.cluster_size should already be set */
maxclustsize = 128;
printf("1111111111111111111111\n");
do { //这个do while 循环是找找出合适的簇大小．
fatdata32 = num_sectors
- align_object(reserved_sectors, bs.cluster_size);
fatdata1216 = fatdata32
- align_object(root_dir_sectors, bs.cluster_size);
printf("2222222222222222222222\n");
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)fatdata1216 * sector_size + nr_fats * 3) /
(2 * (int)bs.cluster_size * sector_size + nr_fats * 3);
fatlength12 = cdiv(((clust12 + 2) * 3 + 1) >> 1, sector_size);
fatlength12 = align_object(fatlength12, bs.cluster_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 = (fatdata1216 - 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)fatdata1216 * sector_size + nr_fats * 4) /
((int)bs.cluster_size * sector_size + nr_fats * 2);
fatlength16 = cdiv((clust16 + 2) * 2, sector_size);
fatlength16 = align_object(fatlength16, bs.cluster_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 = (fatdata1216 - 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)fatdata32 * sector_size + nr_fats * 8) /
((int)bs.cluster_size * sector_size + nr_fats * 4);
fatlength32 = cdiv((clust32 + 2) * 4, sector_size);
fatlength32 = align_object(fatlength32, bs.cluster_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 = (fatdata32 - 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);
printf("3333333333333333333333\n");
/* 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);
}
printf("4444444444444444444444size_fat = %d\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");
die("Make the file system a bit smaller manually.");
}
}
cluster_count = clust16;
fat_length = fatlength16;
bs.fat_length = CT_LE_W(fatlength16);
memcpy(vi->fs_type, MSDOS_FAT16_SIGN, 8);
break;
case 32:
if (clust32 < MIN_CLUST_32) //#define MIN_CLUST_32 65529
fprintf(stderr,
"WARNING: Not enough clusters for a 32 bit FAT!\n");
printf("clust32 = %d,MIN_CLUST_32 = %d\n",clust32,MIN_CLUST_32); //clust32 = 2092804,MIN_CLUST_32 = 65529
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); //#define MSDOS_FAT32_SIGN "FAT32 " /* FAT32 filesystem signature */
root_dir_entries = 0;
break;
default:
die("FAT not 12, 16 or 32 bits");
}
/* Adjust the reserved number of sectors for alignment */
reserved_sectors = align_object(reserved_sectors, bs.cluster_size);
bs.reserved = CT_LE_W(reserved_sectors); //保留的扇区数．
printf("align_structures = %d\n",align_structures);
/* Adjust the number of root directory entries to help enforce alignment */
if (align_structures) { //未通过mkdosfs -a设置．默认为true ,强制对齐目录项．root_dir_entries ＝ ０；
root_dir_entries = align_object(root_dir_sectors, bs.cluster_size)
* (sector_size >> 5);
printf("root_dir_entries = %d\n",root_dir_entries);
}
} else {
unsigned clusters, maxclust, fatdata;
/* 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=%d, fat_len=%d, maxclu=%d\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 <=
(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)
die("With this sector size, the maximum number of FAT entries "
"would be exceeded.");
num_sectors >>= 1;
sector_size <<= 1;
} while (sector_size <= GEMDOS_MAX_SECTOR_SIZE);
if (sector_size > GEMDOS_MAX_SECTOR_SIZE)
die("Would need a sector size > 16k, which GEMDOS can't work with");
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);
}
}
printf("sector_size = %d,root_dir_entries = %d\n",sector_size,root_dir_entries); //sector_size = 512,root_dir_entries = 0
bs.sector_size[0] = (char)(sector_size & 0x00ff);
bs.sector_size[1] = (char)((sector_size & 0xff00) >> 8);
bs.dir_entries[0] = (char)(root_dir_entries & 0x00ff);
bs.dir_entries[1] = (char)((root_dir_entries & 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未通过mkdosfs -b设置．默认为0.
backup_boot = (reserved_sectors >= 7) ? 6 : //保留扇区reserved_sectors 为 32;
(reserved_sectors >= 2) ? reserved_sectors - 1 : 0;
else {
if (backup_boot == 1)
die("Backup boot sector must be after sector 1");
else if (backup_boot >= reserved_sectors)
die("Backup boot sector must be a reserved sector");
}
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);
printf("backup_boot = %d\n",backup_boot); //backup_boot = 6
memset(&bs.fat32.reserved2, 0, sizeof(bs.fat32.reserved2));
}
if (atari_format) {
/* Just some consistency checks */
if (num_sectors >= GEMDOS_MAX_SECTORS)
die("GEMDOS can't handle more than 65531 sectors");
else if (num_sectors >= OLDGEMDOS_MAX_SECTORS)
printf("Warning: More than 32765 sector need TOS 1.04 "
"or higher.\n");
}
printf("num_sectors = %d\n",num_sectors);//num_sectors = 16775168
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; //#define MSDOS_EXT_SIGN 0x29 /* extended boot sector signature */
if (!cluster_count) {
if (sectors_per_cluster) /* If yes, die if we'd spec'd sectors per cluster */
die("Too many clusters for file system - try more sectors per cluster");
else
die("Attempting to create a too large file system");
}
/* 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);
printf("reserved_sectors = %d, nr_fats = %d, fat_length = %d, sector_size = %d, HARD_SECTOR_SIZE = %d\n",reserved_sectors , nr_fats , fat_length , sector_size , HARD_SECTOR_SIZE);
//reserved_sectors = 32, nr_fats = 2, fat_length = 16352, sector_size = 512, HARD_SECTOR_SIZE = 512
start_data_block = (start_data_sector + SECTORS_PER_BLOCK - 1) /
SECTORS_PER_BLOCK;
if (blocks < start_data_block + 32) /* Arbitrary undersize file system! */
die("Too few blocks for viable file system");
printf("verbose = %d\n",verbose); //verbose = 0 ,感觉这一变量是调试用的．
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 %d 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 %d sector%s, and provides %d cluster%s.\n",
fat_length, (fat_length != 1) ? "s" : "",
cluster_count, (cluster_count != 1) ? "s" : "");
printf("There %s %u reserved sector%s.\n",
(reserved_sectors != 1) ? "are" : "is",
reserved_sectors, (reserved_sectors != 1) ? "s" : "");
if (size_fat != 32) {
unsigned root_dir_entries =
bs.dir_entries[0] + ((bs.dir_entries[1]) * 256);
unsigned root_dir_sectors =
cdiv(root_dir_entries * 32, sector_size);
printf("Root directory contains %u slots and uses %u sectors.\n",
root_dir_entries, root_dir_sectors);
}
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! */
printf("malloc_entire_fat = %d,alloced_fat_length = %d,fat_length = %d\n",malloc_entire_fat,alloced_fat_length,fat_length);
//malloc_entire_fat = 0,alloced_fat_length = 0,fat_length = 16352
if (malloc_entire_fat)
alloced_fat_length = fat_length;
else
alloced_fat_length = 1;
if ((fat =
(unsigned char *)malloc(alloced_fat_length * sector_size)) == NULL)
die("unable to allocate space for FAT image in memory");
memset(fat, 0, alloced_fat_length * sector_size);
mark_FAT_cluster(0, 0xffffffff); /* Initial fat entries */
mark_FAT_cluster(1, 0xffffffff); //前两个簇，初始化，用户只能从第2簇开始。
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); //#define FAT_EOF (atari_format ? 0x0fffffff : 0x0ffffff8)
}
/* Make the root directory entries */
printf("bs.cluster_size = %d , sector_size = %d\n",bs.cluster_size , sector_size); //bs.cluster_size = 8 , sector_size = 512 一个簇＝８扇区＝８＊５１２bytes
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)); //根目录项size_root_dir =bs.cluster_size * sector_size = 8 个簇
if ((root_dir = (struct msdos_dir_entry *)malloc(size_root_dir)) == NULL) {
free(fat); /* Tidy up before we die! */
die("unable to allocate space for root directory in memory");
}
memset(root_dir, 0, size_root_dir);
//设置磁盘卷名volume_name
if (memcmp(volume_name, " ", 11)) {
struct msdos_dir_entry *de = &root_dir[0]; //struct msdos_dir_entry目录项信息结构体．
memcpy(de->name, volume_name, 8);
memcpy(de->ext, volume_name + 8, 3);
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 = malloc(sector_size)))
die("Out of memory");
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); //2簇为根目录．
/* Info sector also must have boot sign */
*(__u16 *) (info_sector + 0x1fe) = CT_LE_W(BOOT_SIGN);
}
if (!(blank_sector = malloc(sector_size)))
die("Out of memory");
memset(blank_sector, 0, sector_size);
}
908
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
