fs/sdcardfs/lookup.c

   1 /*
   2  * fs/sdcardfs/lookup.c
   3  *
   4  * Copyright (c) 2013 Samsung Electronics Co. Ltd
   5  *   Authors: Daeho Jeong, Woojoong Lee, Seunghwan Hyun,
   6  *               Sunghwan Yun, Sungjong Seo
   7  *
   8  * This program has been developed as a stackable file system based on
   9  * the WrapFS which written by
  10  *
  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
  15  *
  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.
  19  */
  20
  21 #include "sdcardfs.h"
  22 #include "linux/delay.h"
  23
  24 /* The dentry cache is just so we have properly sized dentries */
  25 static struct kmem_cache *sdcardfs_dentry_cachep;
  26
  27 int sdcardfs_init_dentry_cache(void)
  28 {
  29         sdcardfs_dentry_cachep =
  30                 kmem_cache_create("sdcardfs_dentry",
  31                                   sizeof(struct sdcardfs_dentry_info),
  32                                   0, SLAB_RECLAIM_ACCOUNT, NULL);
  33
  34         return sdcardfs_dentry_cachep ? 0 : -ENOMEM;
  35 }
  36
  37 void sdcardfs_destroy_dentry_cache(void)
  38 {
  39         if (sdcardfs_dentry_cachep)
  40                 kmem_cache_destroy(sdcardfs_dentry_cachep);
  41 }
  42
  43 void free_dentry_private_data(struct dentry *dentry)
  44 {
  45         if (!dentry || !dentry->d_fsdata)
  46                 return;
  47         kmem_cache_free(sdcardfs_dentry_cachep, dentry->d_fsdata);
  48         dentry->d_fsdata = NULL;
  49 }
  50
  51 /* allocate new dentry private data */
  52 int new_dentry_private_data(struct dentry *dentry)
  53 {
  54         struct sdcardfs_dentry_info *info = SDCARDFS_D(dentry);
  55
  56         /* use zalloc to init dentry_info.lower_path */
  57         info = kmem_cache_zalloc(sdcardfs_dentry_cachep, GFP_ATOMIC);
  58         if (!info)
  59                 return -ENOMEM;
  60
  61         spin_lock_init(&info->lock);
  62         dentry->d_fsdata = info;
  63
  64         return 0;
  65 }
  66
  67 struct inode_data {
  68         struct inode *lower_inode;
  69         userid_t id;
  70 };
  71
  72 static int sdcardfs_inode_test(struct inode *inode, void *candidate_data/*void *candidate_lower_inode*/)
  73 {
  74         struct inode *current_lower_inode = sdcardfs_lower_inode(inode);
  75         userid_t current_userid = SDCARDFS_I(inode)->userid;
  76         if (current_lower_inode == ((struct inode_data *)candidate_data)->lower_inode &&
  77                         current_userid == ((struct inode_data *)candidate_data)->id)
  78                 return 1; /* found a match */
  79         else
  80                 return 0; /* no match */
  81 }
  82
  83 static int sdcardfs_inode_set(struct inode *inode, void *lower_inode)
  84 {
  85         /* we do actual inode initialization in sdcardfs_iget */
  86         return 0;
  87 }
  88
  89 struct inode *sdcardfs_iget(struct super_block *sb, struct inode *lower_inode, userid_t id)
  90 {
  91         struct sdcardfs_inode_info *info;
  92         struct inode_data data;
  93         struct inode *inode; /* the new inode to return */
  94         int err;
  95
  96         data.id = id;
  97         data.lower_inode = lower_inode;
  98         inode = iget5_locked(sb, /* our superblock */
  99                              /*
 100                               * hashval: we use inode number, but we can
 101                               * also use "(unsigned long)lower_inode"
 102                               * instead.
 103                               */
 104                              lower_inode->i_ino, /* hashval */
 105                              sdcardfs_inode_test,       /* inode comparison function */
 106                              sdcardfs_inode_set, /* inode init function */
 107                              &data); /* data passed to test+set fxns */
 108         if (!inode) {
 109                 err = -EACCES;
 110                 iput(lower_inode);
 111                 return ERR_PTR(err);
 112         }
 113         /* if found a cached inode, then just return it */
 114         if (!(inode->i_state & I_NEW))
 115                 return inode;
 116
 117         /* initialize new inode */
 118         info = SDCARDFS_I(inode);
 119
 120         inode->i_ino = lower_inode->i_ino;
 121         if (!igrab(lower_inode)) {
 122                 err = -ESTALE;
 123                 return ERR_PTR(err);
 124         }
 125         sdcardfs_set_lower_inode(inode, lower_inode);
 126
 127         inode->i_version++;
 128
 129         /* use different set of inode ops for symlinks & directories */
 130         if (S_ISDIR(lower_inode->i_mode))
 131                 inode->i_op = &sdcardfs_dir_iops;
 132         else if (S_ISLNK(lower_inode->i_mode))
 133                 inode->i_op = &sdcardfs_symlink_iops;
 134         else
 135                 inode->i_op = &sdcardfs_main_iops;
 136
 137         /* use different set of file ops for directories */
 138         if (S_ISDIR(lower_inode->i_mode))
 139                 inode->i_fop = &sdcardfs_dir_fops;
 140         else
 141                 inode->i_fop = &sdcardfs_main_fops;
 142
 143         inode->i_mapping->a_ops = &sdcardfs_aops;
 144
 145         inode->i_atime.tv_sec = 0;
 146         inode->i_atime.tv_nsec = 0;
 147         inode->i_mtime.tv_sec = 0;
 148         inode->i_mtime.tv_nsec = 0;
 149         inode->i_ctime.tv_sec = 0;
 150         inode->i_ctime.tv_nsec = 0;
 151
 152         /* properly initialize special inodes */
 153         if (S_ISBLK(lower_inode->i_mode) || S_ISCHR(lower_inode->i_mode) ||
 154             S_ISFIFO(lower_inode->i_mode) || S_ISSOCK(lower_inode->i_mode))
 155                 init_special_inode(inode, lower_inode->i_mode,
 156                                    lower_inode->i_rdev);
 157
 158         /* all well, copy inode attributes */
 159         sdcardfs_copy_and_fix_attrs(inode, lower_inode);
 160         fsstack_copy_inode_size(inode, lower_inode);
 161
 162         unlock_new_inode(inode);
 163         return inode;
 164 }
 165
 166 /*
 167  * Connect a sdcardfs inode dentry/inode with several lower ones.  This is
 168  * the classic stackable file system "vnode interposition" action.
 169  *
 170  * @dentry: sdcardfs's dentry which interposes on lower one
 171  * @sb: sdcardfs's super_block
 172  * @lower_path: the lower path (caller does path_get/put)
 173  */
 174 int sdcardfs_interpose(struct dentry *dentry, struct super_block *sb,
 175                      struct path *lower_path, userid_t id)
 176 {
 177         int err = 0;
 178         struct inode *inode;
 179         struct inode *lower_inode;
 180         struct super_block *lower_sb;
 181
 182         lower_inode = d_inode(lower_path->dentry);
 183         lower_sb = sdcardfs_lower_super(sb);
 184
 185         /* check that the lower file system didn't cross a mount point */
 186         if (lower_inode->i_sb != lower_sb) {
 187                 err = -EXDEV;
 188                 goto out;
 189         }
 190
 191         /*
 192          * We allocate our new inode below by calling sdcardfs_iget,
 193          * which will initialize some of the new inode's fields
 194          */
 195
 196         /* inherit lower inode number for sdcardfs's inode */
 197         inode = sdcardfs_iget(sb, lower_inode, id);
 198         if (IS_ERR(inode)) {
 199                 err = PTR_ERR(inode);
 200                 goto out;
 201         }
 202
 203         d_add(dentry, inode);
 204         update_derived_permission_lock(dentry);
 205 out:
 206         return err;
 207 }
 208
 209 /*
 210  * Main driver function for sdcardfs's lookup.
 211  *
 212  * Returns: NULL (ok), ERR_PTR if an error occurred.
 213  * Fills in lower_parent_path with <dentry,mnt> on success.
 214  */
 215 static struct dentry *__sdcardfs_lookup(struct dentry *dentry,
 216                 unsigned int flags, struct path *lower_parent_path, userid_t id)
 217 {
 218         int err = 0;
 219         struct vfsmount *lower_dir_mnt;
 220         struct dentry *lower_dir_dentry = NULL;
 221         struct dentry *lower_dentry;
 222         const struct qstr *name;
 223         struct path lower_path;
 224         struct sdcardfs_sb_info *sbi;
 225
 226         sbi = SDCARDFS_SB(dentry->d_sb);
 227         /* must initialize dentry operations */
 228         d_set_d_op(dentry, &sdcardfs_ci_dops);
 229
 230         if (IS_ROOT(dentry))
 231                 goto out;
 232
 233         name = &dentry->d_name;
 234
 235         /* now start the actual lookup procedure */
 236         lower_dir_dentry = lower_parent_path->dentry;
 237         lower_dir_mnt = lower_parent_path->mnt;
 238
 239         /* Use vfs_path_lookup to check if the dentry exists or not */
 240         err = vfs_path_lookup(lower_dir_dentry, lower_dir_mnt, name->name, 0,
 241                                 &lower_path);
 242         /* check for other cases */
 243         if (err == -ENOENT) {
 244                 struct dentry *child;
 245                 struct dentry *match = NULL;
 246                 mutex_lock(&d_inode(lower_dir_dentry)->i_mutex);
 247                 spin_lock(&lower_dir_dentry->d_lock);
 248                 list_for_each_entry(child, &lower_dir_dentry->d_subdirs, d_child) {
 249                         if (child && d_inode(child)) {
 250                                 if (qstr_case_eq(&child->d_name, name)) {
 251                                         match = dget(child);
 252                                         break;
 253                                 }
 254                         }
 255                 }
 256                 spin_unlock(&lower_dir_dentry->d_lock);
 257                 mutex_unlock(&d_inode(lower_dir_dentry)->i_mutex);
 258                 if (match) {
 259                         err = vfs_path_lookup(lower_dir_dentry,
 260                                                 lower_dir_mnt,
 261                                                 match->d_name.name, 0,
 262                                                 &lower_path);
 263                         dput(match);
 264                 }
 265         }
 266
 267         /* no error: handle positive dentries */
 268         if (!err) {
 269                 /* check if the dentry is an obb dentry
 270                  * if true, the lower_inode must be replaced with
 271                  * the inode of the graft path */
 272
 273                 if(need_graft_path(dentry)) {
 274
 275                         /* setup_obb_dentry()
 276                          * The lower_path will be stored to the dentry's orig_path
 277                          * and the base obbpath will be copyed to the lower_path variable.
 278                          * if an error returned, there's no change in the lower_path
 279                          *              returns: -ERRNO if error (0: no error) */
 280                         err = setup_obb_dentry(dentry, &lower_path);
 281
 282                         if(err) {
 283                                 /* if the sbi->obbpath is not available, we can optionally
 284                                  * setup the lower_path with its orig_path.
 285                                  * but, the current implementation just returns an error
 286                                  * because the sdcard daemon also regards this case as
 287                                  * a lookup fail. */
 288                                 printk(KERN_INFO "sdcardfs: base obbpath is not available\n");
 289                                 sdcardfs_put_reset_orig_path(dentry);
 290                                 goto out;
 291                         }
 292                 }
 293
 294                 sdcardfs_set_lower_path(dentry, &lower_path);
 295                 err = sdcardfs_interpose(dentry, dentry->d_sb, &lower_path, id);
 296                 if (err) /* path_put underlying path on error */
 297                         sdcardfs_put_reset_lower_path(dentry);
 298                 goto out;
 299         }
 300
 301         /*
 302          * We don't consider ENOENT an error, and we want to return a
 303          * negative dentry.
 304          */
 305         if (err && err != -ENOENT)
 306                 goto out;
 307
 308         /* instatiate a new negative dentry */
 309         lower_dentry = d_lookup(lower_dir_dentry, name);
 310         if (lower_dentry)
 311                 goto setup_lower;
 312
 313         lower_dentry = d_alloc(lower_dir_dentry, name);
 314         if (!lower_dentry) {
 315                 err = -ENOMEM;
 316                 goto out;
 317         }
 318         d_add(lower_dentry, NULL); /* instantiate and hash */
 319
 320 setup_lower:
 321         lower_path.dentry = lower_dentry;
 322         lower_path.mnt = mntget(lower_dir_mnt);
 323         sdcardfs_set_lower_path(dentry, &lower_path);
 324
 325         /*
 326          * If the intent is to create a file, then don't return an error, so
 327          * the VFS will continue the process of making this negative dentry
 328          * into a positive one.
 329          */
 330         if (flags & (LOOKUP_CREATE|LOOKUP_RENAME_TARGET))
 331                 err = 0;
 332
 333 out:
 334         return ERR_PTR(err);
 335 }
 336
 337 /*
 338  * On success:
 339  *      fills dentry object appropriate values and returns NULL.
 340  * On fail (== error)
 341  *      returns error ptr
 342  *
 343  * @dir : Parent inode. It is locked (dir->i_mutex)
 344  * @dentry : Target dentry to lookup. we should set each of fields.
 345  *           (dentry->d_name is initialized already)
 346  * @nd : nameidata of parent inode
 347  */
 348 struct dentry *sdcardfs_lookup(struct inode *dir, struct dentry *dentry,
 349                              unsigned int flags)
 350 {
 351         struct dentry *ret = NULL, *parent;
 352         struct path lower_parent_path;
 353         int err = 0;
 354         const struct cred *saved_cred = NULL;
 355
 356         parent = dget_parent(dentry);
 357
 358         if(!check_caller_access_to_name(d_inode(parent), &dentry->d_name)) {
 359                 ret = ERR_PTR(-EACCES);
 360                 printk(KERN_INFO "%s: need to check the caller's gid in packages.list\n"
 361                          "      dentry: %s, task:%s\n",
 362                                                  __func__, dentry->d_name.name, current->comm);
 363                 goto out_err;
 364         }
 365
 366         /* save current_cred and override it */
 367         OVERRIDE_CRED_PTR(SDCARDFS_SB(dir->i_sb), saved_cred, SDCARDFS_I(dir));
 368
 369         sdcardfs_get_lower_path(parent, &lower_parent_path);
 370
 371         /* allocate dentry private data.  We free it in ->d_release */
 372         err = new_dentry_private_data(dentry);
 373         if (err) {
 374                 ret = ERR_PTR(err);
 375                 goto out;
 376         }
 377
 378         ret = __sdcardfs_lookup(dentry, flags, &lower_parent_path, SDCARDFS_I(dir)->userid);
 379         if (IS_ERR(ret))
 380         {
 381                 goto out;
 382         }
 383         if (ret)
 384                 dentry = ret;
 385         if (d_inode(dentry)) {
 386                 fsstack_copy_attr_times(d_inode(dentry),
 387                                         sdcardfs_lower_inode(d_inode(dentry)));
 388                 /* get derived permission */
 389                 get_derived_permission(parent, dentry);
 390                 fixup_tmp_permissions(d_inode(dentry));
 391                 fixup_lower_ownership(dentry, dentry->d_name.name);
 392         }
 393         /* update parent directory's atime */
 394         fsstack_copy_attr_atime(d_inode(parent),
 395                                 sdcardfs_lower_inode(d_inode(parent)));
 396
 397 out:
 398         sdcardfs_put_lower_path(parent, &lower_parent_path);
 399         REVERT_CRED(saved_cred);
 400 out_err:
 401         dput(parent);
 402         return ret;
 403 }