1 // SPDX-License-Identifier: GPL-2.0-or-later
2 /*
3 * Copyright (C) 2019 Namjae Jeon <linkinjeon@kernel.org>
4 */
5
6 #include <stdio.h>
7 #include <stdlib.h>
8 #include <stdbool.h>
9 #include <string.h>
10 #include <unistd.h>
11 #include <sys/types.h>
12 #include <sys/stat.h>
13 #include <sys/ioctl.h>
14 #include <fcntl.h>
15 #include <getopt.h>
16 #include <inttypes.h>
17 #include <limits.h>
18 #include <errno.h>
19 #include <locale.h>
20 #include <time.h>
21
22 #include "exfat_ondisk.h"
23 #include "libexfat.h"
24 #include "mkfs.h"
25
26 struct exfat_mkfs_info finfo;
27
28 /* random serial generator based on current time */
get_new_serial(void)29 static unsigned int get_new_serial(void)
30 {
31 struct timespec ts;
32
33 if (clock_gettime(CLOCK_REALTIME, &ts)) {
34 /* set 0000-0000 on error */
35 ts.tv_sec = 0;
36 ts.tv_nsec = 0;
37 }
38
39 return (unsigned int)(ts.tv_nsec << 12 | ts.tv_sec);
40 }
41
exfat_setup_boot_sector(struct pbr * ppbr,struct exfat_blk_dev * bd,struct exfat_user_input * ui)42 static void exfat_setup_boot_sector(struct pbr *ppbr,
43 struct exfat_blk_dev *bd, struct exfat_user_input *ui)
44 {
45 struct bpb64 *pbpb = &ppbr->bpb;
46 struct bsx64 *pbsx = &ppbr->bsx;
47 unsigned int i;
48
49 /* Fill exfat BIOS parameter block */
50 pbpb->jmp_boot[0] = 0xeb;
51 pbpb->jmp_boot[1] = 0x76;
52 pbpb->jmp_boot[2] = 0x90;
53 memcpy(pbpb->oem_name, "EXFAT ", 8);
54 memset(pbpb->res_zero, 0, 53);
55
56 /* Fill exfat extend BIOS parameter block */
57 pbsx->vol_offset = cpu_to_le64(bd->offset / bd->sector_size);
58 pbsx->vol_length = cpu_to_le64(bd->size / bd->sector_size);
59 pbsx->fat_offset = cpu_to_le32(finfo.fat_byte_off / bd->sector_size);
60 pbsx->fat_length = cpu_to_le32(finfo.fat_byte_len / bd->sector_size);
61 pbsx->clu_offset = cpu_to_le32(finfo.clu_byte_off / bd->sector_size);
62 pbsx->clu_count = cpu_to_le32(finfo.total_clu_cnt);
63 pbsx->root_cluster = cpu_to_le32(finfo.root_start_clu);
64 pbsx->vol_serial = cpu_to_le32(finfo.volume_serial);
65 pbsx->vol_flags = 0;
66 pbsx->sect_size_bits = bd->sector_size_bits;
67 pbsx->sect_per_clus_bits = 0;
68 /* Compute base 2 logarithm of ui->cluster_size / bd->sector_size */
69 for (i = ui->cluster_size / bd->sector_size; i > 1; i /= 2)
70 pbsx->sect_per_clus_bits++;
71 pbsx->num_fats = 1;
72 /* fs_version[0] : minor and fs_version[1] : major */
73 pbsx->fs_version[0] = 0;
74 pbsx->fs_version[1] = 1;
75 pbsx->phy_drv_no = 0x80;
76 memset(pbsx->reserved2, 0, 7);
77
78 memset(ppbr->boot_code, 0, 390);
79 ppbr->signature = cpu_to_le16(PBR_SIGNATURE);
80
81 exfat_debug("Volume Offset(sectors) : %" PRIu64 "\n",
82 le64_to_cpu(pbsx->vol_offset));
83 exfat_debug("Volume Length(sectors) : %" PRIu64 "\n",
84 le64_to_cpu(pbsx->vol_length));
85 exfat_debug("FAT Offset(sector offset) : %u\n",
86 le32_to_cpu(pbsx->fat_offset));
87 exfat_debug("FAT Length(sectors) : %u\n",
88 le32_to_cpu(pbsx->fat_length));
89 exfat_debug("Cluster Heap Offset (sector offset) : %u\n",
90 le32_to_cpu(pbsx->clu_offset));
91 exfat_debug("Cluster Count : %u\n",
92 le32_to_cpu(pbsx->clu_count));
93 exfat_debug("Root Cluster (cluster offset) : %u\n",
94 le32_to_cpu(pbsx->root_cluster));
95 exfat_debug("Volume Serial : 0x%x\n", le32_to_cpu(pbsx->vol_serial));
96 exfat_debug("Sector Size Bits : %u\n",
97 pbsx->sect_size_bits);
98 exfat_debug("Sector per Cluster bits : %u\n",
99 pbsx->sect_per_clus_bits);
100 }
101
exfat_write_boot_sector(struct exfat_blk_dev * bd,struct exfat_user_input * ui,unsigned int * checksum,bool is_backup)102 static int exfat_write_boot_sector(struct exfat_blk_dev *bd,
103 struct exfat_user_input *ui, unsigned int *checksum,
104 bool is_backup)
105 {
106 struct pbr *ppbr;
107 unsigned int sec_idx = BOOT_SEC_IDX;
108 int ret = 0;
109
110 if (is_backup)
111 sec_idx += BACKUP_BOOT_SEC_IDX;
112
113 ppbr = malloc(bd->sector_size);
114 if (!ppbr) {
115 exfat_err("Cannot allocate pbr: out of memory\n");
116 return -1;
117 }
118 memset(ppbr, 0, bd->sector_size);
119
120 exfat_setup_boot_sector(ppbr, bd, ui);
121
122 /* write main boot sector */
123 ret = exfat_write_sector(bd, ppbr, sec_idx);
124 if (ret < 0) {
125 exfat_err("main boot sector write failed\n");
126 ret = -1;
127 goto free_ppbr;
128 }
129
130 boot_calc_checksum((unsigned char *)ppbr, bd->sector_size,
131 true, checksum);
132
133 free_ppbr:
134 free(ppbr);
135 return ret;
136 }
137
exfat_write_extended_boot_sectors(struct exfat_blk_dev * bd,unsigned int * checksum,bool is_backup)138 static int exfat_write_extended_boot_sectors(struct exfat_blk_dev *bd,
139 unsigned int *checksum, bool is_backup)
140 {
141 char *peb;
142 __le16 *peb_signature;
143 int ret = 0;
144 int i;
145 unsigned int sec_idx = EXBOOT_SEC_IDX;
146
147 peb = malloc(bd->sector_size);
148 if (!peb)
149 return -1;
150
151 if (is_backup)
152 sec_idx += BACKUP_BOOT_SEC_IDX;
153
154 memset(peb, 0, bd->sector_size);
155 peb_signature = (__le16*) (peb + bd->sector_size - 2);
156 *peb_signature = cpu_to_le16(PBR_SIGNATURE);
157 for (i = 0; i < EXBOOT_SEC_NUM; i++) {
158 if (exfat_write_sector(bd, peb, sec_idx++)) {
159 exfat_err("extended boot sector write failed\n");
160 ret = -1;
161 goto free_peb;
162 }
163
164 boot_calc_checksum((unsigned char *) peb, bd->sector_size,
165 false, checksum);
166 }
167
168 free_peb:
169 free(peb);
170 return ret;
171 }
172
exfat_write_oem_sector(struct exfat_blk_dev * bd,unsigned int * checksum,bool is_backup)173 static int exfat_write_oem_sector(struct exfat_blk_dev *bd,
174 unsigned int *checksum, bool is_backup)
175 {
176 char *oem;
177 int ret = 0;
178 unsigned int sec_idx = OEM_SEC_IDX;
179
180 oem = malloc(bd->sector_size);
181 if (!oem)
182 return -1;
183
184 if (is_backup)
185 sec_idx += BACKUP_BOOT_SEC_IDX;
186
187 memset(oem, 0xFF, bd->sector_size);
188 ret = exfat_write_sector(bd, oem, sec_idx);
189 if (ret) {
190 exfat_err("oem sector write failed\n");
191 ret = -1;
192 goto free_oem;
193 }
194
195 boot_calc_checksum((unsigned char *)oem, bd->sector_size, false,
196 checksum);
197
198 /* Zero out reserved sector */
199 memset(oem, 0, bd->sector_size);
200 ret = exfat_write_sector(bd, oem, sec_idx + 1);
201 if (ret) {
202 exfat_err("reserved sector write failed\n");
203 ret = -1;
204 goto free_oem;
205 }
206
207 boot_calc_checksum((unsigned char *)oem, bd->sector_size, false,
208 checksum);
209
210 free_oem:
211 free(oem);
212 return ret;
213 }
214
exfat_create_volume_boot_record(struct exfat_blk_dev * bd,struct exfat_user_input * ui,bool is_backup)215 static int exfat_create_volume_boot_record(struct exfat_blk_dev *bd,
216 struct exfat_user_input *ui, bool is_backup)
217 {
218 unsigned int checksum = 0;
219 int ret;
220
221 ret = exfat_write_boot_sector(bd, ui, &checksum, is_backup);
222 if (ret)
223 return ret;
224 ret = exfat_write_extended_boot_sectors(bd, &checksum, is_backup);
225 if (ret)
226 return ret;
227 ret = exfat_write_oem_sector(bd, &checksum, is_backup);
228 if (ret)
229 return ret;
230
231 return exfat_write_checksum_sector(bd, checksum, is_backup);
232 }
233
write_fat_entry(int fd,__le32 clu,unsigned long long offset)234 static int write_fat_entry(int fd, __le32 clu,
235 unsigned long long offset)
236 {
237 int nbyte;
238 off_t fat_entry_offset = finfo.fat_byte_off + (offset * sizeof(__le32));
239
240 nbyte = pwrite(fd, (__u8 *) &clu, sizeof(__le32), fat_entry_offset);
241 if (nbyte != sizeof(int)) {
242 exfat_err("write failed, offset : %llu, clu : %x\n",
243 offset, clu);
244 return -1;
245 }
246
247 return 0;
248 }
249
write_fat_entries(struct exfat_user_input * ui,int fd,unsigned int clu,unsigned int length)250 static int write_fat_entries(struct exfat_user_input *ui, int fd,
251 unsigned int clu, unsigned int length)
252 {
253 int ret;
254 unsigned int count;
255
256 count = clu + round_up(length, ui->cluster_size) / ui->cluster_size;
257
258 for (; clu < count - 1; clu++) {
259 ret = write_fat_entry(fd, cpu_to_le32(clu + 1), clu);
260 if (ret)
261 return ret;
262 }
263
264 ret = write_fat_entry(fd, cpu_to_le32(EXFAT_EOF_CLUSTER), clu);
265 if (ret)
266 return ret;
267
268 return clu;
269 }
270
exfat_create_fat_table(struct exfat_blk_dev * bd,struct exfat_user_input * ui)271 static int exfat_create_fat_table(struct exfat_blk_dev *bd,
272 struct exfat_user_input *ui)
273 {
274 int ret, clu;
275
276 /* fat entry 0 should be media type field(0xF8) */
277 ret = write_fat_entry(bd->dev_fd, cpu_to_le32(0xfffffff8), 0);
278 if (ret) {
279 exfat_err("fat 0 entry write failed\n");
280 return ret;
281 }
282
283 /* fat entry 1 is historical precedence(0xFFFFFFFF) */
284 ret = write_fat_entry(bd->dev_fd, cpu_to_le32(0xffffffff), 1);
285 if (ret) {
286 exfat_err("fat 1 entry write failed\n");
287 return ret;
288 }
289
290 /* write bitmap entries */
291 clu = write_fat_entries(ui, bd->dev_fd, EXFAT_FIRST_CLUSTER,
292 finfo.bitmap_byte_len);
293 if (clu < 0)
294 return ret;
295
296 /* write upcase table entries */
297 clu = write_fat_entries(ui, bd->dev_fd, clu + 1, finfo.ut_byte_len);
298 if (clu < 0)
299 return ret;
300
301 /* write root directory entries */
302 clu = write_fat_entries(ui, bd->dev_fd, clu + 1, finfo.root_byte_len);
303 if (clu < 0)
304 return ret;
305
306 finfo.used_clu_cnt = clu + 1;
307 exfat_debug("Total used cluster count : %d\n", finfo.used_clu_cnt);
308
309 return ret;
310 }
311
exfat_create_bitmap(struct exfat_blk_dev * bd)312 static int exfat_create_bitmap(struct exfat_blk_dev *bd)
313 {
314 char *bitmap;
315 unsigned int full_bytes, rem_bits, zero_offset;
316 unsigned int nbytes;
317
318 bitmap = malloc(finfo.bitmap_byte_len);
319 if (!bitmap)
320 return -1;
321
322 full_bytes = finfo.used_clu_cnt / 8;
323 rem_bits = finfo.used_clu_cnt % 8;
324 zero_offset = full_bytes;
325
326 memset(bitmap, 0xff, full_bytes);
327
328 if (rem_bits != 0) {
329 bitmap[full_bytes] = (1 << rem_bits) - 1;
330 ++zero_offset;
331 }
332
333 if (zero_offset < finfo.bitmap_byte_len)
334 memset(bitmap + zero_offset, 0, finfo.bitmap_byte_len - zero_offset);
335
336
337 nbytes = pwrite(bd->dev_fd, bitmap, finfo.bitmap_byte_len, finfo.bitmap_byte_off);
338 if (nbytes != finfo.bitmap_byte_len) {
339 exfat_err("write failed, nbytes : %d, bitmap_len : %d\n",
340 nbytes, finfo.bitmap_byte_len);
341 free(bitmap);
342 return -1;
343 }
344
345 free(bitmap);
346 return 0;
347 }
348
exfat_create_root_dir(struct exfat_blk_dev * bd,struct exfat_user_input * ui)349 static int exfat_create_root_dir(struct exfat_blk_dev *bd,
350 struct exfat_user_input *ui)
351 {
352 struct exfat_dentry ed[4] = {0};
353 int dentries_len = sizeof(ed);
354 int nbytes;
355
356 /* Set volume label entry */
357 ed[0].type = EXFAT_VOLUME;
358 memset(ed[0].vol_label, 0, 22);
359 memcpy(ed[0].vol_label, ui->volume_label, ui->volume_label_len);
360 ed[0].vol_char_cnt = ui->volume_label_len/2;
361
362 /* Set volume GUID entry */
363 if (ui->guid) {
364 if (__exfat_set_volume_guid(&ed[1], ui->guid))
365 return -1;
366 } else {
367 /*
368 * Since a single empty entry cannot be allocated for a
369 * file, this can reserve the entry for volume GUID.
370 */
371 ed[1].type = EXFAT_GUID & ~EXFAT_INVAL;
372 }
373
374 /* Set bitmap entry */
375 ed[2].type = EXFAT_BITMAP;
376 ed[2].bitmap_flags = 0;
377 ed[2].bitmap_start_clu = cpu_to_le32(EXFAT_FIRST_CLUSTER);
378 ed[2].bitmap_size = cpu_to_le64(finfo.bitmap_byte_len);
379
380 /* Set upcase table entry */
381 ed[3].type = EXFAT_UPCASE;
382 ed[3].upcase_checksum = cpu_to_le32(0xe619d30d);
383 ed[3].upcase_start_clu = cpu_to_le32(finfo.ut_start_clu);
384 ed[3].upcase_size = cpu_to_le64(EXFAT_UPCASE_TABLE_SIZE);
385
386 nbytes = pwrite(bd->dev_fd, ed, dentries_len, finfo.root_byte_off);
387 if (nbytes != dentries_len) {
388 exfat_err("write failed, nbytes : %d, dentries_len : %d\n",
389 nbytes, dentries_len);
390 return -1;
391 }
392
393 return 0;
394 }
395
usage(void)396 static void usage(void)
397 {
398 fputs("Usage: mkfs.exfat\n"
399 "\t-L | --volume-label=label Set volume label\n"
400 "\t-U | --volume-guid=guid Set volume GUID\n"
401 "\t-s | --sector-size=size(or suffixed by 'K') Specify sector size\n"
402 "\t-c | --cluster-size=size(or suffixed by 'K' or 'M') Specify cluster size\n"
403 "\t-b | --boundary-align=size(or suffixed by 'K' or 'M') Specify boundary alignment\n"
404 "\t --pack-bitmap Move bitmap into FAT segment\n"
405 "\t-f | --full-format Full format\n"
406 "\t-V | --version Show version\n"
407 "\t-q | --quiet Print only errors\n"
408 "\t-v | --verbose Print debug\n"
409 "\t-h | --help Show help\n",
410 stderr);
411
412 exit(EXIT_FAILURE);
413 }
414
415 #define PACK_BITMAP (CHAR_MAX + 1)
416
417 static const struct option opts[] = {
418 {"volume-label", required_argument, NULL, 'L' },
419 {"volume-guid", required_argument, NULL, 'U' },
420 {"sector-size", required_argument, NULL, 's' },
421 {"cluster-size", required_argument, NULL, 'c' },
422 {"boundary-align", required_argument, NULL, 'b' },
423 {"pack-bitmap", no_argument, NULL, PACK_BITMAP },
424 {"full-format", no_argument, NULL, 'f' },
425 {"version", no_argument, NULL, 'V' },
426 {"quiet", no_argument, NULL, 'q' },
427 {"verbose", no_argument, NULL, 'v' },
428 {"help", no_argument, NULL, 'h' },
429 {"?", no_argument, NULL, '?' },
430 {NULL, 0, NULL, 0 }
431 };
432
433 /*
434 * Moves the bitmap to just before the alignment boundary if there is space
435 * between the boundary and the end of the FAT. This may allow the FAT and the
436 * bitmap to share the same allocation unit on flash media, thereby improving
437 * performance and endurance.
438 */
exfat_pack_bitmap(const struct exfat_user_input * ui)439 static int exfat_pack_bitmap(const struct exfat_user_input *ui)
440 {
441 unsigned int fat_byte_end = finfo.fat_byte_off + finfo.fat_byte_len,
442 bitmap_byte_len = finfo.bitmap_byte_len,
443 bitmap_clu_len = round_up(bitmap_byte_len, ui->cluster_size),
444 bitmap_clu_cnt, total_clu_cnt, new_bitmap_clu_len;
445
446 for (;;) {
447 bitmap_clu_cnt = bitmap_clu_len / ui->cluster_size;
448 if (finfo.clu_byte_off - bitmap_clu_len < fat_byte_end ||
449 finfo.total_clu_cnt > EXFAT_MAX_NUM_CLUSTER -
450 bitmap_clu_cnt)
451 return -1;
452 total_clu_cnt = finfo.total_clu_cnt + bitmap_clu_cnt;
453 bitmap_byte_len = round_up(total_clu_cnt, 8) / 8;
454 new_bitmap_clu_len = round_up(bitmap_byte_len, ui->cluster_size);
455 if (new_bitmap_clu_len == bitmap_clu_len) {
456 finfo.clu_byte_off -= bitmap_clu_len;
457 finfo.total_clu_cnt = total_clu_cnt;
458 finfo.bitmap_byte_off -= bitmap_clu_len;
459 finfo.bitmap_byte_len = bitmap_byte_len;
460 return 0;
461 }
462 bitmap_clu_len = new_bitmap_clu_len;
463 }
464 }
465
exfat_build_mkfs_info(struct exfat_blk_dev * bd,struct exfat_user_input * ui)466 static int exfat_build_mkfs_info(struct exfat_blk_dev *bd,
467 struct exfat_user_input *ui)
468 {
469 unsigned long long total_clu_cnt;
470 unsigned long long max_clusters;
471 int clu_len;
472 int num_fats = 1;
473
474 if (ui->cluster_size < bd->sector_size) {
475 exfat_err("cluster size (%u bytes) is smaller than sector size (%u bytes)\n",
476 ui->cluster_size, bd->sector_size);
477 return -1;
478 }
479 if (ui->boundary_align < bd->sector_size) {
480 exfat_err("boundary alignment is too small (min %d)\n",
481 bd->sector_size);
482 return -1;
483 }
484 finfo.fat_byte_off = round_up(bd->offset + 24 * bd->sector_size,
485 ui->boundary_align) - bd->offset;
486
487 max_clusters = (bd->size - finfo.fat_byte_off - 8 * num_fats - 1) /
488 (ui->cluster_size + 4 * num_fats) + 1;
489 /* Prevent integer overflow when computing the FAT length */
490 if (max_clusters > UINT_MAX / 4 - 2) {
491 exfat_err("cluster size (%u bytes) is too small\n", ui->cluster_size);
492 return -1;
493 }
494 finfo.fat_byte_len = round_up((max_clusters + 2) * 4, bd->sector_size);
495 finfo.clu_byte_off = round_up(bd->offset + finfo.fat_byte_off +
496 finfo.fat_byte_len * num_fats, ui->boundary_align) - bd->offset;
497 if (bd->size <= finfo.clu_byte_off) {
498 exfat_err("boundary alignment is too big\n");
499 return -1;
500 }
501 total_clu_cnt = (bd->size - finfo.clu_byte_off) / ui->cluster_size;
502 if (total_clu_cnt > EXFAT_MAX_NUM_CLUSTER) {
503 exfat_err("cluster size is too small\n");
504 return -1;
505 }
506 finfo.total_clu_cnt = (unsigned int) total_clu_cnt;
507
508 finfo.bitmap_byte_off = finfo.clu_byte_off;
509 finfo.bitmap_byte_len = round_up(finfo.total_clu_cnt, 8) / 8;
510 if (ui->pack_bitmap)
511 exfat_pack_bitmap(ui);
512 clu_len = round_up(finfo.bitmap_byte_len, ui->cluster_size);
513
514 finfo.ut_start_clu = EXFAT_FIRST_CLUSTER + clu_len / ui->cluster_size;
515 finfo.ut_byte_off = finfo.bitmap_byte_off + clu_len;
516 finfo.ut_byte_len = EXFAT_UPCASE_TABLE_SIZE;
517 clu_len = round_up(finfo.ut_byte_len, ui->cluster_size);
518
519 finfo.root_start_clu = finfo.ut_start_clu + clu_len / ui->cluster_size;
520 finfo.root_byte_off = finfo.ut_byte_off + clu_len;
521 finfo.root_byte_len = sizeof(struct exfat_dentry) * 3;
522 finfo.volume_serial = get_new_serial();
523
524 return 0;
525 }
526
exfat_zero_out_disk(struct exfat_blk_dev * bd,struct exfat_user_input * ui)527 static int exfat_zero_out_disk(struct exfat_blk_dev *bd,
528 struct exfat_user_input *ui)
529 {
530 int ret;
531 unsigned long long total_written = 0;
532 unsigned long long size;
533
534 if (ui->quick)
535 size = finfo.root_byte_off + ui->cluster_size;
536 else
537 size = bd->size;
538
539 ret = exfat_write_zero(bd->dev_fd, size, 0);
540 if (ret) {
541 exfat_err("write failed(errno : %d)\n", errno);
542 return ret;
543 }
544
545 exfat_debug("zero out written size : %llu, disk size : %llu\n",
546 total_written, bd->size);
547 return 0;
548 }
549
make_exfat(struct exfat_blk_dev * bd,struct exfat_user_input * ui)550 static int make_exfat(struct exfat_blk_dev *bd, struct exfat_user_input *ui)
551 {
552 int ret;
553
554 exfat_info("Creating exFAT filesystem(%s, cluster size=%u)\n\n",
555 ui->dev_name, ui->cluster_size);
556
557 exfat_info("Writing volume boot record: ");
558 ret = exfat_create_volume_boot_record(bd, ui, 0);
559 exfat_info("%s\n", ret ? "failed" : "done");
560 if (ret)
561 return ret;
562
563 exfat_info("Writing backup volume boot record: ");
564 /* backup sector */
565 ret = exfat_create_volume_boot_record(bd, ui, 1);
566 exfat_info("%s\n", ret ? "failed" : "done");
567 if (ret)
568 return ret;
569
570 exfat_info("Fat table creation: ");
571 ret = exfat_create_fat_table(bd, ui);
572 exfat_info("%s\n", ret ? "failed" : "done");
573 if (ret)
574 return ret;
575
576 exfat_info("Allocation bitmap creation: ");
577 ret = exfat_create_bitmap(bd);
578 exfat_info("%s\n", ret ? "failed" : "done");
579 if (ret)
580 return ret;
581
582 exfat_info("Upcase table creation: ");
583 ret = exfat_create_upcase_table(bd);
584 exfat_info("%s\n", ret ? "failed" : "done");
585 if (ret)
586 return ret;
587
588 exfat_info("Writing root directory entry: ");
589 ret = exfat_create_root_dir(bd, ui);
590 exfat_info("%s\n", ret ? "failed" : "done");
591 if (ret)
592 return ret;
593
594 return 0;
595 }
596
parse_size(const char * size)597 static long long parse_size(const char *size)
598 {
599 char *data_unit;
600 unsigned long long byte_size = strtoull(size, &data_unit, 0);
601
602 switch (*data_unit) {
603 case 'M':
604 case 'm':
605 byte_size <<= 20;
606 break;
607 case 'K':
608 case 'k':
609 byte_size <<= 10;
610 break;
611 case '\0':
612 break;
613 default:
614 exfat_err("Wrong unit input('%c') for size\n",
615 *data_unit);
616 return -EINVAL;
617 }
618
619 return byte_size;
620 }
621
main(int argc,char * argv[])622 int main(int argc, char *argv[])
623 {
624 int c;
625 int ret = EXIT_FAILURE;
626 struct exfat_blk_dev bd;
627 struct exfat_user_input ui;
628 bool version_only = false;
629 bool quiet = false;
630
631 init_user_input(&ui);
632
633 if (!setlocale(LC_CTYPE, ""))
634 exfat_err("failed to init locale/codeset\n");
635
636 opterr = 0;
637 while ((c = getopt_long(argc, argv, "n:L:U:s:c:b:fVqvh", opts, NULL)) != EOF)
638 switch (c) {
639 /*
640 * Make 'n' option fallthrough to 'L' option for for backward
641 * compatibility with old utils.
642 */
643 case 'n':
644 case 'L':
645 {
646 ret = exfat_utf16_enc(optarg,
647 ui.volume_label, sizeof(ui.volume_label));
648 if (ret < 0)
649 goto out;
650
651 ui.volume_label_len = ret;
652 break;
653 }
654 case 'U':
655 if (*optarg != '\0' && *optarg != '\r')
656 ui.guid = optarg;
657 break;
658 case 's':
659 ret = parse_size(optarg);
660 if (ret < 0)
661 goto out;
662 else if (ret & (ret - 1)) {
663 exfat_err("sector size(%d) is not a power of 2\n",
664 ret);
665 goto out;
666 } else if ((ret & 0x1e00) == 0) {
667 exfat_err("sector size(%d) must be 512, 1024, "
668 "2048 or 4096 bytes\n",
669 ret);
670 goto out;
671 }
672 ui.sector_size = ret;
673 break;
674 case 'c':
675 ret = parse_size(optarg);
676 if (ret < 0)
677 goto out;
678 else if (ret & (ret - 1)) {
679 exfat_err("cluster size(%d) is not a power of 2)\n",
680 ret);
681 goto out;
682 } else if (ret > EXFAT_MAX_CLUSTER_SIZE) {
683 exfat_err("cluster size(%d) exceeds max cluster size(%d)\n",
684 ui.cluster_size, EXFAT_MAX_CLUSTER_SIZE);
685 goto out;
686 }
687 ui.cluster_size = ret;
688 break;
689 case 'b':
690 ret = parse_size(optarg);
691 if (ret < 0)
692 goto out;
693 else if (ret & (ret - 1)) {
694 exfat_err("boundary align(%d) is not a power of 2)\n",
695 ret);
696 goto out;
697 }
698 ui.boundary_align = ret;
699 break;
700 case PACK_BITMAP:
701 ui.pack_bitmap = true;
702 break;
703 case 'f':
704 ui.quick = false;
705 break;
706 case 'V':
707 version_only = true;
708 break;
709 case 'q':
710 print_level = EXFAT_ERROR;
711 quiet = true;
712 break;
713 case 'v':
714 print_level = EXFAT_DEBUG;
715 break;
716 case '?':
717 case 'h':
718 default:
719 usage();
720 }
721
722 if (version_only) {
723 show_version();
724 exit(EXIT_FAILURE);
725 } else if (!quiet) {
726 show_version();
727 }
728
729 if (argc - optind != 1) {
730 usage();
731 }
732
733 if (ui.sector_size && ui.cluster_size && ui.sector_size > ui.cluster_size) {
734 exfat_err("cluster size (%u bytes) is smaller than sector size (%u bytes)\n",
735 ui.cluster_size, ui.sector_size);
736 ret = -1;
737 goto out;
738 }
739
740 ui.dev_name = argv[optind];
741
742 ret = exfat_get_blk_dev_info(&ui, &bd);
743 if (ret < 0)
744 goto out;
745
746 ret = exfat_build_mkfs_info(&bd, &ui);
747 if (ret)
748 goto close;
749
750 ret = exfat_zero_out_disk(&bd, &ui);
751 if (ret)
752 goto close;
753
754 ret = make_exfat(&bd, &ui);
755 if (ret)
756 goto close;
757
758 exfat_info("Synchronizing...\n");
759 ret = fsync(bd.dev_fd);
760 close:
761 close(bd.dev_fd);
762 out:
763 if (!ret)
764 exfat_info("\nexFAT format complete!\n");
765 else
766 exfat_err("\nexFAT format fail!\n");
767 return ret;
768 }
769