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 8struct 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 */ 23static 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 44static 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 56static 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 92static 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 99static int 100fat_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 */ 148static 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 155static 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 */ 186static 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 193static 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 */ 219static 220struct 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 */ 268static 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 287const 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 294const 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}; 300