1 // SPDX-License-Identifier: GPL-2.0-or-later
3 * Copyright (C) 2019 Namjae Jeon <linkinjeon@kernel.org>
9 #include <sys/sysmacros.h>
20 #include "exfat_ondisk.h"
24 #include "exfat_dir.h"
26 unsigned int print_level = EXFAT_INFO;
28 void exfat_bitmap_set_range(struct exfat *exfat, char *bitmap,
29 clus_t start_clus, clus_t count)
33 if (!exfat_heap_clus(exfat, start_clus) ||
34 !exfat_heap_clus(exfat, start_clus + count - 1))
38 while (clus < start_clus + count) {
39 exfat_bitmap_set(bitmap, clus);
44 static int exfat_bitmap_find_bit(struct exfat *exfat, char *bmap,
45 clus_t start_clu, clus_t *next,
50 last_clu = le32_to_cpu(exfat->bs->bsx.clu_count) +
52 while (start_clu < last_clu) {
53 if (!!exfat_bitmap_get(bmap, start_clu) == bit) {
62 int exfat_bitmap_find_zero(struct exfat *exfat, char *bmap,
63 clus_t start_clu, clus_t *next)
65 return exfat_bitmap_find_bit(exfat, bmap,
69 int exfat_bitmap_find_one(struct exfat *exfat, char *bmap,
70 clus_t start_clu, clus_t *next)
72 return exfat_bitmap_find_bit(exfat, bmap,
76 wchar_t exfat_bad_char(wchar_t w)
79 || (w == '*') || (w == '?') || (w == '<') || (w == '>')
80 || (w == '|') || (w == '"') || (w == ':') || (w == '/')
84 void boot_calc_checksum(unsigned char *sector, unsigned short size,
85 bool is_boot_sec, __le32 *checksum)
90 for (index = 0; index < size; index++) {
91 if ((index == 106) || (index == 107) || (index == 112))
93 *checksum = ((*checksum & 1) ? 0x80000000 : 0) +
94 (*checksum >> 1) + sector[index];
97 for (index = 0; index < size; index++) {
98 *checksum = ((*checksum & 1) ? 0x80000000 : 0) +
99 (*checksum >> 1) + sector[index];
104 void show_version(void)
106 printf("exfatprogs version : %s\n", EXFAT_PROGS_VERSION);
109 static inline unsigned int sector_size_bits(unsigned int size)
111 unsigned int bits = 8;
116 } while (size > 256);
121 static void exfat_set_default_cluster_size(struct exfat_blk_dev *bd,
122 struct exfat_user_input *ui)
124 if (256 * MB >= bd->size)
125 ui->cluster_size = 4 * KB;
126 else if (32 * GB >= bd->size)
127 ui->cluster_size = 32 * KB;
129 ui->cluster_size = 128 * KB;
132 void init_user_input(struct exfat_user_input *ui)
134 memset(ui, 0, sizeof(struct exfat_user_input));
135 ui->writeable = true;
139 int exfat_get_blk_dev_info(struct exfat_user_input *ui,
140 struct exfat_blk_dev *bd)
145 unsigned long long blk_dev_offset = 0;
147 fd = open(ui->dev_name, ui->writeable ? O_RDWR|O_EXCL : O_RDONLY);
149 exfat_err("open failed : %s, %s\n", ui->dev_name,
153 blk_dev_size = lseek(fd, 0, SEEK_END);
154 if (blk_dev_size <= 0) {
155 exfat_err("invalid block device size(%s)\n",
162 if (fstat(fd, &st) == 0 && S_ISBLK(st.st_mode)) {
163 char pathname[sizeof("/sys/dev/block/4294967295:4294967295/start")];
166 snprintf(pathname, sizeof(pathname), "/sys/dev/block/%u:%u/start",
167 major(st.st_rdev), minor(st.st_rdev));
168 fp = fopen(pathname, "r");
170 if (fscanf(fp, "%llu", &blk_dev_offset) == 1) {
172 * Linux kernel always reports partition offset
173 * in 512-byte units, regardless of sector size
175 blk_dev_offset <<= 9;
182 bd->offset = blk_dev_offset;
183 bd->size = blk_dev_size;
184 if (!ui->cluster_size)
185 exfat_set_default_cluster_size(bd, ui);
187 if (!ui->boundary_align)
188 ui->boundary_align = DEFAULT_BOUNDARY_ALIGNMENT;
191 bd->sector_size = ui->sector_size;
192 else if (ioctl(fd, BLKSSZGET, &bd->sector_size) < 0)
193 bd->sector_size = DEFAULT_SECTOR_SIZE;
194 bd->sector_size_bits = sector_size_bits(bd->sector_size);
195 bd->num_sectors = blk_dev_size / bd->sector_size;
196 bd->num_clusters = blk_dev_size / ui->cluster_size;
198 exfat_debug("Block device name : %s\n", ui->dev_name);
199 exfat_debug("Block device offset : %llu\n", bd->offset);
200 exfat_debug("Block device size : %llu\n", bd->size);
201 exfat_debug("Block sector size : %u\n", bd->sector_size);
202 exfat_debug("Number of the sectors : %llu\n",
204 exfat_debug("Number of the clusters : %u\n",
213 ssize_t exfat_read(int fd, void *buf, size_t size, off_t offset)
215 return pread(fd, buf, size, offset);
218 ssize_t exfat_write(int fd, void *buf, size_t size, off_t offset)
220 return pwrite(fd, buf, size, offset);
223 ssize_t exfat_write_zero(int fd, size_t size, off_t offset)
225 const char zero_buf[4 * KB] = {0};
227 lseek(fd, offset, SEEK_SET);
230 int iter_size = MIN(size, sizeof(zero_buf));
232 if (iter_size != write(fd, zero_buf, iter_size))
241 size_t exfat_utf16_len(const __le16 *str, size_t max_size)
245 while (le16_to_cpu(str[i]) && i < max_size)
250 ssize_t exfat_utf16_enc(const char *in_str, __u16 *out_str, size_t out_size)
252 size_t mbs_len, out_len, i;
255 mbs_len = mbstowcs(NULL, in_str, 0);
256 if (mbs_len == (size_t)-1) {
257 if (errno == EINVAL || errno == EILSEQ)
258 exfat_err("invalid character sequence in current locale\n");
262 wcs = calloc(mbs_len+1, sizeof(wchar_t));
266 /* First convert multibyte char* string to wchar_t* string */
267 if (mbstowcs(wcs, in_str, mbs_len+1) == (size_t)-1) {
268 if (errno == EINVAL || errno == EILSEQ)
269 exfat_err("invalid character sequence in current locale\n");
274 /* Convert wchar_t* string (sequence of code points) to UTF-16 string */
275 for (i = 0, out_len = 0; i < mbs_len; i++) {
276 if (2*(out_len+1) > out_size ||
277 (wcs[i] >= 0x10000 && 2*(out_len+2) > out_size)) {
278 exfat_err("input string is too long\n");
283 /* Encode code point above Plane0 as UTF-16 surrogate pair */
284 if (wcs[i] >= 0x10000) {
286 cpu_to_le16(((wcs[i] - 0x10000) >> 10) + 0xD800);
287 wcs[i] = ((wcs[i] - 0x10000) & 0x3FF) + 0xDC00;
290 out_str[out_len++] = cpu_to_le16(wcs[i]);
297 ssize_t exfat_utf16_dec(const __u16 *in_str, size_t in_len,
298 char *out_str, size_t out_size)
300 size_t wcs_len, out_len, c_len, i;
301 char c_str[MB_LEN_MAX];
306 wcs = calloc(in_len/2+1, sizeof(wchar_t));
310 /* First convert UTF-16 string to wchar_t* string */
311 for (i = 0, wcs_len = 0; i < in_len/2; i++, wcs_len++) {
312 wcs[wcs_len] = le16_to_cpu(in_str[i]);
314 * If wchar_t can store code point above Plane0
315 * then unpack UTF-16 surrogate pair to code point
317 #if WCHAR_MAX >= 0x10FFFF
318 if (wcs[wcs_len] >= 0xD800 && wcs[wcs_len] <= 0xDBFF &&
320 w = le16_to_cpu(in_str[i+1]);
321 if (w >= 0xDC00 && w <= 0xDFFF) {
322 wcs[wcs_len] = 0x10000 +
323 ((wcs[wcs_len] - 0xD800) << 10) +
331 memset(&ps, 0, sizeof(ps));
333 /* And then convert wchar_t* string to multibyte char* string */
334 for (i = 0, out_len = 0, c_len = 0; i <= wcs_len; i++) {
335 c_len = wcrtomb(c_str, wcs[i], &ps);
337 * If character is non-representable in current locale then
338 * try to store it as Unicode replacement code point U+FFFD
340 if (c_len == (size_t)-1 && errno == EILSEQ)
341 c_len = wcrtomb(c_str, 0xFFFD, &ps);
342 /* If U+FFFD is also non-representable, try question mark */
343 if (c_len == (size_t)-1 && errno == EILSEQ)
344 c_len = wcrtomb(c_str, L'?', &ps);
345 /* If also (7bit) question mark fails then we cannot do more */
346 if (c_len == (size_t)-1) {
347 exfat_err("invalid UTF-16 sequence\n");
351 if (out_len+c_len > out_size) {
352 exfat_err("input string is too long\n");
356 memcpy(out_str+out_len, c_str, c_len);
362 /* Last iteration of above loop should have produced null byte */
363 if (c_len == 0 || out_str[out_len-1] != 0) {
364 exfat_err("invalid UTF-16 sequence\n");
371 off_t exfat_get_root_entry_offset(struct exfat_blk_dev *bd)
375 unsigned int cluster_size, sector_size;
378 bs = malloc(EXFAT_MAX_SECTOR_SIZE);
380 exfat_err("failed to allocate memory\n");
384 nbytes = exfat_read(bd->dev_fd, bs, EXFAT_MAX_SECTOR_SIZE, 0);
385 if (nbytes != EXFAT_MAX_SECTOR_SIZE) {
386 exfat_err("boot sector read failed: %d\n", errno);
391 if (memcmp(bs->bpb.oem_name, "EXFAT ", 8) != 0) {
392 exfat_err("Bad fs_name in boot sector, which does not describe a valid exfat filesystem\n");
397 sector_size = 1 << bs->bsx.sect_size_bits;
398 cluster_size = (1 << bs->bsx.sect_per_clus_bits) * sector_size;
399 root_clu_off = le32_to_cpu(bs->bsx.clu_offset) * sector_size +
400 (le32_to_cpu(bs->bsx.root_cluster) - EXFAT_RESERVED_CLUSTERS) *
407 char *exfat_conv_volume_label(struct exfat_dentry *vol_entry)
410 __le16 disk_label[VOLUME_LABEL_MAX_LEN];
412 volume_label = malloc(VOLUME_LABEL_BUFFER_SIZE);
416 memcpy(disk_label, vol_entry->vol_label, sizeof(disk_label));
417 memset(volume_label, 0, VOLUME_LABEL_BUFFER_SIZE);
418 if (exfat_utf16_dec(disk_label, vol_entry->vol_char_cnt*2,
419 volume_label, VOLUME_LABEL_BUFFER_SIZE) < 0) {
420 exfat_err("failed to decode volume label\n");
428 int exfat_read_volume_label(struct exfat *exfat)
430 struct exfat_dentry *dentry;
432 __le16 disk_label[VOLUME_LABEL_MAX_LEN];
433 struct exfat_lookup_filter filter = {
434 .in.type = EXFAT_VOLUME,
435 .in.dentry_count = 0,
439 err = exfat_lookup_dentry_set(exfat, exfat->root, &filter);
443 dentry = filter.out.dentry_set;
445 if (dentry->vol_char_cnt == 0)
448 if (dentry->vol_char_cnt > VOLUME_LABEL_MAX_LEN) {
449 exfat_err("too long label. %d\n", dentry->vol_char_cnt);
454 memcpy(disk_label, dentry->vol_label, sizeof(disk_label));
455 if (exfat_utf16_dec(disk_label, dentry->vol_char_cnt*2,
456 exfat->volume_label, sizeof(exfat->volume_label)) < 0) {
457 exfat_err("failed to decode volume label\n");
462 exfat_info("label: %s\n", exfat->volume_label);
464 free(filter.out.dentry_set);
468 int exfat_set_volume_label(struct exfat *exfat, char *label_input)
470 struct exfat_dentry *pvol;
471 struct exfat_dentry_loc loc;
472 __u16 volume_label[VOLUME_LABEL_MAX_LEN];
473 int volume_label_len, dcount, err;
475 struct exfat_lookup_filter filter = {
476 .in.type = EXFAT_VOLUME,
477 .in.dentry_count = 1,
481 err = exfat_lookup_dentry_set(exfat, exfat->root, &filter);
483 pvol = filter.out.dentry_set;
484 dcount = filter.out.dentry_count;
485 memset(pvol->vol_label, 0, sizeof(pvol->vol_label));
487 pvol = calloc(1, sizeof(struct exfat_dentry));
492 pvol->type = EXFAT_VOLUME;
495 volume_label_len = exfat_utf16_enc(label_input,
496 volume_label, sizeof(volume_label));
497 if (volume_label_len < 0) {
498 exfat_err("failed to encode volume label\n");
503 memcpy(pvol->vol_label, volume_label, volume_label_len);
504 pvol->vol_char_cnt = volume_label_len/2;
506 loc.parent = exfat->root;
507 loc.file_offset = filter.out.file_offset;
508 loc.dev_offset = filter.out.dev_offset;
509 err = exfat_add_dentry_set(exfat, &loc, pvol, dcount, false);
510 exfat_info("new label: %s\n", label_input);
517 static inline void print_guid(const char *msg, const __u8 *guid)
519 exfat_info("%s: %02x%02x%02x%02x-%02x%02x-%02x%02x-%02x%02x-%02x%02x%02x%02x%02x%02x\n",
521 guid[0], guid[1], guid[2], guid[3],
522 guid[4], guid[5], guid[5], guid[7],
523 guid[8], guid[9], guid[10], guid[11],
524 guid[12], guid[13], guid[14], guid[15]);
527 static int set_guid(__u8 *guid, const char *input)
529 int i, j, zero_len = 0;
530 int len = strlen(input);
532 if (len != EXFAT_GUID_LEN * 2 && len != EXFAT_GUID_LEN * 2 + 4) {
533 exfat_err("invalid format for volume guid\n");
537 for (i = 0, j = 0; i < len; i++) {
538 unsigned char ch = input[i];
540 if (ch >= '0' && ch <= '9')
542 else if (ch >= 'a' && ch <= 'f')
544 else if (ch >= 'A' && ch <= 'F')
546 else if (ch == '-' && len == EXFAT_GUID_LEN * 2 + 4 &&
547 (i == 8 || i == 13 || i == 18 || i == 23))
550 exfat_err("invalid character '%c' for volume GUID\n", ch);
557 guid[j >> 1] = ch << 4;
565 if (zero_len == EXFAT_GUID_LEN * 2) {
566 exfat_err("%s is invalid for volume GUID\n", input);
573 int exfat_read_volume_guid(struct exfat *exfat)
576 uint16_t checksum = 0;
577 struct exfat_dentry *dentry;
578 struct exfat_lookup_filter filter = {
579 .in.type = EXFAT_GUID,
580 .in.dentry_count = 1,
584 err = exfat_lookup_dentry_set(exfat, exfat->root, &filter);
588 dentry = filter.out.dentry_set;
589 exfat_calc_dentry_checksum(dentry, &checksum, true);
591 if (cpu_to_le16(checksum) == dentry->dentry.guid.checksum)
592 print_guid("GUID", dentry->dentry.guid.guid);
594 exfat_info("GUID is corrupted, please delete it or set a new one\n");
601 int __exfat_set_volume_guid(struct exfat_dentry *dentry, const char *guid)
604 uint16_t checksum = 0;
606 memset(dentry, 0, sizeof(*dentry));
607 dentry->type = EXFAT_GUID;
609 err = set_guid(dentry->dentry.guid.guid, guid);
613 exfat_calc_dentry_checksum(dentry, &checksum, true);
614 dentry->dentry.guid.checksum = cpu_to_le16(checksum);
620 * Create/Update/Delete GUID dentry in root directory
622 * create/update GUID if @guid is not NULL.
623 * delete GUID if @guid is NULL.
625 int exfat_set_volume_guid(struct exfat *exfat, const char *guid)
627 struct exfat_dentry *dentry;
628 struct exfat_dentry_loc loc;
631 struct exfat_lookup_filter filter = {
632 .in.type = EXFAT_GUID,
633 .in.dentry_count = 1,
637 err = exfat_lookup_dentry_set(exfat, exfat->root, &filter);
639 /* GUID entry is found */
640 dentry = filter.out.dentry_set;
642 /* no GUID to delete */
646 dentry = calloc(1, sizeof(*dentry));
653 err = __exfat_set_volume_guid(dentry, guid);
658 dentry->type &= ~EXFAT_INVAL;
661 loc.parent = exfat->root;
662 loc.file_offset = filter.out.file_offset;
663 loc.dev_offset = filter.out.dev_offset;
664 err = exfat_add_dentry_set(exfat, &loc, dentry, 1, false);
667 print_guid("new GUID", dentry->dentry.guid.guid);
669 exfat_info("GUID is deleted\n");
678 int exfat_read_sector(struct exfat_blk_dev *bd, void *buf, unsigned int sec_off)
681 unsigned long long offset =
682 (unsigned long long)sec_off * bd->sector_size;
684 ret = pread(bd->dev_fd, buf, bd->sector_size, offset);
686 exfat_err("read failed, sec_off : %u\n", sec_off);
692 int exfat_write_sector(struct exfat_blk_dev *bd, void *buf,
693 unsigned int sec_off)
696 unsigned long long offset =
697 (unsigned long long)sec_off * bd->sector_size;
699 bytes = pwrite(bd->dev_fd, buf, bd->sector_size, offset);
700 if (bytes != (int)bd->sector_size) {
701 exfat_err("write failed, sec_off : %u, bytes : %d\n", sec_off,
708 int exfat_write_checksum_sector(struct exfat_blk_dev *bd,
709 unsigned int checksum, bool is_backup)
711 __le32 *checksum_buf;
714 unsigned int sec_idx = CHECKSUM_SEC_IDX;
716 checksum_buf = malloc(bd->sector_size);
721 sec_idx += BACKUP_BOOT_SEC_IDX;
723 for (i = 0; i < bd->sector_size / sizeof(int); i++)
724 checksum_buf[i] = cpu_to_le32(checksum);
726 ret = exfat_write_sector(bd, checksum_buf, sec_idx);
728 exfat_err("checksum sector write failed\n");
737 int exfat_show_volume_serial(int fd)
742 ppbr = malloc(EXFAT_MAX_SECTOR_SIZE);
744 exfat_err("Cannot allocate pbr: out of memory\n");
748 /* read main boot sector */
749 ret = exfat_read(fd, (char *)ppbr, EXFAT_MAX_SECTOR_SIZE, 0);
751 exfat_err("main boot sector read failed\n");
756 if (memcmp(ppbr->bpb.oem_name, "EXFAT ", 8) != 0) {
757 exfat_err("Bad fs_name in boot sector, which does not describe a valid exfat filesystem\n");
762 exfat_info("volume serial : 0x%x\n", ppbr->bsx.vol_serial);
769 static int exfat_update_boot_checksum(struct exfat_blk_dev *bd, bool is_backup)
771 unsigned int checksum = 0;
772 int ret, sec_idx, backup_sec_idx = 0;
775 buf = malloc(bd->sector_size);
777 exfat_err("Cannot allocate pbr: out of memory\n");
782 backup_sec_idx = BACKUP_BOOT_SEC_IDX;
784 for (sec_idx = BOOT_SEC_IDX; sec_idx < CHECKSUM_SEC_IDX; sec_idx++) {
785 bool is_boot_sec = false;
787 ret = exfat_read_sector(bd, buf, sec_idx + backup_sec_idx);
789 exfat_err("sector(%d) read failed\n", sec_idx);
794 if (sec_idx == BOOT_SEC_IDX)
797 boot_calc_checksum(buf, bd->sector_size, is_boot_sec,
801 ret = exfat_write_checksum_sector(bd, checksum, is_backup);
809 int exfat_set_volume_serial(struct exfat_blk_dev *bd,
810 struct exfat_user_input *ui)
815 ppbr = malloc(EXFAT_MAX_SECTOR_SIZE);
817 exfat_err("Cannot allocate pbr: out of memory\n");
821 /* read main boot sector */
822 ret = exfat_read(bd->dev_fd, (char *)ppbr, EXFAT_MAX_SECTOR_SIZE,
825 exfat_err("main boot sector read failed\n");
830 if (memcmp(ppbr->bpb.oem_name, "EXFAT ", 8) != 0) {
831 exfat_err("Bad fs_name in boot sector, which does not describe a valid exfat filesystem\n");
836 bd->sector_size = 1 << ppbr->bsx.sect_size_bits;
837 ppbr->bsx.vol_serial = cpu_to_le32(ui->volume_serial);
839 /* update main boot sector */
840 ret = exfat_write_sector(bd, (char *)ppbr, BOOT_SEC_IDX);
842 exfat_err("main boot sector write failed\n");
847 /* update backup boot sector */
848 ret = exfat_write_sector(bd, (char *)ppbr, BACKUP_BOOT_SEC_IDX);
850 exfat_err("backup boot sector write failed\n");
855 ret = exfat_update_boot_checksum(bd, 0);
857 exfat_err("main checksum update failed\n");
861 ret = exfat_update_boot_checksum(bd, 1);
863 exfat_err("backup checksum update failed\n");
867 exfat_info("New volume serial : 0x%x\n", ui->volume_serial);
872 unsigned int exfat_clus_to_blk_dev_off(struct exfat_blk_dev *bd,
873 unsigned int clu_off_sectnr, unsigned int clu)
875 return clu_off_sectnr * bd->sector_size +
876 (clu - EXFAT_RESERVED_CLUSTERS) * bd->cluster_size;
879 int exfat_get_next_clus(struct exfat *exfat, clus_t clus, clus_t *next)
883 *next = EXFAT_EOF_CLUSTER;
885 if (!exfat_heap_clus(exfat, clus))
888 offset = (off_t)le32_to_cpu(exfat->bs->bsx.fat_offset) <<
889 exfat->bs->bsx.sect_size_bits;
890 offset += sizeof(clus_t) * clus;
892 if (exfat_read(exfat->blk_dev->dev_fd, next, sizeof(*next), offset)
895 *next = le32_to_cpu(*next);
899 int exfat_get_inode_next_clus(struct exfat *exfat, struct exfat_inode *node,
900 clus_t clus, clus_t *next)
902 *next = EXFAT_EOF_CLUSTER;
904 if (node->is_contiguous) {
905 if (!exfat_heap_clus(exfat, clus))
911 return exfat_get_next_clus(exfat, clus, next);
914 int exfat_set_fat(struct exfat *exfat, clus_t clus, clus_t next_clus)
918 offset = le32_to_cpu(exfat->bs->bsx.fat_offset) <<
919 exfat->bs->bsx.sect_size_bits;
920 offset += sizeof(clus_t) * clus;
922 if (exfat_write(exfat->blk_dev->dev_fd, &next_clus, sizeof(next_clus),
923 offset) != sizeof(next_clus))
928 off_t exfat_s2o(struct exfat *exfat, off_t sect)
930 return sect << exfat->bs->bsx.sect_size_bits;
933 off_t exfat_c2o(struct exfat *exfat, unsigned int clus)
935 assert(clus >= EXFAT_FIRST_CLUSTER);
937 return exfat_s2o(exfat, le32_to_cpu(exfat->bs->bsx.clu_offset) +
938 ((off_t)(clus - EXFAT_FIRST_CLUSTER) <<
939 exfat->bs->bsx.sect_per_clus_bits));
942 int exfat_o2c(struct exfat *exfat, off_t device_offset,
943 unsigned int *clu, unsigned int *offset)
947 heap_offset = exfat_s2o(exfat, le32_to_cpu(exfat->bs->bsx.clu_offset));
948 if (device_offset < heap_offset)
951 *clu = (unsigned int)((device_offset - heap_offset) /
952 exfat->clus_size) + EXFAT_FIRST_CLUSTER;
953 if (!exfat_heap_clus(exfat, *clu))
955 *offset = (device_offset - heap_offset) % exfat->clus_size;
959 bool exfat_heap_clus(struct exfat *exfat, clus_t clus)
961 return clus >= EXFAT_FIRST_CLUSTER &&
962 (clus - EXFAT_FIRST_CLUSTER) < exfat->clus_count;
965 int exfat_root_clus_count(struct exfat *exfat)
967 struct exfat_inode *node = exfat->root;
971 if (!exfat_heap_clus(exfat, node->first_clus))
974 clus = node->first_clus;
976 if (exfat_bitmap_get(exfat->alloc_bitmap, clus))
979 exfat_bitmap_set(exfat->alloc_bitmap, clus);
981 if (exfat_get_inode_next_clus(exfat, node, clus, &next)) {
982 exfat_err("ERROR: failed to read the fat entry of root");
986 if (next != EXFAT_EOF_CLUSTER && !exfat_heap_clus(exfat, next))
991 } while (clus != EXFAT_EOF_CLUSTER);
993 node->size = clus_count * exfat->clus_size;
997 int read_boot_sect(struct exfat_blk_dev *bdev, struct pbr **bs)
1001 unsigned int sect_size, clu_size;
1003 pbr = malloc(sizeof(struct pbr));
1005 exfat_err("failed to allocate memory\n");
1009 if (exfat_read(bdev->dev_fd, pbr, sizeof(*pbr), 0) !=
1010 (ssize_t)sizeof(*pbr)) {
1011 exfat_err("failed to read a boot sector\n");
1017 if (memcmp(pbr->bpb.oem_name, "EXFAT ", 8) != 0) {
1018 exfat_err("failed to find exfat file system\n");
1022 sect_size = 1 << pbr->bsx.sect_size_bits;
1023 clu_size = 1 << (pbr->bsx.sect_size_bits +
1024 pbr->bsx.sect_per_clus_bits);
1026 if (sect_size < 512 || sect_size > 4 * KB) {
1027 exfat_err("too small or big sector size: %d\n",
1032 if (clu_size < sect_size || clu_size > 32 * MB) {
1033 exfat_err("too small or big cluster size: %d\n",
1045 int exfat_parse_ulong(const char *s, unsigned long *out)
1051 *out = strtoul(s, &endptr, 0);
1056 if (s == endptr || *endptr != '\0')