mkfs_vfat.c 22 KB

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