GNU Linux-libre 6.9-gnu
[releases.git] / fs / fat / nfs.c
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 static 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
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
56 static 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
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;
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  */
148 static 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
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
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  */
186 static 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
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
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
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  */
268 static 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
287 const 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
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 };