LCOV - code coverage report
Current view: top level - fs/fat - fat.h (source / functions) Hit Total Coverage
Test: coverage.info Lines: 0 53 0.0 %
Date: 2014-02-18 Functions: 0 0 -
Branches: 0 76 0.0 %

           Branch data     Line data    Source code
       1                 :            : #ifndef _FAT_H
       2                 :            : #define _FAT_H
       3                 :            : 
       4                 :            : #include <linux/buffer_head.h>
       5                 :            : #include <linux/string.h>
       6                 :            : #include <linux/nls.h>
       7                 :            : #include <linux/fs.h>
       8                 :            : #include <linux/hash.h>
       9                 :            : #include <linux/mutex.h>
      10                 :            : #include <linux/ratelimit.h>
      11                 :            : #include <linux/msdos_fs.h>
      12                 :            : 
      13                 :            : /*
      14                 :            :  * vfat shortname flags
      15                 :            :  */
      16                 :            : #define VFAT_SFN_DISPLAY_LOWER  0x0001 /* convert to lowercase for display */
      17                 :            : #define VFAT_SFN_DISPLAY_WIN95  0x0002 /* emulate win95 rule for display */
      18                 :            : #define VFAT_SFN_DISPLAY_WINNT  0x0004 /* emulate winnt rule for display */
      19                 :            : #define VFAT_SFN_CREATE_WIN95   0x0100 /* emulate win95 rule for create */
      20                 :            : #define VFAT_SFN_CREATE_WINNT   0x0200 /* emulate winnt rule for create */
      21                 :            : 
      22                 :            : #define FAT_ERRORS_CONT         1      /* ignore error and continue */
      23                 :            : #define FAT_ERRORS_PANIC        2      /* panic on error */
      24                 :            : #define FAT_ERRORS_RO           3      /* remount r/o on error */
      25                 :            : 
      26                 :            : #define FAT_NFS_STALE_RW        1      /* NFS RW support, can cause ESTALE */
      27                 :            : #define FAT_NFS_NOSTALE_RO      2      /* NFS RO support, no ESTALE issue */
      28                 :            : 
      29                 :            : struct fat_mount_options {
      30                 :            :         kuid_t fs_uid;
      31                 :            :         kgid_t fs_gid;
      32                 :            :         unsigned short fs_fmask;
      33                 :            :         unsigned short fs_dmask;
      34                 :            :         unsigned short codepage;   /* Codepage for shortname conversions */
      35                 :            :         int time_offset;           /* Offset of timestamps from UTC (in minutes) */
      36                 :            :         char *iocharset;           /* Charset used for filename input/display */
      37                 :            :         unsigned short shortname;  /* flags for shortname display/create rule */
      38                 :            :         unsigned char name_check;  /* r = relaxed, n = normal, s = strict */
      39                 :            :         unsigned char errors;      /* On error: continue, panic, remount-ro */
      40                 :            :         unsigned char nfs;        /* NFS support: nostale_ro, stale_rw */
      41                 :            :         unsigned short allow_utime;/* permission for setting the [am]time */
      42                 :            :         unsigned quiet:1,          /* set = fake successful chmods and chowns */
      43                 :            :                  showexec:1,       /* set = only set x bit for com/exe/bat */
      44                 :            :                  sys_immutable:1,  /* set = system files are immutable */
      45                 :            :                  dotsOK:1,         /* set = hidden and system files are named '.filename' */
      46                 :            :                  isvfat:1,         /* 0=no vfat long filename support, 1=vfat support */
      47                 :            :                  utf8:1,           /* Use of UTF-8 character set (Default) */
      48                 :            :                  unicode_xlate:1,  /* create escape sequences for unhandled Unicode */
      49                 :            :                  numtail:1,        /* Does first alias have a numeric '~1' type tail? */
      50                 :            :                  flush:1,          /* write things quickly */
      51                 :            :                  nocase:1,         /* Does this need case conversion? 0=need case conversion*/
      52                 :            :                  usefree:1,        /* Use free_clusters for FAT32 */
      53                 :            :                  tz_set:1,         /* Filesystem timestamps' offset set */
      54                 :            :                  rodir:1,          /* allow ATTR_RO for directory */
      55                 :            :                  discard:1;        /* Issue discard requests on deletions */
      56                 :            : };
      57                 :            : 
      58                 :            : #define FAT_HASH_BITS   8
      59                 :            : #define FAT_HASH_SIZE   (1UL << FAT_HASH_BITS)
      60                 :            : 
      61                 :            : /*
      62                 :            :  * MS-DOS file system in-core superblock data
      63                 :            :  */
      64                 :            : struct msdos_sb_info {
      65                 :            :         unsigned short sec_per_clus;  /* sectors/cluster */
      66                 :            :         unsigned short cluster_bits;  /* log2(cluster_size) */
      67                 :            :         unsigned int cluster_size;    /* cluster size */
      68                 :            :         unsigned char fats, fat_bits; /* number of FATs, FAT bits (12 or 16) */
      69                 :            :         unsigned short fat_start;
      70                 :            :         unsigned long fat_length;     /* FAT start & length (sec.) */
      71                 :            :         unsigned long dir_start;
      72                 :            :         unsigned short dir_entries;   /* root dir start & entries */
      73                 :            :         unsigned long data_start;     /* first data sector */
      74                 :            :         unsigned long max_cluster;    /* maximum cluster number */
      75                 :            :         unsigned long root_cluster;   /* first cluster of the root directory */
      76                 :            :         unsigned long fsinfo_sector;  /* sector number of FAT32 fsinfo */
      77                 :            :         struct mutex fat_lock;
      78                 :            :         struct mutex nfs_build_inode_lock;
      79                 :            :         struct mutex s_lock;
      80                 :            :         unsigned int prev_free;      /* previously allocated cluster number */
      81                 :            :         unsigned int free_clusters;  /* -1 if undefined */
      82                 :            :         unsigned int free_clus_valid; /* is free_clusters valid? */
      83                 :            :         struct fat_mount_options options;
      84                 :            :         struct nls_table *nls_disk;   /* Codepage used on disk */
      85                 :            :         struct nls_table *nls_io;     /* Charset used for input and display */
      86                 :            :         const void *dir_ops;          /* Opaque; default directory operations */
      87                 :            :         int dir_per_block;            /* dir entries per block */
      88                 :            :         int dir_per_block_bits;       /* log2(dir_per_block) */
      89                 :            :         unsigned int vol_id;            /*volume ID*/
      90                 :            : 
      91                 :            :         int fatent_shift;
      92                 :            :         struct fatent_operations *fatent_ops;
      93                 :            :         struct inode *fat_inode;
      94                 :            :         struct inode *fsinfo_inode;
      95                 :            : 
      96                 :            :         struct ratelimit_state ratelimit;
      97                 :            : 
      98                 :            :         spinlock_t inode_hash_lock;
      99                 :            :         struct hlist_head inode_hashtable[FAT_HASH_SIZE];
     100                 :            : 
     101                 :            :         spinlock_t dir_hash_lock;
     102                 :            :         struct hlist_head dir_hashtable[FAT_HASH_SIZE];
     103                 :            : 
     104                 :            :         unsigned int dirty;           /* fs state before mount */
     105                 :            :         struct rcu_head rcu;
     106                 :            : };
     107                 :            : 
     108                 :            : #define FAT_CACHE_VALID 0       /* special case for valid cache */
     109                 :            : 
     110                 :            : /*
     111                 :            :  * MS-DOS file system inode data in memory
     112                 :            :  */
     113                 :            : struct msdos_inode_info {
     114                 :            :         spinlock_t cache_lru_lock;
     115                 :            :         struct list_head cache_lru;
     116                 :            :         int nr_caches;
     117                 :            :         /* for avoiding the race between fat_free() and fat_get_cluster() */
     118                 :            :         unsigned int cache_valid_id;
     119                 :            : 
     120                 :            :         /* NOTE: mmu_private is 64bits, so must hold ->i_mutex to access */
     121                 :            :         loff_t mmu_private;     /* physically allocated size */
     122                 :            : 
     123                 :            :         int i_start;            /* first cluster or 0 */
     124                 :            :         int i_logstart;         /* logical first cluster */
     125                 :            :         int i_attrs;            /* unused attribute bits */
     126                 :            :         loff_t i_pos;           /* on-disk position of directory entry or 0 */
     127                 :            :         struct hlist_node i_fat_hash;   /* hash by i_location */
     128                 :            :         struct hlist_node i_dir_hash;   /* hash by i_logstart */
     129                 :            :         struct rw_semaphore truncate_lock; /* protect bmap against truncate */
     130                 :            :         struct inode vfs_inode;
     131                 :            : };
     132                 :            : 
     133                 :            : struct fat_slot_info {
     134                 :            :         loff_t i_pos;           /* on-disk position of directory entry */
     135                 :            :         loff_t slot_off;        /* offset for slot or de start */
     136                 :            :         int nr_slots;           /* number of slots + 1(de) in filename */
     137                 :            :         struct msdos_dir_entry *de;
     138                 :            :         struct buffer_head *bh;
     139                 :            : };
     140                 :            : 
     141                 :            : static inline struct msdos_sb_info *MSDOS_SB(struct super_block *sb)
     142                 :            : {
     143                 :            :         return sb->s_fs_info;
     144                 :            : }
     145                 :            : 
     146                 :            : static inline struct msdos_inode_info *MSDOS_I(struct inode *inode)
     147                 :            : {
     148                 :            :         return container_of(inode, struct msdos_inode_info, vfs_inode);
     149                 :            : }
     150                 :            : 
     151                 :            : /*
     152                 :            :  * If ->i_mode can't hold S_IWUGO (i.e. ATTR_RO), we use ->i_attrs to
     153                 :            :  * save ATTR_RO instead of ->i_mode.
     154                 :            :  *
     155                 :            :  * If it's directory and !sbi->options.rodir, ATTR_RO isn't read-only
     156                 :            :  * bit, it's just used as flag for app.
     157                 :            :  */
     158                 :            : static inline int fat_mode_can_hold_ro(struct inode *inode)
     159                 :            : {
     160                 :          0 :         struct msdos_sb_info *sbi = MSDOS_SB(inode->i_sb);
     161                 :            :         umode_t mask;
     162                 :            : 
     163 [ #  # ][ #  # ]:          0 :         if (S_ISDIR(inode->i_mode)) {
         [ #  # ][ #  # ]
     164 [ #  # ][ #  # ]:          0 :                 if (!sbi->options.rodir)
         [ #  # ][ #  # ]
     165                 :            :                         return 0;
     166                 :          0 :                 mask = ~sbi->options.fs_dmask;
     167                 :            :         } else
     168                 :          0 :                 mask = ~sbi->options.fs_fmask;
     169                 :            : 
     170 [ #  # ][ #  # ]:          0 :         if (!(mask & S_IWUGO))
         [ #  # ][ #  # ]
     171                 :            :                 return 0;
     172                 :            :         return 1;
     173                 :            : }
     174                 :            : 
     175                 :            : /* Convert attribute bits and a mask to the UNIX mode. */
     176                 :            : static inline umode_t fat_make_mode(struct msdos_sb_info *sbi,
     177                 :            :                                    u8 attrs, umode_t mode)
     178                 :            : {
     179 [ #  # ][ #  # ]:          0 :         if (attrs & ATTR_RO && !((attrs & ATTR_DIR) && !sbi->options.rodir))
         [ #  # ][ #  # ]
         [ #  # ][ #  # ]
     180                 :          0 :                 mode &= ~S_IWUGO;
     181                 :            : 
     182 [ #  # ][ #  # ]:          0 :         if (attrs & ATTR_DIR)
     183                 :          0 :                 return (mode & ~sbi->options.fs_dmask) | S_IFDIR;
     184                 :            :         else
     185                 :          0 :                 return (mode & ~sbi->options.fs_fmask) | S_IFREG;
     186                 :            : }
     187                 :            : 
     188                 :            : /* Return the FAT attribute byte for this inode */
     189                 :          0 : static inline u8 fat_make_attrs(struct inode *inode)
     190                 :            : {
     191                 :          0 :         u8 attrs = MSDOS_I(inode)->i_attrs;
     192   [ #  #  #  # ]:          0 :         if (S_ISDIR(inode->i_mode))
     193                 :          0 :                 attrs |= ATTR_DIR;
     194 [ #  # ][ #  # ]:          0 :         if (fat_mode_can_hold_ro(inode) && !(inode->i_mode & S_IWUGO))
         [ #  # ][ #  # ]
     195                 :          0 :                 attrs |= ATTR_RO;
     196                 :            :         return attrs;
     197                 :            : }
     198                 :            : 
     199                 :          0 : static inline void fat_save_attrs(struct inode *inode, u8 attrs)
     200                 :            : {
     201 [ #  # ][ #  # ]:          0 :         if (fat_mode_can_hold_ro(inode))
     202                 :          0 :                 MSDOS_I(inode)->i_attrs = attrs & ATTR_UNUSED;
     203                 :            :         else
     204                 :          0 :                 MSDOS_I(inode)->i_attrs = attrs & (ATTR_UNUSED | ATTR_RO);
     205                 :            : }
     206                 :            : 
     207                 :            : static inline unsigned char fat_checksum(const __u8 *name)
     208                 :            : {
     209                 :          0 :         unsigned char s = name[0];
     210                 :          0 :         s = (s<<7) + (s>>1) + name[1];      s = (s<<7) + (s>>1) + name[2];
     211                 :          0 :         s = (s<<7) + (s>>1) + name[3];      s = (s<<7) + (s>>1) + name[4];
     212                 :          0 :         s = (s<<7) + (s>>1) + name[5];      s = (s<<7) + (s>>1) + name[6];
     213                 :          0 :         s = (s<<7) + (s>>1) + name[7];      s = (s<<7) + (s>>1) + name[8];
     214                 :          0 :         s = (s<<7) + (s>>1) + name[9];      s = (s<<7) + (s>>1) + name[10];
     215                 :            :         return s;
     216                 :            : }
     217                 :            : 
     218                 :            : static inline sector_t fat_clus_to_blknr(struct msdos_sb_info *sbi, int clus)
     219                 :            : {
     220                 :          0 :         return ((sector_t)clus - FAT_START_ENT) * sbi->sec_per_clus
     221                 :          0 :                 + sbi->data_start;
     222                 :            : }
     223                 :            : 
     224                 :            : static inline void fat_get_blknr_offset(struct msdos_sb_info *sbi,
     225                 :            :                                 loff_t i_pos, sector_t *blknr, int *offset)
     226                 :            : {
     227                 :          0 :         *blknr = i_pos >> sbi->dir_per_block_bits;
     228                 :          0 :         *offset = i_pos & (sbi->dir_per_block - 1);
     229                 :            : }
     230                 :            : 
     231                 :            : static inline loff_t fat_i_pos_read(struct msdos_sb_info *sbi,
     232                 :            :                                         struct inode *inode)
     233                 :            : {
     234                 :            :         loff_t i_pos;
     235                 :            : #if BITS_PER_LONG == 32
     236                 :            :         spin_lock(&sbi->inode_hash_lock);
     237                 :            : #endif
     238                 :          0 :         i_pos = MSDOS_I(inode)->i_pos;
     239                 :            : #if BITS_PER_LONG == 32
     240                 :            :         spin_unlock(&sbi->inode_hash_lock);
     241                 :            : #endif
     242                 :            :         return i_pos;
     243                 :            : }
     244                 :            : 
     245                 :            : static inline void fat16_towchar(wchar_t *dst, const __u8 *src, size_t len)
     246                 :            : {
     247                 :            : #ifdef __BIG_ENDIAN
     248                 :            :         while (len--) {
     249                 :            :                 *dst++ = src[0] | (src[1] << 8);
     250                 :            :                 src += 2;
     251                 :            :         }
     252                 :            : #else
     253                 :          0 :         memcpy(dst, src, len * 2);
     254                 :            : #endif
     255                 :            : }
     256                 :            : 
     257                 :            : static inline int fat_get_start(const struct msdos_sb_info *sbi,
     258                 :            :                                 const struct msdos_dir_entry *de)
     259                 :            : {
     260                 :          0 :         int cluster = le16_to_cpu(de->start);
     261 [ #  # ][ #  # ]:          0 :         if (sbi->fat_bits == 32)
                 [ #  # ]
     262                 :          0 :                 cluster |= (le16_to_cpu(de->starthi) << 16);
     263                 :            :         return cluster;
     264                 :            : }
     265                 :            : 
     266                 :            : static inline void fat_set_start(struct msdos_dir_entry *de, int cluster)
     267                 :            : {
     268                 :          0 :         de->start   = cpu_to_le16(cluster);
     269                 :          0 :         de->starthi = cpu_to_le16(cluster >> 16);
     270                 :            : }
     271                 :            : 
     272                 :            : static inline void fatwchar_to16(__u8 *dst, const wchar_t *src, size_t len)
     273                 :            : {
     274                 :            : #ifdef __BIG_ENDIAN
     275                 :            :         while (len--) {
     276                 :            :                 dst[0] = *src & 0x00FF;
     277                 :            :                 dst[1] = (*src & 0xFF00) >> 8;
     278                 :            :                 dst += 2;
     279                 :            :                 src++;
     280                 :            :         }
     281                 :            : #else
     282                 :          0 :         memcpy(dst, src, len * 2);
     283                 :            : #endif
     284                 :            : }
     285                 :            : 
     286                 :            : /* fat/cache.c */
     287                 :            : extern void fat_cache_inval_inode(struct inode *inode);
     288                 :            : extern int fat_get_cluster(struct inode *inode, int cluster,
     289                 :            :                            int *fclus, int *dclus);
     290                 :            : extern int fat_bmap(struct inode *inode, sector_t sector, sector_t *phys,
     291                 :            :                     unsigned long *mapped_blocks, int create);
     292                 :            : 
     293                 :            : /* fat/dir.c */
     294                 :            : extern const struct file_operations fat_dir_operations;
     295                 :            : extern int fat_search_long(struct inode *inode, const unsigned char *name,
     296                 :            :                            int name_len, struct fat_slot_info *sinfo);
     297                 :            : extern int fat_dir_empty(struct inode *dir);
     298                 :            : extern int fat_subdirs(struct inode *dir);
     299                 :            : extern int fat_scan(struct inode *dir, const unsigned char *name,
     300                 :            :                     struct fat_slot_info *sinfo);
     301                 :            : extern int fat_scan_logstart(struct inode *dir, int i_logstart,
     302                 :            :                              struct fat_slot_info *sinfo);
     303                 :            : extern int fat_get_dotdot_entry(struct inode *dir, struct buffer_head **bh,
     304                 :            :                                 struct msdos_dir_entry **de);
     305                 :            : extern int fat_alloc_new_dir(struct inode *dir, struct timespec *ts);
     306                 :            : extern int fat_add_entries(struct inode *dir, void *slots, int nr_slots,
     307                 :            :                            struct fat_slot_info *sinfo);
     308                 :            : extern int fat_remove_entries(struct inode *dir, struct fat_slot_info *sinfo);
     309                 :            : 
     310                 :            : /* fat/fatent.c */
     311                 :            : struct fat_entry {
     312                 :            :         int entry;
     313                 :            :         union {
     314                 :            :                 u8 *ent12_p[2];
     315                 :            :                 __le16 *ent16_p;
     316                 :            :                 __le32 *ent32_p;
     317                 :            :         } u;
     318                 :            :         int nr_bhs;
     319                 :            :         struct buffer_head *bhs[2];
     320                 :            :         struct inode *fat_inode;
     321                 :            : };
     322                 :            : 
     323                 :            : static inline void fatent_init(struct fat_entry *fatent)
     324                 :            : {
     325                 :          0 :         fatent->nr_bhs = 0;
     326                 :          0 :         fatent->entry = 0;
     327                 :          0 :         fatent->u.ent32_p = NULL;
     328                 :          0 :         fatent->bhs[0] = fatent->bhs[1] = NULL;
     329                 :          0 :         fatent->fat_inode = NULL;
     330                 :            : }
     331                 :            : 
     332                 :            : static inline void fatent_set_entry(struct fat_entry *fatent, int entry)
     333                 :            : {
     334                 :          0 :         fatent->entry = entry;
     335                 :          0 :         fatent->u.ent32_p = NULL;
     336                 :            : }
     337                 :            : 
     338                 :            : static inline void fatent_brelse(struct fat_entry *fatent)
     339                 :            : {
     340                 :            :         int i;
     341                 :          0 :         fatent->u.ent32_p = NULL;
     342 [ #  # ][ #  # ]:          0 :         for (i = 0; i < fatent->nr_bhs; i++)
         [ #  # ][ #  # ]
         [ #  # ][ #  # ]
                 [ #  # ]
     343                 :          0 :                 brelse(fatent->bhs[i]);
     344                 :          0 :         fatent->nr_bhs = 0;
     345                 :          0 :         fatent->bhs[0] = fatent->bhs[1] = NULL;
     346                 :          0 :         fatent->fat_inode = NULL;
     347                 :            : }
     348                 :            : 
     349                 :            : extern void fat_ent_access_init(struct super_block *sb);
     350                 :            : extern int fat_ent_read(struct inode *inode, struct fat_entry *fatent,
     351                 :            :                         int entry);
     352                 :            : extern int fat_ent_write(struct inode *inode, struct fat_entry *fatent,
     353                 :            :                          int new, int wait);
     354                 :            : extern int fat_alloc_clusters(struct inode *inode, int *cluster,
     355                 :            :                               int nr_cluster);
     356                 :            : extern int fat_free_clusters(struct inode *inode, int cluster);
     357                 :            : extern int fat_count_free_clusters(struct super_block *sb);
     358                 :            : 
     359                 :            : /* fat/file.c */
     360                 :            : extern long fat_generic_ioctl(struct file *filp, unsigned int cmd,
     361                 :            :                               unsigned long arg);
     362                 :            : extern const struct file_operations fat_file_operations;
     363                 :            : extern const struct inode_operations fat_file_inode_operations;
     364                 :            : extern int fat_setattr(struct dentry *dentry, struct iattr *attr);
     365                 :            : extern void fat_truncate_blocks(struct inode *inode, loff_t offset);
     366                 :            : extern int fat_getattr(struct vfsmount *mnt, struct dentry *dentry,
     367                 :            :                        struct kstat *stat);
     368                 :            : extern int fat_file_fsync(struct file *file, loff_t start, loff_t end,
     369                 :            :                           int datasync);
     370                 :            : 
     371                 :            : /* fat/inode.c */
     372                 :            : extern void fat_attach(struct inode *inode, loff_t i_pos);
     373                 :            : extern void fat_detach(struct inode *inode);
     374                 :            : extern struct inode *fat_iget(struct super_block *sb, loff_t i_pos);
     375                 :            : extern struct inode *fat_build_inode(struct super_block *sb,
     376                 :            :                         struct msdos_dir_entry *de, loff_t i_pos);
     377                 :            : extern int fat_sync_inode(struct inode *inode);
     378                 :            : extern int fat_fill_super(struct super_block *sb, void *data, int silent,
     379                 :            :                           int isvfat, void (*setup)(struct super_block *));
     380                 :            : extern int fat_fill_inode(struct inode *inode, struct msdos_dir_entry *de);
     381                 :            : 
     382                 :            : extern int fat_flush_inodes(struct super_block *sb, struct inode *i1,
     383                 :            :                             struct inode *i2);
     384                 :            : static inline unsigned long fat_dir_hash(int logstart)
     385                 :            : {
     386                 :          0 :         return hash_32(logstart, FAT_HASH_BITS);
     387                 :            : }
     388                 :            : 
     389                 :            : /* fat/misc.c */
     390                 :            : extern __printf(3, 4) __cold
     391                 :            : void __fat_fs_error(struct super_block *sb, int report, const char *fmt, ...);
     392                 :            : #define fat_fs_error(sb, fmt, args...)          \
     393                 :            :         __fat_fs_error(sb, 1, fmt , ## args)
     394                 :            : #define fat_fs_error_ratelimit(sb, fmt, args...) \
     395                 :            :         __fat_fs_error(sb, __ratelimit(&MSDOS_SB(sb)->ratelimit), fmt , ## args)
     396                 :            : __printf(3, 4) __cold
     397                 :            : void fat_msg(struct super_block *sb, const char *level, const char *fmt, ...);
     398                 :            : #define fat_msg_ratelimit(sb, level, fmt, args...)      \
     399                 :            :         do {    \
     400                 :            :                         if (__ratelimit(&MSDOS_SB(sb)->ratelimit))       \
     401                 :            :                                 fat_msg(sb, level, fmt, ## args);       \
     402                 :            :          } while (0)
     403                 :            : extern int fat_clusters_flush(struct super_block *sb);
     404                 :            : extern int fat_chain_add(struct inode *inode, int new_dclus, int nr_cluster);
     405                 :            : extern void fat_time_fat2unix(struct msdos_sb_info *sbi, struct timespec *ts,
     406                 :            :                               __le16 __time, __le16 __date, u8 time_cs);
     407                 :            : extern void fat_time_unix2fat(struct msdos_sb_info *sbi, struct timespec *ts,
     408                 :            :                               __le16 *time, __le16 *date, u8 *time_cs);
     409                 :            : extern int fat_sync_bhs(struct buffer_head **bhs, int nr_bhs);
     410                 :            : 
     411                 :            : int fat_cache_init(void);
     412                 :            : void fat_cache_destroy(void);
     413                 :            : 
     414                 :            : /* fat/nfs.c */
     415                 :            : extern const struct export_operations fat_export_ops;
     416                 :            : extern const struct export_operations fat_export_ops_nostale;
     417                 :            : 
     418                 :            : /* helper for printk */
     419                 :            : typedef unsigned long long      llu;
     420                 :            : 
     421                 :            : #endif /* !_FAT_H */

Generated by: LCOV version 1.9