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