1// SPDX-License-Identifier: GPL-2.0-or-later 2/* 3 * Copyright (C) 2019 Namjae Jeon <linkinjeon@kernel.org> 4 */ 5 6#include <sys/types.h> 7#include <sys/stat.h> 8#include <sys/ioctl.h> 9#include <sys/sysmacros.h> 10#include <unistd.h> 11#include <fcntl.h> 12#include <stdlib.h> 13#include <stdio.h> 14#include <string.h> 15#include <errno.h> 16#include <wchar.h> 17#include <limits.h> 18 19#include "exfat_ondisk.h" 20#include "libexfat.h" 21#include "version.h" 22#include "exfat_fs.h" 23#include "exfat_dir.h" 24 25unsigned int print_level = EXFAT_INFO; 26 27void exfat_bitmap_set_range(struct exfat *exfat, char *bitmap, 28 clus_t start_clus, clus_t count) 29{ 30 clus_t clus; 31 32 if (!exfat_heap_clus(exfat, start_clus) || 33 !exfat_heap_clus(exfat, start_clus + count - 1)) 34 return; 35 36 clus = start_clus; 37 while (clus < start_clus + count) { 38 exfat_bitmap_set(bitmap, clus); 39 clus++; 40 } 41} 42 43static int exfat_bitmap_find_bit(struct exfat *exfat, char *bmap, 44 clus_t start_clu, clus_t *next, 45 int bit) 46{ 47 clus_t last_clu; 48 49 last_clu = le32_to_cpu(exfat->bs->bsx.clu_count) + 50 EXFAT_FIRST_CLUSTER; 51 while (start_clu < last_clu) { 52 if (!!exfat_bitmap_get(bmap, start_clu) == bit) { 53 *next = start_clu; 54 return 0; 55 } 56 start_clu++; 57 } 58 return 1; 59} 60 61int exfat_bitmap_find_zero(struct exfat *exfat, char *bmap, 62 clus_t start_clu, clus_t *next) 63{ 64 return exfat_bitmap_find_bit(exfat, bmap, 65 start_clu, next, 0); 66} 67 68int exfat_bitmap_find_one(struct exfat *exfat, char *bmap, 69 clus_t start_clu, clus_t *next) 70{ 71 return exfat_bitmap_find_bit(exfat, bmap, 72 start_clu, next, 1); 73} 74 75wchar_t exfat_bad_char(wchar_t w) 76{ 77 return (w < 0x0020) 78 || (w == '*') || (w == '?') || (w == '<') || (w == '>') 79 || (w == '|') || (w == '"') || (w == ':') || (w == '/') 80 || (w == '\\'); 81} 82 83void boot_calc_checksum(unsigned char *sector, unsigned short size, 84 bool is_boot_sec, __le32 *checksum) 85{ 86 unsigned int index; 87 88 if (is_boot_sec) { 89 for (index = 0; index < size; index++) { 90 if ((index == 106) || (index == 107) || (index == 112)) 91 continue; 92 *checksum = ((*checksum & 1) ? 0x80000000 : 0) + 93 (*checksum >> 1) + sector[index]; 94 } 95 } else { 96 for (index = 0; index < size; index++) { 97 *checksum = ((*checksum & 1) ? 0x80000000 : 0) + 98 (*checksum >> 1) + sector[index]; 99 } 100 } 101} 102 103void show_version(void) 104{ 105 printf("exfatprogs version : %s\n", EXFAT_PROGS_VERSION); 106} 107 108static inline unsigned int sector_size_bits(unsigned int size) 109{ 110 unsigned int bits = 8; 111 112 do { 113 bits++; 114 size >>= 1; 115 } while (size > 256); 116 117 return bits; 118} 119 120static void exfat_set_default_cluster_size(struct exfat_blk_dev *bd, 121 struct exfat_user_input *ui) 122{ 123 if (256 * MB >= bd->size) 124 ui->cluster_size = 4 * KB; 125 else if (32 * GB >= bd->size) 126 ui->cluster_size = 32 * KB; 127 else 128 ui->cluster_size = 128 * KB; 129} 130 131void init_user_input(struct exfat_user_input *ui) 132{ 133 memset(ui, 0, sizeof(struct exfat_user_input)); 134 ui->writeable = true; 135 ui->quick = true; 136} 137 138int exfat_get_blk_dev_info(struct exfat_user_input *ui, 139 struct exfat_blk_dev *bd) 140{ 141 int fd, ret = -1; 142 off_t blk_dev_size; 143 struct stat st; 144 unsigned long long blk_dev_offset = 0; 145 146 fd = open(ui->dev_name, ui->writeable ? O_RDWR|O_EXCL : O_RDONLY); 147 if (fd < 0) { 148 exfat_err("open failed : %s, %s\n", ui->dev_name, 149 strerror(errno)); 150 return -1; 151 } 152 blk_dev_size = lseek(fd, 0, SEEK_END); 153 if (blk_dev_size <= 0) { 154 exfat_err("invalid block device size(%s)\n", 155 ui->dev_name); 156 ret = blk_dev_size; 157 close(fd); 158 goto out; 159 } 160 161 if (fstat(fd, &st) == 0 && S_ISBLK(st.st_mode)) { 162 char pathname[sizeof("/sys/dev/block/4294967295:4294967295/start")]; 163 FILE *fp; 164 165 snprintf(pathname, sizeof(pathname), "/sys/dev/block/%u:%u/start", 166 major(st.st_rdev), minor(st.st_rdev)); 167 fp = fopen(pathname, "r"); 168 if (fp != NULL) { 169 if (fscanf(fp, "%llu", &blk_dev_offset) == 1) { 170 /* 171 * Linux kernel always reports partition offset 172 * in 512-byte units, regardless of sector size 173 */ 174 blk_dev_offset <<= 9; 175 } 176 fclose(fp); 177 } 178 } 179 180 bd->dev_fd = fd; 181 bd->offset = blk_dev_offset; 182 bd->size = blk_dev_size; 183 if (!ui->cluster_size) 184 exfat_set_default_cluster_size(bd, ui); 185 186 if (!ui->boundary_align) 187 ui->boundary_align = DEFAULT_BOUNDARY_ALIGNMENT; 188 189 if (ioctl(fd, BLKSSZGET, &bd->sector_size) < 0) 190 bd->sector_size = DEFAULT_SECTOR_SIZE; 191 bd->sector_size_bits = sector_size_bits(bd->sector_size); 192 bd->num_sectors = blk_dev_size / bd->sector_size; 193 bd->num_clusters = blk_dev_size / ui->cluster_size; 194 195 exfat_debug("Block device name : %s\n", ui->dev_name); 196 exfat_debug("Block device offset : %llu\n", bd->offset); 197 exfat_debug("Block device size : %llu\n", bd->size); 198 exfat_debug("Block sector size : %u\n", bd->sector_size); 199 exfat_debug("Number of the sectors : %llu\n", 200 bd->num_sectors); 201 exfat_debug("Number of the clusters : %u\n", 202 bd->num_clusters); 203 204 ret = 0; 205 bd->dev_fd = fd; 206out: 207 return ret; 208} 209 210ssize_t exfat_read(int fd, void *buf, size_t size, off_t offset) 211{ 212 return pread(fd, buf, size, offset); 213} 214 215ssize_t exfat_write(int fd, void *buf, size_t size, off_t offset) 216{ 217 return pwrite(fd, buf, size, offset); 218} 219 220size_t exfat_utf16_len(const __le16 *str, size_t max_size) 221{ 222 size_t i = 0; 223 224 while (le16_to_cpu(str[i]) && i < max_size) 225 i++; 226 return i; 227} 228 229ssize_t exfat_utf16_enc(const char *in_str, __u16 *out_str, size_t out_size) 230{ 231 size_t mbs_len, out_len, i; 232 wchar_t *wcs; 233 234 mbs_len = mbstowcs(NULL, in_str, 0); 235 if (mbs_len == (size_t)-1) { 236 if (errno == EINVAL || errno == EILSEQ) 237 exfat_err("invalid character sequence in current locale\n"); 238 return -errno; 239 } 240 241 wcs = calloc(mbs_len+1, sizeof(wchar_t)); 242 if (!wcs) 243 return -ENOMEM; 244 245 /* First convert multibyte char* string to wchar_t* string */ 246 if (mbstowcs(wcs, in_str, mbs_len+1) == (size_t)-1) { 247 if (errno == EINVAL || errno == EILSEQ) 248 exfat_err("invalid character sequence in current locale\n"); 249 free(wcs); 250 return -errno; 251 } 252 253 /* Convert wchar_t* string (sequence of code points) to UTF-16 string */ 254 for (i = 0, out_len = 0; i < mbs_len; i++) { 255 if (2*(out_len+1) > out_size || 256 (wcs[i] >= 0x10000 && 2*(out_len+2) > out_size)) { 257 exfat_err("input string is too long\n"); 258 free(wcs); 259 return -E2BIG; 260 } 261 262 /* Encode code point above Plane0 as UTF-16 surrogate pair */ 263 if (wcs[i] >= 0x10000) { 264 out_str[out_len++] = 265 cpu_to_le16(((wcs[i] - 0x10000) >> 10) + 0xD800); 266 wcs[i] = ((wcs[i] - 0x10000) & 0x3FF) + 0xDC00; 267 } 268 269 out_str[out_len++] = cpu_to_le16(wcs[i]); 270 } 271 272 free(wcs); 273 return 2*out_len; 274} 275 276ssize_t exfat_utf16_dec(const __u16 *in_str, size_t in_len, 277 char *out_str, size_t out_size) 278{ 279 size_t wcs_len, out_len, c_len, i; 280 char c_str[MB_LEN_MAX]; 281 wchar_t *wcs; 282 mbstate_t ps; 283 wchar_t w; 284 285 wcs = calloc(in_len/2+1, sizeof(wchar_t)); 286 if (!wcs) 287 return -ENOMEM; 288 289 /* First convert UTF-16 string to wchar_t* string */ 290 for (i = 0, wcs_len = 0; i < in_len/2; i++, wcs_len++) { 291 wcs[wcs_len] = le16_to_cpu(in_str[i]); 292 /* 293 * If wchar_t can store code point above Plane0 294 * then unpack UTF-16 surrogate pair to code point 295 */ 296#if WCHAR_MAX >= 0x10FFFF 297 if (wcs[wcs_len] >= 0xD800 && wcs[wcs_len] <= 0xDBFF && 298 i+1 < in_len/2) { 299 w = le16_to_cpu(in_str[i+1]); 300 if (w >= 0xDC00 && w <= 0xDFFF) { 301 wcs[wcs_len] = 0x10000 + 302 ((wcs[wcs_len] - 0xD800) << 10) + 303 (w - 0xDC00); 304 i++; 305 } 306 } 307#endif 308 } 309 310 memset(&ps, 0, sizeof(ps)); 311 312 /* And then convert wchar_t* string to multibyte char* string */ 313 for (i = 0, out_len = 0, c_len = 0; i <= wcs_len; i++) { 314 c_len = wcrtomb(c_str, wcs[i], &ps); 315 /* 316 * If character is non-representable in current locale then 317 * try to store it as Unicode replacement code point U+FFFD 318 */ 319 if (c_len == (size_t)-1 && errno == EILSEQ) 320 c_len = wcrtomb(c_str, 0xFFFD, &ps); 321 /* If U+FFFD is also non-representable, try question mark */ 322 if (c_len == (size_t)-1 && errno == EILSEQ) 323 c_len = wcrtomb(c_str, L'?', &ps); 324 /* If also (7bit) question mark fails then we cannot do more */ 325 if (c_len == (size_t)-1) { 326 exfat_err("invalid UTF-16 sequence\n"); 327 free(wcs); 328 return -errno; 329 } 330 if (out_len+c_len > out_size) { 331 exfat_err("input string is too long\n"); 332 free(wcs); 333 return -E2BIG; 334 } 335 memcpy(out_str+out_len, c_str, c_len); 336 out_len += c_len; 337 } 338 339 free(wcs); 340 341 /* Last iteration of above loop should have produced null byte */ 342 if (c_len == 0 || out_str[out_len-1] != 0) { 343 exfat_err("invalid UTF-16 sequence\n"); 344 return -errno; 345 } 346 347 return out_len-1; 348} 349 350off_t exfat_get_root_entry_offset(struct exfat_blk_dev *bd) 351{ 352 struct pbr *bs; 353 int nbytes; 354 unsigned int cluster_size, sector_size; 355 off_t root_clu_off; 356 357 bs = (struct pbr *)malloc(EXFAT_MAX_SECTOR_SIZE); 358 if (!bs) { 359 exfat_err("failed to allocate memory\n"); 360 return -ENOMEM; 361 } 362 363 nbytes = exfat_read(bd->dev_fd, bs, EXFAT_MAX_SECTOR_SIZE, 0); 364 if (nbytes != EXFAT_MAX_SECTOR_SIZE) { 365 exfat_err("boot sector read failed: %d\n", errno); 366 free(bs); 367 return -1; 368 } 369 370 if (memcmp(bs->bpb.oem_name, "EXFAT ", 8) != 0) { 371 exfat_err("Bad fs_name in boot sector, which does not describe a valid exfat filesystem\n"); 372 free(bs); 373 return -1; 374 } 375 376 sector_size = 1 << bs->bsx.sect_size_bits; 377 cluster_size = (1 << bs->bsx.sect_per_clus_bits) * sector_size; 378 root_clu_off = le32_to_cpu(bs->bsx.clu_offset) * sector_size + 379 (le32_to_cpu(bs->bsx.root_cluster) - EXFAT_RESERVED_CLUSTERS) * 380 cluster_size; 381 free(bs); 382 383 return root_clu_off; 384} 385 386char *exfat_conv_volume_label(struct exfat_dentry *vol_entry) 387{ 388 char *volume_label; 389 __le16 disk_label[VOLUME_LABEL_MAX_LEN]; 390 391 volume_label = malloc(VOLUME_LABEL_BUFFER_SIZE); 392 if (!volume_label) 393 return NULL; 394 395 memcpy(disk_label, vol_entry->vol_label, sizeof(disk_label)); 396 memset(volume_label, 0, VOLUME_LABEL_BUFFER_SIZE); 397 if (exfat_utf16_dec(disk_label, vol_entry->vol_char_cnt*2, 398 volume_label, VOLUME_LABEL_BUFFER_SIZE) < 0) { 399 exfat_err("failed to decode volume label\n"); 400 free(volume_label); 401 return NULL; 402 } 403 404 return volume_label; 405} 406 407int exfat_read_volume_label(struct exfat *exfat) 408{ 409 struct exfat_dentry *dentry; 410 int err; 411 __le16 disk_label[VOLUME_LABEL_MAX_LEN]; 412 struct exfat_lookup_filter filter = { 413 .in.type = EXFAT_VOLUME, 414 .in.filter = NULL, 415 }; 416 417 err = exfat_lookup_dentry_set(exfat, exfat->root, &filter); 418 if (err) 419 return err; 420 421 dentry = filter.out.dentry_set; 422 423 if (dentry->vol_char_cnt == 0) 424 goto out; 425 426 if (dentry->vol_char_cnt > VOLUME_LABEL_MAX_LEN) { 427 exfat_err("too long label. %d\n", dentry->vol_char_cnt); 428 err = -EINVAL; 429 goto out; 430 } 431 432 memcpy(disk_label, dentry->vol_label, sizeof(disk_label)); 433 if (exfat_utf16_dec(disk_label, dentry->vol_char_cnt*2, 434 exfat->volume_label, sizeof(exfat->volume_label)) < 0) { 435 exfat_err("failed to decode volume label\n"); 436 err = -EINVAL; 437 goto out; 438 } 439 440 exfat_info("label: %s\n", exfat->volume_label); 441out: 442 free(filter.out.dentry_set); 443 return err; 444} 445 446int exfat_set_volume_label(struct exfat *exfat, char *label_input) 447{ 448 struct exfat_dentry *pvol; 449 struct exfat_dentry_loc loc; 450 __u16 volume_label[VOLUME_LABEL_MAX_LEN]; 451 int volume_label_len, dcount, err; 452 453 struct exfat_lookup_filter filter = { 454 .in.type = EXFAT_VOLUME, 455 .in.filter = NULL, 456 }; 457 458 err = exfat_lookup_dentry_set(exfat, exfat->root, &filter); 459 if (!err) { 460 pvol = filter.out.dentry_set; 461 dcount = filter.out.dentry_count; 462 memset(pvol->vol_label, 0, sizeof(pvol->vol_label)); 463 } else { 464 pvol = calloc(sizeof(struct exfat_dentry), 1); 465 if (!pvol) 466 return -ENOMEM; 467 468 dcount = 1; 469 pvol->type = EXFAT_VOLUME; 470 } 471 472 volume_label_len = exfat_utf16_enc(label_input, 473 volume_label, sizeof(volume_label)); 474 if (volume_label_len < 0) { 475 exfat_err("failed to encode volume label\n"); 476 free(pvol); 477 return -1; 478 } 479 480 memcpy(pvol->vol_label, volume_label, volume_label_len); 481 pvol->vol_char_cnt = volume_label_len/2; 482 483 loc.parent = exfat->root; 484 loc.file_offset = filter.out.file_offset; 485 loc.dev_offset = filter.out.dev_offset; 486 err = exfat_add_dentry_set(exfat, &loc, pvol, dcount, false); 487 exfat_info("new label: %s\n", label_input); 488 489 free(pvol); 490 491 return err; 492} 493 494int exfat_read_sector(struct exfat_blk_dev *bd, void *buf, unsigned int sec_off) 495{ 496 int ret; 497 unsigned long long offset = 498 (unsigned long long)sec_off * bd->sector_size; 499 500 ret = pread(bd->dev_fd, buf, bd->sector_size, offset); 501 if (ret < 0) { 502 exfat_err("read failed, sec_off : %u\n", sec_off); 503 return -1; 504 } 505 return 0; 506} 507 508int exfat_write_sector(struct exfat_blk_dev *bd, void *buf, 509 unsigned int sec_off) 510{ 511 int bytes; 512 unsigned long long offset = 513 (unsigned long long)sec_off * bd->sector_size; 514 515 bytes = pwrite(bd->dev_fd, buf, bd->sector_size, offset); 516 if (bytes != (int)bd->sector_size) { 517 exfat_err("write failed, sec_off : %u, bytes : %d\n", sec_off, 518 bytes); 519 return -1; 520 } 521 return 0; 522} 523 524int exfat_write_checksum_sector(struct exfat_blk_dev *bd, 525 unsigned int checksum, bool is_backup) 526{ 527 __le32 *checksum_buf; 528 int ret = 0; 529 unsigned int i; 530 unsigned int sec_idx = CHECKSUM_SEC_IDX; 531 532 checksum_buf = malloc(bd->sector_size); 533 if (!checksum_buf) 534 return -1; 535 536 if (is_backup) 537 sec_idx += BACKUP_BOOT_SEC_IDX; 538 539 for (i = 0; i < bd->sector_size / sizeof(int); i++) 540 checksum_buf[i] = cpu_to_le32(checksum); 541 542 ret = exfat_write_sector(bd, checksum_buf, sec_idx); 543 if (ret) { 544 exfat_err("checksum sector write failed\n"); 545 goto free; 546 } 547 548free: 549 free(checksum_buf); 550 return ret; 551} 552 553int exfat_show_volume_serial(int fd) 554{ 555 struct pbr *ppbr; 556 int ret; 557 558 ppbr = malloc(EXFAT_MAX_SECTOR_SIZE); 559 if (!ppbr) { 560 exfat_err("Cannot allocate pbr: out of memory\n"); 561 return -1; 562 } 563 564 /* read main boot sector */ 565 ret = exfat_read(fd, (char *)ppbr, EXFAT_MAX_SECTOR_SIZE, 0); 566 if (ret < 0) { 567 exfat_err("main boot sector read failed\n"); 568 ret = -1; 569 goto free_ppbr; 570 } 571 572 if (memcmp(ppbr->bpb.oem_name, "EXFAT ", 8) != 0) { 573 exfat_err("Bad fs_name in boot sector, which does not describe a valid exfat filesystem\n"); 574 ret = -1; 575 goto free_ppbr; 576 } 577 578 exfat_info("volume serial : 0x%x\n", ppbr->bsx.vol_serial); 579 580free_ppbr: 581 free(ppbr); 582 return ret; 583} 584 585static int exfat_update_boot_checksum(struct exfat_blk_dev *bd, bool is_backup) 586{ 587 unsigned int checksum = 0; 588 int ret, sec_idx, backup_sec_idx = 0; 589 unsigned char *buf; 590 591 buf = malloc(bd->sector_size); 592 if (!buf) { 593 exfat_err("Cannot allocate pbr: out of memory\n"); 594 return -1; 595 } 596 597 if (is_backup) 598 backup_sec_idx = BACKUP_BOOT_SEC_IDX; 599 600 for (sec_idx = BOOT_SEC_IDX; sec_idx < CHECKSUM_SEC_IDX; sec_idx++) { 601 bool is_boot_sec = false; 602 603 ret = exfat_read_sector(bd, buf, sec_idx + backup_sec_idx); 604 if (ret < 0) { 605 exfat_err("sector(%d) read failed\n", sec_idx); 606 ret = -1; 607 goto free_buf; 608 } 609 610 if (sec_idx == BOOT_SEC_IDX) 611 is_boot_sec = true; 612 613 boot_calc_checksum(buf, bd->sector_size, is_boot_sec, 614 &checksum); 615 } 616 617 ret = exfat_write_checksum_sector(bd, checksum, is_backup); 618 619free_buf: 620 free(buf); 621 622 return ret; 623} 624 625int exfat_set_volume_serial(struct exfat_blk_dev *bd, 626 struct exfat_user_input *ui) 627{ 628 int ret; 629 struct pbr *ppbr; 630 631 ppbr = malloc(EXFAT_MAX_SECTOR_SIZE); 632 if (!ppbr) { 633 exfat_err("Cannot allocate pbr: out of memory\n"); 634 return -1; 635 } 636 637 /* read main boot sector */ 638 ret = exfat_read(bd->dev_fd, (char *)ppbr, EXFAT_MAX_SECTOR_SIZE, 639 BOOT_SEC_IDX); 640 if (ret < 0) { 641 exfat_err("main boot sector read failed\n"); 642 ret = -1; 643 goto free_ppbr; 644 } 645 646 if (memcmp(ppbr->bpb.oem_name, "EXFAT ", 8) != 0) { 647 exfat_err("Bad fs_name in boot sector, which does not describe a valid exfat filesystem\n"); 648 ret = -1; 649 goto free_ppbr; 650 } 651 652 bd->sector_size = 1 << ppbr->bsx.sect_size_bits; 653 ppbr->bsx.vol_serial = ui->volume_serial; 654 655 /* update main boot sector */ 656 ret = exfat_write_sector(bd, (char *)ppbr, BOOT_SEC_IDX); 657 if (ret < 0) { 658 exfat_err("main boot sector write failed\n"); 659 ret = -1; 660 goto free_ppbr; 661 } 662 663 /* update backup boot sector */ 664 ret = exfat_write_sector(bd, (char *)ppbr, BACKUP_BOOT_SEC_IDX); 665 if (ret < 0) { 666 exfat_err("backup boot sector write failed\n"); 667 ret = -1; 668 goto free_ppbr; 669 } 670 671 ret = exfat_update_boot_checksum(bd, 0); 672 if (ret < 0) { 673 exfat_err("main checksum update failed\n"); 674 goto free_ppbr; 675 } 676 677 ret = exfat_update_boot_checksum(bd, 1); 678 if (ret < 0) 679 exfat_err("backup checksum update failed\n"); 680free_ppbr: 681 free(ppbr); 682 683 exfat_info("New volume serial : 0x%x\n", ui->volume_serial); 684 685 return ret; 686} 687 688unsigned int exfat_clus_to_blk_dev_off(struct exfat_blk_dev *bd, 689 unsigned int clu_off_sectnr, unsigned int clu) 690{ 691 return clu_off_sectnr * bd->sector_size + 692 (clu - EXFAT_RESERVED_CLUSTERS) * bd->cluster_size; 693} 694 695int exfat_get_next_clus(struct exfat *exfat, clus_t clus, clus_t *next) 696{ 697 off_t offset; 698 699 *next = EXFAT_EOF_CLUSTER; 700 701 if (!exfat_heap_clus(exfat, clus)) 702 return -EINVAL; 703 704 offset = (off_t)le32_to_cpu(exfat->bs->bsx.fat_offset) << 705 exfat->bs->bsx.sect_size_bits; 706 offset += sizeof(clus_t) * clus; 707 708 if (exfat_read(exfat->blk_dev->dev_fd, next, sizeof(*next), offset) 709 != sizeof(*next)) 710 return -EIO; 711 *next = le32_to_cpu(*next); 712 return 0; 713} 714 715int exfat_get_inode_next_clus(struct exfat *exfat, struct exfat_inode *node, 716 clus_t clus, clus_t *next) 717{ 718 *next = EXFAT_EOF_CLUSTER; 719 720 if (node->is_contiguous) { 721 if (!exfat_heap_clus(exfat, clus)) 722 return -EINVAL; 723 *next = clus + 1; 724 return 0; 725 } 726 727 return exfat_get_next_clus(exfat, clus, next); 728} 729 730int exfat_set_fat(struct exfat *exfat, clus_t clus, clus_t next_clus) 731{ 732 off_t offset; 733 734 offset = le32_to_cpu(exfat->bs->bsx.fat_offset) << 735 exfat->bs->bsx.sect_size_bits; 736 offset += sizeof(clus_t) * clus; 737 738 if (exfat_write(exfat->blk_dev->dev_fd, &next_clus, sizeof(next_clus), 739 offset) != sizeof(next_clus)) 740 return -EIO; 741 return 0; 742} 743 744off_t exfat_s2o(struct exfat *exfat, off_t sect) 745{ 746 return sect << exfat->bs->bsx.sect_size_bits; 747} 748 749off_t exfat_c2o(struct exfat *exfat, unsigned int clus) 750{ 751 if (clus < EXFAT_FIRST_CLUSTER) 752 return ~0L; 753 754 return exfat_s2o(exfat, le32_to_cpu(exfat->bs->bsx.clu_offset) + 755 ((off_t)(clus - EXFAT_FIRST_CLUSTER) << 756 exfat->bs->bsx.sect_per_clus_bits)); 757} 758 759int exfat_o2c(struct exfat *exfat, off_t device_offset, 760 unsigned int *clu, unsigned int *offset) 761{ 762 off_t heap_offset; 763 764 heap_offset = exfat_s2o(exfat, le32_to_cpu(exfat->bs->bsx.clu_offset)); 765 if (device_offset < heap_offset) 766 return -ERANGE; 767 768 *clu = (unsigned int)((device_offset - heap_offset) / 769 exfat->clus_size) + EXFAT_FIRST_CLUSTER; 770 if (!exfat_heap_clus(exfat, *clu)) 771 return -ERANGE; 772 *offset = (device_offset - heap_offset) % exfat->clus_size; 773 return 0; 774} 775 776bool exfat_heap_clus(struct exfat *exfat, clus_t clus) 777{ 778 return clus >= EXFAT_FIRST_CLUSTER && 779 (clus - EXFAT_FIRST_CLUSTER) < exfat->clus_count; 780} 781 782int exfat_root_clus_count(struct exfat *exfat) 783{ 784 struct exfat_inode *node = exfat->root; 785 clus_t clus, next; 786 int clus_count = 0; 787 788 if (!exfat_heap_clus(exfat, node->first_clus)) 789 return -EIO; 790 791 clus = node->first_clus; 792 do { 793 if (exfat_bitmap_get(exfat->alloc_bitmap, clus)) 794 return -EINVAL; 795 796 exfat_bitmap_set(exfat->alloc_bitmap, clus); 797 798 if (exfat_get_inode_next_clus(exfat, node, clus, &next)) { 799 exfat_err("ERROR: failed to read the fat entry of root"); 800 return -EIO; 801 } 802 803 if (next != EXFAT_EOF_CLUSTER && !exfat_heap_clus(exfat, next)) 804 return -EINVAL; 805 806 clus = next; 807 clus_count++; 808 } while (clus != EXFAT_EOF_CLUSTER); 809 810 node->size = clus_count * exfat->clus_size; 811 return 0; 812} 813 814int read_boot_sect(struct exfat_blk_dev *bdev, struct pbr **bs) 815{ 816 struct pbr *pbr; 817 int err = 0; 818 unsigned int sect_size, clu_size; 819 820 pbr = malloc(sizeof(struct pbr)); 821 822 if (exfat_read(bdev->dev_fd, pbr, sizeof(*pbr), 0) != 823 (ssize_t)sizeof(*pbr)) { 824 exfat_err("failed to read a boot sector\n"); 825 err = -EIO; 826 goto err; 827 } 828 829 err = -EINVAL; 830 if (memcmp(pbr->bpb.oem_name, "EXFAT ", 8) != 0) { 831 exfat_err("failed to find exfat file system\n"); 832 goto err; 833 } 834 835 sect_size = 1 << pbr->bsx.sect_size_bits; 836 clu_size = 1 << (pbr->bsx.sect_size_bits + 837 pbr->bsx.sect_per_clus_bits); 838 839 if (sect_size < 512 || sect_size > 4 * KB) { 840 exfat_err("too small or big sector size: %d\n", 841 sect_size); 842 goto err; 843 } 844 845 if (clu_size < sect_size || clu_size > 32 * MB) { 846 exfat_err("too small or big cluster size: %d\n", 847 clu_size); 848 goto err; 849 } 850 851 *bs = pbr; 852 return 0; 853err: 854 free(pbr); 855 return err; 856} 857