fs/fat/fat.c

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