1
2
3
4
5
6
7
8
9
10
11#include <linux/exportfs.h>
12#include <linux/fs.h>
13#include <linux/file.h>
14#include <linux/module.h>
15#include <linux/mount.h>
16#include <linux/namei.h>
17
18#define dprintk(fmt, args...) do{}while(0)
19
20
21static int get_name(struct vfsmount *mnt, struct dentry *dentry, char *name,
22 struct dentry *child);
23
24
25static int exportfs_get_name(struct vfsmount *mnt, struct dentry *dir,
26 char *name, struct dentry *child)
27{
28 const struct export_operations *nop = dir->d_sb->s_export_op;
29
30 if (nop->get_name)
31 return nop->get_name(dir, name, child);
32 else
33 return get_name(mnt, dir, name, child);
34}
35
36
37
38
39static struct dentry *
40find_acceptable_alias(struct dentry *result,
41 int (*acceptable)(void *context, struct dentry *dentry),
42 void *context)
43{
44 struct dentry *dentry, *toput = NULL;
45
46 if (acceptable(context, result))
47 return result;
48
49 spin_lock(&dcache_lock);
50 list_for_each_entry(dentry, &result->d_inode->i_dentry, d_alias) {
51 dget_locked(dentry);
52 spin_unlock(&dcache_lock);
53 if (toput)
54 dput(toput);
55 if (dentry != result && acceptable(context, dentry)) {
56 dput(result);
57 return dentry;
58 }
59 spin_lock(&dcache_lock);
60 toput = dentry;
61 }
62 spin_unlock(&dcache_lock);
63
64 if (toput)
65 dput(toput);
66 return NULL;
67}
68
69
70
71
72static struct dentry *
73find_disconnected_root(struct dentry *dentry)
74{
75 dget(dentry);
76 spin_lock(&dentry->d_lock);
77 while (!IS_ROOT(dentry) &&
78 (dentry->d_parent->d_flags & DCACHE_DISCONNECTED)) {
79 struct dentry *parent = dentry->d_parent;
80 dget(parent);
81 spin_unlock(&dentry->d_lock);
82 dput(dentry);
83 dentry = parent;
84 spin_lock(&dentry->d_lock);
85 }
86 spin_unlock(&dentry->d_lock);
87 return dentry;
88}
89
90
91
92
93
94
95
96static int
97reconnect_path(struct vfsmount *mnt, struct dentry *target_dir)
98{
99 char nbuf[NAME_MAX+1];
100 int noprogress = 0;
101 int err = -ESTALE;
102
103
104
105
106
107
108
109
110
111 while (target_dir->d_flags & DCACHE_DISCONNECTED && noprogress++ < 10) {
112 struct dentry *pd = find_disconnected_root(target_dir);
113
114 if (!IS_ROOT(pd)) {
115
116 spin_lock(&pd->d_lock);
117 pd->d_flags &= ~DCACHE_DISCONNECTED;
118 spin_unlock(&pd->d_lock);
119 noprogress = 0;
120 } else if (pd == mnt->mnt_sb->s_root) {
121 printk(KERN_ERR "export: Eeek filesystem root is not connected, impossible\n");
122 spin_lock(&pd->d_lock);
123 pd->d_flags &= ~DCACHE_DISCONNECTED;
124 spin_unlock(&pd->d_lock);
125 noprogress = 0;
126 } else {
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142 struct dentry *ppd = ERR_PTR(-EACCES);
143 struct dentry *npd;
144
145 mutex_lock(&pd->d_inode->i_mutex);
146 if (mnt->mnt_sb->s_export_op->get_parent)
147 ppd = mnt->mnt_sb->s_export_op->get_parent(pd);
148 mutex_unlock(&pd->d_inode->i_mutex);
149
150 if (IS_ERR(ppd)) {
151 err = PTR_ERR(ppd);
152 dprintk("%s: get_parent of %ld failed, err %d\n",
153 __FUNCTION__, pd->d_inode->i_ino, err);
154 dput(pd);
155 break;
156 }
157
158 dprintk("%s: find name of %lu in %lu\n", __FUNCTION__,
159 pd->d_inode->i_ino, ppd->d_inode->i_ino);
160 err = exportfs_get_name(mnt, ppd, nbuf, pd);
161 if (err) {
162 dput(ppd);
163 dput(pd);
164 if (err == -ENOENT)
165
166
167
168 continue;
169 break;
170 }
171 dprintk("%s: found name: %s\n", __FUNCTION__, nbuf);
172 mutex_lock(&ppd->d_inode->i_mutex);
173 npd = lookup_one_len(nbuf, ppd, strlen(nbuf));
174 mutex_unlock(&ppd->d_inode->i_mutex);
175 if (IS_ERR(npd)) {
176 err = PTR_ERR(npd);
177 dprintk("%s: lookup failed: %d\n",
178 __FUNCTION__, err);
179 dput(ppd);
180 dput(pd);
181 break;
182 }
183
184
185
186
187
188 if (npd == pd)
189 noprogress = 0;
190 else
191 printk("%s: npd != pd\n", __FUNCTION__);
192 dput(npd);
193 dput(ppd);
194 if (IS_ROOT(pd)) {
195
196 dput(pd);
197 break;
198 }
199 }
200 dput(pd);
201 }
202
203 if (target_dir->d_flags & DCACHE_DISCONNECTED) {
204
205 if (!err)
206 err = -ESTALE;
207 return err;
208 }
209
210 return 0;
211}
212
213struct getdents_callback {
214 char *name;
215
216 unsigned long ino;
217 int found;
218 int sequence;
219};
220
221
222
223
224
225static int filldir_one(void * __buf, const char * name, int len,
226 loff_t pos, u64 ino, unsigned int d_type)
227{
228 struct getdents_callback *buf = __buf;
229 int result = 0;
230
231 buf->sequence++;
232 if (buf->ino == ino) {
233 memcpy(buf->name, name, len);
234 buf->name[len] = '\0';
235 buf->found = 1;
236 result = -1;
237 }
238 return result;
239}
240
241
242
243
244
245
246
247
248
249
250static int get_name(struct vfsmount *mnt, struct dentry *dentry,
251 char *name, struct dentry *child)
252{
253 struct inode *dir = dentry->d_inode;
254 int error;
255 struct file *file;
256 struct getdents_callback buffer;
257
258 error = -ENOTDIR;
259 if (!dir || !S_ISDIR(dir->i_mode))
260 goto out;
261 error = -EINVAL;
262 if (!dir->i_fop)
263 goto out;
264
265
266
267 file = dentry_open(dget(dentry), mntget(mnt), O_RDONLY);
268 error = PTR_ERR(file);
269 if (IS_ERR(file))
270 goto out;
271
272 error = -EINVAL;
273 if (!file->f_op->readdir)
274 goto out_close;
275
276 buffer.name = name;
277 buffer.ino = child->d_inode->i_ino;
278 buffer.found = 0;
279 buffer.sequence = 0;
280 while (1) {
281 int old_seq = buffer.sequence;
282
283 error = vfs_readdir(file, filldir_one, &buffer);
284
285 if (error < 0)
286 break;
287
288 error = 0;
289 if (buffer.found)
290 break;
291 error = -ENOENT;
292 if (old_seq == buffer.sequence)
293 break;
294 }
295
296out_close:
297 fput(file);
298out:
299 return error;
300}
301
302
303
304
305
306
307
308
309
310
311
312
313
314static int export_encode_fh(struct dentry *dentry, struct fid *fid,
315 int *max_len, int connectable)
316{
317 struct inode * inode = dentry->d_inode;
318 int len = *max_len;
319 int type = FILEID_INO32_GEN;
320
321 if (len < 2 || (connectable && len < 4))
322 return 255;
323
324 len = 2;
325 fid->i32.ino = inode->i_ino;
326 fid->i32.gen = inode->i_generation;
327 if (connectable && !S_ISDIR(inode->i_mode)) {
328 struct inode *parent;
329
330 spin_lock(&dentry->d_lock);
331 parent = dentry->d_parent->d_inode;
332 fid->i32.parent_ino = parent->i_ino;
333 fid->i32.parent_gen = parent->i_generation;
334 spin_unlock(&dentry->d_lock);
335 len = 4;
336 type = FILEID_INO32_GEN_PARENT;
337 }
338 *max_len = len;
339 return type;
340}
341
342int exportfs_encode_fh(struct dentry *dentry, struct fid *fid, int *max_len,
343 int connectable)
344{
345 const struct export_operations *nop = dentry->d_sb->s_export_op;
346 int error;
347
348 if (nop->encode_fh)
349 error = nop->encode_fh(dentry, fid->raw, max_len, connectable);
350 else
351 error = export_encode_fh(dentry, fid, max_len, connectable);
352
353 return error;
354}
355EXPORT_SYMBOL_GPL(exportfs_encode_fh);
356
357struct dentry *exportfs_decode_fh(struct vfsmount *mnt, struct fid *fid,
358 int fh_len, int fileid_type,
359 int (*acceptable)(void *, struct dentry *), void *context)
360{
361 const struct export_operations *nop = mnt->mnt_sb->s_export_op;
362 struct dentry *result, *alias;
363 int err;
364
365
366
367
368 result = nop->fh_to_dentry(mnt->mnt_sb, fid, fh_len, fileid_type);
369 if (!result)
370 result = ERR_PTR(-ESTALE);
371 if (IS_ERR(result))
372 return result;
373
374 if (S_ISDIR(result->d_inode->i_mode)) {
375
376
377
378
379
380
381
382
383 if (result->d_flags & DCACHE_DISCONNECTED) {
384 err = reconnect_path(mnt, result);
385 if (err)
386 goto err_result;
387 }
388
389 if (!acceptable(context, result)) {
390 err = -EACCES;
391 goto err_result;
392 }
393
394 return result;
395 } else {
396
397
398
399 struct dentry *target_dir, *nresult;
400 char nbuf[NAME_MAX+1];
401
402
403
404
405
406
407
408
409
410
411 alias = find_acceptable_alias(result, acceptable, context);
412 if (alias)
413 return alias;
414
415
416
417
418
419 err = -ESTALE;
420 if (!nop->fh_to_parent)
421 goto err_result;
422
423 target_dir = nop->fh_to_parent(mnt->mnt_sb, fid,
424 fh_len, fileid_type);
425 if (!target_dir)
426 goto err_result;
427 err = PTR_ERR(target_dir);
428 if (IS_ERR(target_dir))
429 goto err_result;
430
431
432
433
434
435
436 err = reconnect_path(mnt, target_dir);
437 if (err) {
438 dput(target_dir);
439 goto err_result;
440 }
441
442
443
444
445
446
447 err = exportfs_get_name(mnt, target_dir, nbuf, result);
448 if (!err) {
449 mutex_lock(&target_dir->d_inode->i_mutex);
450 nresult = lookup_one_len(nbuf, target_dir,
451 strlen(nbuf));
452 mutex_unlock(&target_dir->d_inode->i_mutex);
453 if (!IS_ERR(nresult)) {
454 if (nresult->d_inode) {
455 dput(result);
456 result = nresult;
457 } else
458 dput(nresult);
459 }
460 }
461
462
463
464
465
466 dput(target_dir);
467
468
469
470
471
472 alias = find_acceptable_alias(result, acceptable, context);
473 if (!alias) {
474 err = -EACCES;
475 goto err_result;
476 }
477
478 return alias;
479 }
480
481 err_result:
482 dput(result);
483 return ERR_PTR(err);
484}
485EXPORT_SYMBOL_GPL(exportfs_decode_fh);
486
487MODULE_LICENSE("GPL");
488