mkfs/mkfs.c

   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 */
  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
  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
 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
 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
 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
 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
 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
 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
 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
 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
 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
 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  */
 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
 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
 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
 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
 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
 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         memset(ui.dev_name, 0, sizeof(ui.dev_name));
 741         snprintf(ui.dev_name, sizeof(ui.dev_name), "%s", argv[optind]);
 742
 743         ret = exfat_get_blk_dev_info(&ui, &bd);
 744         if (ret < 0)
 745                 goto out;
 746
 747         ret = exfat_build_mkfs_info(&bd, &ui);
 748         if (ret)
 749                 goto close;
 750
 751         ret = exfat_zero_out_disk(&bd, &ui);
 752         if (ret)
 753                 goto close;
 754
 755         ret = make_exfat(&bd, &ui);
 756         if (ret)
 757                 goto close;
 758
 759         exfat_info("Synchronizing...\n");
 760         ret = fsync(bd.dev_fd);
 761 close:
 762         close(bd.dev_fd);
 763 out:
 764         if (!ret)
 765                 exfat_info("\nexFAT format complete!\n");
 766         else
 767                 exfat_err("\nexFAT format fail!\n");
 768         return ret;
 769 }