]> git.proxmox.com Git - mirror_ubuntu-impish-kernel.git/blob - fs/shiftfs.c
projects / mirror_ubuntu-impish-kernel.git / blob
? search:
summary | shortlog | log | commit | commitdiff | tree
blame | history | raw | HEAD
UBUNTU: link-to-tracker: update tracking bug
[mirror_ubuntu-impish-kernel.git] / fs / shiftfs.c
1 #include <linux/btrfs.h>
2 #include <linux/capability.h>
3 #include <linux/cred.h>
4 #include <linux/mount.h>
5 #include <linux/fdtable.h>
6 #include <linux/file.h>
7 #include <linux/fs.h>
8 #include <linux/namei.h>
9 #include <linux/module.h>
10 #include <linux/kernel.h>
11 #include <linux/magic.h>
12 #include <linux/parser.h>
13 #include <linux/security.h>
14 #include <linux/seq_file.h>
15 #include <linux/statfs.h>
16 #include <linux/slab.h>
17 #include <linux/user_namespace.h>
18 #include <linux/uidgid.h>
19 #include <linux/xattr.h>
20 #include <linux/posix_acl.h>
21 #include <linux/posix_acl_xattr.h>
22 #include <linux/uio.h>
23 #include <linux/fiemap.h>
24
25 struct shiftfs_super_info {
26 struct vfsmount *mnt;
27 struct user_namespace *userns;
28 /* creds of process who created the super block */
29 const struct cred *creator_cred;
30 bool mark;
31 unsigned int passthrough;
32 unsigned int passthrough_mark;
33 };
34
35 static void shiftfs_fill_inode(struct inode *inode, unsigned long ino,
36 umode_t mode, dev_t dev, struct dentry *dentry);
37
38 #define SHIFTFS_PASSTHROUGH_NONE 0
39 #define SHIFTFS_PASSTHROUGH_STAT 1
40 #define SHIFTFS_PASSTHROUGH_IOCTL 2
41 #define SHIFTFS_PASSTHROUGH_ALL \
42 (SHIFTFS_PASSTHROUGH_STAT | SHIFTFS_PASSTHROUGH_IOCTL)
43
44 static inline bool shiftfs_passthrough_ioctls(struct shiftfs_super_info *info)
45 {
46 if (!(info->passthrough & SHIFTFS_PASSTHROUGH_IOCTL))
47 return false;
48
49 return true;
50 }
51
52 static inline bool shiftfs_passthrough_statfs(struct shiftfs_super_info *info)
53 {
54 if (!(info->passthrough & SHIFTFS_PASSTHROUGH_STAT))
55 return false;
56
57 return true;
58 }
59
60 enum {
61 OPT_MARK,
62 OPT_PASSTHROUGH,
63 OPT_LAST,
64 };
65
66 /* global filesystem options */
67 static const match_table_t tokens = {
68 { OPT_MARK, "mark" },
69 { OPT_PASSTHROUGH, "passthrough=%u" },
70 { OPT_LAST, NULL }
71 };
72
73 static const struct cred *shiftfs_override_creds(const struct super_block *sb)
74 {
75 struct shiftfs_super_info *sbinfo = sb->s_fs_info;
76
77 return override_creds(sbinfo->creator_cred);
78 }
79
80 static inline void shiftfs_revert_object_creds(const struct cred *oldcred,
81 struct cred *newcred)
82 {
83 revert_creds(oldcred);
84 put_cred(newcred);
85 }
86
87 static kuid_t shift_kuid(struct user_namespace *from, struct user_namespace *to,
88 kuid_t kuid)
89 {
90 uid_t uid = from_kuid(from, kuid);
91 return make_kuid(to, uid);
92 }
93
94 static kgid_t shift_kgid(struct user_namespace *from, struct user_namespace *to,
95 kgid_t kgid)
96 {
97 gid_t gid = from_kgid(from, kgid);
98 return make_kgid(to, gid);
99 }
100
101 static int shiftfs_override_object_creds(const struct super_block *sb,
102 const struct cred **oldcred,
103 struct cred **newcred,
104 struct dentry *dentry, umode_t mode,
105 bool hardlink)
106 {
107 struct shiftfs_super_info *sbinfo = sb->s_fs_info;
108 kuid_t fsuid = current_fsuid();
109 kgid_t fsgid = current_fsgid();
110
111 *oldcred = shiftfs_override_creds(sb);
112
113 *newcred = prepare_creds();
114 if (!*newcred) {
115 revert_creds(*oldcred);
116 return -ENOMEM;
117 }
118
119 (*newcred)->fsuid = shift_kuid(sb->s_user_ns, sbinfo->userns, fsuid);
120 (*newcred)->fsgid = shift_kgid(sb->s_user_ns, sbinfo->userns, fsgid);
121
122 if (!hardlink) {
123 int err = security_dentry_create_files_as(dentry, mode,
124 &dentry->d_name,
125 *oldcred, *newcred);
126 if (err) {
127 shiftfs_revert_object_creds(*oldcred, *newcred);
128 return err;
129 }
130 }
131
132 put_cred(override_creds(*newcred));
133 return 0;
134 }
135
136 static void shiftfs_copyattr(struct inode *from, struct inode *to)
137 {
138 struct user_namespace *from_ns = from->i_sb->s_user_ns;
139 struct user_namespace *to_ns = to->i_sb->s_user_ns;
140
141 to->i_uid = shift_kuid(from_ns, to_ns, from->i_uid);
142 to->i_gid = shift_kgid(from_ns, to_ns, from->i_gid);
143 to->i_mode = from->i_mode;
144 to->i_atime = from->i_atime;
145 to->i_mtime = from->i_mtime;
146 to->i_ctime = from->i_ctime;
147 i_size_write(to, i_size_read(from));
148 }
149
150 static void shiftfs_copyflags(struct inode *from, struct inode *to)
151 {
152 unsigned int mask = S_SYNC | S_IMMUTABLE | S_APPEND | S_NOATIME;
153
154 inode_set_flags(to, from->i_flags & mask, mask);
155 }
156
157 static void shiftfs_file_accessed(struct file *file)
158 {
159 struct inode *upperi, *loweri;
160
161 if (file->f_flags & O_NOATIME)
162 return;
163
164 upperi = file_inode(file);
165 loweri = upperi->i_private;
166
167 if (!loweri)
168 return;
169
170 upperi->i_mtime = loweri->i_mtime;
171 upperi->i_ctime = loweri->i_ctime;
172
173 touch_atime(&file->f_path);
174 }
175
176 static int shiftfs_parse_mount_options(struct shiftfs_super_info *sbinfo,
177 char *options)
178 {
179 char *p;
180 substring_t args[MAX_OPT_ARGS];
181
182 sbinfo->mark = false;
183 sbinfo->passthrough = 0;
184
185 while ((p = strsep(&options, ",")) != NULL) {
186 int err, intarg, token;
187
188 if (!*p)
189 continue;
190
191 token = match_token(p, tokens, args);
192 switch (token) {
193 case OPT_MARK:
194 sbinfo->mark = true;
195 break;
196 case OPT_PASSTHROUGH:
197 err = match_int(&args[0], &intarg);
198 if (err)
199 return err;
200
201 if (intarg & ~SHIFTFS_PASSTHROUGH_ALL)
202 return -EINVAL;
203
204 sbinfo->passthrough = intarg;
205 break;
206 default:
207 return -EINVAL;
208 }
209 }
210
211 return 0;
212 }
213
214 static void shiftfs_d_release(struct dentry *dentry)
215 {
216 struct dentry *lowerd = dentry->d_fsdata;
217
218 if (lowerd)
219 dput(lowerd);
220 }
221
222 static struct dentry *shiftfs_d_real(struct dentry *dentry,
223 const struct inode *inode)
224 {
225 struct dentry *lowerd = dentry->d_fsdata;
226
227 if (inode && d_inode(dentry) == inode)
228 return dentry;
229
230 lowerd = d_real(lowerd, inode);
231 if (lowerd && (!inode || inode == d_inode(lowerd)))
232 return lowerd;
233
234 WARN(1, "shiftfs_d_real(%pd4, %s:%lu): real dentry not found\n", dentry,
235 inode ? inode->i_sb->s_id : "NULL", inode ? inode->i_ino : 0);
236 return dentry;
237 }
238
239 static int shiftfs_d_weak_revalidate(struct dentry *dentry, unsigned int flags)
240 {
241 int err = 1;
242 struct dentry *lowerd = dentry->d_fsdata;
243
244 if (d_is_negative(lowerd) != d_is_negative(dentry))
245 return 0;
246
247 if ((lowerd->d_flags & DCACHE_OP_WEAK_REVALIDATE))
248 err = lowerd->d_op->d_weak_revalidate(lowerd, flags);
249
250 if (d_really_is_positive(dentry)) {
251 struct inode *inode = d_inode(dentry);
252 struct inode *loweri = d_inode(lowerd);
253
254 shiftfs_copyattr(loweri, inode);
255 }
256
257 return err;
258 }
259
260 static int shiftfs_d_revalidate(struct dentry *dentry, unsigned int flags)
261 {
262 int err = 1;
263 struct dentry *lowerd = dentry->d_fsdata;
264
265 if (d_unhashed(lowerd) ||
266 ((d_is_negative(lowerd) != d_is_negative(dentry))))
267 return 0;
268
269 if (flags & LOOKUP_RCU)
270 return -ECHILD;
271
272 if ((lowerd->d_flags & DCACHE_OP_REVALIDATE))
273 err = lowerd->d_op->d_revalidate(lowerd, flags);
274
275 if (d_really_is_positive(dentry)) {
276 struct inode *inode = d_inode(dentry);
277 struct inode *loweri = d_inode(lowerd);
278
279 shiftfs_copyattr(loweri, inode);
280 }
281
282 return err;
283 }
284
285 static const struct dentry_operations shiftfs_dentry_ops = {
286 .d_release = shiftfs_d_release,
287 .d_real = shiftfs_d_real,
288 .d_revalidate = shiftfs_d_revalidate,
289 .d_weak_revalidate = shiftfs_d_weak_revalidate,
290 };
291
292 static const char *shiftfs_get_link(struct dentry *dentry, struct inode *inode,
293 struct delayed_call *done)
294 {
295 const char *p;
296 const struct cred *oldcred;
297 struct dentry *lowerd;
298
299 /* RCU lookup not supported */
300 if (!dentry)
301 return ERR_PTR(-ECHILD);
302
303 lowerd = dentry->d_fsdata;
304 oldcred = shiftfs_override_creds(dentry->d_sb);
305 p = vfs_get_link(lowerd, done);
306 revert_creds(oldcred);
307
308 return p;
309 }
310
311 static int shiftfs_setxattr(struct user_namespace *mnt_ns,
312 struct dentry *dentry, struct inode *inode,
313 const char *name, const void *value,
314 size_t size, int flags)
315 {
316 struct dentry *lowerd = dentry->d_fsdata;
317 int err;
318 const struct cred *oldcred;
319
320 oldcred = shiftfs_override_creds(dentry->d_sb);
321 err = vfs_setxattr(&init_user_ns, lowerd, name, value, size, flags);
322 revert_creds(oldcred);
323
324 shiftfs_copyattr(lowerd->d_inode, inode);
325
326 return err;
327 }
328
329 static int shiftfs_xattr_get(const struct xattr_handler *handler,
330 struct dentry *dentry, struct inode *inode,
331 const char *name, void *value, size_t size)
332 {
333 struct dentry *lowerd = dentry->d_fsdata;
334 int err;
335 const struct cred *oldcred;
336
337 oldcred = shiftfs_override_creds(dentry->d_sb);
338 err = vfs_getxattr(&init_user_ns, lowerd, name, value, size);
339 revert_creds(oldcred);
340
341 return err;
342 }
343
344 static ssize_t shiftfs_listxattr(struct dentry *dentry, char *list,
345 size_t size)
346 {
347 struct dentry *lowerd = dentry->d_fsdata;
348 int err;
349 const struct cred *oldcred;
350
351 oldcred = shiftfs_override_creds(dentry->d_sb);
352 err = vfs_listxattr(lowerd, list, size);
353 revert_creds(oldcred);
354
355 return err;
356 }
357
358 static int shiftfs_removexattr(struct user_namespace *mnt_ns, struct dentry *dentry, const char *name)
359 {
360 struct dentry *lowerd = dentry->d_fsdata;
361 int err;
362 const struct cred *oldcred;
363
364 oldcred = shiftfs_override_creds(dentry->d_sb);
365 err = vfs_removexattr(&init_user_ns, lowerd, name);
366 revert_creds(oldcred);
367
368 /* update c/mtime */
369 shiftfs_copyattr(lowerd->d_inode, d_inode(dentry));
370
371 return err;
372 }
373
374 static int shiftfs_xattr_set(const struct xattr_handler *handler,
375 struct user_namespace *mnt_ns,
376 struct dentry *dentry, struct inode *inode,
377 const char *name, const void *value, size_t size,
378 int flags)
379 {
380 if (!value)
381 return shiftfs_removexattr(&init_user_ns, dentry, name);
382 return shiftfs_setxattr(&init_user_ns, dentry, inode, name, value, size,
383 flags);
384 }
385
386 static int shiftfs_inode_test(struct inode *inode, void *data)
387 {
388 return inode->i_private == data;
389 }
390
391 static int shiftfs_inode_set(struct inode *inode, void *data)
392 {
393 inode->i_private = data;
394 return 0;
395 }
396
397 static int shiftfs_create_object(struct user_namespace *mnt_ns,
398 struct inode *diri, struct dentry *dentry,
399 umode_t mode, const char *symlink,
400 struct dentry *hardlink, bool excl)
401 {
402 int err;
403 const struct cred *oldcred;
404 struct cred *newcred;
405 void *loweri_iop_ptr = NULL;
406 umode_t modei = mode;
407 struct super_block *dir_sb = diri->i_sb;
408 struct dentry *lowerd_new = dentry->d_fsdata;
409 struct inode *inode = NULL, *loweri_dir = diri->i_private;
410 const struct inode_operations *loweri_dir_iop = loweri_dir->i_op;
411 struct dentry *lowerd_link = NULL;
412
413 if (hardlink) {
414 loweri_iop_ptr = loweri_dir_iop->link;
415 } else {
416 switch (mode & S_IFMT) {
417 case S_IFDIR:
418 loweri_iop_ptr = loweri_dir_iop->mkdir;
419 break;
420 case S_IFREG:
421 loweri_iop_ptr = loweri_dir_iop->create;
422 break;
423 case S_IFLNK:
424 loweri_iop_ptr = loweri_dir_iop->symlink;
425 break;
426 case S_IFSOCK:
427 /* fall through */
428 case S_IFIFO:
429 loweri_iop_ptr = loweri_dir_iop->mknod;
430 break;
431 }
432 }
433 if (!loweri_iop_ptr) {
434 err = -EINVAL;
435 goto out_iput;
436 }
437
438 inode_lock_nested(loweri_dir, I_MUTEX_PARENT);
439
440 if (!hardlink) {
441 inode = new_inode(dir_sb);
442 if (!inode) {
443 err = -ENOMEM;
444 goto out_iput;
445 }
446
447 /*
448 * new_inode() will have added the new inode to the super
449 * block's list of inodes. Further below we will call
450 * inode_insert5() Which would perform the same operation again
451 * thereby corrupting the list. To avoid this raise I_CREATING
452 * in i_state which will cause inode_insert5() to skip this
453 * step. I_CREATING will be cleared by d_instantiate_new()
454 * below.
455 */
456 spin_lock(&inode->i_lock);
457 inode->i_state |= I_CREATING;
458 spin_unlock(&inode->i_lock);
459
460 inode_init_owner(&init_user_ns, inode, diri, mode);
461 modei = inode->i_mode;
462 }
463
464 err = shiftfs_override_object_creds(dentry->d_sb, &oldcred, &newcred,
465 dentry, modei, hardlink != NULL);
466 if (err)
467 goto out_iput;
468
469 if (hardlink) {
470 lowerd_link = hardlink->d_fsdata;
471 err = vfs_link(lowerd_link, &init_user_ns, loweri_dir, lowerd_new, NULL);
472 } else {
473 switch (modei & S_IFMT) {
474 case S_IFDIR:
475 err = vfs_mkdir(&init_user_ns, loweri_dir, lowerd_new, modei);
476 break;
477 case S_IFREG:
478 err = vfs_create(&init_user_ns, loweri_dir, lowerd_new, modei, excl);
479 break;
480 case S_IFLNK:
481 err = vfs_symlink(&init_user_ns, loweri_dir, lowerd_new, symlink);
482 break;
483 case S_IFSOCK:
484 /* fall through */
485 case S_IFIFO:
486 err = vfs_mknod(&init_user_ns, loweri_dir, lowerd_new, modei, 0);
487 break;
488 default:
489 err = -EINVAL;
490 break;
491 }
492 }
493
494 shiftfs_revert_object_creds(oldcred, newcred);
495
496 if (!err && WARN_ON(!lowerd_new->d_inode))
497 err = -EIO;
498 if (err)
499 goto out_iput;
500
501 if (hardlink) {
502 inode = d_inode(hardlink);
503 ihold(inode);
504
505 /* copy up times from lower inode */
506 shiftfs_copyattr(d_inode(lowerd_link), inode);
507 set_nlink(d_inode(hardlink), d_inode(lowerd_link)->i_nlink);
508 d_instantiate(dentry, inode);
509 } else {
510 struct inode *inode_tmp;
511 struct inode *loweri_new = d_inode(lowerd_new);
512
513 inode_tmp = inode_insert5(inode, (unsigned long)loweri_new,
514 shiftfs_inode_test, shiftfs_inode_set,
515 loweri_new);
516 if (unlikely(inode_tmp != inode)) {
517 pr_err_ratelimited("shiftfs: newly created inode found in cache\n");
518 iput(inode_tmp);
519 err = -EINVAL;
520 goto out_iput;
521 }
522
523 ihold(loweri_new);
524 shiftfs_fill_inode(inode, loweri_new->i_ino, loweri_new->i_mode,
525 0, lowerd_new);
526 d_instantiate_new(dentry, inode);
527 }
528
529 shiftfs_copyattr(loweri_dir, diri);
530 if (loweri_iop_ptr == loweri_dir_iop->mkdir)
531 set_nlink(diri, loweri_dir->i_nlink);
532
533 inode = NULL;
534
535 out_iput:
536 iput(inode);
537 inode_unlock(loweri_dir);
538
539 return err;
540 }
541
542 static int shiftfs_create(struct user_namespace *mnt_ns, struct inode *dir,
543 struct dentry *dentry, umode_t mode, bool excl)
544 {
545 mode |= S_IFREG;
546
547 return shiftfs_create_object(&init_user_ns, dir, dentry, mode, NULL, NULL,
548 excl);
549 }
550
551 static int shiftfs_mkdir(struct user_namespace *mnt_ns, struct inode *dir,
552 struct dentry *dentry, umode_t mode)
553 {
554 mode |= S_IFDIR;
555
556 return shiftfs_create_object(&init_user_ns, dir, dentry, mode, NULL, NULL,
557 false);
558 }
559
560 static int shiftfs_link(struct dentry *hardlink, struct inode *dir,
561 struct dentry *dentry)
562 {
563 return shiftfs_create_object(&init_user_ns, dir, dentry, 0, NULL,
564 hardlink, false);
565 }
566
567 static int shiftfs_mknod(struct user_namespace *mnt_ns, struct inode *dir,
568 struct dentry *dentry, umode_t mode, dev_t rdev)
569 {
570 if (!S_ISFIFO(mode) && !S_ISSOCK(mode))
571 return -EPERM;
572
573 return shiftfs_create_object(&init_user_ns, dir, dentry, mode, NULL, NULL,
574 false);
575 }
576
577 static int shiftfs_symlink(struct user_namespace *mnt_ns, struct inode *dir,
578 struct dentry *dentry, const char *symlink)
579 {
580 return shiftfs_create_object(&init_user_ns, dir, dentry, S_IFLNK, symlink, NULL,
581 false);
582 }
583
584 static int shiftfs_rm(struct inode *dir, struct dentry *dentry, bool rmdir)
585 {
586 struct dentry *lowerd = dentry->d_fsdata;
587 struct inode *loweri = dir->i_private;
588 struct inode *inode = d_inode(dentry);
589 int err;
590 const struct cred *oldcred;
591
592 dget(lowerd);
593 oldcred = shiftfs_override_creds(dentry->d_sb);
594 inode_lock_nested(loweri, I_MUTEX_PARENT);
595 if (rmdir)
596 err = vfs_rmdir(&init_user_ns, loweri, lowerd);
597 else
598 err = vfs_unlink(&init_user_ns, loweri, lowerd, NULL);
599 revert_creds(oldcred);
600
601 if (!err) {
602 d_drop(dentry);
603
604 if (rmdir)
605 clear_nlink(inode);
606 else
607 drop_nlink(inode);
608 }
609 inode_unlock(loweri);
610
611 shiftfs_copyattr(loweri, dir);
612 dput(lowerd);
613
614 return err;
615 }
616
617 static int shiftfs_unlink(struct inode *dir, struct dentry *dentry)
618 {
619 return shiftfs_rm(dir, dentry, false);
620 }
621
622 static int shiftfs_rmdir(struct inode *dir, struct dentry *dentry)
623 {
624 return shiftfs_rm(dir, dentry, true);
625 }
626
627 static int shiftfs_rename(struct user_namespace *mnt_ns,
628 struct inode *olddir, struct dentry *old,
629 struct inode *newdir, struct dentry *new,
630 unsigned int flags)
631 {
632 struct dentry *lowerd_dir_old = old->d_parent->d_fsdata,
633 *lowerd_dir_new = new->d_parent->d_fsdata,
634 *lowerd_old = old->d_fsdata, *lowerd_new = new->d_fsdata,
635 *trapd;
636 struct inode *loweri_dir_old = lowerd_dir_old->d_inode,
637 *loweri_dir_new = lowerd_dir_new->d_inode;
638 int err = -EINVAL;
639 const struct cred *oldcred;
640 struct renamedata rd = {};
641
642 trapd = lock_rename(lowerd_dir_new, lowerd_dir_old);
643
644 if (trapd == lowerd_old || trapd == lowerd_new)
645 goto out_unlock;
646
647 oldcred = shiftfs_override_creds(old->d_sb);
648 rd.old_mnt_userns = &init_user_ns;
649 rd.old_dir = loweri_dir_old;
650 rd.old_dentry = lowerd_old;
651 rd.new_mnt_userns = &init_user_ns;
652 rd.new_dir = loweri_dir_new;
653 rd.new_dentry = lowerd_new;
654 rd.flags = flags;
655 err = vfs_rename(&rd);
656 revert_creds(oldcred);
657
658 shiftfs_copyattr(loweri_dir_old, olddir);
659 shiftfs_copyattr(loweri_dir_new, newdir);
660
661 out_unlock:
662 unlock_rename(lowerd_dir_new, lowerd_dir_old);
663
664 return err;
665 }
666
667 static struct dentry *shiftfs_lookup(struct inode *dir, struct dentry *dentry,
668 unsigned int flags)
669 {
670 struct dentry *new;
671 struct inode *newi;
672 const struct cred *oldcred;
673 struct dentry *lowerd = dentry->d_parent->d_fsdata;
674 struct inode *inode = NULL, *loweri = lowerd->d_inode;
675
676 inode_lock(loweri);
677 oldcred = shiftfs_override_creds(dentry->d_sb);
678 new = lookup_one_len(dentry->d_name.name, lowerd, dentry->d_name.len);
679 revert_creds(oldcred);
680 inode_unlock(loweri);
681
682 if (IS_ERR(new))
683 return new;
684
685 dentry->d_fsdata = new;
686
687 newi = new->d_inode;
688 if (!newi)
689 goto out;
690
691 inode = iget5_locked(dentry->d_sb, (unsigned long)newi,
692 shiftfs_inode_test, shiftfs_inode_set, newi);
693 if (!inode) {
694 dput(new);
695 return ERR_PTR(-ENOMEM);
696 }
697 if (inode->i_state & I_NEW) {
698 /*
699 * inode->i_private set by shiftfs_inode_set(), but we still
700 * need to take a reference
701 */
702 ihold(newi);
703 shiftfs_fill_inode(inode, newi->i_ino, newi->i_mode, 0, new);
704 unlock_new_inode(inode);
705 }
706
707 out:
708 return d_splice_alias(inode, dentry);
709 }
710
711 static int shiftfs_permission(struct user_namespace *mnt_ns,
712 struct inode *inode, int mask)
713 {
714 int err;
715 const struct cred *oldcred;
716 struct inode *loweri = inode->i_private;
717
718 if (!loweri) {
719 WARN_ON(!(mask & MAY_NOT_BLOCK));
720 return -ECHILD;
721 }
722
723 err = generic_permission(&init_user_ns, inode, mask);
724 if (err)
725 return err;
726
727 oldcred = shiftfs_override_creds(inode->i_sb);
728 err = inode_permission(&init_user_ns, loweri, mask);
729 revert_creds(oldcred);
730
731 return err;
732 }
733
734 static int shiftfs_fiemap(struct inode *inode,
735 struct fiemap_extent_info *fieinfo, u64 start,
736 u64 len)
737 {
738 int err;
739 const struct cred *oldcred;
740 struct inode *loweri = inode->i_private;
741
742 if (!loweri->i_op->fiemap)
743 return -EOPNOTSUPP;
744
745 oldcred = shiftfs_override_creds(inode->i_sb);
746 if (fieinfo->fi_flags & FIEMAP_FLAG_SYNC)
747 filemap_write_and_wait(loweri->i_mapping);
748 err = loweri->i_op->fiemap(loweri, fieinfo, start, len);
749 revert_creds(oldcred);
750
751 return err;
752 }
753
754 static int shiftfs_tmpfile(struct user_namespace *mnt_ns, struct inode *dir,
755 struct dentry *dentry, umode_t mode)
756 {
757 int err;
758 const struct cred *oldcred;
759 struct dentry *lowerd = dentry->d_fsdata;
760 struct inode *loweri = dir->i_private;
761
762 if (!loweri->i_op->tmpfile)
763 return -EOPNOTSUPP;
764
765 oldcred = shiftfs_override_creds(dir->i_sb);
766 err = loweri->i_op->tmpfile(&init_user_ns, loweri, lowerd, mode);
767 revert_creds(oldcred);
768
769 return err;
770 }
771
772 static int shiftfs_setattr(struct user_namespace *mnt_ns,
773 struct dentry *dentry, struct iattr *attr)
774 {
775 struct dentry *lowerd = dentry->d_fsdata;
776 struct inode *loweri = lowerd->d_inode;
777 struct iattr newattr;
778 const struct cred *oldcred;
779 struct super_block *sb = dentry->d_sb;
780 struct shiftfs_super_info *sbinfo = sb->s_fs_info;
781 int err;
782
783 err = setattr_prepare(&init_user_ns, dentry, attr);
784 if (err)
785 return err;
786
787 newattr = *attr;
788 newattr.ia_uid = shift_kuid(sb->s_user_ns, sbinfo->userns, attr->ia_uid);
789 newattr.ia_gid = shift_kgid(sb->s_user_ns, sbinfo->userns, attr->ia_gid);
790
791 /*
792 * mode change is for clearing setuid/setgid bits. Allow lower fs
793 * to interpret this in its own way.
794 */
795 if (newattr.ia_valid & (ATTR_KILL_SUID|ATTR_KILL_SGID))
796 newattr.ia_valid &= ~ATTR_MODE;
797
798 inode_lock(loweri);
799 oldcred = shiftfs_override_creds(dentry->d_sb);
800 err = notify_change(&init_user_ns, lowerd, &newattr, NULL);
801 revert_creds(oldcred);
802 inode_unlock(loweri);
803
804 shiftfs_copyattr(loweri, d_inode(dentry));
805
806 return err;
807 }
808
809 static int shiftfs_getattr(struct user_namespace *mnt_ns,
810 const struct path *path, struct kstat *stat,
811 u32 request_mask, unsigned int query_flags)
812 {
813 struct inode *inode = path->dentry->d_inode;
814 struct dentry *lowerd = path->dentry->d_fsdata;
815 struct inode *loweri = lowerd->d_inode;
816 struct shiftfs_super_info *info = path->dentry->d_sb->s_fs_info;
817 struct path newpath = { .mnt = info->mnt, .dentry = lowerd };
818 struct user_namespace *from_ns = loweri->i_sb->s_user_ns;
819 struct user_namespace *to_ns = inode->i_sb->s_user_ns;
820 const struct cred *oldcred;
821 int err;
822
823 oldcred = shiftfs_override_creds(inode->i_sb);
824 err = vfs_getattr(&newpath, stat, request_mask, query_flags);
825 revert_creds(oldcred);
826
827 if (err)
828 return err;
829
830 /* transform the underlying id */
831 stat->uid = shift_kuid(from_ns, to_ns, stat->uid);
832 stat->gid = shift_kgid(from_ns, to_ns, stat->gid);
833 return 0;
834 }
835
836 #ifdef CONFIG_SHIFT_FS_POSIX_ACL
837
838 static int
839 shift_acl_ids(struct user_namespace *from, struct user_namespace *to,
840 struct posix_acl *acl)
841 {
842 int i;
843
844 for (i = 0; i < acl->a_count; i++) {
845 struct posix_acl_entry *e = &acl->a_entries[i];
846 switch(e->e_tag) {
847 case ACL_USER:
848 e->e_uid = shift_kuid(from, to, e->e_uid);
849 if (!uid_valid(e->e_uid))
850 return -EOVERFLOW;
851 break;
852 case ACL_GROUP:
853 e->e_gid = shift_kgid(from, to, e->e_gid);
854 if (!gid_valid(e->e_gid))
855 return -EOVERFLOW;
856 break;
857 }
858 }
859 return 0;
860 }
861
862 static void
863 shift_acl_xattr_ids(struct user_namespace *from, struct user_namespace *to,
864 void *value, size_t size)
865 {
866 struct posix_acl_xattr_header *header = value;
867 struct posix_acl_xattr_entry *entry = (void *)(header + 1), *end;
868 int count;
869 kuid_t kuid;
870 kgid_t kgid;
871
872 if (!value)
873 return;
874 if (size < sizeof(struct posix_acl_xattr_header))
875 return;
876 if (header->a_version != cpu_to_le32(POSIX_ACL_XATTR_VERSION))
877 return;
878
879 count = posix_acl_xattr_count(size);
880 if (count < 0)
881 return;
882 if (count == 0)
883 return;
884
885 for (end = entry + count; entry != end; entry++) {
886 switch(le16_to_cpu(entry->e_tag)) {
887 case ACL_USER:
888 kuid = make_kuid(&init_user_ns, le32_to_cpu(entry->e_id));
889 kuid = shift_kuid(from, to, kuid);
890 entry->e_id = cpu_to_le32(from_kuid(&init_user_ns, kuid));
891 break;
892 case ACL_GROUP:
893 kgid = make_kgid(&init_user_ns, le32_to_cpu(entry->e_id));
894 kgid = shift_kgid(from, to, kgid);
895 entry->e_id = cpu_to_le32(from_kgid(&init_user_ns, kgid));
896 break;
897 default:
898 break;
899 }
900 }
901 }
902
903 static struct posix_acl *shiftfs_get_acl(struct inode *inode, int type)
904 {
905 struct inode *loweri = inode->i_private;
906 const struct cred *oldcred;
907 struct posix_acl *lower_acl, *acl = NULL;
908 struct user_namespace *from_ns = loweri->i_sb->s_user_ns;
909 struct user_namespace *to_ns = inode->i_sb->s_user_ns;
910 int size;
911 int err;
912
913 if (!IS_POSIXACL(loweri))
914 return NULL;
915
916 oldcred = shiftfs_override_creds(inode->i_sb);
917 lower_acl = get_acl(loweri, type);
918 revert_creds(oldcred);
919
920 if (lower_acl && !IS_ERR(lower_acl)) {
921 /* XXX: export posix_acl_clone? */
922 size = sizeof(struct posix_acl) +
923 lower_acl->a_count * sizeof(struct posix_acl_entry);
924 acl = kmemdup(lower_acl, size, GFP_KERNEL);
925 posix_acl_release(lower_acl);
926
927 if (!acl)
928 return ERR_PTR(-ENOMEM);
929
930 refcount_set(&acl->a_refcount, 1);
931
932 err = shift_acl_ids(from_ns, to_ns, acl);
933 if (err) {
934 kfree(acl);
935 return ERR_PTR(err);
936 }
937 }
938
939 return acl;
940 }
941
942 static int
943 shiftfs_posix_acl_xattr_get(const struct xattr_handler *handler,
944 struct dentry *dentry, struct inode *inode,
945 const char *name, void *buffer, size_t size)
946 {
947 struct inode *loweri = inode->i_private;
948 int ret;
949
950 ret = shiftfs_xattr_get(NULL, dentry, inode, handler->name,
951 buffer, size);
952 if (ret < 0)
953 return ret;
954
955 inode_lock(loweri);
956 shift_acl_xattr_ids(loweri->i_sb->s_user_ns, inode->i_sb->s_user_ns,
957 buffer, size);
958 inode_unlock(loweri);
959 return ret;
960 }
961
962 static int
963 shiftfs_posix_acl_xattr_set(const struct xattr_handler *handler,
964 struct user_namespace *mnt_ns,
965 struct dentry *dentry, struct inode *inode,
966 const char *name, const void *value,
967 size_t size, int flags)
968 {
969 struct inode *loweri = inode->i_private;
970 int err;
971
972 if (!IS_POSIXACL(loweri) || !loweri->i_op->set_acl)
973 return -EOPNOTSUPP;
974 if (handler->flags == ACL_TYPE_DEFAULT && !S_ISDIR(inode->i_mode))
975 return value ? -EACCES : 0;
976 if (!inode_owner_or_capable(&init_user_ns, inode))
977 return -EPERM;
978
979 if (value) {
980 shift_acl_xattr_ids(inode->i_sb->s_user_ns,
981 loweri->i_sb->s_user_ns,
982 (void *)value, size);
983 err = shiftfs_setxattr(&init_user_ns, dentry, inode, handler->name, value,
984 size, flags);
985 } else {
986 err = shiftfs_removexattr(&init_user_ns, dentry, handler->name);
987 }
988
989 if (!err)
990 shiftfs_copyattr(loweri, inode);
991
992 return err;
993 }
994
995 static const struct xattr_handler
996 shiftfs_posix_acl_access_xattr_handler = {
997 .name = XATTR_NAME_POSIX_ACL_ACCESS,
998 .flags = ACL_TYPE_ACCESS,
999 .get = shiftfs_posix_acl_xattr_get,
1000 .set = shiftfs_posix_acl_xattr_set,
1001 };
1002
1003 static const struct xattr_handler
1004 shiftfs_posix_acl_default_xattr_handler = {
1005 .name = XATTR_NAME_POSIX_ACL_DEFAULT,
1006 .flags = ACL_TYPE_DEFAULT,
1007 .get = shiftfs_posix_acl_xattr_get,
1008 .set = shiftfs_posix_acl_xattr_set,
1009 };
1010
1011 #else /* !CONFIG_SHIFT_FS_POSIX_ACL */
1012
1013 #define shiftfs_get_acl NULL
1014
1015 #endif /* CONFIG_SHIFT_FS_POSIX_ACL */
1016
1017 static const struct inode_operations shiftfs_dir_inode_operations = {
1018 .lookup = shiftfs_lookup,
1019 .mkdir = shiftfs_mkdir,
1020 .symlink = shiftfs_symlink,
1021 .unlink = shiftfs_unlink,
1022 .rmdir = shiftfs_rmdir,
1023 .rename = shiftfs_rename,
1024 .link = shiftfs_link,
1025 .setattr = shiftfs_setattr,
1026 .create = shiftfs_create,
1027 .mknod = shiftfs_mknod,
1028 .permission = shiftfs_permission,
1029 .getattr = shiftfs_getattr,
1030 .listxattr = shiftfs_listxattr,
1031 .get_acl = shiftfs_get_acl,
1032 };
1033
1034 static const struct inode_operations shiftfs_file_inode_operations = {
1035 .fiemap = shiftfs_fiemap,
1036 .getattr = shiftfs_getattr,
1037 .get_acl = shiftfs_get_acl,
1038 .listxattr = shiftfs_listxattr,
1039 .permission = shiftfs_permission,
1040 .setattr = shiftfs_setattr,
1041 .tmpfile = shiftfs_tmpfile,
1042 };
1043
1044 static const struct inode_operations shiftfs_special_inode_operations = {
1045 .getattr = shiftfs_getattr,
1046 .get_acl = shiftfs_get_acl,
1047 .listxattr = shiftfs_listxattr,
1048 .permission = shiftfs_permission,
1049 .setattr = shiftfs_setattr,
1050 };
1051
1052 static const struct inode_operations shiftfs_symlink_inode_operations = {
1053 .getattr = shiftfs_getattr,
1054 .get_link = shiftfs_get_link,
1055 .listxattr = shiftfs_listxattr,
1056 .setattr = shiftfs_setattr,
1057 };
1058
1059 static struct file *shiftfs_open_realfile(const struct file *file,
1060 struct inode *realinode)
1061 {
1062 struct file *realfile;
1063 const struct cred *old_cred;
1064 struct inode *inode = file_inode(file);
1065 struct dentry *lowerd = file->f_path.dentry->d_fsdata;
1066 struct shiftfs_super_info *info = inode->i_sb->s_fs_info;
1067 struct path realpath = { .mnt = info->mnt, .dentry = lowerd };
1068
1069 old_cred = shiftfs_override_creds(inode->i_sb);
1070 realfile = open_with_fake_path(&realpath, file->f_flags, realinode,
1071 info->creator_cred);
1072 revert_creds(old_cred);
1073
1074 return realfile;
1075 }
1076
1077 #define SHIFTFS_SETFL_MASK (O_APPEND | O_NONBLOCK | O_NDELAY | O_DIRECT)
1078
1079 static int shiftfs_change_flags(struct file *file, unsigned int flags)
1080 {
1081 struct inode *inode = file_inode(file);
1082 int err;
1083
1084 /* if some flag changed that cannot be changed then something's amiss */
1085 if (WARN_ON((file->f_flags ^ flags) & ~SHIFTFS_SETFL_MASK))
1086 return -EIO;
1087
1088 flags &= SHIFTFS_SETFL_MASK;
1089
1090 if (((flags ^ file->f_flags) & O_APPEND) && IS_APPEND(inode))
1091 return -EPERM;
1092
1093 if (flags & O_DIRECT) {
1094 if (!file->f_mapping->a_ops ||
1095 !file->f_mapping->a_ops->direct_IO)
1096 return -EINVAL;
1097 }
1098
1099 if (file->f_op->check_flags) {
1100 err = file->f_op->check_flags(flags);
1101 if (err)
1102 return err;
1103 }
1104
1105 spin_lock(&file->f_lock);
1106 file->f_flags = (file->f_flags & ~SHIFTFS_SETFL_MASK) | flags;
1107 spin_unlock(&file->f_lock);
1108
1109 return 0;
1110 }
1111
1112 static int shiftfs_open(struct inode *inode, struct file *file)
1113 {
1114 struct file *realfile;
1115
1116 realfile = shiftfs_open_realfile(file, inode->i_private);
1117 if (IS_ERR(realfile))
1118 return PTR_ERR(realfile);
1119
1120 file->private_data = realfile;
1121 /* For O_DIRECT dentry_open() checks f_mapping->a_ops->direct_IO. */
1122 file->f_mapping = realfile->f_mapping;
1123
1124 return 0;
1125 }
1126
1127 static int shiftfs_dir_open(struct inode *inode, struct file *file)
1128 {
1129 struct file *realfile;
1130 const struct cred *oldcred;
1131 struct dentry *lowerd = file->f_path.dentry->d_fsdata;
1132 struct shiftfs_super_info *info = inode->i_sb->s_fs_info;
1133 struct path realpath = { .mnt = info->mnt, .dentry = lowerd };
1134
1135 oldcred = shiftfs_override_creds(file->f_path.dentry->d_sb);
1136 realfile = dentry_open(&realpath, file->f_flags | O_NOATIME,
1137 info->creator_cred);
1138 revert_creds(oldcred);
1139 if (IS_ERR(realfile))
1140 return PTR_ERR(realfile);
1141
1142 file->private_data = realfile;
1143
1144 return 0;
1145 }
1146
1147 static int shiftfs_release(struct inode *inode, struct file *file)
1148 {
1149 struct file *realfile = file->private_data;
1150
1151 if (realfile)
1152 fput(realfile);
1153
1154 return 0;
1155 }
1156
1157 static int shiftfs_dir_release(struct inode *inode, struct file *file)
1158 {
1159 return shiftfs_release(inode, file);
1160 }
1161
1162 static loff_t shiftfs_dir_llseek(struct file *file, loff_t offset, int whence)
1163 {
1164 struct file *realfile = file->private_data;
1165
1166 return vfs_llseek(realfile, offset, whence);
1167 }
1168
1169 static loff_t shiftfs_file_llseek(struct file *file, loff_t offset, int whence)
1170 {
1171 struct inode *realinode = file_inode(file)->i_private;
1172
1173 return generic_file_llseek_size(file, offset, whence,
1174 realinode->i_sb->s_maxbytes,
1175 i_size_read(realinode));
1176 }
1177
1178 /* XXX: Need to figure out what to to about atime updates, maybe other
1179 * timestamps too ... ref. ovl_file_accessed() */
1180
1181 static rwf_t shiftfs_iocb_to_rwf(struct kiocb *iocb)
1182 {
1183 int ifl = iocb->ki_flags;
1184 rwf_t flags = 0;
1185
1186 if (ifl & IOCB_NOWAIT)
1187 flags |= RWF_NOWAIT;
1188 if (ifl & IOCB_HIPRI)
1189 flags |= RWF_HIPRI;
1190 if (ifl & IOCB_DSYNC)
1191 flags |= RWF_DSYNC;
1192 if (ifl & IOCB_SYNC)
1193 flags |= RWF_SYNC;
1194
1195 return flags;
1196 }
1197
1198 static int shiftfs_real_fdget(const struct file *file, struct fd *lowerfd)
1199 {
1200 struct file *realfile;
1201
1202 if (file->f_op->open != shiftfs_open &&
1203 file->f_op->open != shiftfs_dir_open)
1204 return -EINVAL;
1205
1206 realfile = file->private_data;
1207 lowerfd->flags = 0;
1208 lowerfd->file = realfile;
1209
1210 /* Did the flags change since open? */
1211 if (unlikely(file->f_flags & ~lowerfd->file->f_flags))
1212 return shiftfs_change_flags(lowerfd->file, file->f_flags);
1213
1214 return 0;
1215 }
1216
1217 static ssize_t shiftfs_read_iter(struct kiocb *iocb, struct iov_iter *iter)
1218 {
1219 struct file *file = iocb->ki_filp;
1220 struct fd lowerfd;
1221 const struct cred *oldcred;
1222 ssize_t ret;
1223
1224 if (!iov_iter_count(iter))
1225 return 0;
1226
1227 ret = shiftfs_real_fdget(file, &lowerfd);
1228 if (ret)
1229 return ret;
1230
1231 oldcred = shiftfs_override_creds(file->f_path.dentry->d_sb);
1232 ret = vfs_iter_read(lowerfd.file, iter, &iocb->ki_pos,
1233 shiftfs_iocb_to_rwf(iocb));
1234 revert_creds(oldcred);
1235
1236 shiftfs_file_accessed(file);
1237
1238 fdput(lowerfd);
1239 return ret;
1240 }
1241
1242 static ssize_t shiftfs_write_iter(struct kiocb *iocb, struct iov_iter *iter)
1243 {
1244 struct file *file = iocb->ki_filp;
1245 struct inode *inode = file_inode(file);
1246 struct fd lowerfd;
1247 const struct cred *oldcred;
1248 ssize_t ret;
1249
1250 if (!iov_iter_count(iter))
1251 return 0;
1252
1253 inode_lock(inode);
1254 /* Update mode */
1255 shiftfs_copyattr(inode->i_private, inode);
1256 ret = file_remove_privs(file);
1257 if (ret)
1258 goto out_unlock;
1259
1260 ret = shiftfs_real_fdget(file, &lowerfd);
1261 if (ret)
1262 goto out_unlock;
1263
1264 oldcred = shiftfs_override_creds(file->f_path.dentry->d_sb);
1265 file_start_write(lowerfd.file);
1266 ret = vfs_iter_write(lowerfd.file, iter, &iocb->ki_pos,
1267 shiftfs_iocb_to_rwf(iocb));
1268 file_end_write(lowerfd.file);
1269 revert_creds(oldcred);
1270
1271 /* Update size */
1272 shiftfs_copyattr(inode->i_private, inode);
1273
1274 fdput(lowerfd);
1275
1276 out_unlock:
1277 inode_unlock(inode);
1278 return ret;
1279 }
1280
1281 static int shiftfs_fsync(struct file *file, loff_t start, loff_t end,
1282 int datasync)
1283 {
1284 struct fd lowerfd;
1285 const struct cred *oldcred;
1286 int ret;
1287
1288 ret = shiftfs_real_fdget(file, &lowerfd);
1289 if (ret)
1290 return ret;
1291
1292 oldcred = shiftfs_override_creds(file->f_path.dentry->d_sb);
1293 ret = vfs_fsync_range(lowerfd.file, start, end, datasync);
1294 revert_creds(oldcred);
1295
1296 fdput(lowerfd);
1297 return ret;
1298 }
1299
1300 static int shiftfs_mmap(struct file *file, struct vm_area_struct *vma)
1301 {
1302 struct file *realfile = file->private_data;
1303 const struct cred *oldcred;
1304 int ret;
1305
1306 if (!realfile->f_op->mmap)
1307 return -ENODEV;
1308
1309 if (WARN_ON(file != vma->vm_file))
1310 return -EIO;
1311
1312 oldcred = shiftfs_override_creds(file->f_path.dentry->d_sb);
1313 vma->vm_file = get_file(realfile);
1314 ret = call_mmap(vma->vm_file, vma);
1315 revert_creds(oldcred);
1316
1317 shiftfs_file_accessed(file);
1318
1319 if (ret) {
1320 /*
1321 * Drop refcount from new vm_file value and restore original
1322 * vm_file value
1323 */
1324 vma->vm_file = file;
1325 fput(realfile);
1326 } else {
1327 /* Drop refcount from previous vm_file value */
1328 fput(file);
1329 }
1330
1331 return ret;
1332 }
1333
1334 static long shiftfs_fallocate(struct file *file, int mode, loff_t offset,
1335 loff_t len)
1336 {
1337 struct inode *inode = file_inode(file);
1338 struct inode *loweri = inode->i_private;
1339 struct fd lowerfd;
1340 const struct cred *oldcred;
1341 int ret;
1342
1343 ret = shiftfs_real_fdget(file, &lowerfd);
1344 if (ret)
1345 return ret;
1346
1347 oldcred = shiftfs_override_creds(file->f_path.dentry->d_sb);
1348 ret = vfs_fallocate(lowerfd.file, mode, offset, len);
1349 revert_creds(oldcred);
1350
1351 /* Update size */
1352 shiftfs_copyattr(loweri, inode);
1353
1354 fdput(lowerfd);
1355 return ret;
1356 }
1357
1358 static int shiftfs_fadvise(struct file *file, loff_t offset, loff_t len,
1359 int advice)
1360 {
1361 struct fd lowerfd;
1362 const struct cred *oldcred;
1363 int ret;
1364
1365 ret = shiftfs_real_fdget(file, &lowerfd);
1366 if (ret)
1367 return ret;
1368
1369 oldcred = shiftfs_override_creds(file->f_path.dentry->d_sb);
1370 ret = vfs_fadvise(lowerfd.file, offset, len, advice);
1371 revert_creds(oldcred);
1372
1373 fdput(lowerfd);
1374 return ret;
1375 }
1376
1377 static int shiftfs_override_ioctl_creds(int cmd, const struct super_block *sb,
1378 const struct cred **oldcred,
1379 struct cred **newcred)
1380 {
1381 struct shiftfs_super_info *sbinfo = sb->s_fs_info;
1382 kuid_t fsuid = current_fsuid();
1383 kgid_t fsgid = current_fsgid();
1384
1385 *oldcred = shiftfs_override_creds(sb);
1386
1387 *newcred = prepare_creds();
1388 if (!*newcred) {
1389 revert_creds(*oldcred);
1390 return -ENOMEM;
1391 }
1392
1393 (*newcred)->fsuid = shift_kuid(sb->s_user_ns, sbinfo->userns, fsuid);
1394 (*newcred)->fsgid = shift_kgid(sb->s_user_ns, sbinfo->userns, fsgid);
1395
1396 /* clear all caps to prevent bypassing capable() checks */
1397 cap_clear((*newcred)->cap_bset);
1398 cap_clear((*newcred)->cap_effective);
1399 cap_clear((*newcred)->cap_inheritable);
1400 cap_clear((*newcred)->cap_permitted);
1401
1402 if (cmd == BTRFS_IOC_SNAP_DESTROY) {
1403 kuid_t kuid_root = make_kuid(sb->s_user_ns, 0);
1404 /*
1405 * Allow the root user in the container to remove subvolumes
1406 * from other users.
1407 */
1408 if (uid_valid(kuid_root) && uid_eq(fsuid, kuid_root))
1409 cap_raise((*newcred)->cap_effective, CAP_DAC_OVERRIDE);
1410 }
1411
1412 put_cred(override_creds(*newcred));
1413 return 0;
1414 }
1415
1416 static inline void shiftfs_revert_ioctl_creds(const struct cred *oldcred,
1417 struct cred *newcred)
1418 {
1419 return shiftfs_revert_object_creds(oldcred, newcred);
1420 }
1421
1422 static inline bool is_btrfs_snap_ioctl(int cmd)
1423 {
1424 if ((cmd == BTRFS_IOC_SNAP_CREATE) || (cmd == BTRFS_IOC_SNAP_CREATE_V2))
1425 return true;
1426
1427 return false;
1428 }
1429
1430 static int shiftfs_btrfs_ioctl_fd_restore(int cmd, int fd, void __user *arg,
1431 struct btrfs_ioctl_vol_args *v1,
1432 struct btrfs_ioctl_vol_args_v2 *v2)
1433 {
1434 int ret;
1435
1436 if (!is_btrfs_snap_ioctl(cmd))
1437 return 0;
1438
1439 if (cmd == BTRFS_IOC_SNAP_CREATE)
1440 ret = copy_to_user(arg, v1, sizeof(*v1));
1441 else
1442 ret = copy_to_user(arg, v2, sizeof(*v2));
1443
1444 close_fd(fd);
1445 kfree(v1);
1446 kfree(v2);
1447
1448 return ret ? -EFAULT: 0;
1449 }
1450
1451 static int shiftfs_btrfs_ioctl_fd_replace(int cmd, void __user *arg,
1452 struct btrfs_ioctl_vol_args **b1,
1453 struct btrfs_ioctl_vol_args_v2 **b2,
1454 int *newfd)
1455 {
1456 int oldfd, ret;
1457 struct fd src;
1458 struct fd lfd = {};
1459 struct btrfs_ioctl_vol_args *v1 = NULL;
1460 struct btrfs_ioctl_vol_args_v2 *v2 = NULL;
1461
1462 *b1 = NULL;
1463 *b2 = NULL;
1464
1465 if (!is_btrfs_snap_ioctl(cmd))
1466 return 0;
1467
1468 if (cmd == BTRFS_IOC_SNAP_CREATE) {
1469 v1 = memdup_user(arg, sizeof(*v1));
1470 if (IS_ERR(v1))
1471 return PTR_ERR(v1);
1472 oldfd = v1->fd;
1473 } else {
1474 v2 = memdup_user(arg, sizeof(*v2));
1475 if (IS_ERR(v2))
1476 return PTR_ERR(v2);
1477 oldfd = v2->fd;
1478 }
1479
1480 src = fdget(oldfd);
1481 if (!src.file) {
1482 ret = -EINVAL;
1483 goto err_free;
1484 }
1485
1486 ret = shiftfs_real_fdget(src.file, &lfd);
1487 if (ret) {
1488 fdput(src);
1489 goto err_free;
1490 }
1491
1492 /*
1493 * shiftfs_real_fdget() does not take a reference to lfd.file, so
1494 * take a reference here to offset the one which will be put by
1495 * close_fd(), and make sure that reference is put on fdput(lfd).
1496 */
1497 get_file(lfd.file);
1498 lfd.flags |= FDPUT_FPUT;
1499 fdput(src);
1500
1501 *newfd = get_unused_fd_flags(lfd.file->f_flags);
1502 if (*newfd < 0) {
1503 fdput(lfd);
1504 ret = *newfd;
1505 goto err_free;
1506 }
1507
1508 fd_install(*newfd, lfd.file);
1509
1510 if (cmd == BTRFS_IOC_SNAP_CREATE) {
1511 v1->fd = *newfd;
1512 ret = copy_to_user(arg, v1, sizeof(*v1));
1513 v1->fd = oldfd;
1514 } else {
1515 v2->fd = *newfd;
1516 ret = copy_to_user(arg, v2, sizeof(*v2));
1517 v2->fd = oldfd;
1518 }
1519
1520 if (!ret) {
1521 *b1 = v1;
1522 *b2 = v2;
1523 } else {
1524 shiftfs_btrfs_ioctl_fd_restore(cmd, *newfd, arg, v1, v2);
1525 ret = -EFAULT;
1526 }
1527
1528 return ret;
1529
1530 err_free:
1531 kfree(v1);
1532 kfree(v2);
1533
1534 return ret;
1535 }
1536
1537 static long shiftfs_real_ioctl(struct file *file, unsigned int cmd,
1538 unsigned long arg)
1539 {
1540 struct fd lowerfd;
1541 struct cred *newcred;
1542 const struct cred *oldcred;
1543 int newfd = -EBADF;
1544 long err = 0, ret = 0;
1545 void __user *argp = (void __user *)arg;
1546 struct super_block *sb = file->f_path.dentry->d_sb;
1547 struct btrfs_ioctl_vol_args *btrfs_v1 = NULL;
1548 struct btrfs_ioctl_vol_args_v2 *btrfs_v2 = NULL;
1549
1550 ret = shiftfs_btrfs_ioctl_fd_replace(cmd, argp, &btrfs_v1, &btrfs_v2,
1551 &newfd);
1552 if (ret < 0)
1553 return ret;
1554
1555 ret = shiftfs_real_fdget(file, &lowerfd);
1556 if (ret)
1557 goto out_restore;
1558
1559 ret = shiftfs_override_ioctl_creds(cmd, sb, &oldcred, &newcred);
1560 if (ret)
1561 goto out_fdput;
1562
1563 ret = vfs_ioctl(lowerfd.file, cmd, arg);
1564
1565 shiftfs_revert_ioctl_creds(oldcred, newcred);
1566
1567 shiftfs_copyattr(file_inode(lowerfd.file), file_inode(file));
1568 shiftfs_copyflags(file_inode(lowerfd.file), file_inode(file));
1569
1570 out_fdput:
1571 fdput(lowerfd);
1572
1573 out_restore:
1574 err = shiftfs_btrfs_ioctl_fd_restore(cmd, newfd, argp,
1575 btrfs_v1, btrfs_v2);
1576 if (!ret)
1577 ret = err;
1578
1579 return ret;
1580 }
1581
1582 static bool in_ioctl_whitelist(int flag, unsigned long arg)
1583 {
1584 void __user *argp = (void __user *)arg;
1585 u64 flags = 0;
1586
1587 switch (flag) {
1588 case BTRFS_IOC_FS_INFO:
1589 return true;
1590 case BTRFS_IOC_SNAP_CREATE:
1591 return true;
1592 case BTRFS_IOC_SNAP_CREATE_V2:
1593 return true;
1594 case BTRFS_IOC_SUBVOL_CREATE:
1595 return true;
1596 case BTRFS_IOC_SUBVOL_CREATE_V2:
1597 return true;
1598 case BTRFS_IOC_SUBVOL_GETFLAGS:
1599 return true;
1600 case BTRFS_IOC_SUBVOL_SETFLAGS:
1601 if (copy_from_user(&flags, argp, sizeof(flags)))
1602 return false;
1603
1604 if (flags & ~BTRFS_SUBVOL_RDONLY)
1605 return false;
1606
1607 return true;
1608 case BTRFS_IOC_SNAP_DESTROY:
1609 return true;
1610 }
1611
1612 return false;
1613 }
1614
1615 static long shiftfs_ioctl(struct file *file, unsigned int cmd,
1616 unsigned long arg)
1617 {
1618 switch (cmd) {
1619 case FS_IOC_GETVERSION:
1620 /* fall through */
1621 case FS_IOC_GETFLAGS:
1622 /* fall through */
1623 case FS_IOC_SETFLAGS:
1624 break;
1625 default:
1626 if (!in_ioctl_whitelist(cmd, arg) ||
1627 !shiftfs_passthrough_ioctls(file->f_path.dentry->d_sb->s_fs_info))
1628 return -ENOTTY;
1629 }
1630
1631 return shiftfs_real_ioctl(file, cmd, arg);
1632 }
1633
1634 static long shiftfs_compat_ioctl(struct file *file, unsigned int cmd,
1635 unsigned long arg)
1636 {
1637 switch (cmd) {
1638 case FS_IOC32_GETVERSION:
1639 /* fall through */
1640 case FS_IOC32_GETFLAGS:
1641 /* fall through */
1642 case FS_IOC32_SETFLAGS:
1643 break;
1644 default:
1645 if (!in_ioctl_whitelist(cmd, arg) ||
1646 !shiftfs_passthrough_ioctls(file->f_path.dentry->d_sb->s_fs_info))
1647 return -ENOIOCTLCMD;
1648 }
1649
1650 return shiftfs_real_ioctl(file, cmd, arg);
1651 }
1652
1653 enum shiftfs_copyop {
1654 SHIFTFS_COPY,
1655 SHIFTFS_CLONE,
1656 SHIFTFS_DEDUPE,
1657 };
1658
1659 static ssize_t shiftfs_copyfile(struct file *file_in, loff_t pos_in,
1660 struct file *file_out, loff_t pos_out, u64 len,
1661 unsigned int flags, enum shiftfs_copyop op)
1662 {
1663 ssize_t ret;
1664 struct fd real_in, real_out;
1665 const struct cred *oldcred;
1666 struct inode *inode_out = file_inode(file_out);
1667 struct inode *loweri = inode_out->i_private;
1668
1669 ret = shiftfs_real_fdget(file_out, &real_out);
1670 if (ret)
1671 return ret;
1672
1673 ret = shiftfs_real_fdget(file_in, &real_in);
1674 if (ret) {
1675 fdput(real_out);
1676 return ret;
1677 }
1678
1679 oldcred = shiftfs_override_creds(inode_out->i_sb);
1680 switch (op) {
1681 case SHIFTFS_COPY:
1682 ret = vfs_copy_file_range(real_in.file, pos_in, real_out.file,
1683 pos_out, len, flags);
1684 break;
1685
1686 case SHIFTFS_CLONE:
1687 ret = vfs_clone_file_range(real_in.file, pos_in, real_out.file,
1688 pos_out, len, flags);
1689 break;
1690
1691 case SHIFTFS_DEDUPE:
1692 ret = vfs_dedupe_file_range_one(real_in.file, pos_in,
1693 real_out.file, pos_out, len,
1694 flags);
1695 break;
1696 }
1697 revert_creds(oldcred);
1698
1699 /* Update size */
1700 shiftfs_copyattr(loweri, inode_out);
1701
1702 fdput(real_in);
1703 fdput(real_out);
1704
1705 return ret;
1706 }
1707
1708 static ssize_t shiftfs_copy_file_range(struct file *file_in, loff_t pos_in,
1709 struct file *file_out, loff_t pos_out,
1710 size_t len, unsigned int flags)
1711 {
1712 return shiftfs_copyfile(file_in, pos_in, file_out, pos_out, len, flags,
1713 SHIFTFS_COPY);
1714 }
1715
1716 static loff_t shiftfs_remap_file_range(struct file *file_in, loff_t pos_in,
1717 struct file *file_out, loff_t pos_out,
1718 loff_t len, unsigned int remap_flags)
1719 {
1720 enum shiftfs_copyop op;
1721
1722 if (remap_flags & ~(REMAP_FILE_DEDUP | REMAP_FILE_ADVISORY))
1723 return -EINVAL;
1724
1725 if (remap_flags & REMAP_FILE_DEDUP)
1726 op = SHIFTFS_DEDUPE;
1727 else
1728 op = SHIFTFS_CLONE;
1729
1730 return shiftfs_copyfile(file_in, pos_in, file_out, pos_out, len,
1731 remap_flags, op);
1732 }
1733
1734 static int shiftfs_iterate_shared(struct file *file, struct dir_context *ctx)
1735 {
1736 const struct cred *oldcred;
1737 int err = -ENOTDIR;
1738 struct file *realfile = file->private_data;
1739
1740 oldcred = shiftfs_override_creds(file->f_path.dentry->d_sb);
1741 err = iterate_dir(realfile, ctx);
1742 revert_creds(oldcred);
1743
1744 return err;
1745 }
1746
1747 const struct file_operations shiftfs_file_operations = {
1748 .open = shiftfs_open,
1749 .release = shiftfs_release,
1750 .llseek = shiftfs_file_llseek,
1751 .read_iter = shiftfs_read_iter,
1752 .write_iter = shiftfs_write_iter,
1753 .fsync = shiftfs_fsync,
1754 .mmap = shiftfs_mmap,
1755 .fallocate = shiftfs_fallocate,
1756 .fadvise = shiftfs_fadvise,
1757 .unlocked_ioctl = shiftfs_ioctl,
1758 .compat_ioctl = shiftfs_compat_ioctl,
1759 .copy_file_range = shiftfs_copy_file_range,
1760 .remap_file_range = shiftfs_remap_file_range,
1761 };
1762
1763 const struct file_operations shiftfs_dir_operations = {
1764 .open = shiftfs_dir_open,
1765 .release = shiftfs_dir_release,
1766 .compat_ioctl = shiftfs_compat_ioctl,
1767 .fsync = shiftfs_fsync,
1768 .iterate_shared = shiftfs_iterate_shared,
1769 .llseek = shiftfs_dir_llseek,
1770 .read = generic_read_dir,
1771 .unlocked_ioctl = shiftfs_ioctl,
1772 };
1773
1774 static const struct address_space_operations shiftfs_aops = {
1775 /* For O_DIRECT dentry_open() checks f_mapping->a_ops->direct_IO */
1776 .direct_IO = noop_direct_IO,
1777 };
1778
1779 static void shiftfs_fill_inode(struct inode *inode, unsigned long ino,
1780 umode_t mode, dev_t dev, struct dentry *dentry)
1781 {
1782 struct inode *loweri;
1783
1784 inode->i_ino = ino;
1785 inode->i_flags |= S_NOCMTIME;
1786
1787 mode &= S_IFMT;
1788 inode->i_mode = mode;
1789 switch (mode & S_IFMT) {
1790 case S_IFDIR:
1791 inode->i_op = &shiftfs_dir_inode_operations;
1792 inode->i_fop = &shiftfs_dir_operations;
1793 break;
1794 case S_IFLNK:
1795 inode->i_op = &shiftfs_symlink_inode_operations;
1796 break;
1797 case S_IFREG:
1798 inode->i_op = &shiftfs_file_inode_operations;
1799 inode->i_fop = &shiftfs_file_operations;
1800 inode->i_mapping->a_ops = &shiftfs_aops;
1801 break;
1802 default:
1803 inode->i_op = &shiftfs_special_inode_operations;
1804 init_special_inode(inode, mode, dev);
1805 break;
1806 }
1807
1808 if (!dentry)
1809 return;
1810
1811 loweri = dentry->d_inode;
1812 if (!loweri->i_op->get_link)
1813 inode->i_opflags |= IOP_NOFOLLOW;
1814
1815 shiftfs_copyattr(loweri, inode);
1816 shiftfs_copyflags(loweri, inode);
1817 set_nlink(inode, loweri->i_nlink);
1818 }
1819
1820 static int shiftfs_show_options(struct seq_file *m, struct dentry *dentry)
1821 {
1822 struct super_block *sb = dentry->d_sb;
1823 struct shiftfs_super_info *sbinfo = sb->s_fs_info;
1824
1825 if (sbinfo->mark)
1826 seq_show_option(m, "mark", NULL);
1827
1828 if (sbinfo->passthrough)
1829 seq_printf(m, ",passthrough=%u", sbinfo->passthrough);
1830
1831 return 0;
1832 }
1833
1834 static int shiftfs_statfs(struct dentry *dentry, struct kstatfs *buf)
1835 {
1836 struct super_block *sb = dentry->d_sb;
1837 struct shiftfs_super_info *sbinfo = sb->s_fs_info;
1838 struct dentry *root = sb->s_root;
1839 struct dentry *realroot = root->d_fsdata;
1840 struct path realpath = { .mnt = sbinfo->mnt, .dentry = realroot };
1841 int err;
1842
1843 err = vfs_statfs(&realpath, buf);
1844 if (err)
1845 return err;
1846
1847 if (!shiftfs_passthrough_statfs(sbinfo))
1848 buf->f_type = sb->s_magic;
1849
1850 return 0;
1851 }
1852
1853 static void shiftfs_evict_inode(struct inode *inode)
1854 {
1855 struct inode *loweri = inode->i_private;
1856
1857 clear_inode(inode);
1858
1859 if (loweri)
1860 iput(loweri);
1861 }
1862
1863 static void shiftfs_put_super(struct super_block *sb)
1864 {
1865 struct shiftfs_super_info *sbinfo = sb->s_fs_info;
1866
1867 if (sbinfo) {
1868 mntput(sbinfo->mnt);
1869 put_cred(sbinfo->creator_cred);
1870 kfree(sbinfo);
1871 }
1872 }
1873
1874 static const struct xattr_handler shiftfs_xattr_handler = {
1875 .prefix = "",
1876 .get = shiftfs_xattr_get,
1877 .set = shiftfs_xattr_set,
1878 };
1879
1880 const struct xattr_handler *shiftfs_xattr_handlers[] = {
1881 #ifdef CONFIG_SHIFT_FS_POSIX_ACL
1882 &shiftfs_posix_acl_access_xattr_handler,
1883 &shiftfs_posix_acl_default_xattr_handler,
1884 #endif
1885 &shiftfs_xattr_handler,
1886 NULL
1887 };
1888
1889 static inline bool passthrough_is_subset(int old_flags, int new_flags)
1890 {
1891 if ((new_flags & old_flags) != new_flags)
1892 return false;
1893
1894 return true;
1895 }
1896
1897 static int shiftfs_super_check_flags(unsigned long old_flags,
1898 unsigned long new_flags)
1899 {
1900 if ((old_flags & SB_RDONLY) && !(new_flags & SB_RDONLY))
1901 return -EPERM;
1902
1903 if ((old_flags & SB_NOSUID) && !(new_flags & SB_NOSUID))
1904 return -EPERM;
1905
1906 if ((old_flags & SB_NODEV) && !(new_flags & SB_NODEV))
1907 return -EPERM;
1908
1909 if ((old_flags & SB_NOEXEC) && !(new_flags & SB_NOEXEC))
1910 return -EPERM;
1911
1912 if ((old_flags & SB_NOATIME) && !(new_flags & SB_NOATIME))
1913 return -EPERM;
1914
1915 if ((old_flags & SB_NODIRATIME) && !(new_flags & SB_NODIRATIME))
1916 return -EPERM;
1917
1918 if (!(old_flags & SB_POSIXACL) && (new_flags & SB_POSIXACL))
1919 return -EPERM;
1920
1921 return 0;
1922 }
1923
1924 static int shiftfs_remount(struct super_block *sb, int *flags, char *data)
1925 {
1926 int err;
1927 struct shiftfs_super_info new = {};
1928 struct shiftfs_super_info *info = sb->s_fs_info;
1929
1930 err = shiftfs_parse_mount_options(&new, data);
1931 if (err)
1932 return err;
1933
1934 err = shiftfs_super_check_flags(sb->s_flags, *flags);
1935 if (err)
1936 return err;
1937
1938 /* Mark mount option cannot be changed. */
1939 if (info->mark || (info->mark != new.mark))
1940 return -EPERM;
1941
1942 if (info->passthrough != new.passthrough) {
1943 /* Don't allow exceeding passthrough options of mark mount. */
1944 if (!passthrough_is_subset(info->passthrough_mark,
1945 info->passthrough))
1946 return -EPERM;
1947
1948 info->passthrough = new.passthrough;
1949 }
1950
1951 return 0;
1952 }
1953
1954 static const struct super_operations shiftfs_super_ops = {
1955 .put_super = shiftfs_put_super,
1956 .show_options = shiftfs_show_options,
1957 .statfs = shiftfs_statfs,
1958 .remount_fs = shiftfs_remount,
1959 .evict_inode = shiftfs_evict_inode,
1960 };
1961
1962 struct shiftfs_data {
1963 void *data;
1964 const char *path;
1965 };
1966
1967 static void shiftfs_super_force_flags(struct super_block *sb,
1968 unsigned long lower_flags)
1969 {
1970 sb->s_flags |= lower_flags & (SB_RDONLY | SB_NOSUID | SB_NODEV |
1971 SB_NOEXEC | SB_NOATIME | SB_NODIRATIME);
1972
1973 if (!(lower_flags & SB_POSIXACL))
1974 sb->s_flags &= ~SB_POSIXACL;
1975 }
1976
1977 static int shiftfs_fill_super(struct super_block *sb, void *raw_data,
1978 int silent)
1979 {
1980 int err;
1981 struct path path = {};
1982 struct shiftfs_super_info *sbinfo_mp;
1983 char *name = NULL;
1984 struct inode *inode = NULL;
1985 struct dentry *dentry = NULL;
1986 struct shiftfs_data *data = raw_data;
1987 struct shiftfs_super_info *sbinfo = NULL;
1988
1989 if (!data->path)
1990 return -EINVAL;
1991
1992 sb->s_fs_info = kzalloc(sizeof(*sbinfo), GFP_KERNEL);
1993 if (!sb->s_fs_info)
1994 return -ENOMEM;
1995 sbinfo = sb->s_fs_info;
1996
1997 err = shiftfs_parse_mount_options(sbinfo, data->data);
1998 if (err)
1999 return err;
2000
2001 /* to mount a mark, must be userns admin */
2002 if (!sbinfo->mark && !ns_capable(current_user_ns(), CAP_SYS_ADMIN))
2003 return -EPERM;
2004
2005 name = kstrdup(data->path, GFP_KERNEL);
2006 if (!name)
2007 return -ENOMEM;
2008
2009 err = kern_path(name, LOOKUP_FOLLOW, &path);
2010 if (err)
2011 goto out_free_name;
2012
2013 if (!S_ISDIR(path.dentry->d_inode->i_mode)) {
2014 err = -ENOTDIR;
2015 goto out_put_path;
2016 }
2017
2018 sb->s_flags |= SB_POSIXACL;
2019
2020 if (sbinfo->mark) {
2021 struct cred *cred_tmp;
2022 struct super_block *lower_sb = path.mnt->mnt_sb;
2023
2024 /* to mark a mount point, must root wrt lower s_user_ns */
2025 if (!ns_capable(lower_sb->s_user_ns, CAP_SYS_ADMIN)) {
2026 err = -EPERM;
2027 goto out_put_path;
2028 }
2029
2030 /*
2031 * this part is visible unshifted, so make sure no
2032 * executables that could be used to give suid
2033 * privileges
2034 */
2035 sb->s_iflags = SB_I_NOEXEC;
2036
2037 shiftfs_super_force_flags(sb, lower_sb->s_flags);
2038
2039 /*
2040 * Handle nesting of shiftfs mounts by referring this mark
2041 * mount back to the original mark mount. This is more
2042 * efficient and alleviates concerns about stack depth.
2043 */
2044 if (lower_sb->s_magic == SHIFTFS_MAGIC) {
2045 sbinfo_mp = lower_sb->s_fs_info;
2046
2047 /* Doesn't make sense to mark a mark mount */
2048 if (sbinfo_mp->mark) {
2049 err = -EINVAL;
2050 goto out_put_path;
2051 }
2052
2053 if (!passthrough_is_subset(sbinfo_mp->passthrough,
2054 sbinfo->passthrough)) {
2055 err = -EPERM;
2056 goto out_put_path;
2057 }
2058
2059 sbinfo->mnt = mntget(sbinfo_mp->mnt);
2060 dentry = dget(path.dentry->d_fsdata);
2061 /*
2062 * Copy up the passthrough mount options from the
2063 * parent mark mountpoint.
2064 */
2065 sbinfo->passthrough_mark = sbinfo_mp->passthrough_mark;
2066 sbinfo->creator_cred = get_cred(sbinfo_mp->creator_cred);
2067 } else {
2068 sbinfo->mnt = mntget(path.mnt);
2069 dentry = dget(path.dentry);
2070 /*
2071 * For a new mark passthrough_mark and passthrough
2072 * are identical.
2073 */
2074 sbinfo->passthrough_mark = sbinfo->passthrough;
2075
2076 /* We don't allow shiftfs on top of idmapped mounts. */
2077 if (path.mnt->mnt_userns != &init_user_ns) {
2078 err = -EPERM;
2079 goto out_put_path;
2080 }
2081
2082 cred_tmp = prepare_creds();
2083 if (!cred_tmp) {
2084 err = -ENOMEM;
2085 goto out_put_path;
2086 }
2087 /* Don't override disk quota limits or use reserved space. */
2088 cap_lower(cred_tmp->cap_effective, CAP_SYS_RESOURCE);
2089 sbinfo->creator_cred = cred_tmp;
2090 }
2091 } else {
2092 /*
2093 * This leg executes if we're admin capable in the namespace,
2094 * so be very careful.
2095 */
2096 err = -EPERM;
2097 if (path.dentry->d_sb->s_magic != SHIFTFS_MAGIC)
2098 goto out_put_path;
2099
2100 sbinfo_mp = path.dentry->d_sb->s_fs_info;
2101 if (!sbinfo_mp->mark)
2102 goto out_put_path;
2103
2104 if (!passthrough_is_subset(sbinfo_mp->passthrough,
2105 sbinfo->passthrough))
2106 goto out_put_path;
2107
2108 sbinfo->mnt = mntget(sbinfo_mp->mnt);
2109 sbinfo->creator_cred = get_cred(sbinfo_mp->creator_cred);
2110 dentry = dget(path.dentry->d_fsdata);
2111 /*
2112 * Copy up passthrough settings from mark mountpoint so we can
2113 * verify when the overlay wants to remount with different
2114 * passthrough settings.
2115 */
2116 sbinfo->passthrough_mark = sbinfo_mp->passthrough;
2117 shiftfs_super_force_flags(sb, path.mnt->mnt_sb->s_flags);
2118 }
2119
2120 sb->s_stack_depth = dentry->d_sb->s_stack_depth + 1;
2121 if (sb->s_stack_depth > FILESYSTEM_MAX_STACK_DEPTH) {
2122 printk(KERN_ERR "shiftfs: maximum stacking depth exceeded\n");
2123 err = -EINVAL;
2124 goto out_put_path;
2125 }
2126
2127 inode = new_inode(sb);
2128 if (!inode) {
2129 err = -ENOMEM;
2130 goto out_put_path;
2131 }
2132 shiftfs_fill_inode(inode, dentry->d_inode->i_ino, S_IFDIR, 0, dentry);
2133
2134 ihold(dentry->d_inode);
2135 inode->i_private = dentry->d_inode;
2136
2137 sb->s_magic = SHIFTFS_MAGIC;
2138 sb->s_maxbytes = MAX_LFS_FILESIZE;
2139 sb->s_op = &shiftfs_super_ops;
2140 sb->s_xattr = shiftfs_xattr_handlers;
2141 sb->s_d_op = &shiftfs_dentry_ops;
2142 sb->s_root = d_make_root(inode);
2143 if (!sb->s_root) {
2144 err = -ENOMEM;
2145 goto out_put_path;
2146 }
2147
2148 sb->s_root->d_fsdata = dentry;
2149 sbinfo->userns = get_user_ns(dentry->d_sb->s_user_ns);
2150 shiftfs_copyattr(dentry->d_inode, sb->s_root->d_inode);
2151
2152 dentry = NULL;
2153 err = 0;
2154
2155 out_put_path:
2156 path_put(&path);
2157
2158 out_free_name:
2159 kfree(name);
2160
2161 dput(dentry);
2162
2163 return err;
2164 }
2165
2166 static struct dentry *shiftfs_mount(struct file_system_type *fs_type,
2167 int flags, const char *dev_name, void *data)
2168 {
2169 struct shiftfs_data d = { data, dev_name };
2170
2171 return mount_nodev(fs_type, flags, &d, shiftfs_fill_super);
2172 }
2173
2174 static struct file_system_type shiftfs_type = {
2175 .owner = THIS_MODULE,
2176 .name = "shiftfs",
2177 .mount = shiftfs_mount,
2178 .kill_sb = kill_anon_super,
2179 .fs_flags = FS_USERNS_MOUNT,
2180 };
2181
2182 static int __init shiftfs_init(void)
2183 {
2184 return register_filesystem(&shiftfs_type);
2185 }
2186
2187 static void __exit shiftfs_exit(void)
2188 {
2189 unregister_filesystem(&shiftfs_type);
2190 }
2191
2192 MODULE_ALIAS_FS("shiftfs");
2193 MODULE_AUTHOR("James Bottomley");
2194 MODULE_AUTHOR("Seth Forshee <seth.forshee@canonical.com>");
2195 MODULE_AUTHOR("Christian Brauner <christian.brauner@ubuntu.com>");
2196 MODULE_DESCRIPTION("id shifting filesystem");
2197 MODULE_LICENSE("GPL v2");
2198 module_init(shiftfs_init)
2199 module_exit(shiftfs_exit)
Ubuntu Impish Linux kernel mirror