1 // SPDX-License-Identifier: GPL-2.0-or-later
3 * Copyright (C) 2019 Namjae Jeon <linkinjeon@kernel.org>
11 #include <sys/types.h>
13 #include <sys/ioctl.h>
21 #include "exfat_ondisk.h"
25 struct exfat_mkfs_info finfo;
27 static void exfat_setup_boot_sector(struct pbr *ppbr,
28 struct exfat_blk_dev *bd, struct exfat_user_input *ui)
30 struct bpb64 *pbpb = &ppbr->bpb;
31 struct bsx64 *pbsx = &ppbr->bsx;
33 /* Fill exfat BIOS paramemter block */
34 pbpb->jmp_boot[0] = 0xeb;
35 pbpb->jmp_boot[1] = 0x76;
36 pbpb->jmp_boot[2] = 0x90;
37 memcpy(pbpb->oem_name, "EXFAT ", 8);
38 memset(pbpb->res_zero, 0, 53);
40 /* Fill exfat extend BIOS paramemter block */
42 pbsx->vol_length = cpu_to_le64(bd->size / bd->sector_size);
43 pbsx->fat_offset = cpu_to_le32(finfo.fat_byte_off / bd->sector_size);
44 pbsx->fat_length = cpu_to_le32(finfo.fat_byte_len / bd->sector_size);
45 pbsx->clu_offset = cpu_to_le32(finfo.clu_byte_off / bd->sector_size);
46 pbsx->clu_count = cpu_to_le32(finfo.total_clu_cnt);
47 pbsx->root_cluster = cpu_to_le32(finfo.root_start_clu);
48 pbsx->vol_serial = cpu_to_le32(1234);
50 pbsx->sect_size_bits = bd->sector_size_bits;
51 pbsx->sect_per_clus_bits = log2(ui->cluster_size / bd->sector_size);
53 /* fs_version[0] : minor and fs_version[1] : major */
54 pbsx->fs_version[0] = 0;
55 pbsx->fs_version[1] = 1;
56 memset(pbsx->reserved2, 0, 7);
58 memset(ppbr->boot_code, 0, 390);
59 ppbr->signature = cpu_to_le16(PBR_SIGNATURE);
61 exfat_debug("Volume Length(sectors) : %" PRIu64 "\n",
62 le64_to_cpu(pbsx->vol_length));
63 exfat_debug("FAT Offset(sector offset) : %u\n",
64 le32_to_cpu(pbsx->fat_offset));
65 exfat_debug("FAT Length(sectors) : %u\n",
66 le32_to_cpu(pbsx->fat_length));
67 exfat_debug("Cluster Heap Offset (sector offset) : %u\n",
68 le32_to_cpu(pbsx->clu_offset));
69 exfat_debug("Cluster Count (sectors) : %u\n",
70 le32_to_cpu(pbsx->clu_count));
71 exfat_debug("Root Cluster (cluster offset) : %u\n",
72 le32_to_cpu(pbsx->root_cluster));
73 exfat_debug("Sector Size Bits : %u\n",
74 pbsx->sect_size_bits);
75 exfat_debug("Sector per Cluster bits : %u\n",
76 pbsx->sect_per_clus_bits);
79 static int exfat_write_sector(struct exfat_blk_dev *bd, void *buf,
83 unsigned long long offset = sec_off * bd->sector_size;
85 lseek(bd->dev_fd, offset, SEEK_SET);
86 bytes = write(bd->dev_fd, buf, bd->sector_size);
87 if (bytes != (int)bd->sector_size) {
88 exfat_err("write failed, sec_off : %u, bytes : %d\n", sec_off,
95 static int exfat_write_boot_sector(struct exfat_blk_dev *bd,
96 struct exfat_user_input *ui, unsigned int *checksum,
100 unsigned int sec_idx = BOOT_SEC_IDX;
104 sec_idx += BACKUP_BOOT_SEC_IDX;
106 ppbr = malloc(sizeof(struct pbr));
108 exfat_err("Cannot allocate pbr: out of memory\n");
111 memset(ppbr, 0, sizeof(struct pbr));
113 exfat_setup_boot_sector(ppbr, bd, ui);
115 /* write main boot sector */
116 ret = exfat_write_sector(bd, ppbr, sec_idx);
118 exfat_err("main boot sector write failed\n");
123 boot_calc_checksum((unsigned char *)ppbr, sizeof(struct pbr),
131 static int exfat_write_extended_boot_sectors(struct exfat_blk_dev *bd,
132 unsigned int *checksum, bool is_backup)
136 unsigned int sec_idx = EXBOOT_SEC_IDX;
139 sec_idx += BACKUP_BOOT_SEC_IDX;
141 memset(&eb, 0, sizeof(struct exbs));
142 eb.signature = cpu_to_le16(PBR_SIGNATURE);
143 for (i = 0; i < EXBOOT_SEC_NUM; i++) {
144 if (exfat_write_sector(bd, &eb, sec_idx++)) {
145 exfat_err("extended boot sector write failed\n");
149 boot_calc_checksum((unsigned char *) &eb, sizeof(struct exbs),
156 static int exfat_write_oem_sector(struct exfat_blk_dev *bd,
157 unsigned int *checksum, bool is_backup)
161 unsigned int sec_idx = OEM_SEC_IDX;
163 oem = malloc(bd->sector_size);
168 sec_idx += BACKUP_BOOT_SEC_IDX;
170 memset(oem, 0xFF, bd->sector_size);
171 ret = exfat_write_sector(bd, oem, sec_idx);
173 exfat_err("oem sector write failed\n");
178 boot_calc_checksum((unsigned char *)oem, bd->sector_size, false,
181 /* Zero out reserved sector */
182 memset(oem, 0, bd->sector_size);
183 ret = exfat_write_sector(bd, oem, sec_idx + 1);
185 exfat_err("reserved sector write failed\n");
190 boot_calc_checksum((unsigned char *)oem, bd->sector_size, false,
198 static int exfat_write_checksum_sector(struct exfat_blk_dev *bd,
199 unsigned int checksum, bool is_backup)
201 __le32 *checksum_buf;
204 unsigned int sec_idx = CHECKSUM_SEC_IDX;
206 checksum_buf = malloc(bd->sector_size);
211 sec_idx += BACKUP_BOOT_SEC_IDX;
213 for (i = 0; i < bd->sector_size / sizeof(int); i++)
214 checksum_buf[i] = cpu_to_le32(checksum);
216 ret = exfat_write_sector(bd, checksum_buf, sec_idx);
218 exfat_err("checksum sector write failed\n");
227 static int exfat_create_volume_boot_record(struct exfat_blk_dev *bd,
228 struct exfat_user_input *ui, bool is_backup)
230 unsigned int checksum = 0;
233 ret = exfat_write_boot_sector(bd, ui, &checksum, is_backup);
236 ret = exfat_write_extended_boot_sectors(bd, &checksum, is_backup);
239 ret = exfat_write_oem_sector(bd, &checksum, is_backup);
243 return exfat_write_checksum_sector(bd, checksum, is_backup);
246 static int write_fat_entry(int fd, __le32 clu,
247 unsigned long long offset)
251 lseek(fd, finfo.fat_byte_off + (offset * sizeof(__le32)), SEEK_SET);
252 nbyte = write(fd, (__u8 *) &clu, sizeof(__le32));
253 if (nbyte != sizeof(int)) {
254 exfat_err("write failed, offset : %llu, clu : %x\n",
262 static int write_fat_entries(struct exfat_user_input *ui, int fd,
263 unsigned int clu, unsigned int length)
268 count = clu + round_up(length, ui->cluster_size) / ui->cluster_size;
270 for (; clu < count - 1; clu++) {
271 ret = write_fat_entry(fd, cpu_to_le32(clu + 1), clu);
276 ret = write_fat_entry(fd, cpu_to_le32(EXFAT_EOF_CLUSTER), clu);
283 static int exfat_create_fat_table(struct exfat_blk_dev *bd,
284 struct exfat_user_input *ui)
288 /* fat entry 0 should be media type field(0xF8) */
289 ret = write_fat_entry(bd->dev_fd, cpu_to_le32(0xfffffff8), 0);
291 exfat_err("fat 0 entry write failed\n");
295 /* fat entry 1 is historical precedence(0xFFFFFFFF) */
296 ret = write_fat_entry(bd->dev_fd, cpu_to_le32(0xffffffff), 1);
298 exfat_err("fat 1 entry write failed\n");
302 /* write bitmap entries */
303 clu = write_fat_entries(ui, bd->dev_fd, EXFAT_FIRST_CLUSTER,
304 finfo.bitmap_byte_len);
308 /* write upcase table entries */
309 clu = write_fat_entries(ui, bd->dev_fd, clu + 1, finfo.ut_byte_len);
313 /* write root directory entries */
314 clu = write_fat_entries(ui, bd->dev_fd, clu + 1, finfo.root_byte_len);
318 finfo.used_clu_cnt = clu + 1;
319 exfat_debug("Total used cluster count : %d\n", finfo.used_clu_cnt);
324 static int exfat_create_bitmap(struct exfat_blk_dev *bd)
327 unsigned int i, nbytes;
329 bitmap = calloc(finfo.bitmap_byte_len, sizeof(*bitmap));
333 for (i = 0; i < finfo.used_clu_cnt - EXFAT_FIRST_CLUSTER; i++)
334 exfat_set_bit(bd, bitmap, i);
336 lseek(bd->dev_fd, finfo.bitmap_byte_off, SEEK_SET);
337 nbytes = write(bd->dev_fd, bitmap, finfo.bitmap_byte_len);
338 if (nbytes != finfo.bitmap_byte_len) {
339 exfat_err("write failed, nbytes : %d, bitmap_len : %d\n",
340 nbytes, finfo.bitmap_byte_len);
349 static int exfat_create_root_dir(struct exfat_blk_dev *bd,
350 struct exfat_user_input *ui)
352 struct exfat_dentry ed[3];
353 int dentries_len = sizeof(struct exfat_dentry) * 3;
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;
362 /* Set bitmap entry */
363 ed[1].type = EXFAT_BITMAP;
364 ed[1].bitmap_flags = 0;
365 ed[1].bitmap_start_clu = cpu_to_le32(EXFAT_FIRST_CLUSTER);
366 ed[1].bitmap_size = cpu_to_le64(finfo.bitmap_byte_len);
368 /* Set upcase table entry */
369 ed[2].type = EXFAT_UPCASE;
370 ed[2].upcase_checksum = cpu_to_le32(0xe619d30d);
371 ed[2].upcase_start_clu = cpu_to_le32(finfo.ut_start_clu);
372 ed[2].upcase_size = cpu_to_le64(EXFAT_UPCASE_TABLE_SIZE);
374 lseek(bd->dev_fd, finfo.root_byte_off, SEEK_SET);
375 nbytes = write(bd->dev_fd, ed, dentries_len);
376 if (nbytes != dentries_len) {
377 exfat_err("write failed, nbytes : %d, dentries_len : %d\n",
378 nbytes, dentries_len);
385 static void usage(void)
387 fprintf(stderr, "Usage: mkfs.exfat\n");
388 fprintf(stderr, "\t-L | --volume-label=label Set volume label\n");
389 fprintf(stderr, "\t-c | --cluster-size=size(or suffixed by 'K' or 'M') Specify cluster size\n");
390 fprintf(stderr, "\t-f | --full-format Full format\n");
391 fprintf(stderr, "\t-V | --version Show version\n");
392 fprintf(stderr, "\t-v | --verbose Print debug\n");
393 fprintf(stderr, "\t-h | --help Show help\n");
398 static struct option opts[] = {
399 {"volume-label", required_argument, NULL, 'L' },
400 {"cluster-size", required_argument, NULL, 'c' },
401 {"full-format", no_argument, NULL, 'f' },
402 {"version", no_argument, NULL, 'V' },
403 {"verbose", no_argument, NULL, 'v' },
404 {"help", no_argument, NULL, 'h' },
405 {"?", no_argument, NULL, '?' },
409 static int exfat_build_mkfs_info(struct exfat_blk_dev *bd,
410 struct exfat_user_input *ui)
412 if (ui->cluster_size > DEFAULT_CLUSTER_SIZE)
413 finfo.fat_byte_off = ui->cluster_size;
415 finfo.fat_byte_off = DEFAULT_CLUSTER_SIZE;
416 finfo.fat_byte_len = round_up((bd->num_clusters * sizeof(int)),
418 finfo.clu_byte_off = round_up(finfo.fat_byte_off + finfo.fat_byte_len,
419 DEFAULT_CLUSTER_SIZE);
420 finfo.total_clu_cnt = (bd->size - finfo.clu_byte_off) /
422 if (finfo.total_clu_cnt > EXFAT_MAX_NUM_CLUSTER) {
423 exfat_err("cluster size is too small\n");
427 finfo.bitmap_byte_off = finfo.clu_byte_off;
428 finfo.bitmap_byte_len = round_up(finfo.total_clu_cnt, 8) / 8;
429 finfo.ut_start_clu = round_up(EXFAT_REVERVED_CLUSTERS *
430 ui->cluster_size + finfo.bitmap_byte_len, ui->cluster_size) /
432 finfo.ut_byte_off = round_up(finfo.bitmap_byte_off +
433 finfo.bitmap_byte_len, ui->cluster_size);
434 finfo.ut_byte_len = EXFAT_UPCASE_TABLE_SIZE;
435 finfo.root_start_clu = round_up(finfo.ut_start_clu * ui->cluster_size
436 + finfo.ut_byte_len, ui->cluster_size) / ui->cluster_size;
437 finfo.root_byte_off = round_up(finfo.ut_byte_off + finfo.ut_byte_len,
439 finfo.root_byte_len = sizeof(struct exfat_dentry) * 3;
444 static int exfat_zero_out_disk(struct exfat_blk_dev *bd,
445 struct exfat_user_input *ui)
448 unsigned long long total_written = 0;
450 unsigned int chunk_size = ui->cluster_size;
451 unsigned long long size;
454 size = finfo.root_byte_off + chunk_size;
458 buf = malloc(chunk_size);
462 memset(buf, 0, chunk_size);
463 lseek(bd->dev_fd, 0, SEEK_SET);
466 nbytes = write(bd->dev_fd, buf, chunk_size);
469 exfat_err("write failed(errno : %d)\n", errno);
472 total_written += nbytes;
473 } while (total_written < size);
476 exfat_debug("zero out written size : %llu, disk size : %llu\n",
477 total_written, bd->size);
481 static int make_exfat(struct exfat_blk_dev *bd, struct exfat_user_input *ui)
485 exfat_info("Creating exFAT filesystem(%s, cluster size=%u)\n\n",
486 ui->dev_name, ui->cluster_size);
488 exfat_info("Writing volume boot record: ");
489 ret = exfat_create_volume_boot_record(bd, ui, 0);
490 exfat_info("%s\n", ret ? "failed" : "done");
494 exfat_info("Writing backup volume boot record: ");
496 ret = exfat_create_volume_boot_record(bd, ui, 1);
497 exfat_info("%s\n", ret ? "failed" : "done");
501 exfat_info("Fat table creation: ");
502 ret = exfat_create_fat_table(bd, ui);
503 exfat_info("%s\n", ret ? "failed" : "done");
507 exfat_info("Allocation bitmap creation: ");
508 ret = exfat_create_bitmap(bd);
509 exfat_info("%s\n", ret ? "failed" : "done");
513 exfat_info("Upcase table creation: ");
514 ret = exfat_create_upcase_table(bd);
515 exfat_info("%s\n", ret ? "failed" : "done");
519 exfat_info("Writing root directory entry: ");
520 ret = exfat_create_root_dir(bd, ui);
521 exfat_info("%s\n", ret ? "failed" : "done");
528 static long long parse_cluster_size(const char *size)
531 unsigned long long byte_size = strtoull(size, &data_unit, 0);
533 switch (*data_unit) {
543 exfat_err("Wrong unit input('%c') for cluster size\n",
551 int main(int argc, char *argv[])
554 int ret = EXIT_FAILURE;
555 struct exfat_blk_dev bd;
556 struct exfat_user_input ui;
557 bool version_only = false;
559 init_user_input(&ui);
561 if (!setlocale(LC_CTYPE, ""))
562 exfat_err("failed to init locale/codeset\n");
565 while ((c = getopt_long(argc, argv, "n:L:c:fVvh", opts, NULL)) != EOF)
568 * Make 'n' option fallthrough to 'L' option for for backward
569 * compatibility with old utils.
574 ret = exfat_utf16_enc(optarg,
575 ui.volume_label, sizeof(ui.volume_label));
579 ui.volume_label_len = ret;
583 ret = parse_cluster_size(optarg);
586 else if (ret > EXFAT_MAX_CLUSTER_SIZE) {
587 exfat_err("cluster size(%d) exceeds max cluster size(%d)\n",
588 ui.cluster_size, EXFAT_MAX_CLUSTER_SIZE);
591 ui.cluster_size = ret;
600 print_level = EXFAT_DEBUG;
612 if (argc - optind != 1) {
616 memset(ui.dev_name, 0, sizeof(ui.dev_name));
617 snprintf(ui.dev_name, sizeof(ui.dev_name), "%s", argv[optind]);
619 ret = exfat_get_blk_dev_info(&ui, &bd);
623 ret = exfat_build_mkfs_info(&bd, &ui);
627 ret = exfat_zero_out_disk(&bd, &ui);
631 ret = make_exfat(&bd, &ui);
635 exfat_info("Synchronizing...\n");
636 ret = fsync(bd.dev_fd);
639 exfat_info("\nexFAT format complete!\n");
641 exfat_info("\nexFAT format fail!\n");