fs/fat/nfs.c

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