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, struct sdcardfs_inode_info *info)
28 const struct cred * old_cred;
31 cred = prepare_creds();
38 uid = multiuser_get_uid(info->userid, sbi->options.fs_low_uid);
39 cred->fsuid = make_kuid(&init_user_ns, uid);
40 cred->fsgid = make_kgid(&init_user_ns, sbi->options.fs_low_gid);
42 old_cred = override_creds(cred);
47 /* Do not directly use this function, use REVERT_CRED() instead. */
48 void revert_fsids(const struct cred * old_cred)
50 const struct cred * cur_cred;
52 cur_cred = current->cred;
53 revert_creds(old_cred);
57 static int sdcardfs_create(struct inode *dir, struct dentry *dentry,
58 umode_t mode, bool want_excl)
61 struct dentry *lower_dentry;
62 struct vfsmount *lower_dentry_mnt;
63 struct dentry *lower_parent_dentry = NULL;
64 struct path lower_path;
65 const struct cred *saved_cred = NULL;
66 struct fs_struct *saved_fs;
67 struct fs_struct *copied_fs;
69 if(!check_caller_access_to_name(dir, &dentry->d_name)) {
70 printk(KERN_INFO "%s: need to check the caller's gid in packages.list\n"
71 " dentry: %s, task:%s\n",
72 __func__, dentry->d_name.name, current->comm);
77 /* save current_cred and override it */
78 OVERRIDE_CRED(SDCARDFS_SB(dir->i_sb), saved_cred, SDCARDFS_I(dir));
80 sdcardfs_get_lower_path(dentry, &lower_path);
81 lower_dentry = lower_path.dentry;
82 lower_dentry_mnt = lower_path.mnt;
83 lower_parent_dentry = lock_parent(lower_dentry);
85 /* set last 16bytes of mode field to 0664 */
86 mode = (mode & S_IFMT) | 00664;
88 /* temporarily change umask for lower fs write */
89 saved_fs = current->fs;
90 copied_fs = copy_fs_struct(current->fs);
95 current->fs = copied_fs;
96 current->fs->umask = 0;
97 err = vfs_create2(lower_dentry_mnt, d_inode(lower_parent_dentry), lower_dentry, mode, want_excl);
101 err = sdcardfs_interpose(dentry, dir->i_sb, &lower_path, SDCARDFS_I(dir)->userid);
104 fsstack_copy_attr_times(dir, sdcardfs_lower_inode(dir));
105 fsstack_copy_inode_size(dir, d_inode(lower_parent_dentry));
106 fixup_lower_ownership(dentry, dentry->d_name.name);
109 current->fs = saved_fs;
110 free_fs_struct(copied_fs);
112 unlock_dir(lower_parent_dentry);
113 sdcardfs_put_lower_path(dentry, &lower_path);
114 REVERT_CRED(saved_cred);
120 static int sdcardfs_link(struct dentry *old_dentry, struct inode *dir,
121 struct dentry *new_dentry)
123 struct dentry *lower_old_dentry;
124 struct dentry *lower_new_dentry;
125 struct dentry *lower_dir_dentry;
128 struct path lower_old_path, lower_new_path;
130 OVERRIDE_CRED(SDCARDFS_SB(dir->i_sb));
132 file_size_save = i_size_read(d_inode(old_dentry));
133 sdcardfs_get_lower_path(old_dentry, &lower_old_path);
134 sdcardfs_get_lower_path(new_dentry, &lower_new_path);
135 lower_old_dentry = lower_old_path.dentry;
136 lower_new_dentry = lower_new_path.dentry;
137 lower_dir_dentry = lock_parent(lower_new_dentry);
139 err = vfs_link(lower_old_dentry, d_inode(lower_dir_dentry),
140 lower_new_dentry, NULL);
141 if (err || !d_inode(lower_new_dentry))
144 err = sdcardfs_interpose(new_dentry, dir->i_sb, &lower_new_path);
147 fsstack_copy_attr_times(dir, d_inode(lower_new_dentry));
148 fsstack_copy_inode_size(dir, d_inode(lower_new_dentry));
149 set_nlink(d_inode(old_dentry),
150 sdcardfs_lower_inode(d_inode(old_dentry))->i_nlink);
151 i_size_write(d_inode(new_dentry), file_size_save);
153 unlock_dir(lower_dir_dentry);
154 sdcardfs_put_lower_path(old_dentry, &lower_old_path);
155 sdcardfs_put_lower_path(new_dentry, &lower_new_path);
161 static int sdcardfs_unlink(struct inode *dir, struct dentry *dentry)
164 struct dentry *lower_dentry;
165 struct vfsmount *lower_mnt;
166 struct inode *lower_dir_inode = sdcardfs_lower_inode(dir);
167 struct dentry *lower_dir_dentry;
168 struct path lower_path;
169 const struct cred *saved_cred = NULL;
171 if(!check_caller_access_to_name(dir, &dentry->d_name)) {
172 printk(KERN_INFO "%s: need to check the caller's gid in packages.list\n"
173 " dentry: %s, task:%s\n",
174 __func__, dentry->d_name.name, current->comm);
179 /* save current_cred and override it */
180 OVERRIDE_CRED(SDCARDFS_SB(dir->i_sb), saved_cred, SDCARDFS_I(dir));
182 sdcardfs_get_lower_path(dentry, &lower_path);
183 lower_dentry = lower_path.dentry;
184 lower_mnt = lower_path.mnt;
186 lower_dir_dentry = lock_parent(lower_dentry);
188 err = vfs_unlink2(lower_mnt, lower_dir_inode, lower_dentry, NULL);
191 * Note: unlinking on top of NFS can cause silly-renamed files.
192 * Trying to delete such files results in EBUSY from NFS
193 * below. Silly-renamed files will get deleted by NFS later on, so
194 * we just need to detect them here and treat such EBUSY errors as
195 * if the upper file was successfully deleted.
197 if (err == -EBUSY && lower_dentry->d_flags & DCACHE_NFSFS_RENAMED)
201 fsstack_copy_attr_times(dir, lower_dir_inode);
202 fsstack_copy_inode_size(dir, lower_dir_inode);
203 set_nlink(d_inode(dentry),
204 sdcardfs_lower_inode(d_inode(dentry))->i_nlink);
205 d_inode(dentry)->i_ctime = dir->i_ctime;
206 d_drop(dentry); /* this is needed, else LTP fails (VFS won't do it) */
208 unlock_dir(lower_dir_dentry);
210 sdcardfs_put_lower_path(dentry, &lower_path);
211 REVERT_CRED(saved_cred);
217 static int sdcardfs_symlink(struct inode *dir, struct dentry *dentry,
221 struct dentry *lower_dentry;
222 struct dentry *lower_parent_dentry = NULL;
223 struct path lower_path;
225 OVERRIDE_CRED(SDCARDFS_SB(dir->i_sb));
227 sdcardfs_get_lower_path(dentry, &lower_path);
228 lower_dentry = lower_path.dentry;
229 lower_parent_dentry = lock_parent(lower_dentry);
231 err = vfs_symlink(d_inode(lower_parent_dentry), lower_dentry, symname);
234 err = sdcardfs_interpose(dentry, dir->i_sb, &lower_path);
237 fsstack_copy_attr_times(dir, sdcardfs_lower_inode(dir));
238 fsstack_copy_inode_size(dir, d_inode(lower_parent_dentry));
241 unlock_dir(lower_parent_dentry);
242 sdcardfs_put_lower_path(dentry, &lower_path);
248 static int touch(char *abs_path, mode_t mode) {
249 struct file *filp = filp_open(abs_path, O_RDWR|O_CREAT|O_EXCL|O_NOFOLLOW, mode);
251 if (PTR_ERR(filp) == -EEXIST) {
255 printk(KERN_ERR "sdcardfs: failed to open(%s): %ld\n",
256 abs_path, PTR_ERR(filp));
257 return PTR_ERR(filp);
260 filp_close(filp, current->files);
264 static int sdcardfs_mkdir(struct inode *dir, struct dentry *dentry, umode_t mode)
267 int make_nomedia_in_obb = 0;
268 struct dentry *lower_dentry;
269 struct vfsmount *lower_mnt;
270 struct dentry *lower_parent_dentry = NULL;
271 struct path lower_path;
272 struct sdcardfs_sb_info *sbi = SDCARDFS_SB(dentry->d_sb);
273 const struct cred *saved_cred = NULL;
274 struct sdcardfs_inode_info *pi = SDCARDFS_I(dir);
276 struct fs_struct *saved_fs;
277 struct fs_struct *copied_fs;
278 struct qstr q_obb = QSTR_LITERAL("obb");
279 struct qstr q_data = QSTR_LITERAL("data");
281 if(!check_caller_access_to_name(dir, &dentry->d_name)) {
282 printk(KERN_INFO "%s: need to check the caller's gid in packages.list\n"
283 " dentry: %s, task:%s\n",
284 __func__, dentry->d_name.name, current->comm);
289 /* save current_cred and override it */
290 OVERRIDE_CRED(SDCARDFS_SB(dir->i_sb), saved_cred, SDCARDFS_I(dir));
292 /* check disk space */
293 if (!check_min_free_space(dentry, 0, 1)) {
294 printk(KERN_INFO "sdcardfs: No minimum free space.\n");
299 /* the lower_dentry is negative here */
300 sdcardfs_get_lower_path(dentry, &lower_path);
301 lower_dentry = lower_path.dentry;
302 lower_mnt = lower_path.mnt;
303 lower_parent_dentry = lock_parent(lower_dentry);
305 /* set last 16bytes of mode field to 0775 */
306 mode = (mode & S_IFMT) | 00775;
308 /* temporarily change umask for lower fs write */
309 saved_fs = current->fs;
310 copied_fs = copy_fs_struct(current->fs);
313 unlock_dir(lower_parent_dentry);
316 current->fs = copied_fs;
317 current->fs->umask = 0;
318 err = vfs_mkdir2(lower_mnt, d_inode(lower_parent_dentry), lower_dentry, mode);
321 unlock_dir(lower_parent_dentry);
325 /* if it is a local obb dentry, setup it with the base obbpath */
326 if(need_graft_path(dentry)) {
328 err = setup_obb_dentry(dentry, &lower_path);
330 /* if the sbi->obbpath is not available, the lower_path won't be
331 * changed by setup_obb_dentry() but the lower path is saved to
332 * its orig_path. this dentry will be revalidated later.
333 * but now, the lower_path should be NULL */
334 sdcardfs_put_reset_lower_path(dentry);
336 /* the newly created lower path which saved to its orig_path or
337 * the lower_path is the base obbpath.
338 * therefore, an additional path_get is required */
339 path_get(&lower_path);
341 make_nomedia_in_obb = 1;
344 err = sdcardfs_interpose(dentry, dir->i_sb, &lower_path, pi->userid);
346 unlock_dir(lower_parent_dentry);
350 fsstack_copy_attr_times(dir, sdcardfs_lower_inode(dir));
351 fsstack_copy_inode_size(dir, d_inode(lower_parent_dentry));
352 /* update number of links on parent directory */
353 set_nlink(dir, sdcardfs_lower_inode(dir)->i_nlink);
354 fixup_lower_ownership(dentry, dentry->d_name.name);
355 unlock_dir(lower_parent_dentry);
356 if ((!sbi->options.multiuser) && (qstr_case_eq(&dentry->d_name, &q_obb))
357 && (pi->perm == PERM_ANDROID) && (pi->userid == 0))
358 make_nomedia_in_obb = 1;
360 /* When creating /Android/data and /Android/obb, mark them as .nomedia */
361 if (make_nomedia_in_obb ||
362 ((pi->perm == PERM_ANDROID) && (qstr_case_eq(&dentry->d_name, &q_data)))) {
363 REVERT_CRED(saved_cred);
364 OVERRIDE_CRED(SDCARDFS_SB(dir->i_sb), saved_cred, SDCARDFS_I(d_inode(dentry)));
365 set_fs_pwd(current->fs, &lower_path);
366 touch_err = touch(".nomedia", 0664);
368 printk(KERN_ERR "sdcardfs: failed to create .nomedia in %s: %d\n",
369 lower_path.dentry->d_name.name, touch_err);
374 current->fs = saved_fs;
375 free_fs_struct(copied_fs);
377 sdcardfs_put_lower_path(dentry, &lower_path);
379 REVERT_CRED(saved_cred);
384 static int sdcardfs_rmdir(struct inode *dir, struct dentry *dentry)
386 struct dentry *lower_dentry;
387 struct dentry *lower_dir_dentry;
388 struct vfsmount *lower_mnt;
390 struct path lower_path;
391 const struct cred *saved_cred = NULL;
393 if(!check_caller_access_to_name(dir, &dentry->d_name)) {
394 printk(KERN_INFO "%s: need to check the caller's gid in packages.list\n"
395 " dentry: %s, task:%s\n",
396 __func__, dentry->d_name.name, current->comm);
401 /* save current_cred and override it */
402 OVERRIDE_CRED(SDCARDFS_SB(dir->i_sb), saved_cred, SDCARDFS_I(dir));
404 /* sdcardfs_get_real_lower(): in case of remove an user's obb dentry
405 * the dentry on the original path should be deleted. */
406 sdcardfs_get_real_lower(dentry, &lower_path);
408 lower_dentry = lower_path.dentry;
409 lower_mnt = lower_path.mnt;
410 lower_dir_dentry = lock_parent(lower_dentry);
412 err = vfs_rmdir2(lower_mnt, d_inode(lower_dir_dentry), lower_dentry);
416 d_drop(dentry); /* drop our dentry on success (why not VFS's job?) */
418 clear_nlink(d_inode(dentry));
419 fsstack_copy_attr_times(dir, d_inode(lower_dir_dentry));
420 fsstack_copy_inode_size(dir, d_inode(lower_dir_dentry));
421 set_nlink(dir, d_inode(lower_dir_dentry)->i_nlink);
424 unlock_dir(lower_dir_dentry);
425 sdcardfs_put_real_lower(dentry, &lower_path);
426 REVERT_CRED(saved_cred);
432 static int sdcardfs_mknod(struct inode *dir, struct dentry *dentry, umode_t mode,
436 struct dentry *lower_dentry;
437 struct dentry *lower_parent_dentry = NULL;
438 struct path lower_path;
440 OVERRIDE_CRED(SDCARDFS_SB(dir->i_sb));
442 sdcardfs_get_lower_path(dentry, &lower_path);
443 lower_dentry = lower_path.dentry;
444 lower_parent_dentry = lock_parent(lower_dentry);
446 err = vfs_mknod(d_inode(lower_parent_dentry), lower_dentry, mode, dev);
450 err = sdcardfs_interpose(dentry, dir->i_sb, &lower_path);
453 fsstack_copy_attr_times(dir, sdcardfs_lower_inode(dir));
454 fsstack_copy_inode_size(dir, d_inode(lower_parent_dentry));
457 unlock_dir(lower_parent_dentry);
458 sdcardfs_put_lower_path(dentry, &lower_path);
465 * The locking rules in sdcardfs_rename are complex. We could use a simpler
466 * superblock-level name-space lock for renames and copy-ups.
468 static int sdcardfs_rename(struct inode *old_dir, struct dentry *old_dentry,
469 struct inode *new_dir, struct dentry *new_dentry)
472 struct dentry *lower_old_dentry = NULL;
473 struct dentry *lower_new_dentry = NULL;
474 struct dentry *lower_old_dir_dentry = NULL;
475 struct dentry *lower_new_dir_dentry = NULL;
476 struct vfsmount *lower_mnt = NULL;
477 struct dentry *trap = NULL;
478 struct path lower_old_path, lower_new_path;
479 const struct cred *saved_cred = NULL;
481 if(!check_caller_access_to_name(old_dir, &old_dentry->d_name) ||
482 !check_caller_access_to_name(new_dir, &new_dentry->d_name)) {
483 printk(KERN_INFO "%s: need to check the caller's gid in packages.list\n"
484 " new_dentry: %s, task:%s\n",
485 __func__, new_dentry->d_name.name, current->comm);
490 /* save current_cred and override it */
491 OVERRIDE_CRED(SDCARDFS_SB(old_dir->i_sb), saved_cred, SDCARDFS_I(new_dir));
493 sdcardfs_get_real_lower(old_dentry, &lower_old_path);
494 sdcardfs_get_lower_path(new_dentry, &lower_new_path);
495 lower_old_dentry = lower_old_path.dentry;
496 lower_new_dentry = lower_new_path.dentry;
497 lower_mnt = lower_old_path.mnt;
498 lower_old_dir_dentry = dget_parent(lower_old_dentry);
499 lower_new_dir_dentry = dget_parent(lower_new_dentry);
501 trap = lock_rename(lower_old_dir_dentry, lower_new_dir_dentry);
502 /* source should not be ancestor of target */
503 if (trap == lower_old_dentry) {
507 /* target should not be ancestor of source */
508 if (trap == lower_new_dentry) {
513 err = vfs_rename2(lower_mnt,
514 d_inode(lower_old_dir_dentry), lower_old_dentry,
515 d_inode(lower_new_dir_dentry), lower_new_dentry,
520 /* Copy attrs from lower dir, but i_uid/i_gid */
521 sdcardfs_copy_and_fix_attrs(new_dir, d_inode(lower_new_dir_dentry));
522 fsstack_copy_inode_size(new_dir, d_inode(lower_new_dir_dentry));
524 if (new_dir != old_dir) {
525 sdcardfs_copy_and_fix_attrs(old_dir, d_inode(lower_old_dir_dentry));
526 fsstack_copy_inode_size(old_dir, d_inode(lower_old_dir_dentry));
528 get_derived_permission_new(new_dentry->d_parent, old_dentry, &new_dentry->d_name);
529 fixup_tmp_permissions(d_inode(old_dentry));
530 fixup_lower_ownership(old_dentry, new_dentry->d_name.name);
531 drop_recursive(old_dentry); /* Can't fixup ownership recursively :( */
533 unlock_rename(lower_old_dir_dentry, lower_new_dir_dentry);
534 dput(lower_old_dir_dentry);
535 dput(lower_new_dir_dentry);
536 sdcardfs_put_real_lower(old_dentry, &lower_old_path);
537 sdcardfs_put_lower_path(new_dentry, &lower_new_path);
538 REVERT_CRED(saved_cred);
544 static int sdcardfs_readlink(struct dentry *dentry, char __user *buf, int bufsiz)
547 struct dentry *lower_dentry;
548 struct path lower_path;
549 /* XXX readlink does not requires overriding credential */
551 sdcardfs_get_lower_path(dentry, &lower_path);
552 lower_dentry = lower_path.dentry;
553 if (!d_inode(lower_dentry)->i_op ||
554 !d_inode(lower_dentry)->i_op->readlink) {
559 err = d_inode(lower_dentry)->i_op->readlink(lower_dentry,
563 fsstack_copy_attr_atime(d_inode(dentry), d_inode(lower_dentry));
566 sdcardfs_put_lower_path(dentry, &lower_path);
572 static const char *sdcardfs_follow_link(struct dentry *dentry, void **cookie)
575 int len = PAGE_SIZE, err;
578 /* This is freed by the put_link method assuming a successful call. */
579 buf = kmalloc(len, GFP_KERNEL);
581 buf = ERR_PTR(-ENOMEM);
585 /* read the symlink, and then we will follow it */
588 err = sdcardfs_readlink(dentry, buf, len);
596 return *cookie = buf;
600 static int sdcardfs_permission_wrn(struct inode *inode, int mask)
602 WARN(1, "sdcardfs does not support permission. Use permission2.\n");
606 void copy_attrs(struct inode *dest, const struct inode *src)
608 dest->i_mode = src->i_mode;
609 dest->i_uid = src->i_uid;
610 dest->i_gid = src->i_gid;
611 dest->i_rdev = src->i_rdev;
612 dest->i_atime = src->i_atime;
613 dest->i_mtime = src->i_mtime;
614 dest->i_ctime = src->i_ctime;
615 dest->i_blkbits = src->i_blkbits;
616 dest->i_flags = src->i_flags;
617 #ifdef CONFIG_FS_POSIX_ACL
618 dest->i_acl = src->i_acl;
620 #ifdef CONFIG_SECURITY
621 dest->i_security = src->i_security;
625 static int sdcardfs_permission(struct vfsmount *mnt, struct inode *inode, int mask)
629 struct inode *top = grab_top(SDCARDFS_I(inode));
632 release_top(SDCARDFS_I(inode));
633 WARN(1, "Top value was null!\n");
638 * Permission check on sdcardfs inode.
639 * Calling process should have AID_SDCARD_RW permission
640 * Since generic_permission only needs i_mode, i_uid,
641 * i_gid, and i_sb, we can create a fake inode to pass
642 * this information down in.
644 * The underlying code may attempt to take locks in some
645 * cases for features we're not using, but if that changes,
646 * locks must be dealt with to avoid undefined behavior.
648 copy_attrs(&tmp, inode);
649 tmp.i_uid = make_kuid(&init_user_ns, SDCARDFS_I(top)->d_uid);
650 tmp.i_gid = make_kgid(&init_user_ns, get_gid(mnt, SDCARDFS_I(top)));
651 tmp.i_mode = (inode->i_mode & S_IFMT) | get_mode(mnt, SDCARDFS_I(top));
652 release_top(SDCARDFS_I(inode));
653 tmp.i_sb = inode->i_sb;
654 if (IS_POSIXACL(inode))
655 printk(KERN_WARNING "%s: This may be undefined behavior... \n", __func__);
656 err = generic_permission(&tmp, mask);
658 * Original sdcardfs code calls inode_permission(lower_inode,.. )
659 * for checking inode permission. But doing such things here seems
660 * duplicated work, because the functions called after this func,
661 * such as vfs_create, vfs_unlink, vfs_rename, and etc,
662 * does exactly same thing, i.e., they calls inode_permission().
663 * So we just let they do the things.
664 * If there are any security hole, just uncomment following if block.
669 * Permission check on lower_inode(=EXT4).
670 * we check it with AID_MEDIA_RW permission
672 struct inode *lower_inode;
673 OVERRIDE_CRED(SDCARDFS_SB(inode->sb));
675 lower_inode = sdcardfs_lower_inode(inode);
676 err = inode_permission(lower_inode, mask);
685 static int sdcardfs_setattr_wrn(struct dentry *dentry, struct iattr *ia)
687 WARN(1, "sdcardfs does not support setattr. User setattr2.\n");
691 static int sdcardfs_setattr(struct vfsmount *mnt, struct dentry *dentry, struct iattr *ia)
694 struct dentry *lower_dentry;
695 struct vfsmount *lower_mnt;
697 struct inode *lower_inode;
698 struct path lower_path;
699 struct iattr lower_ia;
700 struct dentry *parent;
703 const struct cred *saved_cred = NULL;
705 inode = d_inode(dentry);
706 top = grab_top(SDCARDFS_I(inode));
709 release_top(SDCARDFS_I(inode));
714 * Permission check on sdcardfs inode.
715 * Calling process should have AID_SDCARD_RW permission
716 * Since generic_permission only needs i_mode, i_uid,
717 * i_gid, and i_sb, we can create a fake inode to pass
718 * this information down in.
720 * The underlying code may attempt to take locks in some
721 * cases for features we're not using, but if that changes,
722 * locks must be dealt with to avoid undefined behavior.
725 copy_attrs(&tmp, inode);
726 tmp.i_uid = make_kuid(&init_user_ns, SDCARDFS_I(top)->d_uid);
727 tmp.i_gid = make_kgid(&init_user_ns, get_gid(mnt, SDCARDFS_I(top)));
728 tmp.i_mode = (inode->i_mode & S_IFMT) | get_mode(mnt, SDCARDFS_I(top));
729 tmp.i_size = i_size_read(inode);
730 release_top(SDCARDFS_I(inode));
731 tmp.i_sb = inode->i_sb;
734 * Check if user has permission to change inode. We don't check if
735 * this user can change the lower inode: that should happen when
736 * calling notify_change on the lower inode.
738 /* prepare our own lower struct iattr (with the lower file) */
739 memcpy(&lower_ia, ia, sizeof(lower_ia));
740 /* Allow touch updating timestamps. A previous permission check ensures
741 * we have write access. Changes to mode, owner, and group are ignored*/
742 ia->ia_valid |= ATTR_FORCE;
743 err = inode_change_ok(&tmp, ia);
746 /* check the Android group ID */
747 parent = dget_parent(dentry);
748 if(!check_caller_access_to_name(d_inode(parent), &dentry->d_name)) {
749 printk(KERN_INFO "%s: need to check the caller's gid in packages.list\n"
750 " dentry: %s, task:%s\n",
751 __func__, dentry->d_name.name, current->comm);
760 /* save current_cred and override it */
761 OVERRIDE_CRED(SDCARDFS_SB(dentry->d_sb), saved_cred, SDCARDFS_I(inode));
763 sdcardfs_get_lower_path(dentry, &lower_path);
764 lower_dentry = lower_path.dentry;
765 lower_mnt = lower_path.mnt;
766 lower_inode = sdcardfs_lower_inode(inode);
768 if (ia->ia_valid & ATTR_FILE)
769 lower_ia.ia_file = sdcardfs_lower_file(ia->ia_file);
771 lower_ia.ia_valid &= ~(ATTR_UID | ATTR_GID | ATTR_MODE);
774 * If shrinking, first truncate upper level to cancel writing dirty
775 * pages beyond the new eof; and also if its' maxbytes is more
776 * limiting (fail with -EFBIG before making any change to the lower
777 * level). There is no need to vmtruncate the upper level
778 * afterwards in the other cases: we fsstack_copy_inode_size from
782 down_write(¤t->mm->mmap_sem);
783 if (ia->ia_valid & ATTR_SIZE) {
784 err = inode_newsize_ok(&tmp, ia->ia_size);
787 up_write(¤t->mm->mmap_sem);
790 truncate_setsize(inode, ia->ia_size);
794 * mode change is for clearing setuid/setgid bits. Allow lower fs
795 * to interpret this in its own way.
797 if (lower_ia.ia_valid & (ATTR_KILL_SUID | ATTR_KILL_SGID))
798 lower_ia.ia_valid &= ~ATTR_MODE;
800 /* notify the (possibly copied-up) lower inode */
802 * Note: we use d_inode(lower_dentry), because lower_inode may be
803 * unlinked (no inode->i_sb and i_ino==0. This happens if someone
804 * tries to open(), unlink(), then ftruncate() a file.
806 mutex_lock(&d_inode(lower_dentry)->i_mutex);
807 err = notify_change2(lower_mnt, lower_dentry, &lower_ia, /* note: lower_ia */
809 mutex_unlock(&d_inode(lower_dentry)->i_mutex);
811 up_write(¤t->mm->mmap_sem);
815 /* get attributes from the lower inode and update derived permissions */
816 sdcardfs_copy_and_fix_attrs(inode, lower_inode);
819 * Not running fsstack_copy_inode_size(inode, lower_inode), because
820 * VFS should update our inode size, and notify_change on
821 * lower_inode should update its size.
825 sdcardfs_put_lower_path(dentry, &lower_path);
826 REVERT_CRED(saved_cred);
831 static int sdcardfs_fillattr(struct vfsmount *mnt, struct inode *inode, struct kstat *stat)
833 struct sdcardfs_inode_info *info = SDCARDFS_I(inode);
834 struct inode *top = grab_top(info);
838 stat->dev = inode->i_sb->s_dev;
839 stat->ino = inode->i_ino;
840 stat->mode = (inode->i_mode & S_IFMT) | get_mode(mnt, SDCARDFS_I(top));
841 stat->nlink = inode->i_nlink;
842 stat->uid = make_kuid(&init_user_ns, SDCARDFS_I(top)->d_uid);
843 stat->gid = make_kgid(&init_user_ns, get_gid(mnt, SDCARDFS_I(top)));
844 stat->rdev = inode->i_rdev;
845 stat->size = i_size_read(inode);
846 stat->atime = inode->i_atime;
847 stat->mtime = inode->i_mtime;
848 stat->ctime = inode->i_ctime;
849 stat->blksize = (1 << inode->i_blkbits);
850 stat->blocks = inode->i_blocks;
855 static int sdcardfs_getattr(struct vfsmount *mnt, struct dentry *dentry,
858 struct dentry *lower_dentry;
860 struct inode *lower_inode;
861 struct path lower_path;
862 struct dentry *parent;
865 parent = dget_parent(dentry);
866 if(!check_caller_access_to_name(d_inode(parent), &dentry->d_name)) {
867 printk(KERN_INFO "%s: need to check the caller's gid in packages.list\n"
868 " dentry: %s, task:%s\n",
869 __func__, dentry->d_name.name, current->comm);
875 inode = d_inode(dentry);
877 sdcardfs_get_lower_path(dentry, &lower_path);
878 lower_dentry = lower_path.dentry;
879 lower_inode = sdcardfs_lower_inode(inode);
881 sdcardfs_copy_and_fix_attrs(inode, lower_inode);
882 fsstack_copy_inode_size(inode, lower_inode);
884 err = sdcardfs_fillattr(mnt, inode, stat);
885 sdcardfs_put_lower_path(dentry, &lower_path);
889 const struct inode_operations sdcardfs_symlink_iops = {
890 .permission2 = sdcardfs_permission,
891 .setattr2 = sdcardfs_setattr,
892 /* XXX Following operations are implemented,
893 * but FUSE(sdcard) or FAT does not support them
894 * These methods are *NOT* perfectly tested.
895 .readlink = sdcardfs_readlink,
896 .follow_link = sdcardfs_follow_link,
897 .put_link = kfree_put_link,
901 const struct inode_operations sdcardfs_dir_iops = {
902 .create = sdcardfs_create,
903 .lookup = sdcardfs_lookup,
904 .permission = sdcardfs_permission_wrn,
905 .permission2 = sdcardfs_permission,
906 .unlink = sdcardfs_unlink,
907 .mkdir = sdcardfs_mkdir,
908 .rmdir = sdcardfs_rmdir,
909 .rename = sdcardfs_rename,
910 .setattr = sdcardfs_setattr_wrn,
911 .setattr2 = sdcardfs_setattr,
912 .getattr = sdcardfs_getattr,
913 /* XXX Following operations are implemented,
914 * but FUSE(sdcard) or FAT does not support them
915 * These methods are *NOT* perfectly tested.
916 .symlink = sdcardfs_symlink,
917 .link = sdcardfs_link,
918 .mknod = sdcardfs_mknod,
922 const struct inode_operations sdcardfs_main_iops = {
923 .permission = sdcardfs_permission_wrn,
924 .permission2 = sdcardfs_permission,
925 .setattr = sdcardfs_setattr_wrn,
926 .setattr2 = sdcardfs_setattr,
927 .getattr = sdcardfs_getattr,