Commit | Line | Data |
---|---|---|
9c92ab61 | 1 | // SPDX-License-Identifier: GPL-2.0-only |
21b6633d | 2 | /* fs/fat/nfs.c |
21b6633d SM |
3 | */ |
4 | ||
5 | #include <linux/exportfs.h> | |
6 | #include "fat.h" | |
7 | ||
ea3983ac NJ |
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 | ||
811b99fd | 20 | /* |
7669e8fb | 21 | * Look up a directory inode given its starting cluster. |
21b6633d | 22 | */ |
7669e8fb | 23 | static struct inode *fat_dget(struct super_block *sb, int i_logstart) |
21b6633d | 24 | { |
7669e8fb SM |
25 | struct msdos_sb_info *sbi = MSDOS_SB(sb); |
26 | struct hlist_head *head; | |
7669e8fb SM |
27 | struct msdos_inode_info *i; |
28 | struct inode *inode = NULL; | |
21b6633d | 29 | |
7669e8fb SM |
30 | head = sbi->dir_hashtable + fat_dir_hash(i_logstart); |
31 | spin_lock(&sbi->dir_hash_lock); | |
b67bfe0d | 32 | hlist_for_each_entry(i, head, i_dir_hash) { |
7669e8fb SM |
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; | |
21b6633d | 39 | } |
7669e8fb SM |
40 | spin_unlock(&sbi->dir_hash_lock); |
41 | return inode; | |
21b6633d SM |
42 | } |
43 | ||
8fceb4e0 NJ |
44 | static 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 | ||
ea3983ac NJ |
56 | static struct inode *__fat_nfs_get_inode(struct super_block *sb, |
57 | u64 ino, u32 generation, loff_t i_pos) | |
21b6633d | 58 | { |
8fceb4e0 | 59 | struct inode *inode = fat_ilookup(sb, ino, i_pos); |
7669e8fb | 60 | |
7669e8fb SM |
61 | if (inode && generation && (inode->i_generation != generation)) { |
62 | iput(inode); | |
63 | inode = NULL; | |
64 | } | |
8fceb4e0 NJ |
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 | } | |
7669e8fb SM |
88 | |
89 | return inode; | |
21b6633d SM |
90 | } |
91 | ||
ea3983ac NJ |
92 | static 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 | ||
99 | static int | |
100 | fat_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; | |
fde2497d JK |
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; | |
ea3983ac NJ |
139 | } |
140 | ||
141 | return type; | |
142 | } | |
143 | ||
811b99fd | 144 | /* |
21b6633d SM |
145 | * Map a NFS file handle to a corresponding dentry. |
146 | * The dentry may or may not be connected to the filesystem root. | |
147 | */ | |
ea3983ac | 148 | static struct dentry *fat_fh_to_dentry(struct super_block *sb, struct fid *fid, |
21b6633d SM |
149 | int fh_len, int fh_type) |
150 | { | |
7669e8fb SM |
151 | return generic_fh_to_dentry(sb, fid, fh_len, fh_type, |
152 | fat_nfs_get_inode); | |
153 | } | |
21b6633d | 154 | |
ea3983ac NJ |
155 | static 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 | ||
7669e8fb SM |
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 | */ | |
ea3983ac | 186 | static struct dentry *fat_fh_to_parent(struct super_block *sb, struct fid *fid, |
7669e8fb SM |
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); | |
21b6633d SM |
191 | } |
192 | ||
ea3983ac NJ |
193 | static 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 | ||
f1e6fb0a NJ |
215 | /* |
216 | * Rebuild the parent for a directory that is not connected | |
217 | * to the filesystem root | |
218 | */ | |
219 | static | |
220 | struct 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 | ||
21b6633d SM |
262 | /* |
263 | * Find the parent for a directory that is not currently connected to | |
264 | * the filesystem root. | |
265 | * | |
2b0143b5 | 266 | * On entry, the caller holds d_inode(child_dir)->i_mutex. |
21b6633d | 267 | */ |
ea3983ac | 268 | static struct dentry *fat_get_parent(struct dentry *child_dir) |
21b6633d SM |
269 | { |
270 | struct super_block *sb = child_dir->d_sb; | |
271 | struct buffer_head *bh = NULL; | |
272 | struct msdos_dir_entry *de; | |
7669e8fb | 273 | struct inode *parent_inode = NULL; |
f1e6fb0a | 274 | struct msdos_sb_info *sbi = MSDOS_SB(sb); |
21b6633d | 275 | |
2b0143b5 | 276 | if (!fat_get_dotdot_entry(d_inode(child_dir), &bh, &de)) { |
f1e6fb0a | 277 | int parent_logstart = fat_get_start(sbi, de); |
7669e8fb | 278 | parent_inode = fat_dget(sb, parent_logstart); |
f1e6fb0a NJ |
279 | if (!parent_inode && sbi->options.nfs == FAT_NFS_NOSTALE_RO) |
280 | parent_inode = fat_rebuild_parent(sb, parent_logstart); | |
21b6633d | 281 | } |
21b6633d | 282 | brelse(bh); |
21b6633d | 283 | |
7669e8fb | 284 | return d_obtain_alias(parent_inode); |
21b6633d | 285 | } |
ea3983ac NJ |
286 | |
287 | const struct export_operations fat_export_ops = { | |
e21fc203 | 288 | .encode_fh = generic_encode_ino32_fh, |
ea3983ac NJ |
289 | .fh_to_dentry = fat_fh_to_dentry, |
290 | .fh_to_parent = fat_fh_to_parent, | |
291 | .get_parent = fat_get_parent, | |
292 | }; | |
293 | ||
294 | const 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 | }; |