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/delay.h"
24 /* The dentry cache is just so we have properly sized dentries */
25 static struct kmem_cache *sdcardfs_dentry_cachep;
27 int sdcardfs_init_dentry_cache(void)
29 sdcardfs_dentry_cachep =
30 kmem_cache_create("sdcardfs_dentry",
31 sizeof(struct sdcardfs_dentry_info),
32 0, SLAB_RECLAIM_ACCOUNT, NULL);
34 return sdcardfs_dentry_cachep ? 0 : -ENOMEM;
37 void sdcardfs_destroy_dentry_cache(void)
39 if (sdcardfs_dentry_cachep)
40 kmem_cache_destroy(sdcardfs_dentry_cachep);
43 void free_dentry_private_data(struct dentry *dentry)
45 if (!dentry || !dentry->d_fsdata)
47 kmem_cache_free(sdcardfs_dentry_cachep, dentry->d_fsdata);
48 dentry->d_fsdata = NULL;
51 /* allocate new dentry private data */
52 int new_dentry_private_data(struct dentry *dentry)
54 struct sdcardfs_dentry_info *info = SDCARDFS_D(dentry);
56 /* use zalloc to init dentry_info.lower_path */
57 info = kmem_cache_zalloc(sdcardfs_dentry_cachep, GFP_ATOMIC);
61 spin_lock_init(&info->lock);
62 dentry->d_fsdata = info;
68 struct inode *lower_inode;
72 static int sdcardfs_inode_test(struct inode *inode, void *candidate_data/*void *candidate_lower_inode*/)
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 */
80 return 0; /* no match */
83 static int sdcardfs_inode_set(struct inode *inode, void *lower_inode)
85 /* we do actual inode initialization in sdcardfs_iget */
89 struct inode *sdcardfs_iget(struct super_block *sb, struct inode *lower_inode, userid_t id)
91 struct sdcardfs_inode_info *info;
92 struct inode_data data;
93 struct inode *inode; /* the new inode to return */
97 data.lower_inode = lower_inode;
98 inode = iget5_locked(sb, /* our superblock */
100 * hashval: we use inode number, but we can
101 * also use "(unsigned long)lower_inode"
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 */
113 /* if found a cached inode, then just return it */
114 if (!(inode->i_state & I_NEW))
117 /* initialize new inode */
118 info = SDCARDFS_I(inode);
120 inode->i_ino = lower_inode->i_ino;
121 if (!igrab(lower_inode)) {
125 sdcardfs_set_lower_inode(inode, lower_inode);
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;
135 inode->i_op = &sdcardfs_main_iops;
137 /* use different set of file ops for directories */
138 if (S_ISDIR(lower_inode->i_mode))
139 inode->i_fop = &sdcardfs_dir_fops;
141 inode->i_fop = &sdcardfs_main_fops;
143 inode->i_mapping->a_ops = &sdcardfs_aops;
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;
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);
158 /* all well, copy inode attributes */
159 sdcardfs_copy_and_fix_attrs(inode, lower_inode);
160 fsstack_copy_inode_size(inode, lower_inode);
162 unlock_new_inode(inode);
167 * Connect a sdcardfs inode dentry/inode with several lower ones. This is
168 * the classic stackable file system "vnode interposition" action.
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)
174 int sdcardfs_interpose(struct dentry *dentry, struct super_block *sb,
175 struct path *lower_path, userid_t id)
179 struct inode *lower_inode;
180 struct super_block *lower_sb;
182 lower_inode = lower_path->dentry->d_inode;
183 lower_sb = sdcardfs_lower_super(sb);
185 /* check that the lower file system didn't cross a mount point */
186 if (lower_inode->i_sb != lower_sb) {
192 * We allocate our new inode below by calling sdcardfs_iget,
193 * which will initialize some of the new inode's fields
196 /* inherit lower inode number for sdcardfs's inode */
197 inode = sdcardfs_iget(sb, lower_inode, id);
199 err = PTR_ERR(inode);
203 d_add(dentry, inode);
204 update_derived_permission_lock(dentry);
210 * Main driver function for sdcardfs's lookup.
212 * Returns: NULL (ok), ERR_PTR if an error occurred.
213 * Fills in lower_parent_path with <dentry,mnt> on success.
215 static struct dentry *__sdcardfs_lookup(struct dentry *dentry,
216 unsigned int flags, struct path *lower_parent_path, userid_t id)
219 struct vfsmount *lower_dir_mnt;
220 struct dentry *lower_dir_dentry = NULL;
221 struct dentry *lower_dentry;
223 struct path lower_path;
225 struct sdcardfs_sb_info *sbi;
227 sbi = SDCARDFS_SB(dentry->d_sb);
228 /* must initialize dentry operations */
229 d_set_d_op(dentry, &sdcardfs_ci_dops);
234 name = dentry->d_name.name;
236 /* now start the actual lookup procedure */
237 lower_dir_dentry = lower_parent_path->dentry;
238 lower_dir_mnt = lower_parent_path->mnt;
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,
244 /* no error: handle positive dentries */
246 /* check if the dentry is an obb dentry
247 * if true, the lower_inode must be replaced with
248 * the inode of the graft path */
250 if(need_graft_path(dentry)) {
252 /* setup_obb_dentry()
253 * The lower_path will be stored to the dentry's orig_path
254 * and the base obbpath will be copyed to the lower_path variable.
255 * if an error returned, there's no change in the lower_path
256 * returns: -ERRNO if error (0: no error) */
257 err = setup_obb_dentry(dentry, &lower_path);
260 /* if the sbi->obbpath is not available, we can optionally
261 * setup the lower_path with its orig_path.
262 * but, the current implementation just returns an error
263 * because the sdcard daemon also regards this case as
265 printk(KERN_INFO "sdcardfs: base obbpath is not available\n");
266 sdcardfs_put_reset_orig_path(dentry);
271 sdcardfs_set_lower_path(dentry, &lower_path);
272 err = sdcardfs_interpose(dentry, dentry->d_sb, &lower_path, id);
273 if (err) /* path_put underlying path on error */
274 sdcardfs_put_reset_lower_path(dentry);
279 * We don't consider ENOENT an error, and we want to return a
282 if (err && err != -ENOENT)
285 /* instatiate a new negative dentry */
287 this.len = strlen(name);
288 this.hash = full_name_hash(this.name, this.len);
289 lower_dentry = d_lookup(lower_dir_dentry, &this);
293 lower_dentry = d_alloc(lower_dir_dentry, &this);
298 d_add(lower_dentry, NULL); /* instantiate and hash */
301 lower_path.dentry = lower_dentry;
302 lower_path.mnt = mntget(lower_dir_mnt);
303 sdcardfs_set_lower_path(dentry, &lower_path);
306 * If the intent is to create a file, then don't return an error, so
307 * the VFS will continue the process of making this negative dentry
308 * into a positive one.
310 if (flags & (LOOKUP_CREATE|LOOKUP_RENAME_TARGET))
319 * fills dentry object appropriate values and returns NULL.
323 * @dir : Parent inode. It is locked (dir->i_mutex)
324 * @dentry : Target dentry to lookup. we should set each of fields.
325 * (dentry->d_name is initialized already)
326 * @nd : nameidata of parent inode
328 struct dentry *sdcardfs_lookup(struct inode *dir, struct dentry *dentry,
331 struct dentry *ret = NULL, *parent;
332 struct path lower_parent_path;
334 const struct cred *saved_cred = NULL;
336 parent = dget_parent(dentry);
338 if(!check_caller_access_to_name(parent->d_inode, dentry->d_name.name)) {
339 ret = ERR_PTR(-EACCES);
340 printk(KERN_INFO "%s: need to check the caller's gid in packages.list\n"
341 " dentry: %s, task:%s\n",
342 __func__, dentry->d_name.name, current->comm);
346 /* save current_cred and override it */
347 OVERRIDE_CRED_PTR(SDCARDFS_SB(dir->i_sb), saved_cred);
349 sdcardfs_get_lower_path(parent, &lower_parent_path);
351 /* allocate dentry private data. We free it in ->d_release */
352 err = new_dentry_private_data(dentry);
358 ret = __sdcardfs_lookup(dentry, flags, &lower_parent_path, SDCARDFS_I(dir)->userid);
365 if (dentry->d_inode) {
366 fsstack_copy_attr_times(dentry->d_inode,
367 sdcardfs_lower_inode(dentry->d_inode));
368 /* get drived permission */
369 mutex_lock(&dentry->d_inode->i_mutex);
370 get_derived_permission(parent, dentry);
371 fix_derived_permission(dentry->d_inode);
372 mutex_unlock(&dentry->d_inode->i_mutex);
374 /* update parent directory's atime */
375 fsstack_copy_attr_atime(parent->d_inode,
376 sdcardfs_lower_inode(parent->d_inode));
379 sdcardfs_put_lower_path(parent, &lower_parent_path);
380 REVERT_CRED(saved_cred);