Branch data     Line data    Source code

       1                 :            : // SPDX-License-Identifier: GPL-2.0-only
       2                 :            : /* fs/fat/nfs.c
       3                 :            :  */
       4                 :            : 
       5                 :            : #include <linux/exportfs.h>
       6                 :            : #include "fat.h"
       7                 :            : 
       8                 :            : struct fat_fid {
       9                 :            :         u32 i_gen;
      10                 :            :         u32 i_pos_low;
      11                 :            :         u16 i_pos_hi;
      12                 :            :         u16 parent_i_pos_hi;
      13                 :            :         u32 parent_i_pos_low;
      14                 :            :         u32 parent_i_gen;
      15                 :            : };
      16                 :            : 
      17                 :            : #define FAT_FID_SIZE_WITHOUT_PARENT 3
      18                 :            : #define FAT_FID_SIZE_WITH_PARENT (sizeof(struct fat_fid)/sizeof(u32))
      19                 :            : 
      20                 :            : /**
      21                 :            :  * Look up a directory inode given its starting cluster.
      22                 :            :  */
      23                 :          0 : static struct inode *fat_dget(struct super_block *sb, int i_logstart)
      24                 :            : {
      25                 :            :         struct msdos_sb_info *sbi = MSDOS_SB(sb);
      26                 :            :         struct hlist_head *head;
      27                 :            :         struct msdos_inode_info *i;
      28                 :            :         struct inode *inode = NULL;
      29                 :            : 
      30                 :            :         head = sbi->dir_hashtable + fat_dir_hash(i_logstart);
      31                 :            :         spin_lock(&sbi->dir_hash_lock);
      32   [ #  #  #  #  :          0 :         hlist_for_each_entry(i, head, i_dir_hash) {
                   #  # ]
      33         [ #  # ]:          0 :                 BUG_ON(i->vfs_inode.i_sb != sb);
      34         [ #  # ]:          0 :                 if (i->i_logstart != i_logstart)
      35                 :          0 :                         continue;
      36                 :          0 :                 inode = igrab(&i->vfs_inode);
      37         [ #  # ]:          0 :                 if (inode)
      38                 :            :                         break;
      39                 :            :         }
      40                 :            :         spin_unlock(&sbi->dir_hash_lock);
      41                 :          0 :         return inode;
      42                 :            : }
      43                 :            : 
      44                 :          0 : static struct inode *fat_ilookup(struct super_block *sb, u64 ino, loff_t i_pos)
      45                 :            : {
      46         [ #  # ]:          0 :         if (MSDOS_SB(sb)->options.nfs == FAT_NFS_NOSTALE_RO)
      47                 :          0 :                 return fat_iget(sb, i_pos);
      48                 :            : 
      49                 :            :         else {
      50         [ #  # ]:          0 :                 if ((ino < MSDOS_ROOT_INO) || (ino == MSDOS_FSINFO_INO))
      51                 :            :                         return NULL;
      52                 :          0 :                 return ilookup(sb, ino);
      53                 :            :         }
      54                 :            : }
      55                 :            : 
      56                 :          0 : static struct inode *__fat_nfs_get_inode(struct super_block *sb,
      57                 :            :                                        u64 ino, u32 generation, loff_t i_pos)
      58                 :            : {
      59                 :          0 :         struct inode *inode = fat_ilookup(sb, ino, i_pos);
      60                 :            : 
      61   [ #  #  #  # ]:          0 :         if (inode && generation && (inode->i_generation != generation)) {
      62                 :          0 :                 iput(inode);
      63                 :            :                 inode = NULL;
      64                 :            :         }
      65   [ #  #  #  # ]:          0 :         if (inode == NULL && MSDOS_SB(sb)->options.nfs == FAT_NFS_NOSTALE_RO) {
      66                 :            :                 struct buffer_head *bh = NULL;
      67                 :            :                 struct msdos_dir_entry *de ;
      68                 :            :                 sector_t blocknr;
      69                 :            :                 int offset;
      70                 :            :                 fat_get_blknr_offset(MSDOS_SB(sb), i_pos, &blocknr, &offset);
      71                 :            :                 bh = sb_bread(sb, blocknr);
      72         [ #  # ]:          0 :                 if (!bh) {
      73                 :          0 :                         fat_msg(sb, KERN_ERR,
      74                 :            :                                 "unable to read block(%llu) for building NFS inode",
      75                 :            :                                 (llu)blocknr);
      76                 :            :                         return inode;
      77                 :            :                 }
      78                 :          0 :                 de = (struct msdos_dir_entry *)bh->b_data;
      79                 :            :                 /* If a file is deleted on server and client is not updated
      80                 :            :                  * yet, we must not build the inode upon a lookup call.
      81                 :            :                  */
      82         [ #  # ]:          0 :                 if (IS_FREE(de[offset].name))
      83                 :            :                         inode = NULL;
      84                 :            :                 else
      85                 :          0 :                         inode = fat_build_inode(sb, &de[offset], i_pos);
      86                 :            :                 brelse(bh);
      87                 :            :         }
      88                 :            : 
      89                 :          0 :         return inode;
      90                 :            : }
      91                 :            : 
      92                 :          0 : static struct inode *fat_nfs_get_inode(struct super_block *sb,
      93                 :            :                                        u64 ino, u32 generation)
      94                 :            : {
      95                 :            : 
      96                 :          0 :         return __fat_nfs_get_inode(sb, ino, generation, 0);
      97                 :            : }
      98                 :            : 
      99                 :            : static int
     100                 :          0 : fat_encode_fh_nostale(struct inode *inode, __u32 *fh, int *lenp,
     101                 :            :                       struct inode *parent)
     102                 :            : {
     103                 :          0 :         int len = *lenp;
     104                 :          0 :         struct msdos_sb_info *sbi = MSDOS_SB(inode->i_sb);
     105                 :            :         struct fat_fid *fid = (struct fat_fid *) fh;
     106                 :            :         loff_t i_pos;
     107                 :            :         int type = FILEID_FAT_WITHOUT_PARENT;
     108                 :            : 
     109         [ #  # ]:          0 :         if (parent) {
     110         [ #  # ]:          0 :                 if (len < FAT_FID_SIZE_WITH_PARENT) {
     111                 :          0 :                         *lenp = FAT_FID_SIZE_WITH_PARENT;
     112                 :          0 :                         return FILEID_INVALID;
     113                 :            :                 }
     114                 :            :         } else {
     115         [ #  # ]:          0 :                 if (len < FAT_FID_SIZE_WITHOUT_PARENT) {
     116                 :          0 :                         *lenp = FAT_FID_SIZE_WITHOUT_PARENT;
     117                 :          0 :                         return FILEID_INVALID;
     118                 :            :                 }
     119                 :            :         }
     120                 :            : 
     121                 :            :         i_pos = fat_i_pos_read(sbi, inode);
     122                 :          0 :         *lenp = FAT_FID_SIZE_WITHOUT_PARENT;
     123                 :          0 :         fid->i_gen = inode->i_generation;
     124                 :          0 :         fid->i_pos_low = i_pos & 0xFFFFFFFF;
     125                 :          0 :         fid->i_pos_hi = (i_pos >> 32) & 0xFFFF;
     126         [ #  # ]:          0 :         if (parent) {
     127                 :            :                 i_pos = fat_i_pos_read(sbi, parent);
     128                 :          0 :                 fid->parent_i_pos_hi = (i_pos >> 32) & 0xFFFF;
     129                 :          0 :                 fid->parent_i_pos_low = i_pos & 0xFFFFFFFF;
     130                 :          0 :                 fid->parent_i_gen = parent->i_generation;
     131                 :            :                 type = FILEID_FAT_WITH_PARENT;
     132                 :          0 :                 *lenp = FAT_FID_SIZE_WITH_PARENT;
     133                 :            :         }
     134                 :            : 
     135                 :          0 :         return type;
     136                 :            : }
     137                 :            : 
     138                 :            : /**
     139                 :            :  * Map a NFS file handle to a corresponding dentry.
     140                 :            :  * The dentry may or may not be connected to the filesystem root.
     141                 :            :  */
     142                 :          0 : static struct dentry *fat_fh_to_dentry(struct super_block *sb, struct fid *fid,
     143                 :            :                                 int fh_len, int fh_type)
     144                 :            : {
     145                 :          0 :         return generic_fh_to_dentry(sb, fid, fh_len, fh_type,
     146                 :            :                                     fat_nfs_get_inode);
     147                 :            : }
     148                 :            : 
     149                 :          0 : static struct dentry *fat_fh_to_dentry_nostale(struct super_block *sb,
     150                 :            :                                                struct fid *fh, int fh_len,
     151                 :            :                                                int fh_type)
     152                 :            : {
     153                 :            :         struct inode *inode = NULL;
     154                 :            :         struct fat_fid *fid = (struct fat_fid *)fh;
     155                 :            :         loff_t i_pos;
     156                 :            : 
     157      [ #  #  # ]:          0 :         switch (fh_type) {
     158                 :            :         case FILEID_FAT_WITHOUT_PARENT:
     159         [ #  # ]:          0 :                 if (fh_len < FAT_FID_SIZE_WITHOUT_PARENT)
     160                 :            :                         return NULL;
     161                 :            :                 break;
     162                 :            :         case FILEID_FAT_WITH_PARENT:
     163         [ #  # ]:          0 :                 if (fh_len < FAT_FID_SIZE_WITH_PARENT)
     164                 :            :                         return NULL;
     165                 :            :                 break;
     166                 :            :         default:
     167                 :            :                 return NULL;
     168                 :            :         }
     169                 :          0 :         i_pos = fid->i_pos_hi;
     170                 :          0 :         i_pos = (i_pos << 32) | (fid->i_pos_low);
     171                 :          0 :         inode = __fat_nfs_get_inode(sb, 0, fid->i_gen, i_pos);
     172                 :            : 
     173                 :          0 :         return d_obtain_alias(inode);
     174                 :            : }
     175                 :            : 
     176                 :            : /*
     177                 :            :  * Find the parent for a file specified by NFS handle.
     178                 :            :  * This requires that the handle contain the i_ino of the parent.
     179                 :            :  */
     180                 :          0 : static struct dentry *fat_fh_to_parent(struct super_block *sb, struct fid *fid,
     181                 :            :                                 int fh_len, int fh_type)
     182                 :            : {
     183                 :          0 :         return generic_fh_to_parent(sb, fid, fh_len, fh_type,
     184                 :            :                                     fat_nfs_get_inode);
     185                 :            : }
     186                 :            : 
     187                 :          0 : static struct dentry *fat_fh_to_parent_nostale(struct super_block *sb,
     188                 :            :                                                struct fid *fh, int fh_len,
     189                 :            :                                                int fh_type)
     190                 :            : {
     191                 :            :         struct inode *inode = NULL;
     192                 :            :         struct fat_fid *fid = (struct fat_fid *)fh;
     193                 :            :         loff_t i_pos;
     194                 :            : 
     195         [ #  # ]:          0 :         if (fh_len < FAT_FID_SIZE_WITH_PARENT)
     196                 :            :                 return NULL;
     197                 :            : 
     198         [ #  # ]:          0 :         switch (fh_type) {
     199                 :            :         case FILEID_FAT_WITH_PARENT:
     200                 :          0 :                 i_pos = fid->parent_i_pos_hi;
     201                 :          0 :                 i_pos = (i_pos << 32) | (fid->parent_i_pos_low);
     202                 :          0 :                 inode = __fat_nfs_get_inode(sb, 0, fid->parent_i_gen, i_pos);
     203                 :          0 :                 break;
     204                 :            :         }
     205                 :            : 
     206                 :          0 :         return d_obtain_alias(inode);
     207                 :            : }
     208                 :            : 
     209                 :            : /*
     210                 :            :  * Rebuild the parent for a directory that is not connected
     211                 :            :  *  to the filesystem root
     212                 :            :  */
     213                 :            : static
     214                 :          0 : struct inode *fat_rebuild_parent(struct super_block *sb, int parent_logstart)
     215                 :            : {
     216                 :            :         int search_clus, clus_to_match;
     217                 :            :         struct msdos_dir_entry *de;
     218                 :            :         struct inode *parent = NULL;
     219                 :            :         struct inode *dummy_grand_parent = NULL;
     220                 :            :         struct fat_slot_info sinfo;
     221                 :            :         struct msdos_sb_info *sbi = MSDOS_SB(sb);
     222                 :            :         sector_t blknr = fat_clus_to_blknr(sbi, parent_logstart);
     223                 :            :         struct buffer_head *parent_bh = sb_bread(sb, blknr);
     224         [ #  # ]:          0 :         if (!parent_bh) {
     225                 :          0 :                 fat_msg(sb, KERN_ERR,
     226                 :            :                         "unable to read cluster of parent directory");
     227                 :          0 :                 return NULL;
     228                 :            :         }
     229                 :            : 
     230                 :          0 :         de = (struct msdos_dir_entry *) parent_bh->b_data;
     231                 :            :         clus_to_match = fat_get_start(sbi, &de[0]);
     232                 :            :         search_clus = fat_get_start(sbi, &de[1]);
     233                 :            : 
     234                 :          0 :         dummy_grand_parent = fat_dget(sb, search_clus);
     235         [ #  # ]:          0 :         if (!dummy_grand_parent) {
     236                 :          0 :                 dummy_grand_parent = new_inode(sb);
     237         [ #  # ]:          0 :                 if (!dummy_grand_parent) {
     238                 :            :                         brelse(parent_bh);
     239                 :            :                         return parent;
     240                 :            :                 }
     241                 :            : 
     242                 :          0 :                 dummy_grand_parent->i_ino = iunique(sb, MSDOS_ROOT_INO);
     243                 :          0 :                 fat_fill_inode(dummy_grand_parent, &de[1]);
     244                 :          0 :                 MSDOS_I(dummy_grand_parent)->i_pos = -1;
     245                 :            :         }
     246                 :            : 
     247         [ #  # ]:          0 :         if (!fat_scan_logstart(dummy_grand_parent, clus_to_match, &sinfo))
     248                 :          0 :                 parent = fat_build_inode(sb, sinfo.de, sinfo.i_pos);
     249                 :            : 
     250                 :            :         brelse(parent_bh);
     251                 :          0 :         iput(dummy_grand_parent);
     252                 :            : 
     253                 :          0 :         return parent;
     254                 :            : }
     255                 :            : 
     256                 :            : /*
     257                 :            :  * Find the parent for a directory that is not currently connected to
     258                 :            :  * the filesystem root.
     259                 :            :  *
     260                 :            :  * On entry, the caller holds d_inode(child_dir)->i_mutex.
     261                 :            :  */
     262                 :          0 : static struct dentry *fat_get_parent(struct dentry *child_dir)
     263                 :            : {
     264                 :          0 :         struct super_block *sb = child_dir->d_sb;
     265                 :          0 :         struct buffer_head *bh = NULL;
     266                 :            :         struct msdos_dir_entry *de;
     267                 :            :         struct inode *parent_inode = NULL;
     268                 :            :         struct msdos_sb_info *sbi = MSDOS_SB(sb);
     269                 :            : 
     270         [ #  # ]:          0 :         if (!fat_get_dotdot_entry(d_inode(child_dir), &bh, &de)) {
     271                 :          0 :                 int parent_logstart = fat_get_start(sbi, de);
     272                 :          0 :                 parent_inode = fat_dget(sb, parent_logstart);
     273   [ #  #  #  # ]:          0 :                 if (!parent_inode && sbi->options.nfs == FAT_NFS_NOSTALE_RO)
     274                 :          0 :                         parent_inode = fat_rebuild_parent(sb, parent_logstart);
     275                 :            :         }
     276                 :          0 :         brelse(bh);
     277                 :            : 
     278                 :          0 :         return d_obtain_alias(parent_inode);
     279                 :            : }
     280                 :            : 
     281                 :            : const struct export_operations fat_export_ops = {
     282                 :            :         .fh_to_dentry   = fat_fh_to_dentry,
     283                 :            :         .fh_to_parent   = fat_fh_to_parent,
     284                 :            :         .get_parent     = fat_get_parent,
     285                 :            : };
     286                 :            : 
     287                 :            : const struct export_operations fat_export_ops_nostale = {
     288                 :            :         .encode_fh      = fat_encode_fh_nostale,
     289                 :            :         .fh_to_dentry   = fat_fh_to_dentry_nostale,
     290                 :            :         .fh_to_parent   = fat_fh_to_parent_nostale,
     291                 :            :         .get_parent     = fat_get_parent,
     292                 :            : };