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 = lower_path->dentry->d_inode;
 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 char *name;
 223         struct path lower_path;
 224         struct qstr this;
 225         struct sdcardfs_sb_info *sbi;
 226
 227         sbi = SDCARDFS_SB(dentry->d_sb);
 228         /* must initialize dentry operations */
 229         d_set_d_op(dentry, &sdcardfs_ci_dops);
 230
 231         if (IS_ROOT(dentry))
 232                 goto out;
 233
 234         name = dentry->d_name.name;
 235
 236         /* now start the actual lookup procedure */
 237         lower_dir_dentry = lower_parent_path->dentry;
 238         lower_dir_mnt = lower_parent_path->mnt;
 239
 240         /* Use vfs_path_lookup to check if the dentry exists or not */
 241         err = vfs_path_lookup(lower_dir_dentry, lower_dir_mnt, name, 0,
 242                                 &lower_path);
 243         /* check for other cases */
 244         if (err == -ENOENT) {
 245                 struct dentry *child;
 246                 struct dentry *match = NULL;
 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 (strcasecmp(child->d_name.name, name)==0) {
 251                                         match = dget(child);
 252                                         break;
 253                                 }
 254                         }
 255                 }
 256                 spin_unlock(&lower_dir_dentry->d_lock);
 257                 if (match) {
 258                         err = vfs_path_lookup(lower_dir_dentry,
 259                                                 lower_dir_mnt,
 260                                                 match->d_name.name, 0,
 261                                                 &lower_path);
 262                         dput(match);
 263                 }
 264         }
 265
 266         /* no error: handle positive dentries */
 267         if (!err) {
 268                 /* check if the dentry is an obb dentry
 269                  * if true, the lower_inode must be replaced with
 270                  * the inode of the graft path */
 271
 272                 if(need_graft_path(dentry)) {
 273
 274                         /* setup_obb_dentry()
 275                          * The lower_path will be stored to the dentry's orig_path
 276                          * and the base obbpath will be copyed to the lower_path variable.
 277                          * if an error returned, there's no change in the lower_path
 278                          *              returns: -ERRNO if error (0: no error) */
 279                         err = setup_obb_dentry(dentry, &lower_path);
 280
 281                         if(err) {
 282                                 /* if the sbi->obbpath is not available, we can optionally
 283                                  * setup the lower_path with its orig_path.
 284                                  * but, the current implementation just returns an error
 285                                  * because the sdcard daemon also regards this case as
 286                                  * a lookup fail. */
 287                                 printk(KERN_INFO "sdcardfs: base obbpath is not available\n");
 288                                 sdcardfs_put_reset_orig_path(dentry);
 289                                 goto out;
 290                         }
 291                 }
 292
 293                 sdcardfs_set_lower_path(dentry, &lower_path);
 294                 err = sdcardfs_interpose(dentry, dentry->d_sb, &lower_path, id);
 295                 if (err) /* path_put underlying path on error */
 296                         sdcardfs_put_reset_lower_path(dentry);
 297                 goto out;
 298         }
 299
 300         /*
 301          * We don't consider ENOENT an error, and we want to return a
 302          * negative dentry.
 303          */
 304         if (err && err != -ENOENT)
 305                 goto out;
 306
 307         /* instatiate a new negative dentry */
 308         this.name = name;
 309         this.len = strlen(name);
 310         this.hash = full_name_hash(this.name, this.len);
 311         lower_dentry = d_lookup(lower_dir_dentry, &this);
 312         if (lower_dentry)
 313                 goto setup_lower;
 314
 315         lower_dentry = d_alloc(lower_dir_dentry, &this);
 316         if (!lower_dentry) {
 317                 err = -ENOMEM;
 318                 goto out;
 319         }
 320         d_add(lower_dentry, NULL); /* instantiate and hash */
 321
 322 setup_lower:
 323         lower_path.dentry = lower_dentry;
 324         lower_path.mnt = mntget(lower_dir_mnt);
 325         sdcardfs_set_lower_path(dentry, &lower_path);
 326
 327         /*
 328          * If the intent is to create a file, then don't return an error, so
 329          * the VFS will continue the process of making this negative dentry
 330          * into a positive one.
 331          */
 332         if (flags & (LOOKUP_CREATE|LOOKUP_RENAME_TARGET))
 333                 err = 0;
 334
 335 out:
 336         return ERR_PTR(err);
 337 }
 338
 339 /*
 340  * On success:
 341  *      fills dentry object appropriate values and returns NULL.
 342  * On fail (== error)
 343  *      returns error ptr
 344  *
 345  * @dir : Parent inode. It is locked (dir->i_mutex)
 346  * @dentry : Target dentry to lookup. we should set each of fields.
 347  *           (dentry->d_name is initialized already)
 348  * @nd : nameidata of parent inode
 349  */
 350 struct dentry *sdcardfs_lookup(struct inode *dir, struct dentry *dentry,
 351                              unsigned int flags)
 352 {
 353         struct dentry *ret = NULL, *parent;
 354         struct path lower_parent_path;
 355         int err = 0;
 356         const struct cred *saved_cred = NULL;
 357
 358         parent = dget_parent(dentry);
 359
 360         if(!check_caller_access_to_name(parent->d_inode, dentry->d_name.name)) {
 361                 ret = ERR_PTR(-EACCES);
 362                 printk(KERN_INFO "%s: need to check the caller's gid in packages.list\n"
 363                          "      dentry: %s, task:%s\n",
 364                                                  __func__, dentry->d_name.name, current->comm);
 365                 goto out_err;
 366         }
 367
 368         /* save current_cred and override it */
 369         OVERRIDE_CRED_PTR(SDCARDFS_SB(dir->i_sb), saved_cred);
 370
 371         sdcardfs_get_lower_path(parent, &lower_parent_path);
 372
 373         /* allocate dentry private data.  We free it in ->d_release */
 374         err = new_dentry_private_data(dentry);
 375         if (err) {
 376                 ret = ERR_PTR(err);
 377                 goto out;
 378         }
 379
 380         ret = __sdcardfs_lookup(dentry, flags, &lower_parent_path, SDCARDFS_I(dir)->userid);
 381         if (IS_ERR(ret))
 382         {
 383                 goto out;
 384         }
 385         if (ret)
 386                 dentry = ret;
 387         if (dentry->d_inode) {
 388                 fsstack_copy_attr_times(dentry->d_inode,
 389                                         sdcardfs_lower_inode(dentry->d_inode));
 390                 /* get derived permission */
 391                 get_derived_permission(parent, dentry);
 392                 fix_derived_permission(dentry->d_inode);
 393         }
 394         /* update parent directory's atime */
 395         fsstack_copy_attr_atime(parent->d_inode,
 396                                 sdcardfs_lower_inode(parent->d_inode));
 397
 398 out:
 399         sdcardfs_put_lower_path(parent, &lower_parent_path);
 400         REVERT_CRED(saved_cred);
 401 out_err:
 402         dput(parent);
 403         return ret;
 404 }