fs/fat/nfs.c

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