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(logstart: i_logstart);
31 spin_lock(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(lock: &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(sbi: MSDOS_SB(sb), i_pos, blknr: &blocknr, offset: &offset);
71 bh = sb_bread(sb, block: 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: &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, i_pos: 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(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, inode: 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 }
134
135 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 */
142static struct dentry *fat_fh_to_dentry(struct super_block *sb, struct fid *fid,
143 int fh_len, int fh_type)
144{
145 return generic_fh_to_dentry(sb, fid, fh_len, fh_type,
146 get_inode: fat_nfs_get_inode);
147}
148
149static 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 switch (fh_type) {
158 case FILEID_FAT_WITHOUT_PARENT:
159 if (fh_len < FAT_FID_SIZE_WITHOUT_PARENT)
160 return NULL;
161 break;
162 case FILEID_FAT_WITH_PARENT:
163 if (fh_len < FAT_FID_SIZE_WITH_PARENT)
164 return NULL;
165 break;
166 default:
167 return NULL;
168 }
169 i_pos = fid->i_pos_hi;
170 i_pos = (i_pos << 32) | (fid->i_pos_low);
171 inode = __fat_nfs_get_inode(sb, ino: 0, generation: fid->i_gen, i_pos);
172
173 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 */
180static struct dentry *fat_fh_to_parent(struct super_block *sb, struct fid *fid,
181 int fh_len, int fh_type)
182{
183 return generic_fh_to_parent(sb, fid, fh_len, fh_type,
184 get_inode: fat_nfs_get_inode);
185}
186
187static 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 if (fh_len < FAT_FID_SIZE_WITH_PARENT)
196 return NULL;
197
198 switch (fh_type) {
199 case FILEID_FAT_WITH_PARENT:
200 i_pos = fid->parent_i_pos_hi;
201 i_pos = (i_pos << 32) | (fid->parent_i_pos_low);
202 inode = __fat_nfs_get_inode(sb, ino: 0, generation: fid->parent_i_gen, i_pos);
203 break;
204 }
205
206 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 */
213static
214struct 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, clus: parent_logstart);
223 struct buffer_head *parent_bh = sb_bread(sb, block: blknr);
224 if (!parent_bh) {
225 fat_msg(sb, KERN_ERR,
226 "unable to read cluster of parent directory");
227 return NULL;
228 }
229
230 de = (struct msdos_dir_entry *) parent_bh->b_data;
231 clus_to_match = fat_get_start(sbi, de: &de[0]);
232 search_clus = fat_get_start(sbi, de: &de[1]);
233
234 dummy_grand_parent = fat_dget(sb, i_logstart: search_clus);
235 if (!dummy_grand_parent) {
236 dummy_grand_parent = new_inode(sb);
237 if (!dummy_grand_parent) {
238 brelse(bh: parent_bh);
239 return parent;
240 }
241
242 dummy_grand_parent->i_ino = iunique(sb, MSDOS_ROOT_INO);
243 fat_fill_inode(inode: dummy_grand_parent, de: &de[1]);
244 MSDOS_I(inode: dummy_grand_parent)->i_pos = -1;
245 }
246
247 if (!fat_scan_logstart(dir: dummy_grand_parent, i_logstart: clus_to_match, sinfo: &sinfo))
248 parent = fat_build_inode(sb, de: sinfo.de, i_pos: sinfo.i_pos);
249
250 brelse(bh: parent_bh);
251 iput(dummy_grand_parent);
252
253 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 */
262static struct dentry *fat_get_parent(struct dentry *child_dir)
263{
264 struct super_block *sb = child_dir->d_sb;
265 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 if (!fat_get_dotdot_entry(dir: d_inode(dentry: child_dir), bh: &bh, de: &de)) {
271 int parent_logstart = fat_get_start(sbi, de);
272 parent_inode = fat_dget(sb, i_logstart: parent_logstart);
273 if (!parent_inode && sbi->options.nfs == FAT_NFS_NOSTALE_RO)
274 parent_inode = fat_rebuild_parent(sb, parent_logstart);
275 }
276 brelse(bh);
277
278 return d_obtain_alias(parent_inode);
279}
280
281const struct export_operations fat_export_ops = {
282 .encode_fh = generic_encode_ino32_fh,
283 .fh_to_dentry = fat_fh_to_dentry,
284 .fh_to_parent = fat_fh_to_parent,
285 .get_parent = fat_get_parent,
286};
287
288const struct export_operations fat_export_ops_nostale = {
289 .encode_fh = fat_encode_fh_nostale,
290 .fh_to_dentry = fat_fh_to_dentry_nostale,
291 .fh_to_parent = fat_fh_to_parent_nostale,
292 .get_parent = fat_get_parent,
293};
294

source code of linux/fs/fat/nfs.c