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