4 * Copyright (c) 2013 Samsung Electronics Co. Ltd
5 * Authors: Daeho Jeong, Woojoong Lee, Seunghwan Hyun,
6 * Sunghwan Yun, Sungjong Seo
8 * This program has been developed as a stackable file system based on
9 * the WrapFS which written by
11 * Copyright (c) 1998-2011 Erez Zadok
12 * Copyright (c) 2009 Shrikar Archak
13 * Copyright (c) 2003-2011 Stony Brook University
14 * Copyright (c) 2003-2011 The Research Foundation of SUNY
16 * This file is dual licensed. It may be redistributed and/or modified
17 * under the terms of the Apache 2.0 License OR version 2 of the GNU
18 * General Public License.
22 #include <linux/fs_struct.h>
24 /* Do not directly use this function. Use OVERRIDE_CRED() instead. */
25 const struct cred * override_fsids(struct sdcardfs_sb_info* sbi)
28 const struct cred * old_cred;
30 cred = prepare_creds();
34 cred->fsuid = make_kuid(&init_user_ns, sbi->options.fs_low_uid);
35 cred->fsgid = make_kgid(&init_user_ns, sbi->options.fs_low_gid);
37 old_cred = override_creds(cred);
42 /* Do not directly use this function, use REVERT_CRED() instead. */
43 void revert_fsids(const struct cred * old_cred)
45 const struct cred * cur_cred;
47 cur_cred = current->cred;
48 revert_creds(old_cred);
52 static int sdcardfs_create(struct inode *dir, struct dentry *dentry,
53 umode_t mode, bool want_excl)
56 struct dentry *lower_dentry;
57 struct vfsmount *lower_dentry_mnt;
58 struct dentry *lower_parent_dentry = NULL;
59 struct path lower_path;
60 const struct cred *saved_cred = NULL;
61 struct fs_struct *saved_fs;
62 struct fs_struct *copied_fs;
64 if(!check_caller_access_to_name(dir, dentry->d_name.name)) {
65 printk(KERN_INFO "%s: need to check the caller's gid in packages.list\n"
66 " dentry: %s, task:%s\n",
67 __func__, dentry->d_name.name, current->comm);
72 /* save current_cred and override it */
73 OVERRIDE_CRED(SDCARDFS_SB(dir->i_sb), saved_cred);
75 sdcardfs_get_lower_path(dentry, &lower_path);
76 lower_dentry = lower_path.dentry;
77 lower_dentry_mnt = lower_path.mnt;
78 lower_parent_dentry = lock_parent(lower_dentry);
80 /* set last 16bytes of mode field to 0664 */
81 mode = (mode & S_IFMT) | 00664;
83 /* temporarily change umask for lower fs write */
84 saved_fs = current->fs;
85 copied_fs = copy_fs_struct(current->fs);
90 current->fs = copied_fs;
91 current->fs->umask = 0;
92 err = vfs_create2(lower_dentry_mnt, d_inode(lower_parent_dentry), lower_dentry, mode, want_excl);
96 err = sdcardfs_interpose(dentry, dir->i_sb, &lower_path, SDCARDFS_I(dir)->userid);
99 fsstack_copy_attr_times(dir, sdcardfs_lower_inode(dir));
100 fsstack_copy_inode_size(dir, d_inode(lower_parent_dentry));
103 current->fs = saved_fs;
104 free_fs_struct(copied_fs);
106 unlock_dir(lower_parent_dentry);
107 sdcardfs_put_lower_path(dentry, &lower_path);
108 REVERT_CRED(saved_cred);
114 static int sdcardfs_link(struct dentry *old_dentry, struct inode *dir,
115 struct dentry *new_dentry)
117 struct dentry *lower_old_dentry;
118 struct dentry *lower_new_dentry;
119 struct dentry *lower_dir_dentry;
122 struct path lower_old_path, lower_new_path;
124 OVERRIDE_CRED(SDCARDFS_SB(dir->i_sb));
126 file_size_save = i_size_read(d_inode(old_dentry));
127 sdcardfs_get_lower_path(old_dentry, &lower_old_path);
128 sdcardfs_get_lower_path(new_dentry, &lower_new_path);
129 lower_old_dentry = lower_old_path.dentry;
130 lower_new_dentry = lower_new_path.dentry;
131 lower_dir_dentry = lock_parent(lower_new_dentry);
133 err = vfs_link(lower_old_dentry, d_inode(lower_dir_dentry),
134 lower_new_dentry, NULL);
135 if (err || !d_inode(lower_new_dentry))
138 err = sdcardfs_interpose(new_dentry, dir->i_sb, &lower_new_path);
141 fsstack_copy_attr_times(dir, d_inode(lower_new_dentry));
142 fsstack_copy_inode_size(dir, d_inode(lower_new_dentry));
143 set_nlink(d_inode(old_dentry),
144 sdcardfs_lower_inode(d_inode(old_dentry))->i_nlink);
145 i_size_write(d_inode(new_dentry), file_size_save);
147 unlock_dir(lower_dir_dentry);
148 sdcardfs_put_lower_path(old_dentry, &lower_old_path);
149 sdcardfs_put_lower_path(new_dentry, &lower_new_path);
155 static int sdcardfs_unlink(struct inode *dir, struct dentry *dentry)
158 struct dentry *lower_dentry;
159 struct vfsmount *lower_mnt;
160 struct inode *lower_dir_inode = sdcardfs_lower_inode(dir);
161 struct dentry *lower_dir_dentry;
162 struct path lower_path;
163 const struct cred *saved_cred = NULL;
165 if(!check_caller_access_to_name(dir, dentry->d_name.name)) {
166 printk(KERN_INFO "%s: need to check the caller's gid in packages.list\n"
167 " dentry: %s, task:%s\n",
168 __func__, dentry->d_name.name, current->comm);
173 /* save current_cred and override it */
174 OVERRIDE_CRED(SDCARDFS_SB(dir->i_sb), saved_cred);
176 sdcardfs_get_lower_path(dentry, &lower_path);
177 lower_dentry = lower_path.dentry;
178 lower_mnt = lower_path.mnt;
180 lower_dir_dentry = lock_parent(lower_dentry);
182 err = vfs_unlink2(lower_mnt, lower_dir_inode, lower_dentry, NULL);
185 * Note: unlinking on top of NFS can cause silly-renamed files.
186 * Trying to delete such files results in EBUSY from NFS
187 * below. Silly-renamed files will get deleted by NFS later on, so
188 * we just need to detect them here and treat such EBUSY errors as
189 * if the upper file was successfully deleted.
191 if (err == -EBUSY && lower_dentry->d_flags & DCACHE_NFSFS_RENAMED)
195 fsstack_copy_attr_times(dir, lower_dir_inode);
196 fsstack_copy_inode_size(dir, lower_dir_inode);
197 set_nlink(d_inode(dentry),
198 sdcardfs_lower_inode(d_inode(dentry))->i_nlink);
199 d_inode(dentry)->i_ctime = dir->i_ctime;
200 d_drop(dentry); /* this is needed, else LTP fails (VFS won't do it) */
202 unlock_dir(lower_dir_dentry);
204 sdcardfs_put_lower_path(dentry, &lower_path);
205 REVERT_CRED(saved_cred);
211 static int sdcardfs_symlink(struct inode *dir, struct dentry *dentry,
215 struct dentry *lower_dentry;
216 struct dentry *lower_parent_dentry = NULL;
217 struct path lower_path;
219 OVERRIDE_CRED(SDCARDFS_SB(dir->i_sb));
221 sdcardfs_get_lower_path(dentry, &lower_path);
222 lower_dentry = lower_path.dentry;
223 lower_parent_dentry = lock_parent(lower_dentry);
225 err = vfs_symlink(d_inode(lower_parent_dentry), lower_dentry, symname);
228 err = sdcardfs_interpose(dentry, dir->i_sb, &lower_path);
231 fsstack_copy_attr_times(dir, sdcardfs_lower_inode(dir));
232 fsstack_copy_inode_size(dir, d_inode(lower_parent_dentry));
235 unlock_dir(lower_parent_dentry);
236 sdcardfs_put_lower_path(dentry, &lower_path);
242 static int touch(char *abs_path, mode_t mode) {
243 struct file *filp = filp_open(abs_path, O_RDWR|O_CREAT|O_EXCL|O_NOFOLLOW, mode);
245 if (PTR_ERR(filp) == -EEXIST) {
249 printk(KERN_ERR "sdcardfs: failed to open(%s): %ld\n",
250 abs_path, PTR_ERR(filp));
251 return PTR_ERR(filp);
254 filp_close(filp, current->files);
258 static int sdcardfs_mkdir(struct inode *dir, struct dentry *dentry, umode_t mode)
261 int make_nomedia_in_obb = 0;
262 struct dentry *lower_dentry;
263 struct vfsmount *lower_mnt;
264 struct dentry *lower_parent_dentry = NULL;
265 struct path lower_path;
266 struct sdcardfs_sb_info *sbi = SDCARDFS_SB(dentry->d_sb);
267 const struct cred *saved_cred = NULL;
268 struct sdcardfs_inode_info *pi = SDCARDFS_I(dir);
270 struct fs_struct *saved_fs;
271 struct fs_struct *copied_fs;
273 if(!check_caller_access_to_name(dir, dentry->d_name.name)) {
274 printk(KERN_INFO "%s: need to check the caller's gid in packages.list\n"
275 " dentry: %s, task:%s\n",
276 __func__, dentry->d_name.name, current->comm);
281 /* save current_cred and override it */
282 OVERRIDE_CRED(SDCARDFS_SB(dir->i_sb), saved_cred);
284 /* check disk space */
285 if (!check_min_free_space(dentry, 0, 1)) {
286 printk(KERN_INFO "sdcardfs: No minimum free space.\n");
291 /* the lower_dentry is negative here */
292 sdcardfs_get_lower_path(dentry, &lower_path);
293 lower_dentry = lower_path.dentry;
294 lower_mnt = lower_path.mnt;
295 lower_parent_dentry = lock_parent(lower_dentry);
297 /* set last 16bytes of mode field to 0775 */
298 mode = (mode & S_IFMT) | 00775;
300 /* temporarily change umask for lower fs write */
301 saved_fs = current->fs;
302 copied_fs = copy_fs_struct(current->fs);
305 unlock_dir(lower_parent_dentry);
308 current->fs = copied_fs;
309 current->fs->umask = 0;
310 err = vfs_mkdir2(lower_mnt, d_inode(lower_parent_dentry), lower_dentry, mode);
313 unlock_dir(lower_parent_dentry);
317 /* if it is a local obb dentry, setup it with the base obbpath */
318 if(need_graft_path(dentry)) {
320 err = setup_obb_dentry(dentry, &lower_path);
322 /* if the sbi->obbpath is not available, the lower_path won't be
323 * changed by setup_obb_dentry() but the lower path is saved to
324 * its orig_path. this dentry will be revalidated later.
325 * but now, the lower_path should be NULL */
326 sdcardfs_put_reset_lower_path(dentry);
328 /* the newly created lower path which saved to its orig_path or
329 * the lower_path is the base obbpath.
330 * therefore, an additional path_get is required */
331 path_get(&lower_path);
333 make_nomedia_in_obb = 1;
336 err = sdcardfs_interpose(dentry, dir->i_sb, &lower_path, pi->userid);
338 unlock_dir(lower_parent_dentry);
342 fsstack_copy_attr_times(dir, sdcardfs_lower_inode(dir));
343 fsstack_copy_inode_size(dir, d_inode(lower_parent_dentry));
344 /* update number of links on parent directory */
345 set_nlink(dir, sdcardfs_lower_inode(dir)->i_nlink);
347 unlock_dir(lower_parent_dentry);
349 if ((!sbi->options.multiuser) && (!strcasecmp(dentry->d_name.name, "obb"))
350 && (pi->perm == PERM_ANDROID) && (pi->userid == 0))
351 make_nomedia_in_obb = 1;
353 /* When creating /Android/data and /Android/obb, mark them as .nomedia */
354 if (make_nomedia_in_obb ||
355 ((pi->perm == PERM_ANDROID) && (!strcasecmp(dentry->d_name.name, "data")))) {
356 set_fs_pwd(current->fs, &lower_path);
357 touch_err = touch(".nomedia", 0664);
359 printk(KERN_ERR "sdcardfs: failed to create .nomedia in %s: %d\n",
360 lower_path.dentry->d_name.name, touch_err);
365 current->fs = saved_fs;
366 free_fs_struct(copied_fs);
368 sdcardfs_put_lower_path(dentry, &lower_path);
370 REVERT_CRED(saved_cred);
375 static int sdcardfs_rmdir(struct inode *dir, struct dentry *dentry)
377 struct dentry *lower_dentry;
378 struct dentry *lower_dir_dentry;
379 struct vfsmount *lower_mnt;
381 struct path lower_path;
382 const struct cred *saved_cred = NULL;
384 if(!check_caller_access_to_name(dir, dentry->d_name.name)) {
385 printk(KERN_INFO "%s: need to check the caller's gid in packages.list\n"
386 " dentry: %s, task:%s\n",
387 __func__, dentry->d_name.name, current->comm);
392 /* save current_cred and override it */
393 OVERRIDE_CRED(SDCARDFS_SB(dir->i_sb), saved_cred);
395 /* sdcardfs_get_real_lower(): in case of remove an user's obb dentry
396 * the dentry on the original path should be deleted. */
397 sdcardfs_get_real_lower(dentry, &lower_path);
399 lower_dentry = lower_path.dentry;
400 lower_mnt = lower_path.mnt;
401 lower_dir_dentry = lock_parent(lower_dentry);
403 err = vfs_rmdir2(lower_mnt, d_inode(lower_dir_dentry), lower_dentry);
407 d_drop(dentry); /* drop our dentry on success (why not VFS's job?) */
409 clear_nlink(d_inode(dentry));
410 fsstack_copy_attr_times(dir, d_inode(lower_dir_dentry));
411 fsstack_copy_inode_size(dir, d_inode(lower_dir_dentry));
412 set_nlink(dir, d_inode(lower_dir_dentry)->i_nlink);
415 unlock_dir(lower_dir_dentry);
416 sdcardfs_put_real_lower(dentry, &lower_path);
417 REVERT_CRED(saved_cred);
423 static int sdcardfs_mknod(struct inode *dir, struct dentry *dentry, umode_t mode,
427 struct dentry *lower_dentry;
428 struct dentry *lower_parent_dentry = NULL;
429 struct path lower_path;
431 OVERRIDE_CRED(SDCARDFS_SB(dir->i_sb));
433 sdcardfs_get_lower_path(dentry, &lower_path);
434 lower_dentry = lower_path.dentry;
435 lower_parent_dentry = lock_parent(lower_dentry);
437 err = vfs_mknod(d_inode(lower_parent_dentry), lower_dentry, mode, dev);
441 err = sdcardfs_interpose(dentry, dir->i_sb, &lower_path);
444 fsstack_copy_attr_times(dir, sdcardfs_lower_inode(dir));
445 fsstack_copy_inode_size(dir, d_inode(lower_parent_dentry));
448 unlock_dir(lower_parent_dentry);
449 sdcardfs_put_lower_path(dentry, &lower_path);
456 * The locking rules in sdcardfs_rename are complex. We could use a simpler
457 * superblock-level name-space lock for renames and copy-ups.
459 static int sdcardfs_rename(struct inode *old_dir, struct dentry *old_dentry,
460 struct inode *new_dir, struct dentry *new_dentry)
463 struct dentry *lower_old_dentry = NULL;
464 struct dentry *lower_new_dentry = NULL;
465 struct dentry *lower_old_dir_dentry = NULL;
466 struct dentry *lower_new_dir_dentry = NULL;
467 struct vfsmount *lower_mnt = NULL;
468 struct dentry *trap = NULL;
469 struct dentry *new_parent = NULL;
470 struct path lower_old_path, lower_new_path;
471 const struct cred *saved_cred = NULL;
473 if(!check_caller_access_to_name(old_dir, old_dentry->d_name.name) ||
474 !check_caller_access_to_name(new_dir, new_dentry->d_name.name)) {
475 printk(KERN_INFO "%s: need to check the caller's gid in packages.list\n"
476 " new_dentry: %s, task:%s\n",
477 __func__, new_dentry->d_name.name, current->comm);
482 /* save current_cred and override it */
483 OVERRIDE_CRED(SDCARDFS_SB(old_dir->i_sb), saved_cred);
485 sdcardfs_get_real_lower(old_dentry, &lower_old_path);
486 sdcardfs_get_lower_path(new_dentry, &lower_new_path);
487 lower_old_dentry = lower_old_path.dentry;
488 lower_new_dentry = lower_new_path.dentry;
489 lower_mnt = lower_old_path.mnt;
490 lower_old_dir_dentry = dget_parent(lower_old_dentry);
491 lower_new_dir_dentry = dget_parent(lower_new_dentry);
493 trap = lock_rename(lower_old_dir_dentry, lower_new_dir_dentry);
494 /* source should not be ancestor of target */
495 if (trap == lower_old_dentry) {
499 /* target should not be ancestor of source */
500 if (trap == lower_new_dentry) {
505 err = vfs_rename2(lower_mnt,
506 d_inode(lower_old_dir_dentry), lower_old_dentry,
507 d_inode(lower_new_dir_dentry), lower_new_dentry,
512 /* Copy attrs from lower dir, but i_uid/i_gid */
513 sdcardfs_copy_and_fix_attrs(new_dir, d_inode(lower_new_dir_dentry));
514 fsstack_copy_inode_size(new_dir, d_inode(lower_new_dir_dentry));
516 if (new_dir != old_dir) {
517 sdcardfs_copy_and_fix_attrs(old_dir, d_inode(lower_old_dir_dentry));
518 fsstack_copy_inode_size(old_dir, d_inode(lower_old_dir_dentry));
520 /* update the derived permission of the old_dentry
521 * with its new parent
523 new_parent = dget_parent(new_dentry);
525 if(d_inode(old_dentry)) {
526 update_derived_permission_lock(old_dentry);
531 /* At this point, not all dentry information has been moved, so
532 * we pass along new_dentry for the name.*/
533 get_derived_permission_new(new_dentry->d_parent, old_dentry, new_dentry);
534 fixup_tmp_permissions(d_inode(old_dentry));
535 fixup_top_recursive(old_dentry);
537 unlock_rename(lower_old_dir_dentry, lower_new_dir_dentry);
538 dput(lower_old_dir_dentry);
539 dput(lower_new_dir_dentry);
540 sdcardfs_put_real_lower(old_dentry, &lower_old_path);
541 sdcardfs_put_lower_path(new_dentry, &lower_new_path);
542 REVERT_CRED(saved_cred);
548 static int sdcardfs_readlink(struct dentry *dentry, char __user *buf, int bufsiz)
551 struct dentry *lower_dentry;
552 struct path lower_path;
553 /* XXX readlink does not requires overriding credential */
555 sdcardfs_get_lower_path(dentry, &lower_path);
556 lower_dentry = lower_path.dentry;
557 if (!d_inode(lower_dentry)->i_op ||
558 !d_inode(lower_dentry)->i_op->readlink) {
563 err = d_inode(lower_dentry)->i_op->readlink(lower_dentry,
567 fsstack_copy_attr_atime(d_inode(dentry), d_inode(lower_dentry));
570 sdcardfs_put_lower_path(dentry, &lower_path);
576 static const char *sdcardfs_follow_link(struct dentry *dentry, void **cookie)
579 int len = PAGE_SIZE, err;
582 /* This is freed by the put_link method assuming a successful call. */
583 buf = kmalloc(len, GFP_KERNEL);
585 buf = ERR_PTR(-ENOMEM);
589 /* read the symlink, and then we will follow it */
592 err = sdcardfs_readlink(dentry, buf, len);
600 return *cookie = buf;
604 static int sdcardfs_permission_wrn(struct inode *inode, int mask)
606 WARN(1, "sdcardfs does not support permission. Use permission2.\n");
610 void copy_attrs(struct inode *dest, const struct inode *src)
612 dest->i_mode = src->i_mode;
613 dest->i_uid = src->i_uid;
614 dest->i_gid = src->i_gid;
615 dest->i_rdev = src->i_rdev;
616 dest->i_atime = src->i_atime;
617 dest->i_mtime = src->i_mtime;
618 dest->i_ctime = src->i_ctime;
619 dest->i_blkbits = src->i_blkbits;
620 dest->i_flags = src->i_flags;
621 #ifdef CONFIG_FS_POSIX_ACL
622 dest->i_acl = src->i_acl;
624 #ifdef CONFIG_SECURITY
625 dest->i_security = src->i_security;
629 static int sdcardfs_permission(struct vfsmount *mnt, struct inode *inode, int mask)
633 struct inode *top = grab_top(SDCARDFS_I(inode));
636 release_top(SDCARDFS_I(inode));
637 WARN(1, "Top value was null!\n");
642 * Permission check on sdcardfs inode.
643 * Calling process should have AID_SDCARD_RW permission
644 * Since generic_permission only needs i_mode, i_uid,
645 * i_gid, and i_sb, we can create a fake inode to pass
646 * this information down in.
648 * The underlying code may attempt to take locks in some
649 * cases for features we're not using, but if that changes,
650 * locks must be dealt with to avoid undefined behavior.
652 copy_attrs(&tmp, inode);
653 tmp.i_uid = make_kuid(&init_user_ns, SDCARDFS_I(top)->d_uid);
654 tmp.i_gid = make_kgid(&init_user_ns, get_gid(mnt, SDCARDFS_I(top)));
655 tmp.i_mode = (inode->i_mode & S_IFMT) | get_mode(mnt, SDCARDFS_I(top));
656 release_top(SDCARDFS_I(inode));
657 tmp.i_sb = inode->i_sb;
658 if (IS_POSIXACL(inode))
659 printk(KERN_WARNING "%s: This may be undefined behavior... \n", __func__);
660 err = generic_permission(&tmp, mask);
662 * Original sdcardfs code calls inode_permission(lower_inode,.. )
663 * for checking inode permission. But doing such things here seems
664 * duplicated work, because the functions called after this func,
665 * such as vfs_create, vfs_unlink, vfs_rename, and etc,
666 * does exactly same thing, i.e., they calls inode_permission().
667 * So we just let they do the things.
668 * If there are any security hole, just uncomment following if block.
673 * Permission check on lower_inode(=EXT4).
674 * we check it with AID_MEDIA_RW permission
676 struct inode *lower_inode;
677 OVERRIDE_CRED(SDCARDFS_SB(inode->sb));
679 lower_inode = sdcardfs_lower_inode(inode);
680 err = inode_permission(lower_inode, mask);
689 static int sdcardfs_setattr_wrn(struct dentry *dentry, struct iattr *ia)
691 WARN(1, "sdcardfs does not support setattr. User setattr2.\n");
695 static int sdcardfs_setattr(struct vfsmount *mnt, struct dentry *dentry, struct iattr *ia)
698 struct dentry *lower_dentry;
699 struct vfsmount *lower_mnt;
701 struct inode *lower_inode;
702 struct path lower_path;
703 struct iattr lower_ia;
704 struct dentry *parent;
707 const struct cred *saved_cred = NULL;
709 inode = d_inode(dentry);
710 top = grab_top(SDCARDFS_I(inode));
713 release_top(SDCARDFS_I(inode));
718 * Permission check on sdcardfs inode.
719 * Calling process should have AID_SDCARD_RW permission
720 * Since generic_permission only needs i_mode, i_uid,
721 * i_gid, and i_sb, we can create a fake inode to pass
722 * this information down in.
724 * The underlying code may attempt to take locks in some
725 * cases for features we're not using, but if that changes,
726 * locks must be dealt with to avoid undefined behavior.
729 copy_attrs(&tmp, inode);
730 tmp.i_uid = make_kuid(&init_user_ns, SDCARDFS_I(top)->d_uid);
731 tmp.i_gid = make_kgid(&init_user_ns, get_gid(mnt, SDCARDFS_I(top)));
732 tmp.i_mode = (inode->i_mode & S_IFMT) | get_mode(mnt, SDCARDFS_I(top));
733 tmp.i_size = i_size_read(inode);
734 release_top(SDCARDFS_I(inode));
735 tmp.i_sb = inode->i_sb;
738 * Check if user has permission to change inode. We don't check if
739 * this user can change the lower inode: that should happen when
740 * calling notify_change on the lower inode.
742 /* prepare our own lower struct iattr (with the lower file) */
743 memcpy(&lower_ia, ia, sizeof(lower_ia));
744 /* Allow touch updating timestamps. A previous permission check ensures
745 * we have write access. Changes to mode, owner, and group are ignored*/
746 ia->ia_valid |= ATTR_FORCE;
747 err = inode_change_ok(&tmp, ia);
750 /* check the Android group ID */
751 parent = dget_parent(dentry);
752 if(!check_caller_access_to_name(d_inode(parent), dentry->d_name.name)) {
753 printk(KERN_INFO "%s: need to check the caller's gid in packages.list\n"
754 " dentry: %s, task:%s\n",
755 __func__, dentry->d_name.name, current->comm);
764 /* save current_cred and override it */
765 OVERRIDE_CRED(SDCARDFS_SB(dentry->d_sb), saved_cred);
767 sdcardfs_get_lower_path(dentry, &lower_path);
768 lower_dentry = lower_path.dentry;
769 lower_mnt = lower_path.mnt;
770 lower_inode = sdcardfs_lower_inode(inode);
772 if (ia->ia_valid & ATTR_FILE)
773 lower_ia.ia_file = sdcardfs_lower_file(ia->ia_file);
775 lower_ia.ia_valid &= ~(ATTR_UID | ATTR_GID | ATTR_MODE);
778 * If shrinking, first truncate upper level to cancel writing dirty
779 * pages beyond the new eof; and also if its' maxbytes is more
780 * limiting (fail with -EFBIG before making any change to the lower
781 * level). There is no need to vmtruncate the upper level
782 * afterwards in the other cases: we fsstack_copy_inode_size from
786 down_write(¤t->mm->mmap_sem);
787 if (ia->ia_valid & ATTR_SIZE) {
788 err = inode_newsize_ok(&tmp, ia->ia_size);
791 up_write(¤t->mm->mmap_sem);
794 truncate_setsize(inode, ia->ia_size);
798 * mode change is for clearing setuid/setgid bits. Allow lower fs
799 * to interpret this in its own way.
801 if (lower_ia.ia_valid & (ATTR_KILL_SUID | ATTR_KILL_SGID))
802 lower_ia.ia_valid &= ~ATTR_MODE;
804 /* notify the (possibly copied-up) lower inode */
806 * Note: we use d_inode(lower_dentry), because lower_inode may be
807 * unlinked (no inode->i_sb and i_ino==0. This happens if someone
808 * tries to open(), unlink(), then ftruncate() a file.
810 mutex_lock(&d_inode(lower_dentry)->i_mutex);
811 err = notify_change2(lower_mnt, lower_dentry, &lower_ia, /* note: lower_ia */
813 mutex_unlock(&d_inode(lower_dentry)->i_mutex);
815 up_write(¤t->mm->mmap_sem);
819 /* get attributes from the lower inode and update derived permissions */
820 sdcardfs_copy_and_fix_attrs(inode, lower_inode);
823 * Not running fsstack_copy_inode_size(inode, lower_inode), because
824 * VFS should update our inode size, and notify_change on
825 * lower_inode should update its size.
829 sdcardfs_put_lower_path(dentry, &lower_path);
830 REVERT_CRED(saved_cred);
835 static int sdcardfs_fillattr(struct vfsmount *mnt, struct inode *inode, struct kstat *stat)
837 struct sdcardfs_inode_info *info = SDCARDFS_I(inode);
838 struct inode *top = grab_top(info);
842 stat->dev = inode->i_sb->s_dev;
843 stat->ino = inode->i_ino;
844 stat->mode = (inode->i_mode & S_IFMT) | get_mode(mnt, SDCARDFS_I(top));
845 stat->nlink = inode->i_nlink;
846 stat->uid = make_kuid(&init_user_ns, SDCARDFS_I(top)->d_uid);
847 stat->gid = make_kgid(&init_user_ns, get_gid(mnt, SDCARDFS_I(top)));
848 stat->rdev = inode->i_rdev;
849 stat->size = i_size_read(inode);
850 stat->atime = inode->i_atime;
851 stat->mtime = inode->i_mtime;
852 stat->ctime = inode->i_ctime;
853 stat->blksize = (1 << inode->i_blkbits);
854 stat->blocks = inode->i_blocks;
859 static int sdcardfs_getattr(struct vfsmount *mnt, struct dentry *dentry,
862 struct dentry *lower_dentry;
864 struct inode *lower_inode;
865 struct path lower_path;
866 struct dentry *parent;
869 parent = dget_parent(dentry);
870 if(!check_caller_access_to_name(d_inode(parent), dentry->d_name.name)) {
871 printk(KERN_INFO "%s: need to check the caller's gid in packages.list\n"
872 " dentry: %s, task:%s\n",
873 __func__, dentry->d_name.name, current->comm);
879 inode = d_inode(dentry);
881 sdcardfs_get_lower_path(dentry, &lower_path);
882 lower_dentry = lower_path.dentry;
883 lower_inode = sdcardfs_lower_inode(inode);
885 sdcardfs_copy_and_fix_attrs(inode, lower_inode);
886 fsstack_copy_inode_size(inode, lower_inode);
888 err = sdcardfs_fillattr(mnt, inode, stat);
889 sdcardfs_put_lower_path(dentry, &lower_path);
893 const struct inode_operations sdcardfs_symlink_iops = {
894 .permission2 = sdcardfs_permission,
895 .setattr2 = sdcardfs_setattr,
896 /* XXX Following operations are implemented,
897 * but FUSE(sdcard) or FAT does not support them
898 * These methods are *NOT* perfectly tested.
899 .readlink = sdcardfs_readlink,
900 .follow_link = sdcardfs_follow_link,
901 .put_link = kfree_put_link,
905 const struct inode_operations sdcardfs_dir_iops = {
906 .create = sdcardfs_create,
907 .lookup = sdcardfs_lookup,
908 .permission = sdcardfs_permission_wrn,
909 .permission2 = sdcardfs_permission,
910 .unlink = sdcardfs_unlink,
911 .mkdir = sdcardfs_mkdir,
912 .rmdir = sdcardfs_rmdir,
913 .rename = sdcardfs_rename,
914 .setattr = sdcardfs_setattr_wrn,
915 .setattr2 = sdcardfs_setattr,
916 .getattr = sdcardfs_getattr,
917 /* XXX Following operations are implemented,
918 * but FUSE(sdcard) or FAT does not support them
919 * These methods are *NOT* perfectly tested.
920 .symlink = sdcardfs_symlink,
921 .link = sdcardfs_link,
922 .mknod = sdcardfs_mknod,
926 const struct inode_operations sdcardfs_main_iops = {
927 .permission = sdcardfs_permission_wrn,
928 .permission2 = sdcardfs_permission,
929 .setattr = sdcardfs_setattr_wrn,
930 .setattr2 = sdcardfs_setattr,
931 .getattr = sdcardfs_getattr,