Branch data Line data Source code
1 : : /* fs/fat/nfs.c
2 : : *
3 : : * This software is licensed under the terms of the GNU General Public
4 : : * License version 2, as published by the Free Software Foundation, and
5 : : * may be copied, distributed, and modified under those terms.
6 : : *
7 : : * This program is distributed in the hope that it will be useful,
8 : : * but WITHOUT ANY WARRANTY; without even the implied warranty of
9 : : * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
10 : : * GNU General Public License for more details.
11 : : *
12 : : */
13 : :
14 : : #include <linux/exportfs.h>
15 : : #include "fat.h"
16 : :
17 : : struct fat_fid {
18 : : u32 i_gen;
19 : : u32 i_pos_low;
20 : : u16 i_pos_hi;
21 : : u16 parent_i_pos_hi;
22 : : u32 parent_i_pos_low;
23 : : u32 parent_i_gen;
24 : : };
25 : :
26 : : #define FAT_FID_SIZE_WITHOUT_PARENT 3
27 : : #define FAT_FID_SIZE_WITH_PARENT (sizeof(struct fat_fid)/sizeof(u32))
28 : :
29 : : /**
30 : : * Look up a directory inode given its starting cluster.
31 : : */
32 : 0 : static struct inode *fat_dget(struct super_block *sb, int i_logstart)
33 : : {
34 : : struct msdos_sb_info *sbi = MSDOS_SB(sb);
35 : : struct hlist_head *head;
36 : : struct msdos_inode_info *i;
37 : : struct inode *inode = NULL;
38 : :
39 : 0 : head = sbi->dir_hashtable + fat_dir_hash(i_logstart);
40 : : spin_lock(&sbi->dir_hash_lock);
41 [ # # ][ # # ]: 0 : hlist_for_each_entry(i, head, i_dir_hash) {
[ # # ]
42 [ # # ]: 0 : BUG_ON(i->vfs_inode.i_sb != sb);
43 [ # # ]: 0 : if (i->i_logstart != i_logstart)
44 : 0 : continue;
45 : 0 : inode = igrab(&i->vfs_inode);
46 [ # # ]: 0 : if (inode)
47 : : break;
48 : : }
49 : : spin_unlock(&sbi->dir_hash_lock);
50 : 0 : return inode;
51 : : }
52 : :
53 : 0 : static struct inode *fat_ilookup(struct super_block *sb, u64 ino, loff_t i_pos)
54 : : {
55 [ # # ]: 0 : if (MSDOS_SB(sb)->options.nfs == FAT_NFS_NOSTALE_RO)
56 : 0 : return fat_iget(sb, i_pos);
57 : :
58 : : else {
59 [ # # ]: 0 : if ((ino < MSDOS_ROOT_INO) || (ino == MSDOS_FSINFO_INO))
60 : : return NULL;
61 : 0 : return ilookup(sb, ino);
62 : : }
63 : : }
64 : :
65 : 0 : static struct inode *__fat_nfs_get_inode(struct super_block *sb,
66 : : u64 ino, u32 generation, loff_t i_pos)
67 : : {
68 : 0 : struct inode *inode = fat_ilookup(sb, ino, i_pos);
69 : :
70 [ # # ][ # # ]: 0 : if (inode && generation && (inode->i_generation != generation)) {
71 : 0 : iput(inode);
72 : : inode = NULL;
73 : : }
74 [ # # ][ # # ]: 0 : if (inode == NULL && MSDOS_SB(sb)->options.nfs == FAT_NFS_NOSTALE_RO) {
75 : : struct buffer_head *bh = NULL;
76 : : struct msdos_dir_entry *de ;
77 : : sector_t blocknr;
78 : : int offset;
79 : 0 : fat_get_blknr_offset(MSDOS_SB(sb), i_pos, &blocknr, &offset);
80 : : bh = sb_bread(sb, blocknr);
81 [ # # ]: 0 : if (!bh) {
82 : 0 : fat_msg(sb, KERN_ERR,
83 : : "unable to read block(%llu) for building NFS inode",
84 : : (llu)blocknr);
85 : : return inode;
86 : : }
87 : 0 : de = (struct msdos_dir_entry *)bh->b_data;
88 : : /* If a file is deleted on server and client is not updated
89 : : * yet, we must not build the inode upon a lookup call.
90 : : */
91 [ # # ]: 0 : if (IS_FREE(de[offset].name))
92 : : inode = NULL;
93 : : else
94 : 0 : inode = fat_build_inode(sb, &de[offset], i_pos);
95 : : brelse(bh);
96 : : }
97 : :
98 : 0 : return inode;
99 : : }
100 : :
101 : 0 : static struct inode *fat_nfs_get_inode(struct super_block *sb,
102 : : u64 ino, u32 generation)
103 : : {
104 : :
105 : 0 : return __fat_nfs_get_inode(sb, ino, generation, 0);
106 : : }
107 : :
108 : : static int
109 : 0 : fat_encode_fh_nostale(struct inode *inode, __u32 *fh, int *lenp,
110 : : struct inode *parent)
111 : : {
112 : 0 : int len = *lenp;
113 : 0 : struct msdos_sb_info *sbi = MSDOS_SB(inode->i_sb);
114 : : struct fat_fid *fid = (struct fat_fid *) fh;
115 : : loff_t i_pos;
116 : : int type = FILEID_FAT_WITHOUT_PARENT;
117 : :
118 [ # # ]: 0 : if (parent) {
119 [ # # ]: 0 : if (len < FAT_FID_SIZE_WITH_PARENT) {
120 : 0 : *lenp = FAT_FID_SIZE_WITH_PARENT;
121 : 0 : return FILEID_INVALID;
122 : : }
123 : : } else {
124 [ # # ]: 0 : if (len < FAT_FID_SIZE_WITHOUT_PARENT) {
125 : 0 : *lenp = FAT_FID_SIZE_WITHOUT_PARENT;
126 : 0 : return FILEID_INVALID;
127 : : }
128 : : }
129 : :
130 : : i_pos = fat_i_pos_read(sbi, inode);
131 : 0 : *lenp = FAT_FID_SIZE_WITHOUT_PARENT;
132 : 0 : fid->i_gen = inode->i_generation;
133 : 0 : fid->i_pos_low = i_pos & 0xFFFFFFFF;
134 : 0 : fid->i_pos_hi = (i_pos >> 32) & 0xFFFF;
135 [ # # ]: 0 : if (parent) {
136 : : i_pos = fat_i_pos_read(sbi, parent);
137 : 0 : fid->parent_i_pos_hi = (i_pos >> 32) & 0xFFFF;
138 : 0 : fid->parent_i_pos_low = i_pos & 0xFFFFFFFF;
139 : 0 : fid->parent_i_gen = parent->i_generation;
140 : : type = FILEID_FAT_WITH_PARENT;
141 : 0 : *lenp = FAT_FID_SIZE_WITH_PARENT;
142 : : }
143 : :
144 : 0 : return type;
145 : : }
146 : :
147 : : /**
148 : : * Map a NFS file handle to a corresponding dentry.
149 : : * The dentry may or may not be connected to the filesystem root.
150 : : */
151 : 0 : static struct dentry *fat_fh_to_dentry(struct super_block *sb, struct fid *fid,
152 : : int fh_len, int fh_type)
153 : : {
154 : 0 : return generic_fh_to_dentry(sb, fid, fh_len, fh_type,
155 : : fat_nfs_get_inode);
156 : : }
157 : :
158 : 0 : static struct dentry *fat_fh_to_dentry_nostale(struct super_block *sb,
159 : : struct fid *fh, int fh_len,
160 : : int fh_type)
161 : : {
162 : : struct inode *inode = NULL;
163 : : struct fat_fid *fid = (struct fat_fid *)fh;
164 : : loff_t i_pos;
165 : :
166 [ # # # ]: 0 : switch (fh_type) {
167 : : case FILEID_FAT_WITHOUT_PARENT:
168 [ # # ]: 0 : if (fh_len < FAT_FID_SIZE_WITHOUT_PARENT)
169 : : return NULL;
170 : : break;
171 : : case FILEID_FAT_WITH_PARENT:
172 [ # # ]: 0 : if (fh_len < FAT_FID_SIZE_WITH_PARENT)
173 : : return NULL;
174 : : break;
175 : : default:
176 : : return NULL;
177 : : }
178 : 0 : i_pos = fid->i_pos_hi;
179 : 0 : i_pos = (i_pos << 32) | (fid->i_pos_low);
180 : 0 : inode = __fat_nfs_get_inode(sb, 0, fid->i_gen, i_pos);
181 : :
182 : 0 : return d_obtain_alias(inode);
183 : : }
184 : :
185 : : /*
186 : : * Find the parent for a file specified by NFS handle.
187 : : * This requires that the handle contain the i_ino of the parent.
188 : : */
189 : 0 : static struct dentry *fat_fh_to_parent(struct super_block *sb, struct fid *fid,
190 : : int fh_len, int fh_type)
191 : : {
192 : 0 : return generic_fh_to_parent(sb, fid, fh_len, fh_type,
193 : : fat_nfs_get_inode);
194 : : }
195 : :
196 : 0 : static struct dentry *fat_fh_to_parent_nostale(struct super_block *sb,
197 : : struct fid *fh, int fh_len,
198 : : int fh_type)
199 : : {
200 : : struct inode *inode = NULL;
201 : : struct fat_fid *fid = (struct fat_fid *)fh;
202 : : loff_t i_pos;
203 : :
204 [ # # ]: 0 : if (fh_len < FAT_FID_SIZE_WITH_PARENT)
205 : : return NULL;
206 : :
207 [ # # ]: 0 : switch (fh_type) {
208 : : case FILEID_FAT_WITH_PARENT:
209 : 0 : i_pos = fid->parent_i_pos_hi;
210 : 0 : i_pos = (i_pos << 32) | (fid->parent_i_pos_low);
211 : 0 : inode = __fat_nfs_get_inode(sb, 0, fid->parent_i_gen, i_pos);
212 : 0 : break;
213 : : }
214 : :
215 : 0 : return d_obtain_alias(inode);
216 : : }
217 : :
218 : : /*
219 : : * Rebuild the parent for a directory that is not connected
220 : : * to the filesystem root
221 : : */
222 : : static
223 : 0 : struct inode *fat_rebuild_parent(struct super_block *sb, int parent_logstart)
224 : : {
225 : : int search_clus, clus_to_match;
226 : 0 : struct msdos_dir_entry *de;
227 : : struct inode *parent = NULL;
228 : : struct inode *dummy_grand_parent = NULL;
229 : : struct fat_slot_info sinfo;
230 : 0 : struct msdos_sb_info *sbi = MSDOS_SB(sb);
231 : : sector_t blknr = fat_clus_to_blknr(sbi, parent_logstart);
232 : : struct buffer_head *parent_bh = sb_bread(sb, blknr);
233 [ # # ]: 0 : if (!parent_bh) {
234 : 0 : fat_msg(sb, KERN_ERR,
235 : : "unable to read cluster of parent directory");
236 : 0 : return NULL;
237 : : }
238 : :
239 : 0 : de = (struct msdos_dir_entry *) parent_bh->b_data;
240 : : clus_to_match = fat_get_start(sbi, &de[0]);
241 : 0 : search_clus = fat_get_start(sbi, &de[1]);
242 : :
243 : 0 : dummy_grand_parent = fat_dget(sb, search_clus);
244 [ # # ]: 0 : if (!dummy_grand_parent) {
245 : 0 : dummy_grand_parent = new_inode(sb);
246 [ # # ]: 0 : if (!dummy_grand_parent) {
247 : : brelse(parent_bh);
248 : : return parent;
249 : : }
250 : :
251 : 0 : dummy_grand_parent->i_ino = iunique(sb, MSDOS_ROOT_INO);
252 : 0 : fat_fill_inode(dummy_grand_parent, &de[1]);
253 : 0 : MSDOS_I(dummy_grand_parent)->i_pos = -1;
254 : : }
255 : :
256 [ # # ]: 0 : if (!fat_scan_logstart(dummy_grand_parent, clus_to_match, &sinfo))
257 : 0 : parent = fat_build_inode(sb, sinfo.de, sinfo.i_pos);
258 : :
259 : : brelse(parent_bh);
260 : 0 : iput(dummy_grand_parent);
261 : :
262 : 0 : return parent;
263 : : }
264 : :
265 : : /*
266 : : * Find the parent for a directory that is not currently connected to
267 : : * the filesystem root.
268 : : *
269 : : * On entry, the caller holds child_dir->d_inode->i_mutex.
270 : : */
271 : 0 : static struct dentry *fat_get_parent(struct dentry *child_dir)
272 : : {
273 : 0 : struct super_block *sb = child_dir->d_sb;
274 : 0 : struct buffer_head *bh = NULL;
275 : : struct msdos_dir_entry *de;
276 : : struct inode *parent_inode = NULL;
277 : 0 : struct msdos_sb_info *sbi = MSDOS_SB(sb);
278 : :
279 [ # # ]: 0 : if (!fat_get_dotdot_entry(child_dir->d_inode, &bh, &de)) {
280 : 0 : int parent_logstart = fat_get_start(sbi, de);
281 : 0 : parent_inode = fat_dget(sb, parent_logstart);
282 [ # # ][ # # ]: 0 : if (!parent_inode && sbi->options.nfs == FAT_NFS_NOSTALE_RO)
283 : 0 : parent_inode = fat_rebuild_parent(sb, parent_logstart);
284 : : }
285 : 0 : brelse(bh);
286 : :
287 : 0 : return d_obtain_alias(parent_inode);
288 : : }
289 : :
290 : : const struct export_operations fat_export_ops = {
291 : : .fh_to_dentry = fat_fh_to_dentry,
292 : : .fh_to_parent = fat_fh_to_parent,
293 : : .get_parent = fat_get_parent,
294 : : };
295 : :
296 : : const struct export_operations fat_export_ops_nostale = {
297 : : .encode_fh = fat_encode_fh_nostale,
298 : : .fh_to_dentry = fat_fh_to_dentry_nostale,
299 : : .fh_to_parent = fat_fh_to_parent_nostale,
300 : : .get_parent = fat_get_parent,
301 : : };
|
