2008-11-06 21:53:46 +01:00
|
|
|
#ifndef _FAT_H
|
|
|
|
#define _FAT_H
|
|
|
|
|
|
|
|
#include <linux/buffer_head.h>
|
|
|
|
#include <linux/string.h>
|
|
|
|
#include <linux/nls.h>
|
|
|
|
#include <linux/fs.h>
|
2012-10-05 02:14:45 +02:00
|
|
|
#include <linux/hash.h>
|
2008-11-06 21:53:46 +01:00
|
|
|
#include <linux/mutex.h>
|
2010-05-24 23:33:12 +02:00
|
|
|
#include <linux/ratelimit.h>
|
2008-11-06 21:53:46 +01:00
|
|
|
#include <linux/msdos_fs.h>
|
|
|
|
|
|
|
|
/*
|
|
|
|
* vfat shortname flags
|
|
|
|
*/
|
|
|
|
#define VFAT_SFN_DISPLAY_LOWER 0x0001 /* convert to lowercase for display */
|
|
|
|
#define VFAT_SFN_DISPLAY_WIN95 0x0002 /* emulate win95 rule for display */
|
|
|
|
#define VFAT_SFN_DISPLAY_WINNT 0x0004 /* emulate winnt rule for display */
|
|
|
|
#define VFAT_SFN_CREATE_WIN95 0x0100 /* emulate win95 rule for create */
|
|
|
|
#define VFAT_SFN_CREATE_WINNT 0x0200 /* emulate winnt rule for create */
|
|
|
|
|
2009-06-03 19:34:22 +02:00
|
|
|
#define FAT_ERRORS_CONT 1 /* ignore error and continue */
|
|
|
|
#define FAT_ERRORS_PANIC 2 /* panic on error */
|
|
|
|
#define FAT_ERRORS_RO 3 /* remount r/o on error */
|
|
|
|
|
2013-04-30 01:21:08 +02:00
|
|
|
#define FAT_NFS_STALE_RW 1 /* NFS RW support, can cause ESTALE */
|
|
|
|
#define FAT_NFS_NOSTALE_RO 2 /* NFS RO support, no ESTALE issue */
|
|
|
|
|
2008-11-06 21:53:46 +01:00
|
|
|
struct fat_mount_options {
|
2012-02-08 01:25:39 +01:00
|
|
|
kuid_t fs_uid;
|
|
|
|
kgid_t fs_gid;
|
2008-11-06 21:53:46 +01:00
|
|
|
unsigned short fs_fmask;
|
|
|
|
unsigned short fs_dmask;
|
2012-10-05 02:14:52 +02:00
|
|
|
unsigned short codepage; /* Codepage for shortname conversions */
|
2012-12-18 01:02:58 +01:00
|
|
|
int time_offset; /* Offset of timestamps from UTC (in minutes) */
|
2012-10-05 02:14:52 +02:00
|
|
|
char *iocharset; /* Charset used for filename input/display */
|
|
|
|
unsigned short shortname; /* flags for shortname display/create rule */
|
|
|
|
unsigned char name_check; /* r = relaxed, n = normal, s = strict */
|
|
|
|
unsigned char errors; /* On error: continue, panic, remount-ro */
|
2013-04-30 01:21:08 +02:00
|
|
|
unsigned char nfs; /* NFS support: nostale_ro, stale_rw */
|
2008-11-06 21:53:46 +01:00
|
|
|
unsigned short allow_utime;/* permission for setting the [am]time */
|
2012-10-05 02:14:52 +02:00
|
|
|
unsigned quiet:1, /* set = fake successful chmods and chowns */
|
|
|
|
showexec:1, /* set = only set x bit for com/exe/bat */
|
|
|
|
sys_immutable:1, /* set = system files are immutable */
|
|
|
|
dotsOK:1, /* set = hidden and system files are named '.filename' */
|
|
|
|
isvfat:1, /* 0=no vfat long filename support, 1=vfat support */
|
|
|
|
utf8:1, /* Use of UTF-8 character set (Default) */
|
|
|
|
unicode_xlate:1, /* create escape sequences for unhandled Unicode */
|
|
|
|
numtail:1, /* Does first alias have a numeric '~1' type tail? */
|
|
|
|
flush:1, /* write things quickly */
|
|
|
|
nocase:1, /* Does this need case conversion? 0=need case conversion*/
|
|
|
|
usefree:1, /* Use free_clusters for FAT32 */
|
2012-12-18 01:02:58 +01:00
|
|
|
tz_set:1, /* Filesystem timestamps' offset set */
|
2012-10-05 02:14:52 +02:00
|
|
|
rodir:1, /* allow ATTR_RO for directory */
|
2013-04-30 01:21:08 +02:00
|
|
|
discard:1; /* Issue discard requests on deletions */
|
2008-11-06 21:53:46 +01:00
|
|
|
};
|
|
|
|
|
|
|
|
#define FAT_HASH_BITS 8
|
|
|
|
#define FAT_HASH_SIZE (1UL << FAT_HASH_BITS)
|
|
|
|
|
|
|
|
/*
|
|
|
|
* MS-DOS file system in-core superblock data
|
|
|
|
*/
|
|
|
|
struct msdos_sb_info {
|
2012-10-05 02:14:52 +02:00
|
|
|
unsigned short sec_per_clus; /* sectors/cluster */
|
|
|
|
unsigned short cluster_bits; /* log2(cluster_size) */
|
|
|
|
unsigned int cluster_size; /* cluster size */
|
2012-10-05 02:14:49 +02:00
|
|
|
unsigned char fats, fat_bits; /* number of FATs, FAT bits (12 or 16) */
|
2008-11-06 21:53:46 +01:00
|
|
|
unsigned short fat_start;
|
2012-10-05 02:14:52 +02:00
|
|
|
unsigned long fat_length; /* FAT start & length (sec.) */
|
2008-11-06 21:53:46 +01:00
|
|
|
unsigned long dir_start;
|
2012-10-05 02:14:52 +02:00
|
|
|
unsigned short dir_entries; /* root dir start & entries */
|
|
|
|
unsigned long data_start; /* first data sector */
|
|
|
|
unsigned long max_cluster; /* maximum cluster number */
|
|
|
|
unsigned long root_cluster; /* first cluster of the root directory */
|
|
|
|
unsigned long fsinfo_sector; /* sector number of FAT32 fsinfo */
|
2008-11-06 21:53:46 +01:00
|
|
|
struct mutex fat_lock;
|
2013-04-30 01:21:12 +02:00
|
|
|
struct mutex nfs_build_inode_lock;
|
2012-10-06 12:40:03 +02:00
|
|
|
struct mutex s_lock;
|
|
|
|
unsigned int prev_free; /* previously allocated cluster number */
|
|
|
|
unsigned int free_clusters; /* -1 if undefined */
|
2008-11-06 21:53:46 +01:00
|
|
|
unsigned int free_clus_valid; /* is free_clusters valid? */
|
|
|
|
struct fat_mount_options options;
|
2012-10-05 02:14:52 +02:00
|
|
|
struct nls_table *nls_disk; /* Codepage used on disk */
|
|
|
|
struct nls_table *nls_io; /* Charset used for input and display */
|
|
|
|
const void *dir_ops; /* Opaque; default directory operations */
|
|
|
|
int dir_per_block; /* dir entries per block */
|
|
|
|
int dir_per_block_bits; /* log2(dir_per_block) */
|
fatfs: add FAT_IOCTL_GET_VOLUME_ID
This patch, originally from Android kernel, adds vfat ioctl command
FAT_IOCTL_GET_VOLUME_ID, with this command we can get the vfat volume ID
using following code:
ioctl(fd, FAT_IOCTL_GET_VOLUME_ID, &volume_ID)
This patch is a modified version of the patch by Mike Lockwood, with
changes from Dmitry Pervushin, who noticed the original patch makes some
volume IDs abiguous with error returns: for example, if volume id is
0xFFFFFDAD, that matches -ENOIOCTLCMD, we get "FFFFFFFF" from the user
space.
So add a parameter to ioctl to get the correct volume ID.
Android uses vfat volume ID to identify different sd card, when a new sd
card is inserted to device, android can scan the media on it and pop up
new contents.
Signed-off-by: Bintian Wang <bintian.wang@linaro.org>
Cc: dmitry pervushin <dpervushin@gmail.com>
Cc: Mike Lockwood <lockwood@android.com>
Cc: Colin Cross <ccross@android.com>
Acked-by: OGAWA Hirofumi <hirofumi@mail.parknet.co.jp>
Cc: John Stultz <john.stultz@linaro.org>
Cc: Sean McNeil <sean@mcneil.com>
Signed-off-by: Andrew Morton <akpm@linux-foundation.org>
Signed-off-by: Linus Torvalds <torvalds@linux-foundation.org>
2013-07-09 01:00:46 +02:00
|
|
|
unsigned int vol_id; /*volume ID*/
|
2008-11-06 21:53:46 +01:00
|
|
|
|
|
|
|
int fatent_shift;
|
|
|
|
struct fatent_operations *fatent_ops;
|
2009-06-07 19:44:36 +02:00
|
|
|
struct inode *fat_inode;
|
2012-06-01 01:26:12 +02:00
|
|
|
struct inode *fsinfo_inode;
|
2008-11-06 21:53:46 +01:00
|
|
|
|
2010-05-24 23:33:12 +02:00
|
|
|
struct ratelimit_state ratelimit;
|
|
|
|
|
2008-11-06 21:53:46 +01:00
|
|
|
spinlock_t inode_hash_lock;
|
|
|
|
struct hlist_head inode_hashtable[FAT_HASH_SIZE];
|
2012-10-05 02:14:45 +02:00
|
|
|
|
|
|
|
spinlock_t dir_hash_lock;
|
|
|
|
struct hlist_head dir_hashtable[FAT_HASH_SIZE];
|
2013-02-28 02:03:09 +01:00
|
|
|
|
|
|
|
unsigned int dirty; /* fs state before mount */
|
2008-11-06 21:53:46 +01:00
|
|
|
};
|
|
|
|
|
|
|
|
#define FAT_CACHE_VALID 0 /* special case for valid cache */
|
|
|
|
|
|
|
|
/*
|
|
|
|
* MS-DOS file system inode data in memory
|
|
|
|
*/
|
|
|
|
struct msdos_inode_info {
|
|
|
|
spinlock_t cache_lru_lock;
|
|
|
|
struct list_head cache_lru;
|
|
|
|
int nr_caches;
|
|
|
|
/* for avoiding the race between fat_free() and fat_get_cluster() */
|
|
|
|
unsigned int cache_valid_id;
|
|
|
|
|
2008-11-06 21:53:57 +01:00
|
|
|
/* NOTE: mmu_private is 64bits, so must hold ->i_mutex to access */
|
|
|
|
loff_t mmu_private; /* physically allocated size */
|
|
|
|
|
2008-11-06 21:53:46 +01:00
|
|
|
int i_start; /* first cluster or 0 */
|
|
|
|
int i_logstart; /* logical first cluster */
|
|
|
|
int i_attrs; /* unused attribute bits */
|
|
|
|
loff_t i_pos; /* on-disk position of directory entry or 0 */
|
|
|
|
struct hlist_node i_fat_hash; /* hash by i_location */
|
2012-10-05 02:14:45 +02:00
|
|
|
struct hlist_node i_dir_hash; /* hash by i_logstart */
|
2011-06-24 20:29:40 +02:00
|
|
|
struct rw_semaphore truncate_lock; /* protect bmap against truncate */
|
2008-11-06 21:53:46 +01:00
|
|
|
struct inode vfs_inode;
|
|
|
|
};
|
|
|
|
|
|
|
|
struct fat_slot_info {
|
|
|
|
loff_t i_pos; /* on-disk position of directory entry */
|
|
|
|
loff_t slot_off; /* offset for slot or de start */
|
|
|
|
int nr_slots; /* number of slots + 1(de) in filename */
|
|
|
|
struct msdos_dir_entry *de;
|
|
|
|
struct buffer_head *bh;
|
|
|
|
};
|
|
|
|
|
|
|
|
static inline struct msdos_sb_info *MSDOS_SB(struct super_block *sb)
|
|
|
|
{
|
|
|
|
return sb->s_fs_info;
|
|
|
|
}
|
|
|
|
|
|
|
|
static inline struct msdos_inode_info *MSDOS_I(struct inode *inode)
|
|
|
|
{
|
|
|
|
return container_of(inode, struct msdos_inode_info, vfs_inode);
|
|
|
|
}
|
|
|
|
|
2008-11-06 21:53:54 +01:00
|
|
|
/*
|
|
|
|
* If ->i_mode can't hold S_IWUGO (i.e. ATTR_RO), we use ->i_attrs to
|
|
|
|
* save ATTR_RO instead of ->i_mode.
|
2008-11-06 21:53:55 +01:00
|
|
|
*
|
|
|
|
* If it's directory and !sbi->options.rodir, ATTR_RO isn't read-only
|
|
|
|
* bit, it's just used as flag for app.
|
2008-11-06 21:53:54 +01:00
|
|
|
*/
|
|
|
|
static inline int fat_mode_can_hold_ro(struct inode *inode)
|
|
|
|
{
|
|
|
|
struct msdos_sb_info *sbi = MSDOS_SB(inode->i_sb);
|
2011-07-26 09:21:30 +02:00
|
|
|
umode_t mask;
|
2008-11-06 21:53:54 +01:00
|
|
|
|
2008-11-06 21:53:55 +01:00
|
|
|
if (S_ISDIR(inode->i_mode)) {
|
|
|
|
if (!sbi->options.rodir)
|
|
|
|
return 0;
|
2008-11-06 21:53:54 +01:00
|
|
|
mask = ~sbi->options.fs_dmask;
|
2008-11-06 21:53:55 +01:00
|
|
|
} else
|
2008-11-06 21:53:54 +01:00
|
|
|
mask = ~sbi->options.fs_fmask;
|
|
|
|
|
|
|
|
if (!(mask & S_IWUGO))
|
|
|
|
return 0;
|
|
|
|
return 1;
|
|
|
|
}
|
|
|
|
|
2008-11-06 21:53:54 +01:00
|
|
|
/* Convert attribute bits and a mask to the UNIX mode. */
|
2011-07-26 09:21:30 +02:00
|
|
|
static inline umode_t fat_make_mode(struct msdos_sb_info *sbi,
|
|
|
|
u8 attrs, umode_t mode)
|
2008-11-06 21:53:54 +01:00
|
|
|
{
|
2008-11-06 21:53:55 +01:00
|
|
|
if (attrs & ATTR_RO && !((attrs & ATTR_DIR) && !sbi->options.rodir))
|
2008-11-06 21:53:54 +01:00
|
|
|
mode &= ~S_IWUGO;
|
|
|
|
|
|
|
|
if (attrs & ATTR_DIR)
|
|
|
|
return (mode & ~sbi->options.fs_dmask) | S_IFDIR;
|
|
|
|
else
|
|
|
|
return (mode & ~sbi->options.fs_fmask) | S_IFREG;
|
|
|
|
}
|
|
|
|
|
2008-11-06 21:53:46 +01:00
|
|
|
/* Return the FAT attribute byte for this inode */
|
2008-11-06 21:53:54 +01:00
|
|
|
static inline u8 fat_make_attrs(struct inode *inode)
|
2008-11-06 21:53:46 +01:00
|
|
|
{
|
2008-11-06 21:53:54 +01:00
|
|
|
u8 attrs = MSDOS_I(inode)->i_attrs;
|
|
|
|
if (S_ISDIR(inode->i_mode))
|
|
|
|
attrs |= ATTR_DIR;
|
|
|
|
if (fat_mode_can_hold_ro(inode) && !(inode->i_mode & S_IWUGO))
|
|
|
|
attrs |= ATTR_RO;
|
|
|
|
return attrs;
|
2008-11-06 21:53:46 +01:00
|
|
|
}
|
|
|
|
|
2008-11-06 21:53:54 +01:00
|
|
|
static inline void fat_save_attrs(struct inode *inode, u8 attrs)
|
|
|
|
{
|
2008-11-06 21:53:54 +01:00
|
|
|
if (fat_mode_can_hold_ro(inode))
|
|
|
|
MSDOS_I(inode)->i_attrs = attrs & ATTR_UNUSED;
|
|
|
|
else
|
|
|
|
MSDOS_I(inode)->i_attrs = attrs & (ATTR_UNUSED | ATTR_RO);
|
2008-11-06 21:53:54 +01:00
|
|
|
}
|
|
|
|
|
2008-11-06 21:53:46 +01:00
|
|
|
static inline unsigned char fat_checksum(const __u8 *name)
|
|
|
|
{
|
|
|
|
unsigned char s = name[0];
|
|
|
|
s = (s<<7) + (s>>1) + name[1]; s = (s<<7) + (s>>1) + name[2];
|
|
|
|
s = (s<<7) + (s>>1) + name[3]; s = (s<<7) + (s>>1) + name[4];
|
|
|
|
s = (s<<7) + (s>>1) + name[5]; s = (s<<7) + (s>>1) + name[6];
|
|
|
|
s = (s<<7) + (s>>1) + name[7]; s = (s<<7) + (s>>1) + name[8];
|
|
|
|
s = (s<<7) + (s>>1) + name[9]; s = (s<<7) + (s>>1) + name[10];
|
|
|
|
return s;
|
|
|
|
}
|
|
|
|
|
|
|
|
static inline sector_t fat_clus_to_blknr(struct msdos_sb_info *sbi, int clus)
|
|
|
|
{
|
|
|
|
return ((sector_t)clus - FAT_START_ENT) * sbi->sec_per_clus
|
|
|
|
+ sbi->data_start;
|
|
|
|
}
|
|
|
|
|
2013-04-30 01:21:10 +02:00
|
|
|
static inline void fat_get_blknr_offset(struct msdos_sb_info *sbi,
|
|
|
|
loff_t i_pos, sector_t *blknr, int *offset)
|
|
|
|
{
|
|
|
|
*blknr = i_pos >> sbi->dir_per_block_bits;
|
|
|
|
*offset = i_pos & (sbi->dir_per_block - 1);
|
|
|
|
}
|
|
|
|
|
2013-04-30 01:21:09 +02:00
|
|
|
static inline loff_t fat_i_pos_read(struct msdos_sb_info *sbi,
|
|
|
|
struct inode *inode)
|
|
|
|
{
|
|
|
|
loff_t i_pos;
|
|
|
|
#if BITS_PER_LONG == 32
|
|
|
|
spin_lock(&sbi->inode_hash_lock);
|
|
|
|
#endif
|
|
|
|
i_pos = MSDOS_I(inode)->i_pos;
|
|
|
|
#if BITS_PER_LONG == 32
|
|
|
|
spin_unlock(&sbi->inode_hash_lock);
|
|
|
|
#endif
|
|
|
|
return i_pos;
|
|
|
|
}
|
|
|
|
|
2008-11-06 21:53:46 +01:00
|
|
|
static inline void fat16_towchar(wchar_t *dst, const __u8 *src, size_t len)
|
|
|
|
{
|
|
|
|
#ifdef __BIG_ENDIAN
|
|
|
|
while (len--) {
|
|
|
|
*dst++ = src[0] | (src[1] << 8);
|
|
|
|
src += 2;
|
|
|
|
}
|
|
|
|
#else
|
|
|
|
memcpy(dst, src, len * 2);
|
|
|
|
#endif
|
|
|
|
}
|
|
|
|
|
2012-07-30 23:42:13 +02:00
|
|
|
static inline int fat_get_start(const struct msdos_sb_info *sbi,
|
|
|
|
const struct msdos_dir_entry *de)
|
|
|
|
{
|
|
|
|
int cluster = le16_to_cpu(de->start);
|
|
|
|
if (sbi->fat_bits == 32)
|
|
|
|
cluster |= (le16_to_cpu(de->starthi) << 16);
|
|
|
|
return cluster;
|
|
|
|
}
|
|
|
|
|
|
|
|
static inline void fat_set_start(struct msdos_dir_entry *de, int cluster)
|
|
|
|
{
|
|
|
|
de->start = cpu_to_le16(cluster);
|
|
|
|
de->starthi = cpu_to_le16(cluster >> 16);
|
|
|
|
}
|
|
|
|
|
2008-11-06 21:53:46 +01:00
|
|
|
static inline void fatwchar_to16(__u8 *dst, const wchar_t *src, size_t len)
|
|
|
|
{
|
|
|
|
#ifdef __BIG_ENDIAN
|
|
|
|
while (len--) {
|
|
|
|
dst[0] = *src & 0x00FF;
|
|
|
|
dst[1] = (*src & 0xFF00) >> 8;
|
|
|
|
dst += 2;
|
|
|
|
src++;
|
|
|
|
}
|
|
|
|
#else
|
|
|
|
memcpy(dst, src, len * 2);
|
|
|
|
#endif
|
|
|
|
}
|
|
|
|
|
|
|
|
/* fat/cache.c */
|
|
|
|
extern void fat_cache_inval_inode(struct inode *inode);
|
|
|
|
extern int fat_get_cluster(struct inode *inode, int cluster,
|
|
|
|
int *fclus, int *dclus);
|
|
|
|
extern int fat_bmap(struct inode *inode, sector_t sector, sector_t *phys,
|
2008-11-06 21:53:57 +01:00
|
|
|
unsigned long *mapped_blocks, int create);
|
2008-11-06 21:53:46 +01:00
|
|
|
|
|
|
|
/* fat/dir.c */
|
|
|
|
extern const struct file_operations fat_dir_operations;
|
|
|
|
extern int fat_search_long(struct inode *inode, const unsigned char *name,
|
|
|
|
int name_len, struct fat_slot_info *sinfo);
|
|
|
|
extern int fat_dir_empty(struct inode *dir);
|
|
|
|
extern int fat_subdirs(struct inode *dir);
|
|
|
|
extern int fat_scan(struct inode *dir, const unsigned char *name,
|
|
|
|
struct fat_slot_info *sinfo);
|
2013-04-30 01:21:14 +02:00
|
|
|
extern int fat_scan_logstart(struct inode *dir, int i_logstart,
|
|
|
|
struct fat_slot_info *sinfo);
|
2008-11-06 21:53:46 +01:00
|
|
|
extern int fat_get_dotdot_entry(struct inode *dir, struct buffer_head **bh,
|
2012-10-05 02:14:45 +02:00
|
|
|
struct msdos_dir_entry **de);
|
2008-11-06 21:53:46 +01:00
|
|
|
extern int fat_alloc_new_dir(struct inode *dir, struct timespec *ts);
|
|
|
|
extern int fat_add_entries(struct inode *dir, void *slots, int nr_slots,
|
|
|
|
struct fat_slot_info *sinfo);
|
|
|
|
extern int fat_remove_entries(struct inode *dir, struct fat_slot_info *sinfo);
|
|
|
|
|
|
|
|
/* fat/fatent.c */
|
|
|
|
struct fat_entry {
|
|
|
|
int entry;
|
|
|
|
union {
|
|
|
|
u8 *ent12_p[2];
|
|
|
|
__le16 *ent16_p;
|
|
|
|
__le32 *ent32_p;
|
|
|
|
} u;
|
|
|
|
int nr_bhs;
|
|
|
|
struct buffer_head *bhs[2];
|
2009-06-07 19:44:36 +02:00
|
|
|
struct inode *fat_inode;
|
2008-11-06 21:53:46 +01:00
|
|
|
};
|
|
|
|
|
|
|
|
static inline void fatent_init(struct fat_entry *fatent)
|
|
|
|
{
|
|
|
|
fatent->nr_bhs = 0;
|
|
|
|
fatent->entry = 0;
|
|
|
|
fatent->u.ent32_p = NULL;
|
|
|
|
fatent->bhs[0] = fatent->bhs[1] = NULL;
|
2009-06-07 19:44:36 +02:00
|
|
|
fatent->fat_inode = NULL;
|
2008-11-06 21:53:46 +01:00
|
|
|
}
|
|
|
|
|
|
|
|
static inline void fatent_set_entry(struct fat_entry *fatent, int entry)
|
|
|
|
{
|
|
|
|
fatent->entry = entry;
|
|
|
|
fatent->u.ent32_p = NULL;
|
|
|
|
}
|
|
|
|
|
|
|
|
static inline void fatent_brelse(struct fat_entry *fatent)
|
|
|
|
{
|
|
|
|
int i;
|
|
|
|
fatent->u.ent32_p = NULL;
|
|
|
|
for (i = 0; i < fatent->nr_bhs; i++)
|
|
|
|
brelse(fatent->bhs[i]);
|
|
|
|
fatent->nr_bhs = 0;
|
|
|
|
fatent->bhs[0] = fatent->bhs[1] = NULL;
|
2009-06-07 19:44:36 +02:00
|
|
|
fatent->fat_inode = NULL;
|
2008-11-06 21:53:46 +01:00
|
|
|
}
|
|
|
|
|
|
|
|
extern void fat_ent_access_init(struct super_block *sb);
|
|
|
|
extern int fat_ent_read(struct inode *inode, struct fat_entry *fatent,
|
|
|
|
int entry);
|
|
|
|
extern int fat_ent_write(struct inode *inode, struct fat_entry *fatent,
|
|
|
|
int new, int wait);
|
|
|
|
extern int fat_alloc_clusters(struct inode *inode, int *cluster,
|
|
|
|
int nr_cluster);
|
|
|
|
extern int fat_free_clusters(struct inode *inode, int cluster);
|
|
|
|
extern int fat_count_free_clusters(struct super_block *sb);
|
|
|
|
|
|
|
|
/* fat/file.c */
|
2010-05-17 01:13:47 +02:00
|
|
|
extern long fat_generic_ioctl(struct file *filp, unsigned int cmd,
|
|
|
|
unsigned long arg);
|
2008-11-06 21:53:46 +01:00
|
|
|
extern const struct file_operations fat_file_operations;
|
|
|
|
extern const struct inode_operations fat_file_inode_operations;
|
2012-10-05 02:14:49 +02:00
|
|
|
extern int fat_setattr(struct dentry *dentry, struct iattr *attr);
|
2010-05-26 17:05:38 +02:00
|
|
|
extern void fat_truncate_blocks(struct inode *inode, loff_t offset);
|
2008-11-06 21:53:46 +01:00
|
|
|
extern int fat_getattr(struct vfsmount *mnt, struct dentry *dentry,
|
|
|
|
struct kstat *stat);
|
2011-07-17 02:44:56 +02:00
|
|
|
extern int fat_file_fsync(struct file *file, loff_t start, loff_t end,
|
|
|
|
int datasync);
|
2008-11-06 21:53:46 +01:00
|
|
|
|
|
|
|
/* fat/inode.c */
|
|
|
|
extern void fat_attach(struct inode *inode, loff_t i_pos);
|
|
|
|
extern void fat_detach(struct inode *inode);
|
|
|
|
extern struct inode *fat_iget(struct super_block *sb, loff_t i_pos);
|
|
|
|
extern struct inode *fat_build_inode(struct super_block *sb,
|
|
|
|
struct msdos_dir_entry *de, loff_t i_pos);
|
|
|
|
extern int fat_sync_inode(struct inode *inode);
|
|
|
|
extern int fat_fill_super(struct super_block *sb, void *data, int silent,
|
2011-04-12 14:08:37 +02:00
|
|
|
int isvfat, void (*setup)(struct super_block *));
|
2013-04-30 01:21:14 +02:00
|
|
|
extern int fat_fill_inode(struct inode *inode, struct msdos_dir_entry *de);
|
2008-11-06 21:53:46 +01:00
|
|
|
|
|
|
|
extern int fat_flush_inodes(struct super_block *sb, struct inode *i1,
|
2012-10-05 02:14:49 +02:00
|
|
|
struct inode *i2);
|
2012-10-05 02:14:45 +02:00
|
|
|
static inline unsigned long fat_dir_hash(int logstart)
|
fat (exportfs): move NFS support code
Under memory pressure, the system may evict dentries from cache. When the
FAT driver receives a NFS request involving an evicted dentry, it is
unable to reconnect it to the filesystem root. This causes the request to
fail, often with ENOENT.
This is partially due to ineffectiveness of the current FAT NFS
implementation, and partially due to an unimplemented fh_to_parent method.
The latter can cause file accesses to fail on shares exported with
subtree_check.
This patch set provides the FAT driver with the ability to
reconnect dentries. NFS file handle generation and lookups are simplified
and made congruent with ext2.
Testing has involved a memory-starved virtual machine running 3.5-rc5 that
exports a ~2 GB vfat filesystem containing a kernel tree (~770 MB, ~40000
files, 9 levels). Both 'cp -r' and 'ls -lR' operations were performed
from a client, some overlapping, some consecutive. Exports with
'subtree_check' and 'no_subtree_check' have been tested.
Note that while this patch set improves FAT's NFS support, it does not
eliminate ESTALE errors completely.
The following should be considered for NFS clients who are sensitive to ESTALE:
* Mounting with lookupcache=none
Unfortunately this can degrade performance severely, particularly for deep
filesystems.
* Incorporating VFS patches to retry ESTALE failures on the client-side,
such as https://lkml.org/lkml/2012/6/29/381
* Handling ESTALE errors in client application code
This patch:
Move NFS-related code into its own C file. No functional changes.
Signed-off-by: Steven J. Magnani <steve@digidescorp.com>
Acked-by: OGAWA Hirofumi <hirofumi@mail.parknet.co.jp>
Signed-off-by: Andrew Morton <akpm@linux-foundation.org>
Signed-off-by: Linus Torvalds <torvalds@linux-foundation.org>
2012-10-05 02:14:44 +02:00
|
|
|
{
|
2012-10-05 02:14:45 +02:00
|
|
|
return hash_32(logstart, FAT_HASH_BITS);
|
fat (exportfs): move NFS support code
Under memory pressure, the system may evict dentries from cache. When the
FAT driver receives a NFS request involving an evicted dentry, it is
unable to reconnect it to the filesystem root. This causes the request to
fail, often with ENOENT.
This is partially due to ineffectiveness of the current FAT NFS
implementation, and partially due to an unimplemented fh_to_parent method.
The latter can cause file accesses to fail on shares exported with
subtree_check.
This patch set provides the FAT driver with the ability to
reconnect dentries. NFS file handle generation and lookups are simplified
and made congruent with ext2.
Testing has involved a memory-starved virtual machine running 3.5-rc5 that
exports a ~2 GB vfat filesystem containing a kernel tree (~770 MB, ~40000
files, 9 levels). Both 'cp -r' and 'ls -lR' operations were performed
from a client, some overlapping, some consecutive. Exports with
'subtree_check' and 'no_subtree_check' have been tested.
Note that while this patch set improves FAT's NFS support, it does not
eliminate ESTALE errors completely.
The following should be considered for NFS clients who are sensitive to ESTALE:
* Mounting with lookupcache=none
Unfortunately this can degrade performance severely, particularly for deep
filesystems.
* Incorporating VFS patches to retry ESTALE failures on the client-side,
such as https://lkml.org/lkml/2012/6/29/381
* Handling ESTALE errors in client application code
This patch:
Move NFS-related code into its own C file. No functional changes.
Signed-off-by: Steven J. Magnani <steve@digidescorp.com>
Acked-by: OGAWA Hirofumi <hirofumi@mail.parknet.co.jp>
Signed-off-by: Andrew Morton <akpm@linux-foundation.org>
Signed-off-by: Linus Torvalds <torvalds@linux-foundation.org>
2012-10-05 02:14:44 +02:00
|
|
|
}
|
|
|
|
|
2008-11-06 21:53:46 +01:00
|
|
|
/* fat/misc.c */
|
2011-11-01 01:11:33 +01:00
|
|
|
extern __printf(3, 4) __cold
|
|
|
|
void __fat_fs_error(struct super_block *sb, int report, const char *fmt, ...);
|
2011-04-12 14:08:38 +02:00
|
|
|
#define fat_fs_error(sb, fmt, args...) \
|
|
|
|
__fat_fs_error(sb, 1, fmt , ## args)
|
|
|
|
#define fat_fs_error_ratelimit(sb, fmt, args...) \
|
|
|
|
__fat_fs_error(sb, __ratelimit(&MSDOS_SB(sb)->ratelimit), fmt , ## args)
|
2011-11-01 01:11:33 +01:00
|
|
|
__printf(3, 4) __cold
|
|
|
|
void fat_msg(struct super_block *sb, const char *level, const char *fmt, ...);
|
2012-06-01 01:26:13 +02:00
|
|
|
#define fat_msg_ratelimit(sb, level, fmt, args...) \
|
|
|
|
do { \
|
|
|
|
if (__ratelimit(&MSDOS_SB(sb)->ratelimit)) \
|
|
|
|
fat_msg(sb, level, fmt, ## args); \
|
|
|
|
} while (0)
|
2009-09-19 18:31:58 +02:00
|
|
|
extern int fat_clusters_flush(struct super_block *sb);
|
2008-11-06 21:53:46 +01:00
|
|
|
extern int fat_chain_add(struct inode *inode, int new_dclus, int nr_cluster);
|
2008-11-06 21:53:47 +01:00
|
|
|
extern void fat_time_fat2unix(struct msdos_sb_info *sbi, struct timespec *ts,
|
|
|
|
__le16 __time, __le16 __date, u8 time_cs);
|
|
|
|
extern void fat_time_unix2fat(struct msdos_sb_info *sbi, struct timespec *ts,
|
|
|
|
__le16 *time, __le16 *date, u8 *time_cs);
|
2008-11-06 21:53:46 +01:00
|
|
|
extern int fat_sync_bhs(struct buffer_head **bhs, int nr_bhs);
|
|
|
|
|
|
|
|
int fat_cache_init(void);
|
|
|
|
void fat_cache_destroy(void);
|
|
|
|
|
fat (exportfs): move NFS support code
Under memory pressure, the system may evict dentries from cache. When the
FAT driver receives a NFS request involving an evicted dentry, it is
unable to reconnect it to the filesystem root. This causes the request to
fail, often with ENOENT.
This is partially due to ineffectiveness of the current FAT NFS
implementation, and partially due to an unimplemented fh_to_parent method.
The latter can cause file accesses to fail on shares exported with
subtree_check.
This patch set provides the FAT driver with the ability to
reconnect dentries. NFS file handle generation and lookups are simplified
and made congruent with ext2.
Testing has involved a memory-starved virtual machine running 3.5-rc5 that
exports a ~2 GB vfat filesystem containing a kernel tree (~770 MB, ~40000
files, 9 levels). Both 'cp -r' and 'ls -lR' operations were performed
from a client, some overlapping, some consecutive. Exports with
'subtree_check' and 'no_subtree_check' have been tested.
Note that while this patch set improves FAT's NFS support, it does not
eliminate ESTALE errors completely.
The following should be considered for NFS clients who are sensitive to ESTALE:
* Mounting with lookupcache=none
Unfortunately this can degrade performance severely, particularly for deep
filesystems.
* Incorporating VFS patches to retry ESTALE failures on the client-side,
such as https://lkml.org/lkml/2012/6/29/381
* Handling ESTALE errors in client application code
This patch:
Move NFS-related code into its own C file. No functional changes.
Signed-off-by: Steven J. Magnani <steve@digidescorp.com>
Acked-by: OGAWA Hirofumi <hirofumi@mail.parknet.co.jp>
Signed-off-by: Andrew Morton <akpm@linux-foundation.org>
Signed-off-by: Linus Torvalds <torvalds@linux-foundation.org>
2012-10-05 02:14:44 +02:00
|
|
|
/* fat/nfs.c */
|
2013-04-30 01:21:11 +02:00
|
|
|
extern const struct export_operations fat_export_ops;
|
|
|
|
extern const struct export_operations fat_export_ops_nostale;
|
fat (exportfs): move NFS support code
Under memory pressure, the system may evict dentries from cache. When the
FAT driver receives a NFS request involving an evicted dentry, it is
unable to reconnect it to the filesystem root. This causes the request to
fail, often with ENOENT.
This is partially due to ineffectiveness of the current FAT NFS
implementation, and partially due to an unimplemented fh_to_parent method.
The latter can cause file accesses to fail on shares exported with
subtree_check.
This patch set provides the FAT driver with the ability to
reconnect dentries. NFS file handle generation and lookups are simplified
and made congruent with ext2.
Testing has involved a memory-starved virtual machine running 3.5-rc5 that
exports a ~2 GB vfat filesystem containing a kernel tree (~770 MB, ~40000
files, 9 levels). Both 'cp -r' and 'ls -lR' operations were performed
from a client, some overlapping, some consecutive. Exports with
'subtree_check' and 'no_subtree_check' have been tested.
Note that while this patch set improves FAT's NFS support, it does not
eliminate ESTALE errors completely.
The following should be considered for NFS clients who are sensitive to ESTALE:
* Mounting with lookupcache=none
Unfortunately this can degrade performance severely, particularly for deep
filesystems.
* Incorporating VFS patches to retry ESTALE failures on the client-side,
such as https://lkml.org/lkml/2012/6/29/381
* Handling ESTALE errors in client application code
This patch:
Move NFS-related code into its own C file. No functional changes.
Signed-off-by: Steven J. Magnani <steve@digidescorp.com>
Acked-by: OGAWA Hirofumi <hirofumi@mail.parknet.co.jp>
Signed-off-by: Andrew Morton <akpm@linux-foundation.org>
Signed-off-by: Linus Torvalds <torvalds@linux-foundation.org>
2012-10-05 02:14:44 +02:00
|
|
|
|
2008-11-06 21:53:58 +01:00
|
|
|
/* helper for printk */
|
|
|
|
typedef unsigned long long llu;
|
|
|
|
|
2008-11-06 21:53:46 +01:00
|
|
|
#endif /* !_FAT_H */
|