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 = d_inode(lower_path->dentry);
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,
243 /* check for other cases */
244 if (err == -ENOENT) {
245 struct dentry *child;
246 struct dentry *match = NULL;
247 mutex_lock(&d_inode(lower_dir_dentry)->i_mutex);
248 spin_lock(&lower_dir_dentry->d_lock);
249 list_for_each_entry(child, &lower_dir_dentry->d_subdirs, d_child) {
250 if (child && d_inode(child)) {
251 if (strcasecmp(child->d_name.name, name)==0) {
257 spin_unlock(&lower_dir_dentry->d_lock);
258 mutex_unlock(&d_inode(lower_dir_dentry)->i_mutex);
260 err = vfs_path_lookup(lower_dir_dentry,
262 match->d_name.name, 0,
268 /* no error: handle positive dentries */
270 /* check if the dentry is an obb dentry
271 * if true, the lower_inode must be replaced with
272 * the inode of the graft path */
274 if(need_graft_path(dentry)) {
276 /* setup_obb_dentry()
277 * The lower_path will be stored to the dentry's orig_path
278 * and the base obbpath will be copyed to the lower_path variable.
279 * if an error returned, there's no change in the lower_path
280 * returns: -ERRNO if error (0: no error) */
281 err = setup_obb_dentry(dentry, &lower_path);
284 /* if the sbi->obbpath is not available, we can optionally
285 * setup the lower_path with its orig_path.
286 * but, the current implementation just returns an error
287 * because the sdcard daemon also regards this case as
289 printk(KERN_INFO "sdcardfs: base obbpath is not available\n");
290 sdcardfs_put_reset_orig_path(dentry);
295 sdcardfs_set_lower_path(dentry, &lower_path);
296 err = sdcardfs_interpose(dentry, dentry->d_sb, &lower_path, id);
297 if (err) /* path_put underlying path on error */
298 sdcardfs_put_reset_lower_path(dentry);
303 * We don't consider ENOENT an error, and we want to return a
306 if (err && err != -ENOENT)
309 /* instatiate a new negative dentry */
311 this.len = strlen(name);
312 this.hash = full_name_hash(this.name, this.len);
313 lower_dentry = d_lookup(lower_dir_dentry, &this);
317 lower_dentry = d_alloc(lower_dir_dentry, &this);
322 d_add(lower_dentry, NULL); /* instantiate and hash */
325 lower_path.dentry = lower_dentry;
326 lower_path.mnt = mntget(lower_dir_mnt);
327 sdcardfs_set_lower_path(dentry, &lower_path);
330 * If the intent is to create a file, then don't return an error, so
331 * the VFS will continue the process of making this negative dentry
332 * into a positive one.
334 if (flags & (LOOKUP_CREATE|LOOKUP_RENAME_TARGET))
343 * fills dentry object appropriate values and returns NULL.
347 * @dir : Parent inode. It is locked (dir->i_mutex)
348 * @dentry : Target dentry to lookup. we should set each of fields.
349 * (dentry->d_name is initialized already)
350 * @nd : nameidata of parent inode
352 struct dentry *sdcardfs_lookup(struct inode *dir, struct dentry *dentry,
355 struct dentry *ret = NULL, *parent;
356 struct path lower_parent_path;
358 const struct cred *saved_cred = NULL;
360 parent = dget_parent(dentry);
362 if(!check_caller_access_to_name(d_inode(parent), dentry->d_name.name)) {
363 ret = ERR_PTR(-EACCES);
364 printk(KERN_INFO "%s: need to check the caller's gid in packages.list\n"
365 " dentry: %s, task:%s\n",
366 __func__, dentry->d_name.name, current->comm);
370 /* save current_cred and override it */
371 OVERRIDE_CRED_PTR(SDCARDFS_SB(dir->i_sb), saved_cred);
373 sdcardfs_get_lower_path(parent, &lower_parent_path);
375 /* allocate dentry private data. We free it in ->d_release */
376 err = new_dentry_private_data(dentry);
382 ret = __sdcardfs_lookup(dentry, flags, &lower_parent_path, SDCARDFS_I(dir)->userid);
389 if (d_inode(dentry)) {
390 fsstack_copy_attr_times(d_inode(dentry),
391 sdcardfs_lower_inode(d_inode(dentry)));
392 /* get derived permission */
393 get_derived_permission(parent, dentry);
394 fixup_tmp_permissions(d_inode(dentry));
396 /* update parent directory's atime */
397 fsstack_copy_attr_atime(d_inode(parent),
398 sdcardfs_lower_inode(d_inode(parent)));
401 sdcardfs_put_lower_path(parent, &lower_parent_path);
402 REVERT_CRED(saved_cred);