1// SPDX-License-Identifier: GPL-2.0+ 2/* 3 * fat.c 4 * 5 * R/O (V)FAT 12/16/32 filesystem implementation by Marcus Sundberg 6 * 7 * 2002-07-28 - rjones@nexus-tech.net - ported to ppcboot v1.1.6 8 * 2003-03-10 - kharris@nexus-tech.net - ported to uboot 9 */ 10 11#define LOG_CATEGORY LOGC_FS 12 13#include <common.h> 14#include <blk.h> 15#include <config.h> 16#include <exports.h> 17#include <fat.h> 18#include <fs.h> 19#include <log.h> 20#include <asm/byteorder.h> 21#include <asm/unaligned.h> 22#include <part.h> 23#include <malloc.h> 24#include <memalign.h> 25#include <asm/cache.h> 26#include <linux/compiler.h> 27#include <linux/ctype.h> 28#include <linux/log2.h> 29 30/* maximum number of clusters for FAT12 */ 31#define MAX_FAT12 0xFF4 32 33/* 34 * Convert a string to lowercase. Converts at most 'len' characters, 35 * 'len' may be larger than the length of 'str' if 'str' is NULL 36 * terminated. 37 */ 38static void downcase(char *str, size_t len) 39{ 40 while (*str != '\0' && len--) { 41 *str = tolower(*str); 42 str++; 43 } 44} 45 46static struct blk_desc *cur_dev; 47static struct disk_partition cur_part_info; 48 49#define DOS_BOOT_MAGIC_OFFSET 0x1fe 50#define DOS_FS_TYPE_OFFSET 0x36 51#define DOS_FS32_TYPE_OFFSET 0x52 52 53static int disk_read(__u32 block, __u32 nr_blocks, void *buf) 54{ 55 ulong ret; 56 57 if (!cur_dev) 58 return -1; 59 60 ret = blk_dread(cur_dev, cur_part_info.start + block, nr_blocks, buf); 61 62 if (ret != nr_blocks) 63 return -1; 64 65 return ret; 66} 67 68int fat_set_blk_dev(struct blk_desc *dev_desc, struct disk_partition *info) 69{ 70 ALLOC_CACHE_ALIGN_BUFFER(unsigned char, buffer, dev_desc->blksz); 71 72 cur_dev = dev_desc; 73 cur_part_info = *info; 74 75 /* Make sure it has a valid FAT header */ 76 if (disk_read(0, 1, buffer) != 1) { 77 cur_dev = NULL; 78 return -1; 79 } 80 81 /* Check if it's actually a DOS volume */ 82 if (memcmp(buffer + DOS_BOOT_MAGIC_OFFSET, "\x55\xAA", 2)) { 83 cur_dev = NULL; 84 return -1; 85 } 86 87 /* Check for FAT12/FAT16/FAT32 filesystem */ 88 if (!memcmp(buffer + DOS_FS_TYPE_OFFSET, "FAT", 3)) 89 return 0; 90 if (!memcmp(buffer + DOS_FS32_TYPE_OFFSET, "FAT32", 5)) 91 return 0; 92 93 cur_dev = NULL; 94 return -1; 95} 96 97int fat_register_device(struct blk_desc *dev_desc, int part_no) 98{ 99 struct disk_partition info; 100 101 /* First close any currently found FAT filesystem */ 102 cur_dev = NULL; 103 104 /* Read the partition table, if present */ 105 if (part_get_info(dev_desc, part_no, &info)) { 106 if (part_no != 0) { 107 log_err("Partition %d invalid on device %d\n", part_no, 108 dev_desc->devnum); 109 return -1; 110 } 111 112 info.start = 0; 113 info.size = dev_desc->lba; 114 info.blksz = dev_desc->blksz; 115 info.name[0] = 0; 116 info.type[0] = 0; 117 info.bootable = 0; 118 disk_partition_clr_uuid(&info); 119 } 120 121 return fat_set_blk_dev(dev_desc, &info); 122} 123 124/* 125 * Extract zero terminated short name from a directory entry. 126 */ 127static void get_name(dir_entry *dirent, char *s_name) 128{ 129 char *ptr; 130 131 memcpy(s_name, dirent->nameext.name, 8); 132 s_name[8] = '\0'; 133 ptr = s_name; 134 while (*ptr && *ptr != ' ') 135 ptr++; 136 if (dirent->lcase & CASE_LOWER_BASE) 137 downcase(s_name, (unsigned)(ptr - s_name)); 138 if (dirent->nameext.ext[0] && dirent->nameext.ext[0] != ' ') { 139 *ptr++ = '.'; 140 memcpy(ptr, dirent->nameext.ext, 3); 141 if (dirent->lcase & CASE_LOWER_EXT) 142 downcase(ptr, 3); 143 ptr[3] = '\0'; 144 while (*ptr && *ptr != ' ') 145 ptr++; 146 } 147 *ptr = '\0'; 148 if (*s_name == DELETED_FLAG) 149 *s_name = '\0'; 150 else if (*s_name == aRING) 151 *s_name = DELETED_FLAG; 152} 153 154static int flush_dirty_fat_buffer(fsdata *mydata); 155 156#if !CONFIG_IS_ENABLED(FAT_WRITE) 157/* Stub for read only operation */ 158int flush_dirty_fat_buffer(fsdata *mydata) 159{ 160 (void)(mydata); 161 return 0; 162} 163#endif 164 165/* 166 * Get the entry at index 'entry' in a FAT (12/16/32) table. 167 * On failure 0x00 is returned. 168 */ 169static __u32 get_fatent(fsdata *mydata, __u32 entry) 170{ 171 __u32 bufnum; 172 __u32 offset, off8; 173 __u32 ret = 0x00; 174 175 if (CHECK_CLUST(entry, mydata->fatsize)) { 176 log_err("Invalid FAT entry: %#08x\n", entry); 177 return ret; 178 } 179 180 switch (mydata->fatsize) { 181 case 32: 182 bufnum = entry / FAT32BUFSIZE; 183 offset = entry - bufnum * FAT32BUFSIZE; 184 break; 185 case 16: 186 bufnum = entry / FAT16BUFSIZE; 187 offset = entry - bufnum * FAT16BUFSIZE; 188 break; 189 case 12: 190 bufnum = entry / FAT12BUFSIZE; 191 offset = entry - bufnum * FAT12BUFSIZE; 192 break; 193 194 default: 195 /* Unsupported FAT size */ 196 return ret; 197 } 198 199 debug("FAT%d: entry: 0x%08x = %d, offset: 0x%04x = %d\n", 200 mydata->fatsize, entry, entry, offset, offset); 201 202 /* Read a new block of FAT entries into the cache. */ 203 if (bufnum != mydata->fatbufnum) { 204 __u32 getsize = FATBUFBLOCKS; 205 __u8 *bufptr = mydata->fatbuf; 206 __u32 fatlength = mydata->fatlength; 207 __u32 startblock = bufnum * FATBUFBLOCKS; 208 209 /* Cap length if fatlength is not a multiple of FATBUFBLOCKS */ 210 if (startblock + getsize > fatlength) 211 getsize = fatlength - startblock; 212 213 startblock += mydata->fat_sect; /* Offset from start of disk */ 214 215 /* Write back the fatbuf to the disk */ 216 if (flush_dirty_fat_buffer(mydata) < 0) 217 return -1; 218 219 if (disk_read(startblock, getsize, bufptr) < 0) { 220 debug("Error reading FAT blocks\n"); 221 return ret; 222 } 223 mydata->fatbufnum = bufnum; 224 } 225 226 /* Get the actual entry from the table */ 227 switch (mydata->fatsize) { 228 case 32: 229 ret = FAT2CPU32(((__u32 *) mydata->fatbuf)[offset]); 230 break; 231 case 16: 232 ret = FAT2CPU16(((__u16 *) mydata->fatbuf)[offset]); 233 break; 234 case 12: 235 off8 = (offset * 3) / 2; 236 /* fatbut + off8 may be unaligned, read in byte granularity */ 237 ret = mydata->fatbuf[off8] + (mydata->fatbuf[off8 + 1] << 8); 238 239 if (offset & 0x1) 240 ret >>= 4; 241 ret &= 0xfff; 242 } 243 debug("FAT%d: ret: 0x%08x, entry: 0x%08x, offset: 0x%04x\n", 244 mydata->fatsize, ret, entry, offset); 245 246 return ret; 247} 248 249/* 250 * Read at most 'size' bytes from the specified cluster into 'buffer'. 251 * Return 0 on success, -1 otherwise. 252 */ 253static int 254get_cluster(fsdata *mydata, __u32 clustnum, __u8 *buffer, unsigned long size) 255{ 256 __u32 startsect; 257 int ret; 258 259 if (clustnum > 0) { 260 startsect = clust_to_sect(mydata, clustnum); 261 } else { 262 startsect = mydata->rootdir_sect; 263 } 264 265 debug("gc - clustnum: %d, startsect: %d\n", clustnum, startsect); 266 267 if ((unsigned long)buffer & (ARCH_DMA_MINALIGN - 1)) { 268 ALLOC_CACHE_ALIGN_BUFFER(__u8, tmpbuf, mydata->sect_size); 269 270 debug("FAT: Misaligned buffer address (%p)\n", buffer); 271 272 while (size >= mydata->sect_size) { 273 ret = disk_read(startsect++, 1, tmpbuf); 274 if (ret != 1) { 275 debug("Error reading data (got %d)\n", ret); 276 return -1; 277 } 278 279 memcpy(buffer, tmpbuf, mydata->sect_size); 280 buffer += mydata->sect_size; 281 size -= mydata->sect_size; 282 } 283 } else if (size >= mydata->sect_size) { 284 __u32 bytes_read; 285 __u32 sect_count = size / mydata->sect_size; 286 287 ret = disk_read(startsect, sect_count, buffer); 288 if (ret != sect_count) { 289 debug("Error reading data (got %d)\n", ret); 290 return -1; 291 } 292 bytes_read = sect_count * mydata->sect_size; 293 startsect += sect_count; 294 buffer += bytes_read; 295 size -= bytes_read; 296 } 297 if (size) { 298 ALLOC_CACHE_ALIGN_BUFFER(__u8, tmpbuf, mydata->sect_size); 299 300 ret = disk_read(startsect, 1, tmpbuf); 301 if (ret != 1) { 302 debug("Error reading data (got %d)\n", ret); 303 return -1; 304 } 305 306 memcpy(buffer, tmpbuf, size); 307 } 308 309 return 0; 310} 311 312/** 313 * get_contents() - read from file 314 * 315 * Read at most 'maxsize' bytes from 'pos' in the file associated with 'dentptr' 316 * into 'buffer'. Update the number of bytes read in *gotsize or return -1 on 317 * fatal errors. 318 * 319 * @mydata: file system description 320 * @dentprt: directory entry pointer 321 * @pos: position from where to read 322 * @buffer: buffer into which to read 323 * @maxsize: maximum number of bytes to read 324 * @gotsize: number of bytes actually read 325 * Return: -1 on error, otherwise 0 326 */ 327static int get_contents(fsdata *mydata, dir_entry *dentptr, loff_t pos, 328 __u8 *buffer, loff_t maxsize, loff_t *gotsize) 329{ 330 loff_t filesize = FAT2CPU32(dentptr->size); 331 unsigned int bytesperclust = mydata->clust_size * mydata->sect_size; 332 __u32 curclust = START(dentptr); 333 __u32 endclust, newclust; 334 loff_t actsize; 335 336 *gotsize = 0; 337 debug("Filesize: %llu bytes\n", filesize); 338 339 if (pos >= filesize) { 340 debug("Read position past EOF: %llu\n", pos); 341 return 0; 342 } 343 344 if (maxsize > 0 && filesize > pos + maxsize) 345 filesize = pos + maxsize; 346 347 debug("%llu bytes\n", filesize); 348 349 actsize = bytesperclust; 350 351 /* go to cluster at pos */ 352 while (actsize <= pos) { 353 curclust = get_fatent(mydata, curclust); 354 if (CHECK_CLUST(curclust, mydata->fatsize)) { 355 debug("curclust: 0x%x\n", curclust); 356 printf("Invalid FAT entry\n"); 357 return -1; 358 } 359 actsize += bytesperclust; 360 } 361 362 /* actsize > pos */ 363 actsize -= bytesperclust; 364 filesize -= actsize; 365 pos -= actsize; 366 367 /* align to beginning of next cluster if any */ 368 if (pos) { 369 __u8 *tmp_buffer; 370 371 actsize = min(filesize, (loff_t)bytesperclust); 372 tmp_buffer = malloc_cache_aligned(actsize); 373 if (!tmp_buffer) { 374 debug("Error: allocating buffer\n"); 375 return -1; 376 } 377 378 if (get_cluster(mydata, curclust, tmp_buffer, actsize) != 0) { 379 printf("Error reading cluster\n"); 380 free(tmp_buffer); 381 return -1; 382 } 383 filesize -= actsize; 384 actsize -= pos; 385 memcpy(buffer, tmp_buffer + pos, actsize); 386 free(tmp_buffer); 387 *gotsize += actsize; 388 if (!filesize) 389 return 0; 390 buffer += actsize; 391 392 curclust = get_fatent(mydata, curclust); 393 if (CHECK_CLUST(curclust, mydata->fatsize)) { 394 debug("curclust: 0x%x\n", curclust); 395 printf("Invalid FAT entry\n"); 396 return -1; 397 } 398 } 399 400 actsize = bytesperclust; 401 endclust = curclust; 402 403 do { 404 /* search for consecutive clusters */ 405 while (actsize < filesize) { 406 newclust = get_fatent(mydata, endclust); 407 if ((newclust - 1) != endclust) 408 goto getit; 409 if (CHECK_CLUST(newclust, mydata->fatsize)) { 410 debug("curclust: 0x%x\n", newclust); 411 printf("Invalid FAT entry\n"); 412 return -1; 413 } 414 endclust = newclust; 415 actsize += bytesperclust; 416 } 417 418 /* get remaining bytes */ 419 actsize = filesize; 420 if (get_cluster(mydata, curclust, buffer, (int)actsize) != 0) { 421 printf("Error reading cluster\n"); 422 return -1; 423 } 424 *gotsize += actsize; 425 return 0; 426getit: 427 if (get_cluster(mydata, curclust, buffer, (int)actsize) != 0) { 428 printf("Error reading cluster\n"); 429 return -1; 430 } 431 *gotsize += (int)actsize; 432 filesize -= actsize; 433 buffer += actsize; 434 435 curclust = get_fatent(mydata, endclust); 436 if (CHECK_CLUST(curclust, mydata->fatsize)) { 437 debug("curclust: 0x%x\n", curclust); 438 printf("Invalid FAT entry\n"); 439 return -1; 440 } 441 actsize = bytesperclust; 442 endclust = curclust; 443 } while (1); 444} 445 446/* 447 * Extract the file name information from 'slotptr' into 'l_name', 448 * starting at l_name[*idx]. 449 * Return 1 if terminator (zero byte) is found, 0 otherwise. 450 */ 451static int slot2str(dir_slot *slotptr, char *l_name, int *idx) 452{ 453 int j; 454 455 for (j = 0; j <= 8; j += 2) { 456 l_name[*idx] = slotptr->name0_4[j]; 457 if (l_name[*idx] == 0x00) 458 return 1; 459 (*idx)++; 460 } 461 for (j = 0; j <= 10; j += 2) { 462 l_name[*idx] = slotptr->name5_10[j]; 463 if (l_name[*idx] == 0x00) 464 return 1; 465 (*idx)++; 466 } 467 for (j = 0; j <= 2; j += 2) { 468 l_name[*idx] = slotptr->name11_12[j]; 469 if (l_name[*idx] == 0x00) 470 return 1; 471 (*idx)++; 472 } 473 474 return 0; 475} 476 477/* Calculate short name checksum */ 478static __u8 mkcksum(struct nameext *nameext) 479{ 480 int i; 481 u8 *pos = (void *)nameext; 482 483 __u8 ret = 0; 484 485 for (i = 0; i < 11; i++) 486 ret = (((ret & 1) << 7) | ((ret & 0xfe) >> 1)) + pos[i]; 487 488 return ret; 489} 490 491/* 492 * Determine if the FAT type is FAT12 or FAT16 493 * 494 * Based on fat_fill_super() from the Linux kernel's fs/fat/inode.c 495 */ 496static int determine_legacy_fat_bits(const boot_sector *bs) 497{ 498 u16 fat_start = bs->reserved; 499 u32 dir_start = fat_start + bs->fats * bs->fat_length; 500 u32 rootdir_sectors = get_unaligned_le16(bs->dir_entries) * 501 sizeof(dir_entry) / 502 get_unaligned_le16(bs->sector_size); 503 u32 data_start = dir_start + rootdir_sectors; 504 u16 sectors = get_unaligned_le16(bs->sectors); 505 u32 total_sectors = sectors ? sectors : bs->total_sect; 506 u32 total_clusters = (total_sectors - data_start) / 507 bs->cluster_size; 508 509 return (total_clusters > MAX_FAT12) ? 16 : 12; 510} 511 512/* 513 * Determines if the boot sector's media field is valid 514 * 515 * Based on fat_valid_media() from Linux kernel's include/linux/msdos_fs.h 516 */ 517static int fat_valid_media(u8 media) 518{ 519 return media >= 0xf8 || media == 0xf0; 520} 521 522/* 523 * Determines if the given boot sector is valid 524 * 525 * Based on fat_read_bpb() from the Linux kernel's fs/fat/inode.c 526 */ 527static int is_bootsector_valid(const boot_sector *bs) 528{ 529 u16 sector_size = get_unaligned_le16(bs->sector_size); 530 u16 dir_per_block = sector_size / sizeof(dir_entry); 531 532 if (!bs->reserved) 533 return 0; 534 535 if (!bs->fats) 536 return 0; 537 538 if (!fat_valid_media(bs->media)) 539 return 0; 540 541 if (!is_power_of_2(sector_size) || 542 sector_size < 512 || 543 sector_size > 4096) 544 return 0; 545 546 if (!is_power_of_2(bs->cluster_size)) 547 return 0; 548 549 if (!bs->fat_length && !bs->fat32_length) 550 return 0; 551 552 if (get_unaligned_le16(bs->dir_entries) & (dir_per_block - 1)) 553 return 0; 554 555 return 1; 556} 557 558/* 559 * Read boot sector and volume info from a FAT filesystem 560 */ 561static int 562read_bootsectandvi(boot_sector *bs, volume_info *volinfo, int *fatsize) 563{ 564 __u8 *block; 565 volume_info *vistart; 566 int ret = 0; 567 568 if (cur_dev == NULL) { 569 debug("Error: no device selected\n"); 570 return -1; 571 } 572 573 block = malloc_cache_aligned(cur_dev->blksz); 574 if (block == NULL) { 575 debug("Error: allocating block\n"); 576 return -1; 577 } 578 579 if (disk_read(0, 1, block) < 0) { 580 debug("Error: reading block\n"); 581 ret = -1; 582 goto out_free; 583 } 584 585 memcpy(bs, block, sizeof(boot_sector)); 586 bs->reserved = FAT2CPU16(bs->reserved); 587 bs->fat_length = FAT2CPU16(bs->fat_length); 588 bs->secs_track = FAT2CPU16(bs->secs_track); 589 bs->heads = FAT2CPU16(bs->heads); 590 bs->total_sect = FAT2CPU32(bs->total_sect); 591 592 if (!is_bootsector_valid(bs)) { 593 debug("Error: bootsector is invalid\n"); 594 ret = -1; 595 goto out_free; 596 } 597 598 /* FAT32 entries */ 599 if (!bs->fat_length && bs->fat32_length) { 600 /* Assume FAT32 */ 601 bs->fat32_length = FAT2CPU32(bs->fat32_length); 602 bs->flags = FAT2CPU16(bs->flags); 603 bs->root_cluster = FAT2CPU32(bs->root_cluster); 604 bs->info_sector = FAT2CPU16(bs->info_sector); 605 bs->backup_boot = FAT2CPU16(bs->backup_boot); 606 vistart = (volume_info *)(block + sizeof(boot_sector)); 607 *fatsize = 32; 608 } else { 609 vistart = (volume_info *)&(bs->fat32_length); 610 *fatsize = determine_legacy_fat_bits(bs); 611 } 612 memcpy(volinfo, vistart, sizeof(volume_info)); 613 614out_free: 615 free(block); 616 return ret; 617} 618 619static int get_fs_info(fsdata *mydata) 620{ 621 boot_sector bs; 622 volume_info volinfo; 623 int ret; 624 625 ret = read_bootsectandvi(&bs, &volinfo, &mydata->fatsize); 626 if (ret) { 627 debug("Error: reading boot sector\n"); 628 return ret; 629 } 630 631 if (mydata->fatsize == 32) { 632 mydata->fatlength = bs.fat32_length; 633 mydata->total_sect = bs.total_sect; 634 } else { 635 mydata->fatlength = bs.fat_length; 636 mydata->total_sect = get_unaligned_le16(bs.sectors); 637 if (!mydata->total_sect) 638 mydata->total_sect = bs.total_sect; 639 } 640 if (!mydata->total_sect) /* unlikely */ 641 mydata->total_sect = (u32)cur_part_info.size; 642 643 mydata->fats = bs.fats; 644 mydata->fat_sect = bs.reserved; 645 646 mydata->rootdir_sect = mydata->fat_sect + mydata->fatlength * bs.fats; 647 648 mydata->sect_size = get_unaligned_le16(bs.sector_size); 649 mydata->clust_size = bs.cluster_size; 650 if (mydata->sect_size != cur_part_info.blksz) { 651 log_err("FAT sector size mismatch (fs=%u, dev=%lu)\n", 652 mydata->sect_size, cur_part_info.blksz); 653 return -1; 654 } 655 if (mydata->clust_size == 0) { 656 log_err("FAT cluster size not set\n"); 657 return -1; 658 } 659 if ((unsigned int)mydata->clust_size * mydata->sect_size > 660 MAX_CLUSTSIZE) { 661 log_err("FAT cluster size too big (cs=%u, max=%u)\n", 662 (uint)mydata->clust_size * mydata->sect_size, 663 MAX_CLUSTSIZE); 664 return -1; 665 } 666 667 if (mydata->fatsize == 32) { 668 mydata->data_begin = mydata->rootdir_sect - 669 (mydata->clust_size * 2); 670 mydata->root_cluster = bs.root_cluster; 671 } else { 672 mydata->rootdir_size = (get_unaligned_le16(bs.dir_entries) * 673 sizeof(dir_entry)) / 674 mydata->sect_size; 675 mydata->data_begin = mydata->rootdir_sect + 676 mydata->rootdir_size - 677 (mydata->clust_size * 2); 678 679 /* 680 * The root directory is not cluster-aligned and may be on a 681 * "negative" cluster, this will be handled specially in 682 * fat_next_cluster(). 683 */ 684 mydata->root_cluster = 0; 685 } 686 687 mydata->fatbufnum = -1; 688 mydata->fat_dirty = 0; 689 mydata->fatbuf = malloc_cache_aligned(FATBUFSIZE); 690 if (mydata->fatbuf == NULL) { 691 debug("Error: allocating memory\n"); 692 return -1; 693 } 694 695 debug("FAT%d, fat_sect: %d, fatlength: %d\n", 696 mydata->fatsize, mydata->fat_sect, mydata->fatlength); 697 debug("Rootdir begins at cluster: %d, sector: %d, offset: %x\n" 698 "Data begins at: %d\n", 699 mydata->root_cluster, 700 mydata->rootdir_sect, 701 mydata->rootdir_sect * mydata->sect_size, mydata->data_begin); 702 debug("Sector size: %d, cluster size: %d\n", mydata->sect_size, 703 mydata->clust_size); 704 705 return 0; 706} 707 708/** 709 * struct fat_itr - directory iterator, to simplify filesystem traversal 710 * 711 * Implements an iterator pattern to traverse directory tables, 712 * transparently handling directory tables split across multiple 713 * clusters, and the difference between FAT12/FAT16 root directory 714 * (contiguous) and subdirectories + FAT32 root (chained). 715 * 716 * Rough usage 717 * 718 * .. code-block:: c 719 * 720 * for (fat_itr_root(&itr, fsdata); fat_itr_next(&itr); ) { 721 * // to traverse down to a subdirectory pointed to by 722 * // current iterator position: 723 * fat_itr_child(&itr, &itr); 724 * } 725 * 726 * For a more complete example, see fat_itr_resolve(). 727 */ 728struct fat_itr { 729 /** 730 * @fsdata: filesystem parameters 731 */ 732 fsdata *fsdata; 733 /** 734 * @start_clust: first cluster 735 */ 736 unsigned int start_clust; 737 /** 738 * @clust: current cluster 739 */ 740 unsigned int clust; 741 /** 742 * @next_clust: next cluster if remaining == 0 743 */ 744 unsigned int next_clust; 745 /** 746 * @last_cluster: set if last cluster of directory reached 747 */ 748 int last_cluster; 749 /** 750 * @is_root: is iterator at root directory 751 */ 752 int is_root; 753 /** 754 * @remaining: remaining directory entries in current cluster 755 */ 756 int remaining; 757 /** 758 * @dent: current directory entry 759 */ 760 dir_entry *dent; 761 /** 762 * @dent_rem: remaining entries after long name start 763 */ 764 int dent_rem; 765 /** 766 * @dent_clust: cluster of long name start 767 */ 768 unsigned int dent_clust; 769 /** 770 * @dent_start: first directory entry for long name 771 */ 772 dir_entry *dent_start; 773 /** 774 * @l_name: long name of current directory entry 775 */ 776 char l_name[VFAT_MAXLEN_BYTES]; 777 /** 778 * @s_name: short 8.3 name of current directory entry 779 */ 780 char s_name[14]; 781 /** 782 * @name: l_name if there is one, else s_name 783 */ 784 char *name; 785 /** 786 * @block: buffer for current cluster 787 */ 788 u8 block[MAX_CLUSTSIZE] __aligned(ARCH_DMA_MINALIGN); 789}; 790 791static int fat_itr_isdir(fat_itr *itr); 792 793/** 794 * fat_itr_root() - initialize an iterator to start at the root 795 * directory 796 * 797 * @itr: iterator to initialize 798 * @fsdata: filesystem data for the partition 799 * Return: 0 on success, else -errno 800 */ 801static int fat_itr_root(fat_itr *itr, fsdata *fsdata) 802{ 803 if (get_fs_info(fsdata)) 804 return -ENXIO; 805 806 itr->fsdata = fsdata; 807 itr->start_clust = fsdata->root_cluster; 808 itr->clust = fsdata->root_cluster; 809 itr->next_clust = fsdata->root_cluster; 810 itr->dent = NULL; 811 itr->remaining = 0; 812 itr->last_cluster = 0; 813 itr->is_root = 1; 814 815 return 0; 816} 817 818/** 819 * fat_itr_child() - initialize an iterator to descend into a sub- 820 * directory 821 * 822 * Initializes 'itr' to iterate the contents of the directory at 823 * the current cursor position of 'parent'. It is an error to 824 * call this if the current cursor of 'parent' is pointing at a 825 * regular file. 826 * 827 * Note that 'itr' and 'parent' can be the same pointer if you do 828 * not need to preserve 'parent' after this call, which is useful 829 * for traversing directory structure to resolve a file/directory. 830 * 831 * @itr: iterator to initialize 832 * @parent: the iterator pointing at a directory entry in the 833 * parent directory of the directory to iterate 834 */ 835static void fat_itr_child(fat_itr *itr, fat_itr *parent) 836{ 837 fsdata *mydata = parent->fsdata; /* for silly macros */ 838 unsigned clustnum = START(parent->dent); 839 840 assert(fat_itr_isdir(parent)); 841 842 itr->fsdata = parent->fsdata; 843 itr->start_clust = clustnum; 844 if (clustnum > 0) { 845 itr->clust = clustnum; 846 itr->next_clust = clustnum; 847 itr->is_root = 0; 848 } else { 849 itr->clust = parent->fsdata->root_cluster; 850 itr->next_clust = parent->fsdata->root_cluster; 851 itr->start_clust = parent->fsdata->root_cluster; 852 itr->is_root = 1; 853 } 854 itr->dent = NULL; 855 itr->remaining = 0; 856 itr->last_cluster = 0; 857} 858 859/** 860 * fat_next_cluster() - load next FAT cluster 861 * 862 * The function is used when iterating through directories. It loads the 863 * next cluster with directory entries 864 * 865 * @itr: directory iterator 866 * @nbytes: number of bytes read, 0 on error 867 * Return: first directory entry, NULL on error 868 */ 869void *fat_next_cluster(fat_itr *itr, unsigned int *nbytes) 870{ 871 int ret; 872 u32 sect; 873 u32 read_size; 874 875 /* have we reached the end? */ 876 if (itr->last_cluster) 877 return NULL; 878 879 if (itr->is_root && itr->fsdata->fatsize != 32) { 880 /* 881 * The root directory is located before the data area and 882 * cannot be indexed using the regular unsigned cluster 883 * numbers (it may start at a "negative" cluster or not at a 884 * cluster boundary at all), so consider itr->next_clust to be 885 * a offset in cluster-sized units from the start of rootdir. 886 */ 887 unsigned sect_offset = itr->next_clust * itr->fsdata->clust_size; 888 unsigned remaining_sects = itr->fsdata->rootdir_size - sect_offset; 889 sect = itr->fsdata->rootdir_sect + sect_offset; 890 /* do not read past the end of rootdir */ 891 read_size = min_t(u32, itr->fsdata->clust_size, 892 remaining_sects); 893 } else { 894 sect = clust_to_sect(itr->fsdata, itr->next_clust); 895 read_size = itr->fsdata->clust_size; 896 } 897 898 log_debug("FAT read(sect=%d), clust_size=%d, read_size=%u\n", 899 sect, itr->fsdata->clust_size, read_size); 900 901 /* 902 * NOTE: do_fat_read_at() had complicated logic to deal w/ 903 * vfat names that span multiple clusters in the fat16 case, 904 * which get_dentfromdir() probably also needed (and was 905 * missing). And not entirely sure what fat32 didn't have 906 * the same issue.. We solve that by only caring about one 907 * dent at a time and iteratively constructing the vfat long 908 * name. 909 */ 910 ret = disk_read(sect, read_size, itr->block); 911 if (ret < 0) { 912 debug("Error: reading block\n"); 913 return NULL; 914 } 915 916 *nbytes = read_size * itr->fsdata->sect_size; 917 itr->clust = itr->next_clust; 918 if (itr->is_root && itr->fsdata->fatsize != 32) { 919 itr->next_clust++; 920 if (itr->next_clust * itr->fsdata->clust_size >= 921 itr->fsdata->rootdir_size) { 922 debug("nextclust: 0x%x\n", itr->next_clust); 923 itr->last_cluster = 1; 924 } 925 } else { 926 itr->next_clust = get_fatent(itr->fsdata, itr->next_clust); 927 if (CHECK_CLUST(itr->next_clust, itr->fsdata->fatsize)) { 928 debug("nextclust: 0x%x\n", itr->next_clust); 929 itr->last_cluster = 1; 930 } 931 } 932 933 return itr->block; 934} 935 936static dir_entry *next_dent(fat_itr *itr) 937{ 938 if (itr->remaining == 0) { 939 unsigned nbytes; 940 struct dir_entry *dent = fat_next_cluster(itr, &nbytes); 941 942 /* have we reached the last cluster? */ 943 if (!dent) { 944 /* a sign for no more entries left */ 945 itr->dent = NULL; 946 return NULL; 947 } 948 949 itr->remaining = nbytes / sizeof(dir_entry) - 1; 950 itr->dent = dent; 951 } else { 952 itr->remaining--; 953 itr->dent++; 954 } 955 956 /* have we reached the last valid entry? */ 957 if (itr->dent->nameext.name[0] == 0) 958 return NULL; 959 960 return itr->dent; 961} 962 963static dir_entry *extract_vfat_name(fat_itr *itr) 964{ 965 struct dir_entry *dent = itr->dent; 966 int seqn = itr->dent->nameext.name[0] & ~LAST_LONG_ENTRY_MASK; 967 u8 chksum, alias_checksum = ((dir_slot *)dent)->alias_checksum; 968 int n = 0; 969 970 while (seqn--) { 971 char buf[13]; 972 int idx = 0; 973 974 slot2str((dir_slot *)dent, buf, &idx); 975 976 if (n + idx >= sizeof(itr->l_name)) 977 return NULL; 978 979 /* shift accumulated long-name up and copy new part in: */ 980 memmove(itr->l_name + idx, itr->l_name, n); 981 memcpy(itr->l_name, buf, idx); 982 n += idx; 983 984 dent = next_dent(itr); 985 if (!dent) 986 return NULL; 987 } 988 989 /* 990 * We are now at the short file name entry. 991 * If it is marked as deleted, just skip it. 992 */ 993 if (dent->nameext.name[0] == DELETED_FLAG || 994 dent->nameext.name[0] == aRING) 995 return NULL; 996 997 itr->l_name[n] = '\0'; 998 999 chksum = mkcksum(&dent->nameext); 1000 1001 /* checksum mismatch could mean deleted file, etc.. skip it: */ 1002 if (chksum != alias_checksum) { 1003 debug("** chksum=%x, alias_checksum=%x, l_name=%s, s_name=%8s.%3s\n", 1004 chksum, alias_checksum, itr->l_name, dent->nameext.name, 1005 dent->nameext.ext); 1006 return NULL; 1007 } 1008 1009 return dent; 1010} 1011 1012/** 1013 * fat_itr_next() - step to the next entry in a directory 1014 * 1015 * Must be called once on a new iterator before the cursor is valid. 1016 * 1017 * @itr: the iterator to iterate 1018 * Return: boolean, 1 if success or 0 if no more entries in the 1019 * current directory 1020 */ 1021static int fat_itr_next(fat_itr *itr) 1022{ 1023 dir_entry *dent; 1024 1025 itr->name = NULL; 1026 1027 /* 1028 * One logical directory entry consist of following slots: 1029 * name[0] Attributes 1030 * dent[N - N]: LFN[N - 1] N|0x40 ATTR_VFAT 1031 * ... 1032 * dent[N - 2]: LFN[1] 2 ATTR_VFAT 1033 * dent[N - 1]: LFN[0] 1 ATTR_VFAT 1034 * dent[N]: SFN ATTR_ARCH 1035 */ 1036 1037 while (1) { 1038 dent = next_dent(itr); 1039 if (!dent) { 1040 itr->dent_start = NULL; 1041 return 0; 1042 } 1043 itr->dent_rem = itr->remaining; 1044 itr->dent_start = itr->dent; 1045 itr->dent_clust = itr->clust; 1046 if (dent->nameext.name[0] == DELETED_FLAG) 1047 continue; 1048 1049 if (dent->attr & ATTR_VOLUME) { 1050 if ((dent->attr & ATTR_VFAT) == ATTR_VFAT && 1051 (dent->nameext.name[0] & LAST_LONG_ENTRY_MASK)) { 1052 /* long file name */ 1053 dent = extract_vfat_name(itr); 1054 /* 1055 * If succeeded, dent has a valid short file 1056 * name entry for the current entry. 1057 * If failed, itr points to a current bogus 1058 * entry. So after fetching a next one, 1059 * it may have a short file name entry 1060 * for this bogus entry so that we can still 1061 * check for a short name. 1062 */ 1063 if (!dent) 1064 continue; 1065 itr->name = itr->l_name; 1066 break; 1067 } else { 1068 /* Volume label or VFAT entry, skip */ 1069 continue; 1070 } 1071 } 1072 1073 /* short file name */ 1074 break; 1075 } 1076 1077 get_name(dent, itr->s_name); 1078 if (!itr->name) 1079 itr->name = itr->s_name; 1080 1081 return 1; 1082} 1083 1084/** 1085 * fat_itr_isdir() - is current cursor position pointing to a directory 1086 * 1087 * @itr: the iterator 1088 * Return: true if cursor is at a directory 1089 */ 1090static int fat_itr_isdir(fat_itr *itr) 1091{ 1092 return !!(itr->dent->attr & ATTR_DIR); 1093} 1094 1095/* 1096 * Helpers: 1097 */ 1098 1099#define TYPE_FILE 0x1 1100#define TYPE_DIR 0x2 1101#define TYPE_ANY (TYPE_FILE | TYPE_DIR) 1102 1103/** 1104 * fat_itr_resolve() - traverse directory structure to resolve the 1105 * requested path. 1106 * 1107 * Traverse directory structure to the requested path. If the specified 1108 * path is to a directory, this will descend into the directory and 1109 * leave it iterator at the start of the directory. If the path is to a 1110 * file, it will leave the iterator in the parent directory with current 1111 * cursor at file's entry in the directory. 1112 * 1113 * @itr: iterator initialized to root 1114 * @path: the requested path 1115 * @type: bitmask of allowable file types 1116 * Return: 0 on success or -errno 1117 */ 1118static int fat_itr_resolve(fat_itr *itr, const char *path, unsigned type) 1119{ 1120 const char *next; 1121 1122 /* chomp any extra leading slashes: */ 1123 while (path[0] && ISDIRDELIM(path[0])) 1124 path++; 1125 1126 /* are we at the end? */ 1127 if (strlen(path) == 0) { 1128 if (!(type & TYPE_DIR)) 1129 return -ENOENT; 1130 return 0; 1131 } 1132 1133 /* find length of next path entry: */ 1134 next = path; 1135 while (next[0] && !ISDIRDELIM(next[0])) 1136 next++; 1137 1138 if (itr->is_root) { 1139 /* root dir doesn't have "." nor ".." */ 1140 if ((((next - path) == 1) && !strncmp(path, ".", 1)) || 1141 (((next - path) == 2) && !strncmp(path, "..", 2))) { 1142 /* point back to itself */ 1143 itr->clust = itr->fsdata->root_cluster; 1144 itr->next_clust = itr->fsdata->root_cluster; 1145 itr->start_clust = itr->fsdata->root_cluster; 1146 itr->dent = NULL; 1147 itr->remaining = 0; 1148 itr->last_cluster = 0; 1149 1150 if (next[0] == 0) { 1151 if (type & TYPE_DIR) 1152 return 0; 1153 else 1154 return -ENOENT; 1155 } 1156 1157 return fat_itr_resolve(itr, next, type); 1158 } 1159 } 1160 1161 while (fat_itr_next(itr)) { 1162 int match = 0; 1163 unsigned n = max(strlen(itr->name), (size_t)(next - path)); 1164 1165 /* check both long and short name: */ 1166 if (!strncasecmp(path, itr->name, n)) 1167 match = 1; 1168 else if (itr->name != itr->s_name && 1169 !strncasecmp(path, itr->s_name, n)) 1170 match = 1; 1171 1172 if (!match) 1173 continue; 1174 1175 if (fat_itr_isdir(itr)) { 1176 /* recurse into directory: */ 1177 fat_itr_child(itr, itr); 1178 return fat_itr_resolve(itr, next, type); 1179 } else if (next[0]) { 1180 /* 1181 * If next is not empty then we have a case 1182 * like: /path/to/realfile/nonsense 1183 */ 1184 debug("bad trailing path: %s\n", next); 1185 return -ENOENT; 1186 } else if (!(type & TYPE_FILE)) { 1187 return -ENOTDIR; 1188 } else { 1189 return 0; 1190 } 1191 } 1192 1193 return -ENOENT; 1194} 1195 1196int file_fat_detectfs(void) 1197{ 1198 boot_sector bs; 1199 volume_info volinfo; 1200 int fatsize; 1201 char vol_label[12]; 1202 1203 if (cur_dev == NULL) { 1204 printf("No current device\n"); 1205 return 1; 1206 } 1207 1208 if (blk_enabled()) { 1209 printf("Interface: %s\n", blk_get_uclass_name(cur_dev->uclass_id)); 1210 printf(" Device %d: ", cur_dev->devnum); 1211 dev_print(cur_dev); 1212 } 1213 1214 if (read_bootsectandvi(&bs, &volinfo, &fatsize)) { 1215 printf("\nNo valid FAT fs found\n"); 1216 return 1; 1217 } 1218 1219 memcpy(vol_label, volinfo.volume_label, 11); 1220 vol_label[11] = '\0'; 1221 1222 printf("Filesystem: FAT%d \"%s\"\n", fatsize, vol_label); 1223 1224 return 0; 1225} 1226 1227int fat_exists(const char *filename) 1228{ 1229 fsdata fsdata; 1230 fat_itr *itr; 1231 int ret; 1232 1233 itr = malloc_cache_aligned(sizeof(fat_itr)); 1234 if (!itr) 1235 return 0; 1236 ret = fat_itr_root(itr, &fsdata); 1237 if (ret) 1238 goto out; 1239 1240 ret = fat_itr_resolve(itr, filename, TYPE_ANY); 1241 free(fsdata.fatbuf); 1242out: 1243 free(itr); 1244 return ret == 0; 1245} 1246 1247/** 1248 * fat2rtc() - convert FAT time stamp to RTC file stamp 1249 * 1250 * @date: FAT date 1251 * @time: FAT time 1252 * @tm: RTC time stamp 1253 */ 1254static void __maybe_unused fat2rtc(u16 date, u16 time, struct rtc_time *tm) 1255{ 1256 tm->tm_mday = date & 0x1f; 1257 tm->tm_mon = (date & 0x1e0) >> 5; 1258 tm->tm_year = (date >> 9) + 1980; 1259 1260 tm->tm_sec = (time & 0x1f) << 1; 1261 tm->tm_min = (time & 0x7e0) >> 5; 1262 tm->tm_hour = time >> 11; 1263 1264 rtc_calc_weekday(tm); 1265 tm->tm_yday = 0; 1266 tm->tm_isdst = 0; 1267} 1268 1269int fat_size(const char *filename, loff_t *size) 1270{ 1271 fsdata fsdata; 1272 fat_itr *itr; 1273 int ret; 1274 1275 itr = malloc_cache_aligned(sizeof(fat_itr)); 1276 if (!itr) 1277 return -ENOMEM; 1278 ret = fat_itr_root(itr, &fsdata); 1279 if (ret) 1280 goto out_free_itr; 1281 1282 ret = fat_itr_resolve(itr, filename, TYPE_FILE); 1283 if (ret) { 1284 /* 1285 * Directories don't have size, but fs_size() is not 1286 * expected to fail if passed a directory path: 1287 */ 1288 free(fsdata.fatbuf); 1289 ret = fat_itr_root(itr, &fsdata); 1290 if (ret) 1291 goto out_free_itr; 1292 ret = fat_itr_resolve(itr, filename, TYPE_DIR); 1293 if (!ret) 1294 *size = 0; 1295 goto out_free_both; 1296 } 1297 1298 *size = FAT2CPU32(itr->dent->size); 1299out_free_both: 1300 free(fsdata.fatbuf); 1301out_free_itr: 1302 free(itr); 1303 return ret; 1304} 1305 1306int fat_read_file(const char *filename, void *buf, loff_t offset, loff_t len, 1307 loff_t *actread) 1308{ 1309 fsdata fsdata; 1310 fat_itr *itr; 1311 int ret; 1312 1313 itr = malloc_cache_aligned(sizeof(fat_itr)); 1314 if (!itr) 1315 return -ENOMEM; 1316 ret = fat_itr_root(itr, &fsdata); 1317 if (ret) 1318 goto out_free_itr; 1319 1320 ret = fat_itr_resolve(itr, filename, TYPE_FILE); 1321 if (ret) 1322 goto out_free_both; 1323 1324 debug("reading %s at pos %llu\n", filename, offset); 1325 1326 /* For saving default max clustersize memory allocated to malloc pool */ 1327 dir_entry *dentptr = itr->dent; 1328 1329 ret = get_contents(&fsdata, dentptr, offset, buf, len, actread); 1330 1331out_free_both: 1332 free(fsdata.fatbuf); 1333out_free_itr: 1334 free(itr); 1335 return ret; 1336} 1337 1338int file_fat_read(const char *filename, void *buffer, int maxsize) 1339{ 1340 loff_t actread; 1341 int ret; 1342 1343 ret = fat_read_file(filename, buffer, 0, maxsize, &actread); 1344 if (ret) 1345 return ret; 1346 else 1347 return actread; 1348} 1349 1350typedef struct { 1351 struct fs_dir_stream parent; 1352 struct fs_dirent dirent; 1353 fsdata fsdata; 1354 fat_itr itr; 1355} fat_dir; 1356 1357int fat_opendir(const char *filename, struct fs_dir_stream **dirsp) 1358{ 1359 fat_dir *dir; 1360 int ret; 1361 1362 dir = malloc_cache_aligned(sizeof(*dir)); 1363 if (!dir) 1364 return -ENOMEM; 1365 memset(dir, 0, sizeof(*dir)); 1366 1367 ret = fat_itr_root(&dir->itr, &dir->fsdata); 1368 if (ret) 1369 goto fail_free_dir; 1370 1371 ret = fat_itr_resolve(&dir->itr, filename, TYPE_DIR); 1372 if (ret) 1373 goto fail_free_both; 1374 1375 *dirsp = (struct fs_dir_stream *)dir; 1376 return 0; 1377 1378fail_free_both: 1379 free(dir->fsdata.fatbuf); 1380fail_free_dir: 1381 free(dir); 1382 return ret; 1383} 1384 1385int fat_readdir(struct fs_dir_stream *dirs, struct fs_dirent **dentp) 1386{ 1387 fat_dir *dir = (fat_dir *)dirs; 1388 struct fs_dirent *dent = &dir->dirent; 1389 1390 if (!fat_itr_next(&dir->itr)) 1391 return -ENOENT; 1392 1393 memset(dent, 0, sizeof(*dent)); 1394 strcpy(dent->name, dir->itr.name); 1395 if (CONFIG_IS_ENABLED(EFI_LOADER)) { 1396 dent->attr = dir->itr.dent->attr; 1397 fat2rtc(le16_to_cpu(dir->itr.dent->cdate), 1398 le16_to_cpu(dir->itr.dent->ctime), &dent->create_time); 1399 fat2rtc(le16_to_cpu(dir->itr.dent->date), 1400 le16_to_cpu(dir->itr.dent->time), &dent->change_time); 1401 fat2rtc(le16_to_cpu(dir->itr.dent->adate), 1402 0, &dent->access_time); 1403 } 1404 if (fat_itr_isdir(&dir->itr)) { 1405 dent->type = FS_DT_DIR; 1406 } else { 1407 dent->type = FS_DT_REG; 1408 dent->size = FAT2CPU32(dir->itr.dent->size); 1409 } 1410 1411 *dentp = dent; 1412 1413 return 0; 1414} 1415 1416void fat_closedir(struct fs_dir_stream *dirs) 1417{ 1418 fat_dir *dir = (fat_dir *)dirs; 1419 free(dir->fsdata.fatbuf); 1420 free(dir); 1421} 1422 1423void fat_close(void) 1424{ 1425} 1426 1427int fat_uuid(char *uuid_str) 1428{ 1429 boot_sector bs; 1430 volume_info volinfo; 1431 int fatsize; 1432 int ret; 1433 u8 *id; 1434 1435 ret = read_bootsectandvi(&bs, &volinfo, &fatsize); 1436 if (ret) 1437 return ret; 1438 1439 id = volinfo.volume_id; 1440 sprintf(uuid_str, "%02X%02X-%02X%02X", id[3], id[2], id[1], id[0]); 1441 1442 return 0; 1443} 1444