Branch data Line data Source code
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 : 0 : static struct inode *fat_dget(struct super_block *sb, int i_logstart)
24 : : {
25 : 0 : struct msdos_sb_info *sbi = MSDOS_SB(sb);
26 : 0 : struct hlist_head *head;
27 : 0 : struct msdos_inode_info *i;
28 : 0 : struct inode *inode = NULL;
29 : :
30 : 0 : head = sbi->dir_hashtable + fat_dir_hash(i_logstart);
31 : 0 : spin_lock(&sbi->dir_hash_lock);
32 [ # # # # : 0 : hlist_for_each_entry(i, head, i_dir_hash) {
# # ]
33 [ # # ]: 0 : BUG_ON(i->vfs_inode.i_sb != sb);
34 [ # # ]: 0 : if (i->i_logstart != i_logstart)
35 : 0 : continue;
36 : 0 : inode = igrab(&i->vfs_inode);
37 [ # # ]: 0 : if (inode)
38 : : break;
39 : : }
40 : 0 : spin_unlock(&sbi->dir_hash_lock);
41 : 0 : return inode;
42 : : }
43 : :
44 : 0 : static struct inode *fat_ilookup(struct super_block *sb, u64 ino, loff_t i_pos)
45 : : {
46 [ # # ]: 0 : if (MSDOS_SB(sb)->options.nfs == FAT_NFS_NOSTALE_RO)
47 : 0 : return fat_iget(sb, i_pos);
48 : :
49 : : else {
50 [ # # ]: 0 : if ((ino < MSDOS_ROOT_INO) || (ino == MSDOS_FSINFO_INO))
51 : : return NULL;
52 : 0 : return ilookup(sb, ino);
53 : : }
54 : : }
55 : :
56 : 0 : static struct inode *__fat_nfs_get_inode(struct super_block *sb,
57 : : u64 ino, u32 generation, loff_t i_pos)
58 : : {
59 : 0 : struct inode *inode = fat_ilookup(sb, ino, i_pos);
60 : :
61 [ # # # # ]: 0 : if (inode && generation && (inode->i_generation != generation)) {
62 : 0 : iput(inode);
63 : 0 : inode = NULL;
64 : : }
65 [ # # # # ]: 0 : if (inode == NULL && MSDOS_SB(sb)->options.nfs == FAT_NFS_NOSTALE_RO) {
66 : 0 : struct buffer_head *bh = NULL;
67 : 0 : struct msdos_dir_entry *de ;
68 : 0 : sector_t blocknr;
69 : 0 : int offset;
70 : 0 : fat_get_blknr_offset(MSDOS_SB(sb), i_pos, &blocknr, &offset);
71 : 0 : bh = sb_bread(sb, blocknr);
72 [ # # ]: 0 : if (!bh) {
73 : 0 : fat_msg(sb, KERN_ERR,
74 : : "unable to read block(%llu) for building NFS inode",
75 : : (llu)blocknr);
76 : 0 : return inode;
77 : : }
78 : 0 : 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 [ # # ]: 0 : if (IS_FREE(de[offset].name))
83 : : inode = NULL;
84 : : else
85 : 0 : inode = fat_build_inode(sb, &de[offset], i_pos);
86 : 0 : brelse(bh);
87 : : }
88 : :
89 : : return inode;
90 : : }
91 : :
92 : 0 : static struct inode *fat_nfs_get_inode(struct super_block *sb,
93 : : u64 ino, u32 generation)
94 : : {
95 : :
96 : 0 : return __fat_nfs_get_inode(sb, ino, generation, 0);
97 : : }
98 : :
99 : : static int
100 : 0 : fat_encode_fh_nostale(struct inode *inode, __u32 *fh, int *lenp,
101 : : struct inode *parent)
102 : : {
103 : 0 : int len = *lenp;
104 [ # # ]: 0 : struct msdos_sb_info *sbi = MSDOS_SB(inode->i_sb);
105 : 0 : struct fat_fid *fid = (struct fat_fid *) fh;
106 : 0 : loff_t i_pos;
107 : 0 : int type = FILEID_FAT_WITHOUT_PARENT;
108 : :
109 [ # # ]: 0 : if (parent) {
110 [ # # ]: 0 : if (len < FAT_FID_SIZE_WITH_PARENT) {
111 : 0 : *lenp = FAT_FID_SIZE_WITH_PARENT;
112 : 0 : return FILEID_INVALID;
113 : : }
114 : : } else {
115 [ # # ]: 0 : if (len < FAT_FID_SIZE_WITHOUT_PARENT) {
116 : 0 : *lenp = FAT_FID_SIZE_WITHOUT_PARENT;
117 : 0 : return FILEID_INVALID;
118 : : }
119 : : }
120 : :
121 [ # # ]: 0 : i_pos = fat_i_pos_read(sbi, inode);
122 : 0 : *lenp = FAT_FID_SIZE_WITHOUT_PARENT;
123 : 0 : fid->i_gen = inode->i_generation;
124 : 0 : fid->i_pos_low = i_pos & 0xFFFFFFFF;
125 : 0 : fid->i_pos_hi = (i_pos >> 32) & 0xFFFF;
126 [ # # ]: 0 : if (parent) {
127 : 0 : i_pos = fat_i_pos_read(sbi, parent);
128 : 0 : fid->parent_i_pos_hi = (i_pos >> 32) & 0xFFFF;
129 : 0 : fid->parent_i_pos_low = i_pos & 0xFFFFFFFF;
130 : 0 : fid->parent_i_gen = parent->i_generation;
131 : 0 : type = FILEID_FAT_WITH_PARENT;
132 : 0 : *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 : : */
142 : 0 : static struct dentry *fat_fh_to_dentry(struct super_block *sb, struct fid *fid,
143 : : int fh_len, int fh_type)
144 : : {
145 : 0 : return generic_fh_to_dentry(sb, fid, fh_len, fh_type,
146 : : fat_nfs_get_inode);
147 : : }
148 : :
149 : 0 : static struct dentry *fat_fh_to_dentry_nostale(struct super_block *sb,
150 : : struct fid *fh, int fh_len,
151 : : int fh_type)
152 : : {
153 : 0 : struct inode *inode = NULL;
154 : 0 : struct fat_fid *fid = (struct fat_fid *)fh;
155 : 0 : loff_t i_pos;
156 : :
157 [ # # # ]: 0 : switch (fh_type) {
158 : 0 : case FILEID_FAT_WITHOUT_PARENT:
159 [ # # ]: 0 : if (fh_len < FAT_FID_SIZE_WITHOUT_PARENT)
160 : : return NULL;
161 : : break;
162 : 0 : case FILEID_FAT_WITH_PARENT:
163 [ # # ]: 0 : if (fh_len < FAT_FID_SIZE_WITH_PARENT)
164 : : return NULL;
165 : : break;
166 : : default:
167 : : return NULL;
168 : : }
169 : 0 : i_pos = fid->i_pos_hi;
170 : 0 : i_pos = (i_pos << 32) | (fid->i_pos_low);
171 : 0 : inode = __fat_nfs_get_inode(sb, 0, fid->i_gen, i_pos);
172 : :
173 : 0 : 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 : : */
180 : 0 : static struct dentry *fat_fh_to_parent(struct super_block *sb, struct fid *fid,
181 : : int fh_len, int fh_type)
182 : : {
183 : 0 : return generic_fh_to_parent(sb, fid, fh_len, fh_type,
184 : : fat_nfs_get_inode);
185 : : }
186 : :
187 : 0 : static struct dentry *fat_fh_to_parent_nostale(struct super_block *sb,
188 : : struct fid *fh, int fh_len,
189 : : int fh_type)
190 : : {
191 : 0 : struct inode *inode = NULL;
192 : 0 : struct fat_fid *fid = (struct fat_fid *)fh;
193 : 0 : loff_t i_pos;
194 : :
195 [ # # ]: 0 : if (fh_len < FAT_FID_SIZE_WITH_PARENT)
196 : : return NULL;
197 : :
198 [ # # ]: 0 : switch (fh_type) {
199 : 0 : case FILEID_FAT_WITH_PARENT:
200 : 0 : i_pos = fid->parent_i_pos_hi;
201 : 0 : i_pos = (i_pos << 32) | (fid->parent_i_pos_low);
202 : 0 : inode = __fat_nfs_get_inode(sb, 0, fid->parent_i_gen, i_pos);
203 : 0 : break;
204 : : }
205 : :
206 : 0 : 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 : : */
213 : : static
214 : 0 : struct inode *fat_rebuild_parent(struct super_block *sb, int parent_logstart)
215 : : {
216 : 0 : int search_clus, clus_to_match;
217 : 0 : struct msdos_dir_entry *de;
218 : 0 : struct inode *parent = NULL;
219 : 0 : struct inode *dummy_grand_parent = NULL;
220 : 0 : struct fat_slot_info sinfo;
221 : 0 : struct msdos_sb_info *sbi = MSDOS_SB(sb);
222 : 0 : sector_t blknr = fat_clus_to_blknr(sbi, parent_logstart);
223 : 0 : struct buffer_head *parent_bh = sb_bread(sb, blknr);
224 [ # # ]: 0 : if (!parent_bh) {
225 : 0 : fat_msg(sb, KERN_ERR,
226 : : "unable to read cluster of parent directory");
227 : 0 : return NULL;
228 : : }
229 : :
230 : 0 : de = (struct msdos_dir_entry *) parent_bh->b_data;
231 [ # # ]: 0 : clus_to_match = fat_get_start(sbi, &de[0]);
232 [ # # ]: 0 : search_clus = fat_get_start(sbi, &de[1]);
233 : :
234 : 0 : dummy_grand_parent = fat_dget(sb, search_clus);
235 [ # # ]: 0 : if (!dummy_grand_parent) {
236 : 0 : dummy_grand_parent = new_inode(sb);
237 [ # # ]: 0 : if (!dummy_grand_parent) {
238 : 0 : brelse(parent_bh);
239 : 0 : return parent;
240 : : }
241 : :
242 : 0 : dummy_grand_parent->i_ino = iunique(sb, MSDOS_ROOT_INO);
243 : 0 : fat_fill_inode(dummy_grand_parent, &de[1]);
244 : 0 : MSDOS_I(dummy_grand_parent)->i_pos = -1;
245 : : }
246 : :
247 [ # # ]: 0 : if (!fat_scan_logstart(dummy_grand_parent, clus_to_match, &sinfo))
248 : 0 : parent = fat_build_inode(sb, sinfo.de, sinfo.i_pos);
249 : :
250 : 0 : brelse(parent_bh);
251 : 0 : iput(dummy_grand_parent);
252 : :
253 : 0 : 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 : : */
262 : 0 : static struct dentry *fat_get_parent(struct dentry *child_dir)
263 : : {
264 : 0 : struct super_block *sb = child_dir->d_sb;
265 : 0 : struct buffer_head *bh = NULL;
266 : 0 : struct msdos_dir_entry *de;
267 : 0 : struct inode *parent_inode = NULL;
268 : 0 : struct msdos_sb_info *sbi = MSDOS_SB(sb);
269 : :
270 [ # # ]: 0 : if (!fat_get_dotdot_entry(d_inode(child_dir), &bh, &de)) {
271 [ # # ]: 0 : int parent_logstart = fat_get_start(sbi, de);
272 : 0 : parent_inode = fat_dget(sb, parent_logstart);
273 [ # # # # ]: 0 : if (!parent_inode && sbi->options.nfs == FAT_NFS_NOSTALE_RO)
274 : 0 : parent_inode = fat_rebuild_parent(sb, parent_logstart);
275 : : }
276 [ # # ]: 0 : brelse(bh);
277 : :
278 : 0 : return d_obtain_alias(parent_inode);
279 : : }
280 : :
281 : : const struct export_operations fat_export_ops = {
282 : : .fh_to_dentry = fat_fh_to_dentry,
283 : : .fh_to_parent = fat_fh_to_parent,
284 : : .get_parent = fat_get_parent,
285 : : };
286 : :
287 : : const struct export_operations fat_export_ops_nostale = {
288 : : .encode_fh = fat_encode_fh_nostale,
289 : : .fh_to_dentry = fat_fh_to_dentry_nostale,
290 : : .fh_to_parent = fat_fh_to_parent_nostale,
291 : : .get_parent = fat_get_parent,
292 : : };
|
