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.
24 * The inode cache is used with alloc_inode for both our inode info and the
27 static struct kmem_cache *sdcardfs_inode_cachep;
29 /* final actions when unmounting a file system */
30 static void sdcardfs_put_super(struct super_block *sb)
32 struct sdcardfs_sb_info *spd;
33 struct super_block *s;
35 spd = SDCARDFS_SB(sb);
40 kfree(spd->obbpath_s);
41 path_put(&spd->obbpath);
44 /* decrement lower super references */
45 s = sdcardfs_lower_super(sb);
46 sdcardfs_set_lower_super(sb, NULL);
47 atomic_dec(&s->s_active);
53 static int sdcardfs_statfs(struct dentry *dentry, struct kstatfs *buf)
56 struct path lower_path;
58 struct sdcardfs_sb_info *sbi = SDCARDFS_SB(dentry->d_sb);
60 sdcardfs_get_lower_path(dentry, &lower_path);
61 err = vfs_statfs(&lower_path, buf);
62 sdcardfs_put_lower_path(dentry, &lower_path);
64 if (sbi->options.reserved_mb) {
65 /* Invalid statfs informations. */
66 if (buf->f_bsize == 0) {
67 printk(KERN_ERR "Returned block size is zero.\n");
71 min_blocks = ((sbi->options.reserved_mb * 1024 * 1024)/buf->f_bsize);
72 buf->f_blocks -= min_blocks;
74 if (buf->f_bavail > min_blocks)
75 buf->f_bavail -= min_blocks;
79 /* Make reserved blocks invisiable to media storage */
80 buf->f_bfree = buf->f_bavail;
83 /* set return buf to our f/s to avoid confusing user-level utils */
84 buf->f_type = SDCARDFS_SUPER_MAGIC;
90 * @flags: numeric mount options
91 * @options: mount options string
93 static int sdcardfs_remount_fs(struct super_block *sb, int *flags, char *options)
98 * The VFS will take care of "ro" and "rw" flags among others. We
99 * can safely accept a few flags (RDONLY, MANDLOCK), and honor
100 * SILENT, but anything else left over is an error.
102 if ((*flags & ~(MS_RDONLY | MS_MANDLOCK | MS_SILENT)) != 0) {
104 "sdcardfs: remount flags 0x%x unsupported\n", *flags);
112 * @mnt: mount point we are remounting
113 * @sb: superblock we are remounting
114 * @flags: numeric mount options
115 * @options: mount options string
117 static int sdcardfs_remount_fs2(struct vfsmount *mnt, struct super_block *sb,
118 int *flags, char *options)
123 * The VFS will take care of "ro" and "rw" flags among others. We
124 * can safely accept a few flags (RDONLY, MANDLOCK), and honor
125 * SILENT, but anything else left over is an error.
127 if ((*flags & ~(MS_RDONLY | MS_MANDLOCK | MS_SILENT | MS_REMOUNT)) != 0) {
129 "sdcardfs: remount flags 0x%x unsupported\n", *flags);
132 printk(KERN_INFO "Remount options were %s for vfsmnt %p.\n", options, mnt);
133 err = parse_options_remount(sb, options, *flags & ~MS_SILENT, mnt->data);
139 static void* sdcardfs_clone_mnt_data(void *data) {
140 struct sdcardfs_vfsmount_options* opt = kmalloc(sizeof(struct sdcardfs_vfsmount_options), GFP_KERNEL);
141 struct sdcardfs_vfsmount_options* old = data;
142 if(!opt) return NULL;
144 opt->mask = old->mask;
148 static void sdcardfs_copy_mnt_data(void *data, void *newdata) {
149 struct sdcardfs_vfsmount_options* old = data;
150 struct sdcardfs_vfsmount_options* new = newdata;
152 old->mask = new->mask;
156 * Called by iput() when the inode reference count reached zero
157 * and the inode is not hashed anywhere. Used to clear anything
158 * that needs to be, before the inode is completely destroyed and put
159 * on the inode free list.
161 static void sdcardfs_evict_inode(struct inode *inode)
163 struct inode *lower_inode;
165 truncate_inode_pages(&inode->i_data, 0);
168 * Decrement a reference to a lower_inode, which was incremented
169 * by our read_inode when it was created initially.
171 lower_inode = sdcardfs_lower_inode(inode);
172 sdcardfs_set_lower_inode(inode, NULL);
173 set_top(SDCARDFS_I(inode), inode);
177 static struct inode *sdcardfs_alloc_inode(struct super_block *sb)
179 struct sdcardfs_inode_info *i;
181 i = kmem_cache_alloc(sdcardfs_inode_cachep, GFP_KERNEL);
185 /* memset everything up to the inode to 0 */
186 memset(i, 0, offsetof(struct sdcardfs_inode_info, vfs_inode));
188 i->vfs_inode.i_version = 1;
189 return &i->vfs_inode;
192 static void sdcardfs_destroy_inode(struct inode *inode)
194 kmem_cache_free(sdcardfs_inode_cachep, SDCARDFS_I(inode));
197 /* sdcardfs inode cache constructor */
198 static void init_once(void *obj)
200 struct sdcardfs_inode_info *i = obj;
202 inode_init_once(&i->vfs_inode);
205 int sdcardfs_init_inode_cache(void)
209 sdcardfs_inode_cachep =
210 kmem_cache_create("sdcardfs_inode_cache",
211 sizeof(struct sdcardfs_inode_info), 0,
212 SLAB_RECLAIM_ACCOUNT, init_once);
213 if (!sdcardfs_inode_cachep)
218 /* sdcardfs inode cache destructor */
219 void sdcardfs_destroy_inode_cache(void)
221 if (sdcardfs_inode_cachep)
222 kmem_cache_destroy(sdcardfs_inode_cachep);
226 * Used only in nfs, to kill any pending RPC tasks, so that subsequent
227 * code can actually succeed and won't leave tasks that need handling.
229 static void sdcardfs_umount_begin(struct super_block *sb)
231 struct super_block *lower_sb;
233 lower_sb = sdcardfs_lower_super(sb);
234 if (lower_sb && lower_sb->s_op && lower_sb->s_op->umount_begin)
235 lower_sb->s_op->umount_begin(lower_sb);
238 static int sdcardfs_show_options(struct vfsmount *mnt, struct seq_file *m, struct dentry *root)
240 struct sdcardfs_sb_info *sbi = SDCARDFS_SB(root->d_sb);
241 struct sdcardfs_mount_options *opts = &sbi->options;
242 struct sdcardfs_vfsmount_options *vfsopts = mnt->data;
244 if (opts->fs_low_uid != 0)
245 seq_printf(m, ",fsuid=%u", opts->fs_low_uid);
246 if (opts->fs_low_gid != 0)
247 seq_printf(m, ",fsgid=%u", opts->fs_low_gid);
248 if (vfsopts->gid != 0)
249 seq_printf(m, ",gid=%u", vfsopts->gid);
251 seq_printf(m, ",multiuser");
253 seq_printf(m, ",mask=%u", vfsopts->mask);
254 if (opts->fs_user_id)
255 seq_printf(m, ",userid=%u", opts->fs_user_id);
256 if (opts->reserved_mb != 0)
257 seq_printf(m, ",reserved=%uMB", opts->reserved_mb);
262 const struct super_operations sdcardfs_sops = {
263 .put_super = sdcardfs_put_super,
264 .statfs = sdcardfs_statfs,
265 .remount_fs = sdcardfs_remount_fs,
266 .remount_fs2 = sdcardfs_remount_fs2,
267 .clone_mnt_data = sdcardfs_clone_mnt_data,
268 .copy_mnt_data = sdcardfs_copy_mnt_data,
269 .evict_inode = sdcardfs_evict_inode,
270 .umount_begin = sdcardfs_umount_begin,
271 .show_options2 = sdcardfs_show_options,
272 .alloc_inode = sdcardfs_alloc_inode,
273 .destroy_inode = sdcardfs_destroy_inode,
274 .drop_inode = generic_delete_inode,