2018-05-07 05:58:06 +08:00
|
|
|
/* SPDX-License-Identifier: GPL-2.0+ */
|
2003-06-16 06:40:42 +08:00
|
|
|
/*
|
|
|
|
* R/O (V)FAT 12/16/32 filesystem implementation by Marcus Sundberg
|
|
|
|
*
|
|
|
|
* 2002-07-28 - rjones@nexus-tech.net - ported to ppcboot v1.1.6
|
|
|
|
* 2003-03-10 - kharris@nexus-tech.net - ported to u-boot
|
|
|
|
*/
|
|
|
|
|
|
|
|
#ifndef _FAT_H_
|
|
|
|
#define _FAT_H_
|
|
|
|
|
2017-09-10 01:15:58 +08:00
|
|
|
#include <fs.h>
|
2020-11-22 16:19:52 +08:00
|
|
|
#include <asm/byteorder.h>
|
|
|
|
#include <asm/cache.h>
|
2004-04-24 04:32:05 +08:00
|
|
|
|
2020-05-11 01:39:58 +08:00
|
|
|
struct disk_partition;
|
|
|
|
|
VFAT: fix processing of scattered long file name entries
The U-Boot code has the following bugs related to the processing of Long File
Name (LFN) entries scattered across several clusters/sectors :
1) get_vfatname() function is designed to gather scattered LFN entries by
cluster chain processing - that doesn't work for FAT12/16 root directory.
In other words, the function expects the following input data:
1.1) FAT32 directory (which is cluster chain based);
OR
1.2) FAT12/16 non-root directory (which is also cluster chain based);
OR
1.3) FAT12/16 root directory (allocated as contiguous sectors area), but
all necessary information MUST be within the input buffer of filesystem cluster
size (thus cluster-chain jump is never initiated).
In order to accomplish the last condition, root directory parsing code in
do_fat_read() uses the following trick: read-out cluster-size block, process
only first sector (512 bytes), then shift 512 forward, read-out cluster-size
block and so on. This works great unless cluster size is equal to 512 bytes
(in a case you have a small partition), or long file name entries are scattered
across three sectors, see 4) for details.
2) Despite of the fact that get_vfatname() supports FAT32 root directory
browsing, do_fat_read() function doesn't send current cluster number correctly,
so root directory look-up doesn't work correctly.
3) get_vfatname() doesn't gather scattered entries correctly also is the case
when all LFN entries are located at the end of the source cluster, but real
directory entry (which must be returned) is at the only beginning of the
next one. No error detected, the resulting directory entry returned contains
a semi-random information (wrong size, wrong start cluster number and so on)
i.e. the entry is not accessible.
4) LFN (VFAT) allows up to 20 entries (slots) each containing 26 bytes (13
UTF-16 code units) to represent a single long file name i.e. up to 520 bytes.
U-Boot allocates 256 bytes buffer instead, i.e. 10 or more LFN slots record
may cause buffer overflow / memory corruption.
Also, it's worth to mention that 20+1 slots occupy 672 bytes space which may
take more than one cluster of 512 bytes (medium-size FAT32 or small FAT16
partition) - get_vfatname() function doesn't support such case as well.
The patch attached fixes these problems in the following way:
- keep using 256 bytes buffer for a long file name, but safely prevent a
possible buffer overflow (skip LFN processing, if it contains 10 or more
slots).
- explicitly specify FAT12/16 root directory parsing buffer size, instead
of relying on cluster size. The value used is a double sector size (to store
current sector and the next one). This fixes the first problem and increases
performance on big FAT12/16 partitions;
- send current cluster number (FAT32) to get_vfatname() during root
directory processing;
- use LFN counter to seek the real directory entry in get_vfatname() - fixes the
third problem;
- skip deleted entries in the root directory (to prevent bogus buffer
overflow detection and LFN counter steps).
Note: it's not advised to split up the patch, because a separate part may
operate incorrectly.
Signed-off-by: Mikhail Zolotaryov <lebon@lebon.org.ua>
2010-09-08 22:06:03 +08:00
|
|
|
/* Maximum Long File Name length supported here is 128 UTF-16 code units */
|
|
|
|
#define VFAT_MAXLEN_BYTES 256 /* Maximum LFN buffer in bytes */
|
|
|
|
#define VFAT_MAXSEQ 9 /* Up to 9 of 13 2-byte UTF-16 entries */
|
2011-08-19 17:37:46 +08:00
|
|
|
#define PREFETCH_BLOCKS 2
|
2003-06-16 06:40:42 +08:00
|
|
|
|
2014-05-26 21:48:37 +08:00
|
|
|
#define MAX_CLUSTSIZE CONFIG_FS_FAT_MAX_CLUSTSIZE
|
|
|
|
|
2011-08-08 17:38:33 +08:00
|
|
|
#define DIRENTSPERCLUST ((mydata->clust_size * mydata->sect_size) / \
|
|
|
|
sizeof(dir_entry))
|
2003-06-16 06:40:42 +08:00
|
|
|
|
|
|
|
#define FATBUFBLOCKS 6
|
2011-08-08 17:38:33 +08:00
|
|
|
#define FATBUFSIZE (mydata->sect_size * FATBUFBLOCKS)
|
2004-02-10 08:03:41 +08:00
|
|
|
#define FAT12BUFSIZE ((FATBUFSIZE*2)/3)
|
2003-06-16 06:40:42 +08:00
|
|
|
#define FAT16BUFSIZE (FATBUFSIZE/2)
|
|
|
|
#define FAT32BUFSIZE (FATBUFSIZE/4)
|
|
|
|
|
2016-07-28 14:08:56 +08:00
|
|
|
/* Maximum number of entry for long file name according to spec */
|
|
|
|
#define MAX_LFN_SLOT 20
|
2003-06-16 06:40:42 +08:00
|
|
|
|
|
|
|
/* Filesystem identifiers */
|
|
|
|
#define FAT12_SIGN "FAT12 "
|
|
|
|
#define FAT16_SIGN "FAT16 "
|
|
|
|
#define FAT32_SIGN "FAT32 "
|
|
|
|
#define SIGNLEN 8
|
|
|
|
|
|
|
|
/* File attributes */
|
2010-07-19 17:37:00 +08:00
|
|
|
#define ATTR_RO 1
|
|
|
|
#define ATTR_HIDDEN 2
|
|
|
|
#define ATTR_SYS 4
|
|
|
|
#define ATTR_VOLUME 8
|
|
|
|
#define ATTR_DIR 16
|
|
|
|
#define ATTR_ARCH 32
|
2003-06-16 06:40:42 +08:00
|
|
|
|
2010-07-19 17:37:00 +08:00
|
|
|
#define ATTR_VFAT (ATTR_RO | ATTR_HIDDEN | ATTR_SYS | ATTR_VOLUME)
|
2003-06-16 06:40:42 +08:00
|
|
|
|
|
|
|
#define DELETED_FLAG ((char)0xe5) /* Marks deleted files when in name[0] */
|
2008-11-28 05:30:27 +08:00
|
|
|
#define aRING 0x05 /* Used as special character in name[0] */
|
2003-06-16 06:40:42 +08:00
|
|
|
|
2010-07-19 17:37:00 +08:00
|
|
|
/*
|
|
|
|
* Indicates that the entry is the last long entry in a set of long
|
* Patch by Thomas Elste, 10 Feb 2004:
Add support for NET+50 CPU and ModNET50 board
* Patch by Sam Song, 10 Feb 2004:
Fix typos in cfi_flash.c
* Patch by Leon Kukovec, 10 Feb 2004
Fixed long dir entry slot id calculation in get_vfatname
* Patch by Robin Gilks, 10 Feb 2004:
add "itest" command (operators: -eq, -ne, -lt, -gt, -le, -ge, ==,
!=, <>, <, >, <=, >=)
2004-02-24 03:30:57 +08:00
|
|
|
* dir entries
|
|
|
|
*/
|
|
|
|
#define LAST_LONG_ENTRY_MASK 0x40
|
2003-06-16 06:40:42 +08:00
|
|
|
|
2010-07-19 17:37:00 +08:00
|
|
|
#define ISDIRDELIM(c) ((c) == '/' || (c) == '\\')
|
2003-06-16 06:40:42 +08:00
|
|
|
|
|
|
|
#define FSTYPE_NONE (-1)
|
|
|
|
|
|
|
|
#if defined(__linux__) && defined(__KERNEL__)
|
|
|
|
#define FAT2CPU16 le16_to_cpu
|
|
|
|
#define FAT2CPU32 le32_to_cpu
|
|
|
|
#else
|
2003-12-08 07:55:12 +08:00
|
|
|
#if __LITTLE_ENDIAN
|
2003-06-16 06:40:42 +08:00
|
|
|
#define FAT2CPU16(x) (x)
|
|
|
|
#define FAT2CPU32(x) (x)
|
|
|
|
#else
|
|
|
|
#define FAT2CPU16(x) ((((x) & 0x00ff) << 8) | (((x) & 0xff00) >> 8))
|
|
|
|
#define FAT2CPU32(x) ((((x) & 0x000000ff) << 24) | \
|
2008-05-20 22:00:29 +08:00
|
|
|
(((x) & 0x0000ff00) << 8) | \
|
2003-06-16 06:40:42 +08:00
|
|
|
(((x) & 0x00ff0000) >> 8) | \
|
|
|
|
(((x) & 0xff000000) >> 24))
|
|
|
|
#endif
|
|
|
|
#endif
|
|
|
|
|
|
|
|
#define START(dent) (FAT2CPU16((dent)->start) \
|
|
|
|
+ (mydata->fatsize != 32 ? 0 : \
|
|
|
|
(FAT2CPU16((dent)->starthi) << 16)))
|
2014-05-08 16:14:06 +08:00
|
|
|
#define IS_LAST_CLUST(x, fatsize) ((x) >= ((fatsize) != 32 ? \
|
|
|
|
((fatsize) != 16 ? 0xff8 : 0xfff8) : \
|
|
|
|
0xffffff8))
|
2008-03-03 06:33:46 +08:00
|
|
|
#define CHECK_CLUST(x, fatsize) ((x) <= 1 || \
|
2014-05-08 16:14:05 +08:00
|
|
|
(x) >= ((fatsize) != 32 ? \
|
|
|
|
((fatsize) != 16 ? 0xff0 : 0xfff0) : \
|
|
|
|
0xffffff0))
|
2003-06-16 06:40:42 +08:00
|
|
|
|
|
|
|
typedef struct boot_sector {
|
|
|
|
__u8 ignored[3]; /* Bootstrap code */
|
|
|
|
char system_id[8]; /* Name of fs */
|
|
|
|
__u8 sector_size[2]; /* Bytes/sector */
|
|
|
|
__u8 cluster_size; /* Sectors/cluster */
|
|
|
|
__u16 reserved; /* Number of reserved sectors */
|
|
|
|
__u8 fats; /* Number of FATs */
|
|
|
|
__u8 dir_entries[2]; /* Number of root directory entries */
|
|
|
|
__u8 sectors[2]; /* Number of sectors */
|
|
|
|
__u8 media; /* Media code */
|
|
|
|
__u16 fat_length; /* Sectors/FAT */
|
|
|
|
__u16 secs_track; /* Sectors/track */
|
|
|
|
__u16 heads; /* Number of heads */
|
|
|
|
__u32 hidden; /* Number of hidden sectors */
|
|
|
|
__u32 total_sect; /* Number of sectors (if sectors == 0) */
|
|
|
|
|
|
|
|
/* FAT32 only */
|
|
|
|
__u32 fat32_length; /* Sectors/FAT */
|
|
|
|
__u16 flags; /* Bit 8: fat mirroring, low 4: active fat */
|
|
|
|
__u8 version[2]; /* Filesystem version */
|
|
|
|
__u32 root_cluster; /* First cluster in root directory */
|
|
|
|
__u16 info_sector; /* Filesystem info sector */
|
|
|
|
__u16 backup_boot; /* Backup boot sector */
|
|
|
|
__u16 reserved2[6]; /* Unused */
|
|
|
|
} boot_sector;
|
|
|
|
|
|
|
|
typedef struct volume_info
|
|
|
|
{
|
|
|
|
__u8 drive_number; /* BIOS drive number */
|
|
|
|
__u8 reserved; /* Unused */
|
|
|
|
__u8 ext_boot_sign; /* 0x29 if fields below exist (DOS 3.3+) */
|
|
|
|
__u8 volume_id[4]; /* Volume ID number */
|
|
|
|
char volume_label[11]; /* Volume label */
|
|
|
|
char fs_type[8]; /* Typically FAT12, FAT16, or FAT32 */
|
|
|
|
/* Boot code comes next, all but 2 bytes to fill up sector */
|
|
|
|
/* Boot sign comes last, 2 bytes */
|
|
|
|
} volume_info;
|
|
|
|
|
2017-09-10 01:15:59 +08:00
|
|
|
/* see dir_entry::lcase: */
|
|
|
|
#define CASE_LOWER_BASE 8 /* base (name) is lower case */
|
|
|
|
#define CASE_LOWER_EXT 16 /* extension is lower case */
|
|
|
|
|
2021-01-21 07:23:33 +08:00
|
|
|
struct nameext {
|
|
|
|
char name[8];
|
|
|
|
char ext[3];
|
|
|
|
};
|
|
|
|
|
2003-06-16 06:40:42 +08:00
|
|
|
typedef struct dir_entry {
|
2021-01-21 07:23:33 +08:00
|
|
|
struct nameext nameext; /* Name and extension */
|
2003-06-16 06:40:42 +08:00
|
|
|
__u8 attr; /* Attribute bits */
|
2017-09-10 01:15:59 +08:00
|
|
|
__u8 lcase; /* Case for name and ext (CASE_LOWER_x) */
|
2003-06-16 06:40:42 +08:00
|
|
|
__u8 ctime_ms; /* Creation time, milliseconds */
|
|
|
|
__u16 ctime; /* Creation time */
|
|
|
|
__u16 cdate; /* Creation date */
|
|
|
|
__u16 adate; /* Last access date */
|
|
|
|
__u16 starthi; /* High 16 bits of cluster in FAT32 */
|
|
|
|
__u16 time,date,start;/* Time, date and first cluster */
|
|
|
|
__u32 size; /* File size in bytes */
|
|
|
|
} dir_entry;
|
|
|
|
|
|
|
|
typedef struct dir_slot {
|
2010-07-19 17:37:00 +08:00
|
|
|
__u8 id; /* Sequence number for slot */
|
|
|
|
__u8 name0_4[10]; /* First 5 characters in name */
|
|
|
|
__u8 attr; /* Attribute byte */
|
|
|
|
__u8 reserved; /* Unused */
|
|
|
|
__u8 alias_checksum;/* Checksum for 8.3 alias */
|
|
|
|
__u8 name5_10[12]; /* 6 more characters in name */
|
|
|
|
__u16 start; /* Unused */
|
|
|
|
__u8 name11_12[4]; /* Last 2 characters in name */
|
2003-06-16 06:40:42 +08:00
|
|
|
} dir_slot;
|
|
|
|
|
2010-07-19 17:37:00 +08:00
|
|
|
/*
|
|
|
|
* Private filesystem parameters
|
2006-08-15 04:05:26 +08:00
|
|
|
*
|
|
|
|
* Note: FAT buffer has to be 32 bit aligned
|
|
|
|
* (see FAT32 accesses)
|
|
|
|
*/
|
2003-06-16 06:40:42 +08:00
|
|
|
typedef struct {
|
2011-08-08 17:38:33 +08:00
|
|
|
__u8 *fatbuf; /* Current FAT buffer */
|
2003-06-16 06:40:42 +08:00
|
|
|
int fatsize; /* Size of FAT in bits */
|
2012-05-19 15:20:40 +08:00
|
|
|
__u32 fatlength; /* Length of FAT in sectors */
|
2003-06-16 06:40:42 +08:00
|
|
|
__u16 fat_sect; /* Starting sector of the FAT */
|
2016-09-12 04:51:40 +08:00
|
|
|
__u8 fat_dirty; /* Set if fatbuf has been modified */
|
2012-05-19 15:20:40 +08:00
|
|
|
__u32 rootdir_sect; /* Start sector of root directory */
|
2011-08-08 17:38:33 +08:00
|
|
|
__u16 sect_size; /* Size of sectors in bytes */
|
2003-06-16 06:40:42 +08:00
|
|
|
__u16 clust_size; /* Size of clusters in sectors */
|
2012-05-19 15:20:40 +08:00
|
|
|
int data_begin; /* The sector of the first cluster, can be negative */
|
2003-06-16 06:40:42 +08:00
|
|
|
int fatbufnum; /* Used by get_fatent, init to -1 */
|
2017-09-10 01:15:52 +08:00
|
|
|
int rootdir_size; /* Size of root dir for non-FAT32 */
|
2017-09-10 01:15:53 +08:00
|
|
|
__u32 root_cluster; /* First cluster of root dir for FAT32 */
|
2018-09-11 14:58:58 +08:00
|
|
|
u32 total_sect; /* Number of sectors */
|
|
|
|
int fats; /* Number of FATs */
|
2003-06-16 06:40:42 +08:00
|
|
|
} fsdata;
|
|
|
|
|
2020-11-22 16:19:52 +08:00
|
|
|
struct fat_itr;
|
|
|
|
typedef struct fat_itr fat_itr;
|
|
|
|
|
2017-09-10 01:15:53 +08:00
|
|
|
static inline u32 clust_to_sect(fsdata *fsdata, u32 clust)
|
|
|
|
{
|
|
|
|
return fsdata->data_begin + clust * fsdata->clust_size;
|
|
|
|
}
|
|
|
|
|
2018-06-04 19:45:54 +08:00
|
|
|
static inline u32 sect_to_clust(fsdata *fsdata, int sect)
|
2017-09-10 01:16:00 +08:00
|
|
|
{
|
|
|
|
return (sect - fsdata->data_begin) / fsdata->clust_size;
|
|
|
|
}
|
|
|
|
|
2003-06-16 06:40:42 +08:00
|
|
|
int file_fat_detectfs(void);
|
2014-02-04 04:21:10 +08:00
|
|
|
int fat_exists(const char *filename);
|
2014-11-18 06:39:38 +08:00
|
|
|
int fat_size(const char *filename, loff_t *size);
|
2014-11-18 06:39:35 +08:00
|
|
|
int file_fat_read_at(const char *filename, loff_t pos, void *buffer,
|
|
|
|
loff_t maxsize, loff_t *actread);
|
|
|
|
int file_fat_read(const char *filename, void *buffer, int maxsize);
|
2020-05-11 01:39:57 +08:00
|
|
|
int fat_set_blk_dev(struct blk_desc *rbdd, struct disk_partition *info);
|
2016-03-01 06:25:34 +08:00
|
|
|
int fat_register_device(struct blk_desc *dev_desc, int part_no);
|
2003-06-16 06:40:42 +08:00
|
|
|
|
2014-11-18 06:39:35 +08:00
|
|
|
int file_fat_write(const char *filename, void *buf, loff_t offset, loff_t len,
|
|
|
|
loff_t *actwrite);
|
2014-11-18 06:39:38 +08:00
|
|
|
int fat_read_file(const char *filename, void *buf, loff_t offset, loff_t len,
|
|
|
|
loff_t *actread);
|
2017-09-10 01:15:58 +08:00
|
|
|
int fat_opendir(const char *filename, struct fs_dir_stream **dirsp);
|
|
|
|
int fat_readdir(struct fs_dir_stream *dirs, struct fs_dirent **dentp);
|
|
|
|
void fat_closedir(struct fs_dir_stream *dirs);
|
2018-09-11 14:59:14 +08:00
|
|
|
int fat_unlink(const char *filename);
|
2018-09-11 14:59:10 +08:00
|
|
|
int fat_mkdir(const char *dirname);
|
2012-12-26 17:53:33 +08:00
|
|
|
void fat_close(void);
|
2020-11-22 16:19:52 +08:00
|
|
|
void *fat_next_cluster(fat_itr *itr, unsigned int *nbytes);
|
2020-12-31 07:38:13 +08:00
|
|
|
|
|
|
|
/**
|
|
|
|
* fat_uuid() - get FAT volume ID
|
|
|
|
*
|
|
|
|
* The FAT volume ID returned in @uuid_str as hexadecimal number in XXXX-XXXX
|
|
|
|
* format.
|
|
|
|
*
|
|
|
|
* @uuid_str: caller allocated buffer of at least 10 bytes for the volume ID
|
|
|
|
* Return: 0 on success
|
|
|
|
*/
|
|
|
|
int fat_uuid(char *uuid_str);
|
|
|
|
|
2003-06-16 06:40:42 +08:00
|
|
|
#endif /* _FAT_H_ */
|