LCOV - code coverage report
Current view: top level - fs/fat - fat.h (source / functions) Hit Total Coverage
Test: Real Lines: 41 66 62.1 %
Date: 2020-10-17 15:46:16 Functions: 0 5 0.0 %
Legend: Neither, QEMU, Real, Both Branches: 0 0 -

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

Generated by: LCOV version 1.14