* Copyright (C) 2019 Namjae Jeon <linkinjeon@kernel.org>
*/
#include <stdio.h>
#include <stdlib.h>
#include <stdbool.h>
#include <string.h>
#include <unistd.h>
#include <sys/types.h>
#include <sys/stat.h>
#include <sys/ioctl.h>
#include <fcntl.h>
#include <getopt.h>
#include <inttypes.h>
#include <limits.h>
#include <errno.h>
#include <locale.h>
#include <time.h>
#include "exfat_ondisk.h"
#include "libexfat.h"
#include "mkfs.h"
struct exfat_mkfs_info finfo;
static unsigned int get_new_serial(void)
{
struct timespec ts;
if (clock_gettime(CLOCK_REALTIME, &ts)) {
ts.tv_sec = 0;
ts.tv_nsec = 0;
}
return (unsigned int)(ts.tv_nsec << 12 | ts.tv_sec);
}
static void exfat_setup_boot_sector(struct pbr *ppbr,
struct exfat_blk_dev *bd, struct exfat_user_input *ui)
{
struct bpb64 *pbpb = &ppbr->bpb;
struct bsx64 *pbsx = &ppbr->bsx;
unsigned int i;
pbpb->jmp_boot[0] = 0xeb;
pbpb->jmp_boot[1] = 0x76;
pbpb->jmp_boot[2] = 0x90;
memcpy(pbpb->oem_name, "EXFAT ", 8);
memset(pbpb->res_zero, 0, 53);
pbsx->vol_offset = cpu_to_le64(bd->offset / bd->sector_size);
pbsx->vol_length = cpu_to_le64(bd->size / bd->sector_size);
pbsx->fat_offset = cpu_to_le32(finfo.fat_byte_off / bd->sector_size);
pbsx->fat_length = cpu_to_le32(finfo.fat_byte_len / bd->sector_size);
pbsx->clu_offset = cpu_to_le32(finfo.clu_byte_off / bd->sector_size);
pbsx->clu_count = cpu_to_le32(finfo.total_clu_cnt);
pbsx->root_cluster = cpu_to_le32(finfo.root_start_clu);
pbsx->vol_serial = cpu_to_le32(finfo.volume_serial);
pbsx->vol_flags = 0;
pbsx->sect_size_bits = bd->sector_size_bits;
pbsx->sect_per_clus_bits = 0;
for (i = ui->cluster_size / bd->sector_size; i > 1; i /= 2)
pbsx->sect_per_clus_bits++;
pbsx->num_fats = 1;
pbsx->fs_version[0] = 0;
pbsx->fs_version[1] = 1;
pbsx->phy_drv_no = 0x80;
memset(pbsx->reserved2, 0, 7);
memset(ppbr->boot_code, 0, 390);
ppbr->signature = cpu_to_le16(PBR_SIGNATURE);
exfat_debug("Volume Offset(sectors) : %" PRIu64 "\n",
le64_to_cpu(pbsx->vol_offset));
exfat_debug("Volume Length(sectors) : %" PRIu64 "\n",
le64_to_cpu(pbsx->vol_length));
exfat_debug("FAT Offset(sector offset) : %u\n",
le32_to_cpu(pbsx->fat_offset));
exfat_debug("FAT Length(sectors) : %u\n",
le32_to_cpu(pbsx->fat_length));
exfat_debug("Cluster Heap Offset (sector offset) : %u\n",
le32_to_cpu(pbsx->clu_offset));
exfat_debug("Cluster Count : %u\n",
le32_to_cpu(pbsx->clu_count));
exfat_debug("Root Cluster (cluster offset) : %u\n",
le32_to_cpu(pbsx->root_cluster));
exfat_debug("Volume Serial : 0x%x\n", le32_to_cpu(pbsx->vol_serial));
exfat_debug("Sector Size Bits : %u\n",
pbsx->sect_size_bits);
exfat_debug("Sector per Cluster bits : %u\n",
pbsx->sect_per_clus_bits);
}
static int exfat_write_boot_sector(struct exfat_blk_dev *bd,
struct exfat_user_input *ui, unsigned int *checksum,
bool is_backup)
{
struct pbr *ppbr;
unsigned int sec_idx = BOOT_SEC_IDX;
int ret = 0;
if (is_backup)
sec_idx += BACKUP_BOOT_SEC_IDX;
ppbr = malloc(bd->sector_size);
if (!ppbr) {
exfat_err("Cannot allocate pbr: out of memory\n");
return -1;
}
memset(ppbr, 0, bd->sector_size);
exfat_setup_boot_sector(ppbr, bd, ui);
ret = exfat_write_sector(bd, ppbr, sec_idx);
if (ret < 0) {
exfat_err("main boot sector write failed\n");
ret = -1;
goto free_ppbr;
}
if (ui->verify) {
ret = exfat_check_written_data(bd,
ppbr, bd->sector_size,
sec_idx * bd->sector_size,
"boot sector");
if (ret) {
exfat_err("boot sector verification failed (read-back mismatch)\n");
goto free_ppbr;
}
}
boot_calc_checksum((unsigned char *)ppbr, bd->sector_size,
true, checksum);
free_ppbr:
free(ppbr);
return ret;
}
static int exfat_write_extended_boot_sectors(struct exfat_blk_dev *bd,
struct exfat_user_input *ui, unsigned int *checksum,
bool is_backup)
{
char *peb;
__le16 *peb_signature;
int ret = 0;
int i;
unsigned int sec_idx = EXBOOT_SEC_IDX;
peb = malloc(bd->sector_size);
if (!peb) {
exfat_err("Cannot allocate peb: out of memory\n");
return -1;
}
if (is_backup)
sec_idx += BACKUP_BOOT_SEC_IDX;
memset(peb, 0, bd->sector_size);
peb_signature = (__le16*) (peb + bd->sector_size - 2);
*peb_signature = cpu_to_le16(PBR_SIGNATURE);
for (i = 0; i < EXBOOT_SEC_NUM; i++) {
if (exfat_write_sector(bd, peb, sec_idx++)) {
exfat_err("extended boot sector write failed\n");
ret = -1;
goto free_peb;
}
if (ui->verify) {
ret = exfat_check_written_data(bd,
peb, bd->sector_size,
(sec_idx - 1) * bd->sector_size,
"extended boot sector");
if (ret) {
exfat_err("extended boot sector verification failed (read-back mismatch)\n");
goto free_peb;
}
}
boot_calc_checksum((unsigned char *) peb, bd->sector_size,
false, checksum);
}
free_peb:
free(peb);
return ret;
}
static int exfat_write_oem_sector(struct exfat_blk_dev *bd,
struct exfat_user_input *ui, unsigned int *checksum,
bool is_backup)
{
char *oem;
int ret = 0;
unsigned int sec_idx = OEM_SEC_IDX;
oem = calloc(1, bd->sector_size);
if (!oem)
return -1;
if (is_backup)
sec_idx += BACKUP_BOOT_SEC_IDX;
ret = exfat_write_sector(bd, oem, sec_idx);
if (ret) {
exfat_err("oem sector write failed\n");
ret = -1;
goto free_oem;
}
if (ui->verify) {
ret = exfat_check_written_data(bd,
oem, bd->sector_size,
sec_idx * bd->sector_size,
"oem sector");
if (ret) {
exfat_err("oem sector verification failed (read-back mismatch)\n");
goto free_oem;
}
}
boot_calc_checksum((unsigned char *)oem, bd->sector_size, false,
checksum);
ret = exfat_write_sector(bd, oem, sec_idx + 1);
if (ret) {
exfat_err("reserved sector write failed\n");
ret = -1;
goto free_oem;
}
if (ui->verify) {
ret = exfat_check_written_data(bd,
oem, bd->sector_size,
(sec_idx + 1) * bd->sector_size,
"reserved sector");
if (ret) {
exfat_err("reserved sector verification failed (read-back mismatch)\n");
goto free_oem;
}
}
boot_calc_checksum((unsigned char *)oem, bd->sector_size, false,
checksum);
free_oem:
free(oem);
return ret;
}
static int exfat_create_volume_boot_record(struct exfat_blk_dev *bd,
struct exfat_user_input *ui, bool is_backup)
{
unsigned int checksum = 0;
int ret;
ret = exfat_write_boot_sector(bd, ui, &checksum, is_backup);
if (ret)
return ret;
ret = exfat_write_extended_boot_sectors(bd, ui, &checksum, is_backup);
if (ret)
return ret;
ret = exfat_write_oem_sector(bd, ui, &checksum, is_backup);
if (ret)
return ret;
return exfat_write_checksum_sector(bd, ui, checksum, is_backup);
}
static int write_fat_entry(struct exfat_user_input *ui, int fd,
__le32 clu, unsigned long long offset)
{
int nbyte;
off_t fat_entry_offset = finfo.fat_byte_off + (offset * sizeof(__le32));
nbyte = pwrite(fd, (__u8 *) &clu, sizeof(__le32), fat_entry_offset);
if (nbyte != sizeof(int)) {
exfat_err("write failed, offset : %llu, clu : %x\n",
offset, clu);
return -1;
}
if (ui->verify) {
memcpy(ui->fat_table_buff + offset * sizeof(__le32),
(__u8 *)&clu, sizeof(__le32));
}
return 0;
}
static int write_fat_entries(struct exfat_user_input *ui, int fd,
unsigned int clu, unsigned int length)
{
int ret;
unsigned int count;
count = clu + round_up(length, ui->cluster_size) / ui->cluster_size;
for (; clu < count - 1; clu++) {
ret = write_fat_entry(ui, fd, cpu_to_le32(clu + 1), clu);
if (ret)
return ret;
}
ret = write_fat_entry(ui, fd, cpu_to_le32(EXFAT_EOF_CLUSTER), clu);
if (ret)
return ret;
return clu;
}
static int exfat_create_fat_table(struct exfat_blk_dev *bd,
struct exfat_user_input *ui)
{
int ret, clu;
unsigned int fat_table_entries = 0;
if (ui->verify) {
fat_table_entries =
EXFAT_FIRST_CLUSTER +
DIV_ROUND_UP(finfo.bitmap_byte_len, ui->cluster_size) +
DIV_ROUND_UP(finfo.ut_byte_len, ui->cluster_size) +
DIV_ROUND_UP(finfo.root_byte_len, ui->cluster_size);
ui->fat_table_buff = calloc(fat_table_entries, sizeof(__le32));
if (!ui->fat_table_buff)
return -ENOMEM;
}
ret = write_fat_entry(ui, bd->dev_fd, cpu_to_le32(0xfffffff8), 0);
if (ret) {
exfat_err("fat 0 entry write failed\n");
goto free_fat_table_buff;
}
ret = write_fat_entry(ui, bd->dev_fd, cpu_to_le32(0xffffffff), 1);
if (ret) {
exfat_err("fat 1 entry write failed\n");
goto free_fat_table_buff;
}
clu = write_fat_entries(ui, bd->dev_fd, EXFAT_FIRST_CLUSTER,
finfo.bitmap_byte_len);
if (clu < 0) {
ret = clu;
goto free_fat_table_buff;
}
clu = write_fat_entries(ui, bd->dev_fd, clu + 1, finfo.ut_byte_len);
if (clu < 0) {
ret = clu;
goto free_fat_table_buff;
}
clu = write_fat_entries(ui, bd->dev_fd, clu + 1, finfo.root_byte_len);
if (clu < 0) {
ret = clu;
goto free_fat_table_buff;
}
finfo.used_clu_cnt = clu + 1 - EXFAT_FIRST_CLUSTER;
exfat_debug("Total used cluster count : %d\n", finfo.used_clu_cnt);
if (ui->verify) {
ret = exfat_check_written_data(bd,
ui->fat_table_buff, fat_table_entries * sizeof(__le32),
finfo.fat_byte_off,
"fat table");
if (ret)
exfat_err("fat table verification failed (read-back mismatch)\n");
}
free_fat_table_buff:
if (ui->verify)
free(ui->fat_table_buff);
return ret;
}
static int exfat_create_bitmap(struct exfat_blk_dev *bd,
struct exfat_user_input *ui)
{
char *bitmap;
unsigned int full_bytes, rem_bits, zero_offset;
unsigned int nbytes;
int ret = 0;
bitmap = malloc(finfo.bitmap_byte_len);
if (!bitmap) {
exfat_err("Cannot allocate bitmap: out of memory\n");
return -1;
}
full_bytes = finfo.used_clu_cnt / 8;
rem_bits = finfo.used_clu_cnt % 8;
zero_offset = full_bytes;
memset(bitmap, 0xff, full_bytes);
if (rem_bits != 0) {
bitmap[full_bytes] = (1 << rem_bits) - 1;
++zero_offset;
}
if (zero_offset < finfo.bitmap_byte_len)
memset(bitmap + zero_offset, 0, finfo.bitmap_byte_len - zero_offset);
nbytes = pwrite(bd->dev_fd, bitmap, finfo.bitmap_byte_len, finfo.bitmap_byte_off);
if (nbytes != finfo.bitmap_byte_len) {
exfat_err("write failed, nbytes : %d, bitmap_len : %d\n",
nbytes, finfo.bitmap_byte_len);
free(bitmap);
return -1;
}
if (ui->verify) {
ret = exfat_check_written_data(bd,
bitmap, finfo.bitmap_byte_len,
finfo.bitmap_byte_off,
"bitmap");
if (ret) {
exfat_err("bitmap verification failed (read-back mismatch)\n");
free(bitmap);
return ret;
}
}
free(bitmap);
return 0;
}
static int exfat_create_root_dir(struct exfat_blk_dev *bd,
struct exfat_user_input *ui)
{
struct exfat_dentry ed[4] = {0};
int dentries_len = sizeof(ed);
int nbytes, ret;
ret = exfat_write_zero(bd->dev_fd, ui->cluster_size,
finfo.root_byte_off);
if (ret) {
exfat_err("zero out write failed for root dir (errno : %d)\n",
errno);
return ret;
}
ed[0].type = EXFAT_VOLUME;
memset(ed[0].vol_label, 0, 22);
memcpy(ed[0].vol_label, ui->volume_label, ui->volume_label_len);
ed[0].vol_char_cnt = ui->volume_label_len/2;
if (ui->guid) {
if (__exfat_set_volume_guid(&ed[1], ui->guid))
return -1;
} else {
* Since a single empty entry cannot be allocated for a
* file, this can reserve the entry for volume GUID.
*/
ed[1].type = EXFAT_GUID & ~EXFAT_INVAL;
}
ed[2].type = EXFAT_BITMAP;
ed[2].bitmap_flags = 0;
ed[2].bitmap_start_clu = cpu_to_le32(EXFAT_FIRST_CLUSTER);
ed[2].bitmap_size = cpu_to_le64(finfo.bitmap_byte_len);
ed[3].type = EXFAT_UPCASE;
ed[3].upcase_checksum = cpu_to_le32(0xe619d30d);
ed[3].upcase_start_clu = cpu_to_le32(finfo.ut_start_clu);
ed[3].upcase_size = cpu_to_le64(EXFAT_UPCASE_TABLE_SIZE);
nbytes = pwrite(bd->dev_fd, ed, dentries_len, finfo.root_byte_off);
if (nbytes != dentries_len) {
exfat_err("write failed, nbytes : %d, dentries_len : %d\n",
nbytes, dentries_len);
return -1;
}
if (ui->verify) {
ret = exfat_check_written_data(bd,
ed, dentries_len,
finfo.root_byte_off,
"root directory");
if (ret) {
exfat_err("root directory verification failed (read-back mismatch)\n");
return ret;
}
}
return 0;
}
static void usage(void)
{
fputs("Usage: mkfs.exfat\n"
"\t-L | --volume-label=label Set volume label\n"
"\t-U | --volume-guid=guid Set volume GUID\n"
"\t-s | --sector-size=size(or suffixed by 'K') Specify sector size\n"
"\t-c | --cluster-size=size(or suffixed by 'K' or 'M') Specify cluster size\n"
"\t-b | --boundary-align=size(or suffixed by 'K' or 'M') Specify boundary alignment\n"
"\t --pack-bitmap Move bitmap into FAT segment\n"
"\t-f | --full-format Full format\n"
"\t-C | --check-written Verify written filesystem metadata by read-back\n"
"\t-K | --no-discard Do not discard blocks\n"
"\t-V | --version Show version\n"
"\t-q | --quiet Print only errors\n"
"\t-v | --verbose Print debug\n"
"\t-h | --help Show help\n",
stderr);
exit(EXIT_FAILURE);
}
#define PACK_BITMAP (CHAR_MAX + 1)
static const struct option opts[] = {
{"volume-label", required_argument, NULL, 'L' },
{"volume-guid", required_argument, NULL, 'U' },
{"sector-size", required_argument, NULL, 's' },
{"cluster-size", required_argument, NULL, 'c' },
{"boundary-align", required_argument, NULL, 'b' },
{"pack-bitmap", no_argument, NULL, PACK_BITMAP },
{"full-format", no_argument, NULL, 'f' },
{"check-written", no_argument, NULL, 'C' },
{"no-discard", no_argument, NULL, 'K' },
{"version", no_argument, NULL, 'V' },
{"quiet", no_argument, NULL, 'q' },
{"verbose", no_argument, NULL, 'v' },
{"help", no_argument, NULL, 'h' },
{"?", no_argument, NULL, '?' },
{NULL, 0, NULL, 0 }
};
* Moves the bitmap to just before the alignment boundary if there is space
* between the boundary and the end of the FAT. This may allow the FAT and the
* bitmap to share the same allocation unit on flash media, thereby improving
* performance and endurance.
*/
static int exfat_pack_bitmap(const struct exfat_user_input *ui)
{
unsigned long long fat_byte_end = finfo.fat_byte_off + finfo.fat_byte_len;
unsigned int bitmap_byte_len = finfo.bitmap_byte_len,
bitmap_clu_len = round_up(bitmap_byte_len, ui->cluster_size),
bitmap_clu_cnt, total_clu_cnt, new_bitmap_clu_len;
for (;;) {
bitmap_clu_cnt = bitmap_clu_len / ui->cluster_size;
if (finfo.clu_byte_off - bitmap_clu_len < fat_byte_end ||
finfo.total_clu_cnt > EXFAT_MAX_NUM_CLUSTER -
bitmap_clu_cnt)
return -1;
total_clu_cnt = finfo.total_clu_cnt + bitmap_clu_cnt;
bitmap_byte_len = round_up(total_clu_cnt, 8) / 8;
new_bitmap_clu_len = round_up(bitmap_byte_len, ui->cluster_size);
if (new_bitmap_clu_len == bitmap_clu_len) {
finfo.clu_byte_off -= bitmap_clu_len;
finfo.total_clu_cnt = total_clu_cnt;
finfo.bitmap_byte_off -= bitmap_clu_len;
finfo.bitmap_byte_len = bitmap_byte_len;
return 0;
}
bitmap_clu_len = new_bitmap_clu_len;
}
}
static int exfat_build_mkfs_info(struct exfat_blk_dev *bd,
struct exfat_user_input *ui)
{
unsigned long long total_clu_cnt;
unsigned long long max_clusters;
int clu_len;
int num_fats = 1;
if (ui->cluster_size < bd->sector_size) {
exfat_err("cluster size (%u bytes) is smaller than sector size (%u bytes)\n",
ui->cluster_size, bd->sector_size);
return -1;
}
if (ui->boundary_align < bd->sector_size) {
exfat_err("boundary alignment is too small (min %d)\n",
bd->sector_size);
return -1;
}
finfo.fat_byte_off = round_up(bd->offset + 24 * bd->sector_size,
ui->boundary_align) - bd->offset;
max_clusters = (bd->size - finfo.fat_byte_off - 8 * num_fats - 1) /
(ui->cluster_size + 4 * num_fats) + 1;
finfo.fat_byte_len = round_up((max_clusters + 2) * 4,
(unsigned long long)bd->sector_size);
if (finfo.fat_byte_len / bd->sector_size > UINT_MAX) {
exfat_err("cluster size (%u bytes) is too small\n", ui->cluster_size);
return -1;
}
finfo.clu_byte_off = round_up(bd->offset + finfo.fat_byte_off +
finfo.fat_byte_len * num_fats,
(unsigned long long)ui->boundary_align) - bd->offset;
if (bd->size <= finfo.clu_byte_off) {
exfat_err("boundary alignment is too big\n");
return -1;
}
total_clu_cnt = (bd->size - finfo.clu_byte_off) / ui->cluster_size;
if (total_clu_cnt > EXFAT_MAX_NUM_CLUSTER) {
exfat_err("cluster size is too small\n");
return -1;
}
finfo.total_clu_cnt = (unsigned int) total_clu_cnt;
finfo.bitmap_byte_off = finfo.clu_byte_off;
finfo.bitmap_byte_len = round_up(finfo.total_clu_cnt, 8) / 8;
if (ui->pack_bitmap)
exfat_pack_bitmap(ui);
clu_len = round_up(finfo.bitmap_byte_len,
(unsigned long long)ui->cluster_size);
finfo.ut_start_clu = EXFAT_FIRST_CLUSTER + clu_len / ui->cluster_size;
finfo.ut_byte_off = finfo.bitmap_byte_off + clu_len;
finfo.ut_byte_len = EXFAT_UPCASE_TABLE_SIZE;
clu_len = round_up(finfo.ut_byte_len,
(unsigned long long)ui->cluster_size);
finfo.root_start_clu = finfo.ut_start_clu + clu_len / ui->cluster_size;
finfo.root_byte_off = finfo.ut_byte_off + clu_len;
finfo.root_byte_len = sizeof(struct exfat_dentry) * 3;
finfo.volume_serial = get_new_serial();
return 0;
}
static int exfat_zero_out_disk(struct exfat_blk_dev *bd,
struct exfat_user_input *ui)
{
int ret;
if (ui->quick)
return 0;
ret = exfat_write_zero(bd->dev_fd, bd->size, 0);
if (ret) {
exfat_err("write failed(errno : %d)\n", errno);
return ret;
}
exfat_debug("zero out written size : %llu\n",
bd->size);
return 0;
}
static void exfat_discard_dev(struct exfat_blk_dev *bd,
struct exfat_user_input *ui)
{
uint64_t offset = 0;
uint64_t tmp_step;
int err;
const uint64_t step = 2ULL << 30;
const uint64_t count = bd->num_sectors * bd->sector_size;
if (!ui->discard || !bd->isblk) {
exfat_debug("no-discard requested or the device is a file\n");
return;
}
* The block discarding happens in smaller batches so it can be
* interrupted prematurely
*/
while (offset < count) {
tmp_step = count - offset;
if (step < tmp_step)
tmp_step = step;
err = exfat_discard_blocks(bd->dev_fd, offset, tmp_step);
* We intentionally ignore errors from the discard ioctl. It is
* not necessary for the mkfs functionality but just an
* optimization. However we should stop on error.
*/
if (err == 0) {
if (offset == 0) {
exfat_info("Discarding blocks: ");
exfat_debug("BLKDISCARD: ");
}
exfat_debug("%"PRIu64"-%"PRIu64" ", offset, offset + tmp_step);
fflush(stdout);
} else {
exfat_debug("BLKDISCARD: %s\n", strerror(err));
if (offset > 0)
exfat_info("\n");
return;
}
offset += tmp_step;
}
if (offset > 0)
exfat_info("done\n");
}
static int make_exfat(struct exfat_blk_dev *bd, struct exfat_user_input *ui)
{
int ret;
exfat_info("Creating exFAT filesystem(%s, cluster size=%u)\n\n",
ui->dev_name, ui->cluster_size);
exfat_info("Writing volume boot record: ");
ret = exfat_create_volume_boot_record(bd, ui, 0);
exfat_info("%s\n", ret ? "failed" : "done");
if (ret)
return ret;
exfat_info("Writing backup volume boot record: ");
ret = exfat_create_volume_boot_record(bd, ui, 1);
exfat_info("%s\n", ret ? "failed" : "done");
if (ret)
return ret;
exfat_info("Fat table creation: ");
ret = exfat_create_fat_table(bd, ui);
exfat_info("%s\n", ret ? "failed" : "done");
if (ret)
return ret;
exfat_info("Allocation bitmap creation: ");
ret = exfat_create_bitmap(bd, ui);
exfat_info("%s\n", ret ? "failed" : "done");
if (ret)
return ret;
exfat_info("Upcase table creation: ");
ret = exfat_create_upcase_table(bd, ui);
exfat_info("%s\n", ret ? "failed" : "done");
if (ret)
return ret;
exfat_info("Writing root directory entry: ");
ret = exfat_create_root_dir(bd, ui);
exfat_info("%s\n", ret ? "failed" : "done");
if (ret)
return ret;
return 0;
}
static long long parse_size(const char *size)
{
char *data_unit;
unsigned long long byte_size = strtoull(size, &data_unit, 0);
switch (*data_unit) {
case 'M':
case 'm':
byte_size <<= 20;
break;
case 'K':
case 'k':
byte_size <<= 10;
break;
case '\0':
break;
default:
exfat_err("Wrong unit input('%c') for size\n",
*data_unit);
return -EINVAL;
}
return byte_size;
}
int main(int argc, char *argv[])
{
int c;
int ret = EXIT_FAILURE;
struct exfat_blk_dev bd;
struct exfat_user_input ui;
bool version_only = false;
bool quiet = false;
init_user_input(&ui);
if (!setlocale(LC_CTYPE, ""))
exfat_err("failed to init locale/codeset\n");
opterr = 0;
while ((c = getopt_long(argc, argv, "n:L:U:s:c:b:fCKVqvh", opts, NULL)) != EOF)
switch (c) {
* Make 'n' option fallthrough to 'L' option for for backward
* compatibility with old utils.
*/
case 'n':
case 'L':
{
ret = exfat_utf16_enc(optarg,
ui.volume_label, sizeof(ui.volume_label));
if (ret < 0)
goto out;
ui.volume_label_len = ret;
break;
}
case 'U':
if (*optarg != '\0' && *optarg != '\r')
ui.guid = optarg;
break;
case 's':
ret = parse_size(optarg);
if (ret < 0)
goto out;
else if (ret & (ret - 1)) {
exfat_err("sector size(%d) is not a power of 2\n",
ret);
goto out;
} else if ((ret & 0x1e00) == 0) {
exfat_err("sector size(%d) must be 512, 1024, "
"2048 or 4096 bytes\n",
ret);
goto out;
}
ui.sector_size = ret;
break;
case 'c':
ret = parse_size(optarg);
if (ret < 0)
goto out;
else if (ret & (ret - 1)) {
exfat_err("cluster size(%d) is not a power of 2)\n",
ret);
goto out;
} else if (ret > EXFAT_MAX_CLUSTER_SIZE) {
exfat_err("cluster size(%d) exceeds max cluster size(%d)\n",
ui.cluster_size, EXFAT_MAX_CLUSTER_SIZE);
goto out;
}
ui.cluster_size = ret;
break;
case 'b':
ret = parse_size(optarg);
if (ret < 0)
goto out;
else if (ret & (ret - 1)) {
exfat_err("boundary align(%d) is not a power of 2)\n",
ret);
goto out;
}
ui.boundary_align = ret;
break;
case PACK_BITMAP:
ui.pack_bitmap = true;
break;
case 'f':
ui.quick = false;
break;
case 'C':
ui.verify = true;
break;
case 'K':
ui.discard = false;
break;
case 'V':
version_only = true;
break;
case 'q':
print_level = EXFAT_ERROR;
quiet = true;
break;
case 'v':
print_level = EXFAT_DEBUG;
break;
case '?':
case 'h':
default:
usage();
}
if (version_only) {
show_version();
exit(EXIT_FAILURE);
} else if (!quiet) {
show_version();
}
if (argc - optind != 1) {
usage();
}
if (ui.sector_size && ui.cluster_size && ui.sector_size > ui.cluster_size) {
exfat_err("cluster size (%u bytes) is smaller than sector size (%u bytes)\n",
ui.cluster_size, ui.sector_size);
ret = -1;
goto out;
}
ui.dev_name = argv[optind];
ret = exfat_get_blk_dev_info(&ui, &bd);
if (ret < 0)
goto out;
ret = exfat_build_mkfs_info(&bd, &ui);
if (ret)
goto close;
exfat_discard_dev(&bd, &ui);
* Zeroing out still needs to be conducted as per JESD84-B51 6.6.9:
* "content of an explicitly erased memory range shall be ‘0’ or ‘1’
* depending on different memory technology,"
*/
ret = exfat_zero_out_disk(&bd, &ui);
if (ret)
goto close;
ret = make_exfat(&bd, &ui);
if (ret)
goto close;
exfat_info("Synchronizing...\n");
ret = fsync(bd.dev_fd);
close:
close(bd.dev_fd);
if (ui.verify)
close(bd.verify_fd);
out:
if (!ret)
exfat_info("\nexFAT format complete!\n");
else
exfat_err("\nexFAT format fail!\n");
return ret ? EXIT_FAILURE : EXIT_SUCCESS;
}
