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