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 child_dir->d_inode->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(child_dir->d_inode, &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 }; 302