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