static void tcptfs_d_release(struct dentry *dentry)
{
/* release and reset the lower paths */
tcptfs_put_reset_lower_path(dentry);
free_dentry_private_data(dentry);
return;
}
/* UNIONFS_D(dentry)->lock must be locked */
int realloc_dentry_private_data(struct dentry *dentry)
{
if (!__realloc_dentry_private_data(dentry))
return 0;
kfree(UNIONFS_D(dentry)->lower_paths);
free_dentry_private_data(dentry);
return -ENOMEM;
}
static void sdcardfs_d_release(struct dentry *dentry)
{
/* release and reset the lower paths */
if(has_graft_path(dentry)) {
sdcardfs_put_reset_orig_path(dentry);
}
sdcardfs_put_reset_lower_path(dentry);
free_dentry_private_data(dentry);
return;
}
void unionfs_d_release(struct dentry *dentry)
{
struct dentry *hidden_dentry;
int bindex, bstart, bend;
print_entry_location();
/* There is no reason to lock the dentry, because we have the only
* reference, but the printing functions verify that we have a lock
* on the dentry before calling dbstart, etc. */
lock_dentry(dentry);
__fist_print_dentry("unionfs_d_release IN dentry", dentry, 0);
/* this could be a negative dentry, so check first */
if (!dtopd(dentry)) {
fist_dprint(6, "dentry without private data: %*s",
dentry->d_name.len, dentry->d_name.name);
goto out;
} else if (dbstart(dentry) < 0) {
/* this is due to a failed lookup */
/* the failed lookup has a dtohd_ptr set to null,
but this is a better check */
fist_dprint(6, "dentry without hidden dentries : %*s",
dentry->d_name.len, dentry->d_name.name);
goto out_free;
}
/* Release all the hidden dentries */
bstart = dbstart(dentry);
bend = dbend(dentry);
for (bindex = bstart; bindex <= bend; bindex++) {
hidden_dentry = dtohd_index(dentry, bindex);
DPUT(hidden_dentry);
set_dtohd_index(dentry, bindex, NULL);
}
/* free private data (unionfs_dentry_info) here */
KFREE(dtohd_ptr(dentry));
dtohd_ptr(dentry) = NULL;
out_free:
/* No need to unlock it, because it is disappeared. */
#ifdef TRACKLOCK
printk("DESTROYLOCK:%p\n", dentry);
#endif
free_dentry_private_data(dtopd(dentry));
dtopd_lhs(dentry) = NULL; /* just to be safe */
out:
print_exit_location();
}
static void wrapfs_d_release(struct dentry *dentry)
{
if (!dentry)
goto out;
if (unlikely(!WRAPFS_D(dentry)))
goto out;
UDBG;
/* wrapfs_lock_dentry(dentry, WRAPFS_DMUTEX_CHILD);
path_put_lowers_all(dentry, true); */
UDBG;
/* release and reset the lower paths */
/* wrapfs_put_reset_lower_path(dentry);
wrpafs_unlock_dentry(dentry);
*/
out:
free_dentry_private_data(dentry);
return;
}
static void unionfs_d_release(struct dentry *dentry)
{
int bindex, bstart, bend;
/* There is no reason to lock the dentry, because we have the only
* reference, but the printing functions verify that we have a lock
* on the dentry before calling dbstart, etc.
*/
unionfs_lock_dentry(dentry);
/* this could be a negative dentry, so check first */
if (!UNIONFS_D(dentry)) {
printk(KERN_DEBUG "dentry without private data: %.*s",
dentry->d_name.len, dentry->d_name.name);
goto out;
} else if (dbstart(dentry) < 0) {
/* this is due to a failed lookup */
printk(KERN_DEBUG "dentry without hidden dentries : %.*s",
dentry->d_name.len, dentry->d_name.name);
goto out_free;
}
/* Release all the hidden dentries */
bstart = dbstart(dentry);
bend = dbend(dentry);
for (bindex = bstart; bindex <= bend; bindex++) {
dput(unionfs_lower_dentry_idx(dentry, bindex));
mntput(unionfs_lower_mnt_idx(dentry, bindex));
unionfs_set_lower_dentry_idx(dentry, bindex, NULL);
unionfs_set_lower_mnt_idx(dentry, bindex, NULL);
}
/* free private data (unionfs_dentry_info) here */
kfree(UNIONFS_D(dentry)->lower_paths);
UNIONFS_D(dentry)->lower_paths = NULL;
out_free:
/* No need to unlock it, because it is disappeared. */
free_dentry_private_data(UNIONFS_D(dentry));
dentry->d_fsdata = NULL; /* just to be safe */
out:
return;
}
/* allocate new dentry private data */
int new_dentry_private_data(struct dentry *dentry, int subclass)
{
struct unionfs_dentry_info *info = UNIONFS_D(dentry);
BUG_ON(info);
info = kmem_cache_alloc(unionfs_dentry_cachep, GFP_ATOMIC);
if (unlikely(!info))
return -ENOMEM;
mutex_init(&info->lock);
mutex_lock_nested(&info->lock, subclass);
info->lower_paths = NULL;
dentry->d_fsdata = info;
if (!__realloc_dentry_private_data(dentry))
return 0;
mutex_unlock(&info->lock);
free_dentry_private_data(dentry);
return -ENOMEM;
}
/*
* our custom d_alloc_root work-alike
*
* we can't use d_alloc_root if we want to use our own interpose function
* unchanged, so we simply call our own "fake" d_alloc_root
*/
static struct dentry *sdcardfs_d_alloc_root(struct super_block *sb)
{
struct dentry *ret = NULL;
//struct sdcardfs_sb_info *sbi = SDCARDFS_SB(sb);
struct dentry *(*__d_alloc_new)(struct super_block *, const struct qstr *) = (void *)kallsyms_lookup_name("__d_alloc");
if (sb) {
static const struct qstr name = {
.name = "/",
.len = 1
};
ret = __d_alloc_new(sb, &name);
if (ret) {
d_set_d_op(ret, &sdcardfs_ci_dops);
ret->d_parent = ret;
}
}
return ret;
}
/*
* There is no need to lock the sdcardfs_super_info's rwsem as there is no
* way anyone can have a reference to the superblock at this point in time.
*/
static int sdcardfs_read_super(struct super_block *sb, const char *dev_name,
void *raw_data, int silent)
{
int err = 0;
int debug;
struct super_block *lower_sb;
struct path lower_path;
struct sdcardfs_sb_info *sb_info;
void *pkgl_id;
printk(KERN_INFO "sdcardfs version 2.0\n");
if (!dev_name) {
printk(KERN_ERR
"sdcardfs: read_super: missing dev_name argument\n");
err = -EINVAL;
goto out;
}
printk(KERN_INFO "sdcardfs: dev_name -> %s\n", dev_name);
printk(KERN_INFO "sdcardfs: options -> %s\n", (char *)raw_data);
/* parse lower path */
err = kern_path(dev_name, LOOKUP_FOLLOW | LOOKUP_DIRECTORY,
&lower_path);
if (err) {
printk(KERN_ERR "sdcardfs: error accessing "
"lower directory '%s'\n", dev_name);
goto out;
}
/* allocate superblock private data */
sb->s_fs_info = kzalloc(sizeof(struct sdcardfs_sb_info), GFP_KERNEL);
if (!SDCARDFS_SB(sb)) {
printk(KERN_CRIT "sdcardfs: read_super: out of memory\n");
err = -ENOMEM;
goto out_free;
}
sb_info = sb->s_fs_info;
/* parse options */
err = parse_options(sb, raw_data, silent, &debug, &sb_info->options);
if (err) {
printk(KERN_ERR "sdcardfs: invalid options\n");
goto out_freesbi;
}
if (sb_info->options.derive != DERIVE_NONE) {
pkgl_id = packagelist_create(sb_info->options.write_gid);
if(IS_ERR(pkgl_id))
goto out_freesbi;
else
sb_info->pkgl_id = pkgl_id;
}
/* set the lower superblock field of upper superblock */
lower_sb = lower_path.dentry->d_sb;
atomic_inc(&lower_sb->s_active);
sdcardfs_set_lower_super(sb, lower_sb);
/* inherit maxbytes from lower file system */
sb->s_maxbytes = lower_sb->s_maxbytes;
/*
* Our c/m/atime granularity is 1 ns because we may stack on file
* systems whose granularity is as good.
*/
sb->s_time_gran = 1;
sb->s_magic = SDCARDFS_SUPER_MAGIC;
sb->s_op = &sdcardfs_sops;
/* see comment next to the definition of sdcardfs_d_alloc_root */
sb->s_root = sdcardfs_d_alloc_root(sb);
if (!sb->s_root) {
err = -ENOMEM;
goto out_sput;
}
/* link the upper and lower dentries */
sb->s_root->d_fsdata = NULL;
err = new_dentry_private_data(sb->s_root);
if (err)
goto out_freeroot;
/* set the lower dentries for s_root */
sdcardfs_set_lower_path(sb->s_root, &lower_path);
/* call interpose to create the upper level inode */
err = sdcardfs_interpose(sb->s_root, sb, &lower_path);
if (!err) {
/* setup permission policy */
switch(sb_info->options.derive) {
case DERIVE_NONE:
setup_derived_state(sb->s_root->d_inode,
PERM_ROOT, 0, AID_ROOT, AID_SDCARD_RW, 00775);
sb_info->obbpath_s = NULL;
break;
case DERIVE_LEGACY:
/* Legacy behavior used to support internal multiuser layout which
* places user_id at the top directory level, with the actual roots
* just below that. Shared OBB path is also at top level. */
setup_derived_state(sb->s_root->d_inode,
PERM_LEGACY_PRE_ROOT, 0, AID_ROOT, AID_SDCARD_R, 00771);
/* initialize the obbpath string and lookup the path
* sb_info->obb_path will be deactivated by path_put
* on sdcardfs_put_super */
sb_info->obbpath_s = kzalloc(PATH_MAX, GFP_KERNEL);
snprintf(sb_info->obbpath_s, PATH_MAX, "%s/obb", dev_name);
err = prepare_dir(sb_info->obbpath_s,
sb_info->options.fs_low_uid,
sb_info->options.fs_low_gid, 00755);
if(err)
printk(KERN_ERR "sdcardfs: %s: %d, error on creating %s\n",
__func__,__LINE__, sb_info->obbpath_s);
break;
case DERIVE_UNIFIED:
/* Unified multiuser layout which places secondary user_id under
* /Android/user and shared OBB path under /Android/obb. */
setup_derived_state(sb->s_root->d_inode,
PERM_ROOT, 0, AID_ROOT, AID_SDCARD_R, 00771);
sb_info->obbpath_s = kzalloc(PATH_MAX, GFP_KERNEL);
snprintf(sb_info->obbpath_s, PATH_MAX, "%s/Android/obb", dev_name);
break;
}
fix_derived_permission(sb->s_root->d_inode);
if (!silent)
printk(KERN_INFO "sdcardfs: mounted on top of %s type %s\n",
dev_name, lower_sb->s_type->name);
goto out;
}
/* else error: fall through */
free_dentry_private_data(sb->s_root);
out_freeroot:
dput(sb->s_root);
out_sput:
/* drop refs we took earlier */
atomic_dec(&lower_sb->s_active);
packagelist_destroy(sb_info->pkgl_id);
out_freesbi:
kfree(SDCARDFS_SB(sb));
sb->s_fs_info = NULL;
out_free:
path_put(&lower_path);
out:
return err;
}
/*
* our custom d_alloc_root work-alike
*
* we can't use d_alloc_root if we want to use our own interpose function
* unchanged, so we simply call our own "fake" d_alloc_root
*/
static struct dentry *sdcardfs_d_alloc_root(struct super_block *sb)
{
struct dentry *ret = NULL;
if (sb) {
static const struct qstr name = {
.name = "/",
.len = 1
};
ret = __d_alloc(sb, &name);
if (ret) {
d_set_d_op(ret, &sdcardfs_ci_dops);
ret->d_parent = ret;
}
}
return ret;
}
/*
* There is no need to lock the sdcardfs_super_info's rwsem as there is no
* way anyone can have a reference to the superblock at this point in time.
*/
static int sdcardfs_read_super(struct super_block *sb, const char *dev_name,
void *raw_data, int silent)
{
int err = 0;
int debug;
struct super_block *lower_sb;
struct path lower_path;
struct sdcardfs_sb_info *sb_info;
void *pkgl_id;
printk(KERN_INFO "sdcardfs: version %s\n", SDCARDFS_VERSION);
if (!dev_name) {
printk(KERN_ERR
"sdcardfs: read_super: missing dev_name argument\n");
err = -EINVAL;
goto out;
}
printk(KERN_INFO "sdcardfs: dev_name -> %s\n", dev_name);
printk(KERN_INFO "sdcardfs: options -> %s\n", (char *)raw_data);
/* parse lower path */
err = kern_path(dev_name, LOOKUP_FOLLOW | LOOKUP_DIRECTORY,
&lower_path);
if (err) {
printk(KERN_ERR "sdcardfs: error accessing "
"lower directory '%s'\n", dev_name);
goto out;
}
/* allocate superblock private data */
sb->s_fs_info = kzalloc(sizeof(struct sdcardfs_sb_info), GFP_KERNEL);
if (!SDCARDFS_SB(sb)) {
printk(KERN_CRIT "sdcardfs: read_super: out of memory\n");
err = -ENOMEM;
goto out_free;
}
sb_info = sb->s_fs_info;
/* parse options */
err = parse_options(sb, raw_data, silent, &debug, &sb_info->options);
if (err) {
printk(KERN_ERR "sdcardfs: invalid options or out of memory\n");
goto out_freesbi;
}
pkgl_id = packagelist_create();
if(IS_ERR(pkgl_id))
goto out_freesbi;
else
sb_info->pkgl_id = pkgl_id;
/* set the lower superblock field of upper superblock */
lower_sb = lower_path.dentry->d_sb;
atomic_inc(&lower_sb->s_active);
sdcardfs_set_lower_super(sb, lower_sb);
/* inherit maxbytes from lower file system */
sb->s_maxbytes = lower_sb->s_maxbytes;
/*
* Our c/m/atime granularity is 1 ns because we may stack on file
* systems whose granularity is as good.
*/
sb->s_time_gran = 1;
sb->s_magic = SDCARDFS_SUPER_MAGIC;
if (sb_info->options.type != TYPE_NONE)
sb->s_op = &sdcardfs_multimount_sops;
else
sb->s_op = &sdcardfs_sops;
/* see comment next to the definition of sdcardfs_d_alloc_root */
sb->s_root = sdcardfs_d_alloc_root(sb);
if (!sb->s_root) {
err = -ENOMEM;
goto out_sput;
}
/* link the upper and lower dentries */
sb->s_root->d_fsdata = NULL;
err = new_dentry_private_data(sb->s_root);
if (err)
goto out_freeroot;
/* set the lower dentries for s_root */
sdcardfs_set_lower_path(sb->s_root, &lower_path);
/* call interpose to create the upper level inode */
err = sdcardfs_interpose(sb->s_root, sb, &lower_path);
if (!err) {
/* setup permission policy */
if(sb_info->options.multi_user){
setup_derived_state(sb->s_root->d_inode,
PERM_PRE_ROOT, sb_info->options.userid, AID_ROOT, sb_info->options.gid, false);
sb_info->obbpath_s = kzalloc(PATH_MAX, GFP_KERNEL);
snprintf(sb_info->obbpath_s, PATH_MAX, "%s/obb", dev_name);
err = prepare_dir(sb_info->obbpath_s,
sb_info->options.fs_low_uid,
sb_info->options.fs_low_gid, 00775);
} else {
setup_derived_state(sb->s_root->d_inode,
PERM_ROOT, sb_info->options.userid, AID_ROOT, sb_info->options.gid, false);
sb_info->obbpath_s = kzalloc(PATH_MAX, GFP_KERNEL);
snprintf(sb_info->obbpath_s, PATH_MAX, "%s/Android/obb", dev_name);
}
fix_derived_permission(sb->s_root->d_inode);
sb_info->devpath = kzalloc(PATH_MAX, GFP_KERNEL);
if(sb_info->devpath && dev_name)
strncpy(sb_info->devpath, dev_name, strlen(dev_name));
if (!silent && !err)
printk(KERN_INFO "sdcardfs: mounted on top of %s type %s\n",
dev_name, lower_sb->s_type->name);
goto out;
}
/* else error: fall through */
free_dentry_private_data(sb->s_root);
out_freeroot:
dput(sb->s_root);
out_sput:
/* drop refs we took earlier */
atomic_dec(&lower_sb->s_active);
packagelist_destroy(sb_info->pkgl_id);
out_freesbi:
kfree(SDCARDFS_SB(sb));
sb->s_fs_info = NULL;
out_free:
path_put(&lower_path);
out:
return err;
}
/* allocate new dentry private data, free old one if necessary */
int new_dentry_private_data(struct dentry *dentry)
{
int newsize;
int oldsize = 0;
struct unionfs_dentry_info *info = UNIONFS_D(dentry);
spin_lock(&dentry->d_lock);
if (!info) {
dentry->d_fsdata = kmem_cache_alloc(unionfs_dentry_cachep,
GFP_ATOMIC);
info = UNIONFS_D(dentry);
if (!info)
goto out;
mutex_init(&info->lock);
mutex_lock(&info->lock);
info->lower_paths = NULL;
} else
oldsize = sizeof(struct path) * info->bcount;
info->bstart = -1;
info->bend = -1;
info->bopaque = -1;
info->bcount = sbmax(dentry->d_sb);
atomic_set(&info->generation,
atomic_read(&UNIONFS_SB(dentry->d_sb)->generation));
newsize = sizeof(struct path) * sbmax(dentry->d_sb);
/* Don't reallocate when we already have enough space. */
/* It would be ideal if we could actually use the slab macros to
* determine what our object sizes is, but those are not exported.
*/
if (oldsize) {
int minsize = malloc_sizes[0].cs_size;
if (!newsize || ((oldsize < newsize) && (newsize > minsize))) {
kfree(info->lower_paths);
info->lower_paths = NULL;
}
}
if (!info->lower_paths && newsize) {
info->lower_paths = kmalloc(newsize, GFP_ATOMIC);
if (!info->lower_paths)
goto out_free;
}
memset(info->lower_paths, 0, (oldsize > newsize ? oldsize : newsize));
spin_unlock(&dentry->d_lock);
return 0;
out_free:
kfree(info->lower_paths);
out:
free_dentry_private_data(info);
dentry->d_fsdata = NULL;
spin_unlock(&dentry->d_lock);
return -ENOMEM;
}
/*
* our custom d_alloc_root work-alike
*
* we can't use d_alloc_root if we want to use our own interpose function
* unchanged, so we simply call our own "fake" d_alloc_root
*/
static struct dentry *unionfs_d_alloc_root(struct super_block *sb)
{
struct dentry *ret = NULL;
if (sb) {
static const struct qstr name = {
.name = "/",
.len = 1
};
ret = d_alloc(NULL, &name);
if (likely(ret)) {
ret->d_op = &unionfs_dops;
ret->d_sb = sb;
ret->d_parent = ret;
}
}
return ret;
}
/*
* There is no need to lock the unionfs_super_info's rwsem as there is no
* way anyone can have a reference to the superblock at this point in time.
*/
static int unionfs_read_super(struct super_block *sb, void *raw_data,
int silent)
{
int err = 0;
struct unionfs_dentry_info *lower_root_info = NULL;
int bindex, bstart, bend;
if (!raw_data) {
printk(KERN_ERR
"unionfs: read_super: missing data argument\n");
err = -EINVAL;
goto out;
}
/* Allocate superblock private data */
sb->s_fs_info = kzalloc(sizeof(struct unionfs_sb_info), GFP_KERNEL);
if (unlikely(!UNIONFS_SB(sb))) {
printk(KERN_CRIT "unionfs: read_super: out of memory\n");
err = -ENOMEM;
goto out;
}
UNIONFS_SB(sb)->bend = -1;
atomic_set(&UNIONFS_SB(sb)->generation, 1);
init_rwsem(&UNIONFS_SB(sb)->rwsem);
UNIONFS_SB(sb)->high_branch_id = -1; /* -1 == invalid branch ID */
lower_root_info = unionfs_parse_options(sb, raw_data);
if (IS_ERR(lower_root_info)) {
printk(KERN_ERR
"unionfs: read_super: error while parsing options "
"(err = %ld)\n", PTR_ERR(lower_root_info));
err = PTR_ERR(lower_root_info);
lower_root_info = NULL;
goto out_free;
}
if (lower_root_info->bstart == -1) {
err = -ENOENT;
goto out_free;
}
/* set the lower superblock field of upper superblock */
bstart = lower_root_info->bstart;
BUG_ON(bstart != 0);
sbend(sb) = bend = lower_root_info->bend;
for (bindex = bstart; bindex <= bend; bindex++) {
struct dentry *d = lower_root_info->lower_paths[bindex].dentry;
atomic_inc(&d->d_sb->s_active);
unionfs_set_lower_super_idx(sb, bindex, d->d_sb);
}
/* max Bytes is the maximum bytes from highest priority branch */
sb->s_maxbytes = unionfs_lower_super_idx(sb, 0)->s_maxbytes;
/*
* Our c/m/atime granularity is 1 ns because we may stack on file
* systems whose granularity is as good. This is important for our
* time-based cache coherency.
*/
sb->s_time_gran = 1;
sb->s_op = &unionfs_sops;
/* See comment next to the definition of unionfs_d_alloc_root */
sb->s_root = unionfs_d_alloc_root(sb);
if (unlikely(!sb->s_root)) {
err = -ENOMEM;
goto out_dput;
}
/* link the upper and lower dentries */
sb->s_root->d_fsdata = NULL;
err = new_dentry_private_data(sb->s_root, UNIONFS_DMUTEX_ROOT);
if (unlikely(err))
goto out_freedpd;
/* Set the lower dentries for s_root */
for (bindex = bstart; bindex <= bend; bindex++) {
struct dentry *d;
struct vfsmount *m;
d = lower_root_info->lower_paths[bindex].dentry;
m = lower_root_info->lower_paths[bindex].mnt;
unionfs_set_lower_dentry_idx(sb->s_root, bindex, d);
unionfs_set_lower_mnt_idx(sb->s_root, bindex, m);
}
dbstart(sb->s_root) = bstart;
dbend(sb->s_root) = bend;
/* Set the generation number to one, since this is for the mount. */
atomic_set(&UNIONFS_D(sb->s_root)->generation, 1);
/*
* Call interpose to create the upper level inode. Only
* INTERPOSE_LOOKUP can return a value other than 0 on err.
*/
err = PTR_ERR(unionfs_interpose(sb->s_root, sb, 0));
unionfs_unlock_dentry(sb->s_root);
if (!err)
goto out;
/* else fall through */
out_freedpd:
if (UNIONFS_D(sb->s_root)) {
kfree(UNIONFS_D(sb->s_root)->lower_paths);
free_dentry_private_data(sb->s_root);
}
dput(sb->s_root);
out_dput:
if (lower_root_info && !IS_ERR(lower_root_info)) {
for (bindex = lower_root_info->bstart;
bindex <= lower_root_info->bend; bindex++) {
struct dentry *d;
struct vfsmount *m;
d = lower_root_info->lower_paths[bindex].dentry;
m = lower_root_info->lower_paths[bindex].mnt;
dput(d);
/* initializing: can't use unionfs_mntput here */
mntput(m);
/* drop refs we took earlier */
atomic_dec(&d->d_sb->s_active);
}
kfree(lower_root_info->lower_paths);
kfree(lower_root_info);
lower_root_info = NULL;
}
out_free:
kfree(UNIONFS_SB(sb)->data);
kfree(UNIONFS_SB(sb));
sb->s_fs_info = NULL;
out:
if (lower_root_info && !IS_ERR(lower_root_info)) {
kfree(lower_root_info->lower_paths);
kfree(lower_root_info);
}
return err;
}
/*
* There is no need to lock the wrapfs_super_info's rwsem as there is no
* way anyone can have a reference to the superblock at this point in time.
*/
static int wrapfs_read_super(struct super_block *sb, void *raw_data, int silent)
{
int err = 0, i = 0;
struct wrapfs_dentry_info *lower_root_info = NULL;
struct inode *inode = NULL;
if (!raw_data) {
printk(KERN_ERR
"u2fs: read_super: missing data argument\n");
err = -EINVAL;
goto out;
}
/* allocate superblock private data */
sb->s_fs_info = kzalloc(sizeof(struct wrapfs_sb_info), GFP_KERNEL);
if (!WRAPFS_SB(sb)) {
printk(KERN_CRIT "u2fs: read_super: out of memory\n");
err = -ENOMEM;
goto out_free;
}
atomic_set(&WRAPFS_SB(sb)->generation, 1);
WRAPFS_SB(sb)->high_branch_id = -1;
/* Parsing the Inputs */
lower_root_info = wrapfs_parse_options(sb, raw_data);
if (IS_ERR(lower_root_info)) {
printk(KERN_ERR
"u2fs: read_super: error while parsing options"
"(err = %ld)\n", PTR_ERR(lower_root_info));
err = PTR_ERR(lower_root_info);
lower_root_info = NULL;
goto out_free;
}
/* set the lower superblock field of upper superblock */
for (i = 0; i <= 1; i++) {
struct dentry *d = lower_root_info->lower_paths[i].dentry;
atomic_inc(&d->d_sb->s_active);
wrapfs_set_lower_super_idx(sb, i, d->d_sb);
}
/* inherit maxbytes from highest priority branch */
sb->s_maxbytes = wrapfs_lower_super_idx(sb, 0)->s_maxbytes;
/*
* Our c/m/atime granularity is 1 ns because we may stack on file
* systems whose granularity is as good.
*/
sb->s_time_gran = 1;
sb->s_op = &wrapfs_sops;
/* get a new inode and allocate our root dentry */
inode = wrapfs_new_iget(sb, iunique(sb, 1));
if (IS_ERR(inode)) {
err = PTR_ERR(inode);
goto out_sput;
}
sb->s_root = d_alloc_root(inode);
if (unlikely(!sb->s_root)) {
err = -ENOMEM;
goto out_iput;
}
d_set_d_op(sb->s_root, &wrapfs_dops);
/* link the upper and lower dentries */
sb->s_root->d_fsdata = NULL;
err = new_dentry_private_data(sb->s_root);
if (unlikely(err))
goto out_freeroot;
/* if get here: cannot have error */
/* set the lower dentries for s_root */
for (i = 0; i <= 1 ; i++) {
struct dentry *d;
struct vfsmount *m;
d = lower_root_info->lower_paths[i].dentry;
m = lower_root_info->lower_paths[i].mnt;
wrapfs_set_lower_dentry_idx(sb->s_root, i, d);
wrapfs_set_lower_mnt_idx(sb->s_root, i, m);
}
atomic_set(&WRAPFS_D(sb->s_root)->generation, 1);
if (atomic_read(&inode->i_count) <= 1)
wrapfs_fill_inode(sb->s_root, inode);
/*
* No need to call interpose because we already have a positive
* dentry, which was instantiated by d_alloc_root. Just need to
* d_rehash it.
*/
d_rehash(sb->s_root);
if (!silent)
printk(KERN_INFO
"u2fs: mounted on top of type\n");
goto out;
/* all is well */
/* no longer needed: free_dentry_private_data(sb->s_root); */
out_freeroot:
if (WRAPFS_D(sb->s_root)) {
kfree(WRAPFS_D(sb->s_root)->lower_paths);
free_dentry_private_data(sb->s_root);
}
dput(sb->s_root);
out_iput:
iput(inode);
out_sput:
/* drop refs we took earlier */
if (lower_root_info && !IS_ERR(lower_root_info)) {
for (i = 0; i <= 1; i++) {
struct dentry *d;
d = lower_root_info->lower_paths[i].dentry;
atomic_dec(&d->d_sb->s_active);
path_put(&lower_root_info->lower_paths[i]);
}
kfree(lower_root_info->lower_paths);
kfree(lower_root_info);
lower_root_info = NULL;
}
out_free:
kfree(WRAPFS_SB(sb)->data);
kfree(WRAPFS_SB(sb));
sb->s_fs_info = NULL;
out:
if (lower_root_info && !IS_ERR(lower_root_info)) {
kfree(lower_root_info->lower_paths);
kfree(lower_root_info);
}
return err;
}
int new_dentry_private_data(struct dentry *dentry)
{
int newsize;
int oldsize = 0;
spin_lock(&dentry->d_lock);
if (!dtopd_nocheck(dentry)) {
dtopd_lhs(dentry) = (struct unionfs_dentry_info *)
kmem_cache_alloc(unionfs_dentry_cachep, SLAB_ATOMIC);
if (!dtopd_nocheck(dentry))
goto out;
init_MUTEX_LOCKED(&dtopd_nocheck(dentry)->udi_sem);
#ifdef TRACKLOCK
printk("INITLOCK:%p\n", dentry);
#endif
dtohd_ptr(dentry) = NULL;
} else {
oldsize = sizeof(struct dentry *) * dtopd(dentry)->udi_bcount;
}
dtopd_nocheck(dentry)->udi_bstart = -1;
dtopd_nocheck(dentry)->udi_bend = -1;
dtopd_nocheck(dentry)->udi_bopaque = -1;
dtopd_nocheck(dentry)->udi_bcount = sbmax(dentry->d_sb);
atomic_set(&dtopd_nocheck(dentry)->udi_generation,
atomic_read(&stopd(dentry->d_sb)->usi_generation));
newsize = sizeof(struct dentry *) * sbmax(dentry->d_sb);
/* Don't reallocate when we already have enough space. */
/* It would be ideal if we could actually use the slab macros to
* determine what our object sizes is, but those are not exported.
*/
if (oldsize) {
int minsize = malloc_sizes[0].cs_size;
if (!newsize || ((oldsize < newsize) && (newsize > minsize))) {
KFREE(dtohd_ptr(dentry));
dtohd_ptr(dentry) = NULL;
}
}
if (!dtohd_ptr(dentry) && newsize) {
dtohd_ptr(dentry) = KMALLOC(newsize, GFP_ATOMIC);
if (!dtohd_ptr(dentry))
goto out;
}
if (oldsize > newsize)
memset(dtohd_ptr(dentry), 0, oldsize);
else
memset(dtohd_ptr(dentry), 0, newsize);
spin_unlock(&dentry->d_lock);
return 0;
out:
free_dentry_private_data(dtopd_nocheck(dentry));
dtopd_lhs(dentry) = NULL;
spin_unlock(&dentry->d_lock);
return -ENOMEM;
}
/*
* our custom d_alloc_root work-alike
*
* we can't use d_alloc_root if we want to use our own interpose function
* unchanged, so we simply call our own "fake" d_alloc_root
*/
static struct dentry *sdcardfs_d_alloc_root(struct super_block *sb)
{
struct dentry *ret = NULL;
if (sb) {
static const struct qstr name = {
.name = "/",
.len = 1
};
ret = d_alloc(NULL, &name);
if (ret) {
d_set_d_op(ret, &sdcardfs_dops);
ret->d_sb = sb;
ret->d_parent = ret;
}
}
return ret;
}
/*
* There is no need to lock the sdcardfs_super_info's rwsem as there is no
* way anyone can have a reference to the superblock at this point in time.
*/
static int sdcardfs_read_super(struct super_block *sb, const char *dev_name,
void *raw_data, int silent)
{
int err = 0;
int debug;
struct super_block *lower_sb;
struct path lower_path;
struct sdcardfs_sb_info *sb_info;
if (!dev_name) {
printk(KERN_ERR
"sdcardfs: read_super: missing dev_name argument\n");
err = -EINVAL;
goto out;
}
printk(KERN_INFO "sdcardfs: dev_name -> %s\n", dev_name);
printk(KERN_INFO "sdcardfs: options -> %s\n", (char *)raw_data);
/* parse lower path */
err = kern_path(dev_name, LOOKUP_FOLLOW | LOOKUP_DIRECTORY,
&lower_path);
if (err) {
printk(KERN_ERR "sdcardfs: error accessing "
"lower directory '%s'\n", dev_name);
goto out;
}
/* allocate superblock private data */
sb->s_fs_info = kzalloc(sizeof(struct sdcardfs_sb_info), GFP_KERNEL);
if (!SDCARDFS_SB(sb)) {
printk(KERN_CRIT "sdcardfs: read_super: out of memory\n");
err = -ENOMEM;
goto out_free;
}
/* setup fs_uid and fs_gid for FAT emulation : wjlee */
sb_info = sb->s_fs_info;
sb_info->fs_uid = AID_ROOT;
sb_info->fs_gid = AID_SDCARD_RW;
/* parse options */
err = parse_options(sb, raw_data, silent, &debug, &sb_info->options);
if (err) {
printk(KERN_ERR "sdcardfs: invalid options\n");
goto out_freesbi;
}
/* set the lower superblock field of upper superblock */
lower_sb = lower_path.dentry->d_sb;
atomic_inc(&lower_sb->s_active);
sdcardfs_set_lower_super(sb, lower_sb);
/* inherit maxbytes from lower file system */
sb->s_maxbytes = lower_sb->s_maxbytes;
/*
* Our c/m/atime granularity is 1 ns because we may stack on file
* systems whose granularity is as good.
*/
sb->s_time_gran = 1;
sb->s_op = &sdcardfs_sops;
/* see comment next to the definition of sdcardfs_d_alloc_root */
sb->s_root = sdcardfs_d_alloc_root(sb);
if (!sb->s_root) {
err = -ENOMEM;
goto out_sput;
}
/* link the upper and lower dentries */
sb->s_root->d_fsdata = NULL;
err = new_dentry_private_data(sb->s_root);
if (err)
goto out_freeroot;
/* set the lower dentries for s_root */
sdcardfs_set_lower_path(sb->s_root, &lower_path);
/* call interpose to create the upper level inode */
err = sdcardfs_interpose(sb->s_root, sb, &lower_path);
if (!err) {
if (!silent)
printk(KERN_INFO
"sdcardfs: mounted on top of %s type %s\n",
dev_name, lower_sb->s_type->name);
goto out;
}
/* else error: fall through */
free_dentry_private_data(sb->s_root);
out_freeroot:
dput(sb->s_root);
out_sput:
/* drop refs we took earlier */
atomic_dec(&lower_sb->s_active);
out_freesbi:
kfree(SDCARDFS_SB(sb));
sb->s_fs_info = NULL;
out_free:
path_put(&lower_path);
out:
return err;
}
/*
* There is no need to lock the unionfs_super_info's rwsem as there is no
* way anyone can have a reference to the superblock at this point in time.
*/
static int unionfs_read_super(struct super_block *sb, void *raw_data,
int silent)
{
int err = 0;
struct unionfs_dentry_info *lower_root_info = NULL;
int bindex, bstart, bend;
struct inode *inode = NULL;
if (!raw_data) {
printk(KERN_ERR
"unionfs: read_super: missing data argument\n");
err = -EINVAL;
goto out;
}
/* Allocate superblock private data */
sb->s_fs_info = kzalloc(sizeof(struct unionfs_sb_info), GFP_KERNEL);
if (unlikely(!UNIONFS_SB(sb))) {
printk(KERN_CRIT "unionfs: read_super: out of memory\n");
err = -ENOMEM;
goto out;
}
UNIONFS_SB(sb)->bend = -1;
atomic_set(&UNIONFS_SB(sb)->generation, 1);
init_rwsem(&UNIONFS_SB(sb)->rwsem);
UNIONFS_SB(sb)->high_branch_id = -1; /* -1 == invalid branch ID */
lower_root_info = unionfs_parse_options(sb, raw_data);
if (IS_ERR(lower_root_info)) {
printk(KERN_ERR
"unionfs: read_super: error while parsing options "
"(err = %ld)\n", PTR_ERR(lower_root_info));
err = PTR_ERR(lower_root_info);
lower_root_info = NULL;
goto out_free;
}
if (lower_root_info->bstart == -1) {
err = -ENOENT;
goto out_free;
}
/* set the lower superblock field of upper superblock */
bstart = lower_root_info->bstart;
BUG_ON(bstart != 0);
sbend(sb) = bend = lower_root_info->bend;
for (bindex = bstart; bindex <= bend; bindex++) {
struct dentry *d = lower_root_info->lower_paths[bindex].dentry;
atomic_inc(&d->d_sb->s_active);
unionfs_set_lower_super_idx(sb, bindex, d->d_sb);
}
/* max Bytes is the maximum bytes from highest priority branch */
sb->s_maxbytes = unionfs_lower_super_idx(sb, 0)->s_maxbytes;
/*
* Our c/m/atime granularity is 1 ns because we may stack on file
* systems whose granularity is as good. This is important for our
* time-based cache coherency.
*/
sb->s_time_gran = 1;
sb->s_op = &unionfs_sops;
/* get a new inode and allocate our root dentry */
inode = unionfs_iget(sb, iunique(sb, UNIONFS_ROOT_INO));
if (IS_ERR(inode)) {
err = PTR_ERR(inode);
goto out_dput;
}
sb->s_root = d_make_root(inode);
if (unlikely(!sb->s_root)) {
err = -ENOMEM;
goto out_iput;
}
d_set_d_op(sb->s_root, &unionfs_dops);
/* link the upper and lower dentries */
sb->s_root->d_fsdata = NULL;
err = new_dentry_private_data(sb->s_root, UNIONFS_DMUTEX_ROOT);
if (unlikely(err))
goto out_freedpd;
/* if get here: cannot have error */
/* Set the lower dentries for s_root */
for (bindex = bstart; bindex <= bend; bindex++) {
struct dentry *d;
struct vfsmount *m;
d = lower_root_info->lower_paths[bindex].dentry;
m = lower_root_info->lower_paths[bindex].mnt;
unionfs_set_lower_dentry_idx(sb->s_root, bindex, d);
unionfs_set_lower_mnt_idx(sb->s_root, bindex, m);
}
dbstart(sb->s_root) = bstart;
dbend(sb->s_root) = bend;
/* Set the generation number to one, since this is for the mount. */
atomic_set(&UNIONFS_D(sb->s_root)->generation, 1);
if (atomic_read(&inode->i_count) <= 1)
unionfs_fill_inode(sb->s_root, inode);
/*
* No need to call interpose because we already have a positive
* dentry, which was instantiated by d_alloc_root. Just need to
* d_rehash it.
*/
d_rehash(sb->s_root);
unionfs_unlock_dentry(sb->s_root);
goto out; /* all is well */
out_freedpd:
if (UNIONFS_D(sb->s_root)) {
kfree(UNIONFS_D(sb->s_root)->lower_paths);
free_dentry_private_data(sb->s_root);
}
dput(sb->s_root);
out_iput:
iput(inode);
out_dput:
if (lower_root_info && !IS_ERR(lower_root_info)) {
for (bindex = lower_root_info->bstart;
bindex <= lower_root_info->bend; bindex++) {
struct dentry *d;
d = lower_root_info->lower_paths[bindex].dentry;
/* drop refs we took earlier */
atomic_dec(&d->d_sb->s_active);
path_put(&lower_root_info->lower_paths[bindex]);
}
kfree(lower_root_info->lower_paths);
kfree(lower_root_info);
lower_root_info = NULL;
}
out_free:
kfree(UNIONFS_SB(sb)->data);
kfree(UNIONFS_SB(sb));
sb->s_fs_info = NULL;
out:
if (lower_root_info && !IS_ERR(lower_root_info)) {
kfree(lower_root_info->lower_paths);
kfree(lower_root_info);
}
return err;
}
static struct dentry *unionfs_d_alloc_root(struct super_block *sb)
{
struct dentry *ret = NULL;
if (sb) {
static const struct qstr name = {.name = "/",.len = 1 };
ret = d_alloc(NULL, &name);
if (ret) {
ret->d_op = &unionfs_dops;
ret->d_sb = sb;
ret->d_parent = ret;
}
}
return ret;
}
static int unionfs_read_super(struct super_block *sb, void *raw_data,
int silent)
{
int err = 0;
struct unionfs_dentry_info *hidden_root_info = NULL;
int bindex, bstart, bend;
unsigned long long maxbytes;
print_entry_location();
if (!raw_data) {
printk(KERN_WARNING
"unionfs_read_super: missing data argument\n");
err = -EINVAL;
goto out;
}
/*
* Allocate superblock private data
*/
stopd_lhs(sb) = KZALLOC(sizeof(struct unionfs_sb_info), GFP_KERNEL);
if (!stopd(sb)) {
printk(KERN_WARNING "%s: out of memory\n", __FUNCTION__);
err = -ENOMEM;
goto out;
}
stopd(sb)->b_end = -1;
atomic_set(&stopd(sb)->usi_generation, 1);
init_rwsem(&stopd(sb)->usi_rwsem);
hidden_root_info = unionfs_parse_options(sb, raw_data);
if (IS_ERR(hidden_root_info)) {
printk(KERN_WARNING
"unionfs_read_super: error while parsing options (err = %ld)\n",
PTR_ERR(hidden_root_info));
err = PTR_ERR(hidden_root_info);
hidden_root_info = NULL;
goto out_free;
}
if (hidden_root_info->udi_bstart == -1) {
err = -ENOENT;
goto out_free;
}
/* set the hidden superblock field of upper superblock */
bstart = hidden_root_info->udi_bstart;
BUG_ON(bstart != 0);
sbend(sb) = bend = hidden_root_info->udi_bend;
for (bindex = bstart; bindex <= bend; bindex++) {
struct dentry *d;
d = hidden_root_info->udi_dentry[bindex];
set_stohs_index(sb, bindex, d->d_sb);
}
/* Unionfs: Max Bytes is the maximum bytes from among all the branches */
maxbytes = -1;
for (bindex = bstart; bindex <= bend; bindex++)
if (maxbytes < stohs_index(sb, bindex)->s_maxbytes)
maxbytes = stohs_index(sb, bindex)->s_maxbytes;
sb->s_maxbytes = maxbytes;
sb->s_op = &unionfs_sops;
sb->s_export_op = &unionfs_export_ops;
/*
* we can't use d_alloc_root if we want to use
* our own interpose function unchanged,
* so we simply call our own "fake" d_alloc_root
*/
sb->s_root = unionfs_d_alloc_root(sb);
if (!sb->s_root) {
err = -ENOMEM;
goto out_dput;
}
/* link the upper and lower dentries */
dtopd_lhs(sb->s_root) = NULL;
if ((err = new_dentry_private_data(sb->s_root)))
goto out_freedpd;
/* Set the hidden dentries for s_root */
for (bindex = bstart; bindex <= bend; bindex++) {
struct dentry *d;
d = hidden_root_info->udi_dentry[bindex];
set_dtohd_index(sb->s_root, bindex, d);
}
set_dbstart(sb->s_root, bstart);
set_dbend(sb->s_root, bend);
/* Set the generation number to one, since this is for the mount. */
atomic_set(&dtopd(sb->s_root)->udi_generation, 1);
/* call interpose to create the upper level inode */
if ((err = unionfs_interpose(sb->s_root, sb, 0)))
goto out_freedpd;
unlock_dentry(sb->s_root);
goto out;
out_freedpd:
if (dtopd(sb->s_root)) {
KFREE(dtohd_ptr(sb->s_root));
free_dentry_private_data(dtopd(sb->s_root));
}
DPUT(sb->s_root);
out_dput:
if (hidden_root_info && !IS_ERR(hidden_root_info)) {
for (bindex = hidden_root_info->udi_bstart;
bindex <= hidden_root_info->udi_bend; bindex++) {
struct dentry *d;
d = hidden_root_info->udi_dentry[bindex];
if (d)
DPUT(d);
if (stopd(sb) && stohiddenmnt_index(sb, bindex))
mntput(stohiddenmnt_index(sb, bindex));
}
KFREE(hidden_root_info->udi_dentry);
KFREE(hidden_root_info);
hidden_root_info = NULL;
}
out_free:
KFREE(stopd(sb)->usi_data);
KFREE(stopd(sb));
stopd_lhs(sb) = NULL;
out:
if (hidden_root_info && !IS_ERR(hidden_root_info)) {
KFREE(hidden_root_info->udi_dentry);
KFREE(hidden_root_info);
}
print_exit_status(err);
return err;
}