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();
}
int unionfs_ioctl_addbranch(struct inode *inode, unsigned int cmd,
unsigned long arg)
{
int err;
struct unionfs_addbranch_args *addargs = NULL;
struct nameidata nd;
char *path = NULL;
int gen;
int i;
int count;
int pobjects;
struct vfsmount **new_hidden_mnt = NULL;
struct inode **new_uii_inode = NULL;
struct dentry **new_udi_dentry = NULL;
struct super_block **new_usi_sb = NULL;
int *new_branchperms = NULL;
atomic_t *new_counts = NULL;
print_entry_location();
err = -ENOMEM;
addargs = KMALLOC(sizeof(struct unionfs_addbranch_args), GFP_UNIONFS);
if (!addargs)
goto out;
err = -EFAULT;
if (copy_from_user
(addargs, (void *)arg, sizeof(struct unionfs_addbranch_args)))
goto out;
err = -EINVAL;
if (addargs->ab_perms & ~(MAY_READ | MAY_WRITE))
goto out;
if (!(addargs->ab_perms & MAY_READ))
goto out;
err = -E2BIG;
if (sbend(inode->i_sb) > FD_SETSIZE)
goto out;
err = -ENOMEM;
if (!(path = getname(addargs->ab_path)))
goto out;
err = path_lookup(path, LOOKUP_FOLLOW, &nd);
RECORD_PATH_LOOKUP(&nd);
if (err)
goto out;
if ((err = check_branch(&nd))) {
path_release(&nd);
RECORD_PATH_RELEASE(&nd);
goto out;
}
unionfs_write_lock(inode->i_sb);
lock_dentry(inode->i_sb->s_root);
err = -EINVAL;
if (addargs->ab_branch < 0
|| (addargs->ab_branch > (sbend(inode->i_sb) + 1)))
goto out;
if ((err = newputmap(inode->i_sb)))
goto out;
stopd(inode->i_sb)->b_end++;
dtopd(inode->i_sb->s_root)->udi_bcount++;
set_dbend(inode->i_sb->s_root, dbend(inode->i_sb->s_root) + 1);
itopd(inode->i_sb->s_root->d_inode)->b_end++;
atomic_inc(&stopd(inode->i_sb)->usi_generation);
gen = atomic_read(&stopd(inode->i_sb)->usi_generation);
pobjects = (sbend(inode->i_sb) + 1) - UNIONFS_INLINE_OBJECTS;
if (pobjects > 0) {
/* Reallocate the dynamic structures. */
new_hidden_mnt =
KMALLOC(sizeof(struct vfsmount *) * pobjects, GFP_UNIONFS);
new_udi_dentry =
KMALLOC(sizeof(struct dentry *) * pobjects, GFP_UNIONFS);
new_uii_inode =
KMALLOC(sizeof(struct inode *) * pobjects, GFP_UNIONFS);
new_usi_sb =
KMALLOC(sizeof(struct super_block *) * pobjects,
GFP_UNIONFS);
new_counts = KMALLOC(sizeof(atomic_t) * pobjects, GFP_UNIONFS);
new_branchperms = KMALLOC(sizeof(int) * pobjects, GFP_UNIONFS);
if (!new_hidden_mnt || !new_udi_dentry || !new_uii_inode
|| !new_counts || !new_usi_sb || !new_branchperms) {
err = -ENOMEM;
goto out;
}
memset(new_hidden_mnt, 0, sizeof(struct vfsmount *) * pobjects);
memset(new_udi_dentry, 0, sizeof(struct dentry *) * pobjects);
memset(new_uii_inode, 0, sizeof(struct inode *) * pobjects);
memset(new_usi_sb, 0, sizeof(struct super_block *) * pobjects);
memset(new_branchperms, 0, sizeof(int) * pobjects);
}
/* Copy the in-place values to our new structure. */
for (i = UNIONFS_INLINE_OBJECTS; i < addargs->ab_branch; i++) {
int j = i - UNIONFS_INLINE_OBJECTS;
count = branch_count(inode->i_sb, i);
atomic_set(&(new_counts[j]), count);
new_branchperms[j] = branchperms(inode->i_sb, i);
new_hidden_mnt[j] = stohiddenmnt_index(inode->i_sb, i);
new_usi_sb[j] = stohs_index(inode->i_sb, i);
new_udi_dentry[j] = dtohd_index(inode->i_sb->s_root, i);
new_uii_inode[j] = itohi_index(inode->i_sb->s_root->d_inode, i);
}
/* Shift the ends to the right (only handle reallocated bits). */
for (i = sbend(inode->i_sb) - 1; i >= (int)addargs->ab_branch; i--) {
int j = i + 1;
int perms;
struct vfsmount *hm;
struct super_block *hs;
struct dentry *hd;
struct inode *hi;
int pmindex;
count = branch_count(inode->i_sb, i);
perms = branchperms(inode->i_sb, i);
hm = stohiddenmnt_index(inode->i_sb, i);
hs = stohs_index(inode->i_sb, i);
hd = dtohd_index(inode->i_sb->s_root, i);
hi = itohi_index(inode->i_sb->s_root->d_inode, i);
/* Update the newest putmap, so it is correct for later. */
pmindex = stopd(inode->i_sb)->usi_lastputmap;
pmindex -= stopd(inode->i_sb)->usi_firstputmap;
stopd(inode->i_sb)->usi_putmaps[pmindex]->map[i] = j;
if (j >= UNIONFS_INLINE_OBJECTS) {
j -= UNIONFS_INLINE_OBJECTS;
atomic_set(&(new_counts[j]), count);
new_branchperms[j] = perms;
new_hidden_mnt[j] = hm;
new_usi_sb[j] = hs;
new_udi_dentry[j] = hd;
new_uii_inode[j] = hi;
} else {
set_branch_count(inode->i_sb, j, count);
set_branchperms(inode->i_sb, j, perms);
set_stohiddenmnt_index(inode->i_sb, j, hm);
set_stohs_index(inode->i_sb, j, hs);
set_dtohd_index(inode->i_sb->s_root, j, hd);
set_itohi_index(inode->i_sb->s_root->d_inode, j, hi);
}
}
/* Now we can free the old ones. */
KFREE(dtopd(inode->i_sb->s_root)->udi_dentry_p);
KFREE(itopd(inode->i_sb->s_root->d_inode)->uii_inode_p);
KFREE(stopd(inode->i_sb)->usi_hidden_mnt_p);
KFREE(stopd(inode->i_sb)->usi_sb_p);
KFREE(stopd(inode->i_sb)->usi_sbcount_p);
KFREE(stopd(inode->i_sb)->usi_branchperms_p);
/* Update the real pointers. */
dtohd_ptr(inode->i_sb->s_root) = new_udi_dentry;
itohi_ptr(inode->i_sb->s_root->d_inode) = new_uii_inode;
stohiddenmnt_ptr(inode->i_sb) = new_hidden_mnt;
stohs_ptr(inode->i_sb) = new_usi_sb;
stopd(inode->i_sb)->usi_sbcount_p = new_counts;
stopd(inode->i_sb)->usi_branchperms_p = new_branchperms;
/* Re-NULL the new ones so we don't try to free them. */
new_hidden_mnt = NULL;
new_udi_dentry = NULL;
new_usi_sb = NULL;
new_uii_inode = NULL;
new_counts = NULL;
new_branchperms = NULL;
/* Put the new dentry information into it's slot. */
set_dtohd_index(inode->i_sb->s_root, addargs->ab_branch, nd.dentry);
set_itohi_index(inode->i_sb->s_root->d_inode, addargs->ab_branch,
igrab(nd.dentry->d_inode));
set_branchperms(inode->i_sb, addargs->ab_branch, addargs->ab_perms);
set_branch_count(inode->i_sb, addargs->ab_branch, 0);
set_stohiddenmnt_index(inode->i_sb, addargs->ab_branch, nd.mnt);
set_stohs_index(inode->i_sb, addargs->ab_branch, nd.dentry->d_sb);
atomic_set(&dtopd(inode->i_sb->s_root)->udi_generation, gen);
atomic_set(&itopd(inode->i_sb->s_root->d_inode)->uii_generation, gen);
fixputmaps(inode->i_sb);
out:
unlock_dentry(inode->i_sb->s_root);
unionfs_write_unlock(inode->i_sb);
KFREE(new_hidden_mnt);
KFREE(new_udi_dentry);
KFREE(new_uii_inode);
KFREE(new_usi_sb);
KFREE(new_counts);
KFREE(new_branchperms);
KFREE(addargs);
if (path)
putname(path);
print_exit_status(err);
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;
}
struct dentry *unionfs_lookup_backend(struct dentry *dentry, int lookupmode)
{
int err = 0;
struct dentry *hidden_dentry = NULL;
struct dentry *wh_hidden_dentry = NULL;
struct dentry *hidden_dir_dentry = NULL;
struct dentry *parent_dentry = NULL;
int bindex, bstart, bend, bopaque;
int dentry_count = 0; /* Number of positive dentries. */
int first_dentry_offset = -1;
struct dentry *first_hidden_dentry = NULL;
int locked_parent = 0;
int locked_child = 0;
int opaque;
char *whname = NULL;
const char *name;
int namelen;
print_entry("mode = %d", lookupmode);
/* We should already have a lock on this dentry in the case of a
* partial lookup, or a revalidation. Otherwise it is returned from
* new_dentry_private_data already locked. */
if (lookupmode == INTERPOSE_PARTIAL || lookupmode == INTERPOSE_REVAL
|| lookupmode == INTERPOSE_REVAL_NEG) {
verify_locked(dentry);
} else {
BUG_ON(dtopd_nocheck(dentry) != NULL);
locked_child = 1;
}
if (lookupmode != INTERPOSE_PARTIAL)
if ((err = new_dentry_private_data(dentry)))
goto out;
/* must initialize dentry operations */
dentry->d_op = &unionfs_dops;
parent_dentry = GET_PARENT(dentry);
/* We never partial lookup the root directory. */
if (parent_dentry != dentry) {
lock_dentry(parent_dentry);
locked_parent = 1;
} else {
DPUT(parent_dentry);
parent_dentry = NULL;
goto out;
}
fist_print_dentry("IN unionfs_lookup (parent)", parent_dentry);
fist_print_dentry("IN unionfs_lookup (child)", dentry);
name = dentry->d_name.name;
namelen = dentry->d_name.len;
/* No dentries should get created for possible whiteout names. */
if (!is_validname(name)) {
err = -EPERM;
goto out_free;
}
/* Now start the actual lookup procedure. */
bstart = dbstart(parent_dentry);
bend = dbend(parent_dentry);
bopaque = dbopaque(parent_dentry);
BUG_ON(bstart < 0);
/* It would be ideal if we could convert partial lookups to only have
* to do this work when they really need to. It could probably improve
* performance quite a bit, and maybe simplify the rest of the code. */
if (lookupmode == INTERPOSE_PARTIAL) {
bstart++;
if ((bopaque != -1) && (bopaque < bend))
bend = bopaque;
}
fist_dprint(8, "bstart = %d, bend = %d\n", bstart, bend);
for (bindex = bstart; bindex <= bend; bindex++) {
hidden_dentry = dtohd_index(dentry, bindex);
if (lookupmode == INTERPOSE_PARTIAL && hidden_dentry)
continue;
BUG_ON(hidden_dentry != NULL);
hidden_dir_dentry = dtohd_index(parent_dentry, bindex);
/* if the parent hidden dentry does not exist skip this */
if (!(hidden_dir_dentry && hidden_dir_dentry->d_inode))
continue;
/* also skip it if the parent isn't a directory. */
if (!S_ISDIR(hidden_dir_dentry->d_inode->i_mode))
continue;
/* Reuse the whiteout name because its value doesn't change. */
if (!whname) {
whname = alloc_whname(name, namelen);
if (IS_ERR(whname)) {
err = PTR_ERR(whname);
goto out_free;
}
}
/* check if whiteout exists in this branch: lookup .wh.foo */
wh_hidden_dentry = LOOKUP_ONE_LEN(whname, hidden_dir_dentry,
namelen + WHLEN);
if (IS_ERR(wh_hidden_dentry)) {
DPUT(first_hidden_dentry);
err = PTR_ERR(wh_hidden_dentry);
goto out_free;
}
if (wh_hidden_dentry->d_inode) {
/* We found a whiteout so lets give up. */
fist_dprint(8, "whiteout found in %d\n", bindex);
if (S_ISREG(wh_hidden_dentry->d_inode->i_mode)) {
set_dbend(dentry, bindex);
set_dbopaque(dentry, bindex);
DPUT(wh_hidden_dentry);
break;
}
err = -EIO;
printk(KERN_NOTICE "EIO: Invalid whiteout entry type"
" %d.\n", wh_hidden_dentry->d_inode->i_mode);
DPUT(wh_hidden_dentry);
DPUT(first_hidden_dentry);
goto out_free;
}
DPUT(wh_hidden_dentry);
wh_hidden_dentry = NULL;
/* Now do regular lookup; lookup foo */
hidden_dentry = LOOKUP_ONE_LEN(name, hidden_dir_dentry,
namelen);
fist_print_generic_dentry("hidden result", hidden_dentry);
if (IS_ERR(hidden_dentry)) {
DPUT(first_hidden_dentry);
err = PTR_ERR(hidden_dentry);
goto out_free;
}
/* Store the first negative dentry specially, because if they
* are all negative we need this for future creates. */
if (!hidden_dentry->d_inode) {
if (!first_hidden_dentry && (dbstart(dentry) == -1)) {
first_hidden_dentry = hidden_dentry;
first_dentry_offset = bindex;
} else {
DPUT(hidden_dentry);
}
continue;
}
/* number of positive dentries */
dentry_count++;
/* store underlying dentry */
if (dbstart(dentry) == -1)
set_dbstart(dentry, bindex);
set_dtohd_index(dentry, bindex, hidden_dentry);
set_dbend(dentry, bindex);
/* update parent directory's atime with the bindex */
fist_copy_attr_atime(parent_dentry->d_inode,
hidden_dir_dentry->d_inode);
/* We terminate file lookups here. */
if (!S_ISDIR(hidden_dentry->d_inode->i_mode)) {
if (lookupmode == INTERPOSE_PARTIAL)
continue;
if (dentry_count == 1)
goto out_positive;
/* This can only happen with mixed D-*-F-* */
BUG_ON(!S_ISDIR(dtohd(dentry)->d_inode->i_mode));
continue;
}
opaque = is_opaque_dir(dentry, bindex);
if (opaque < 0) {
DPUT(first_hidden_dentry);
err = opaque;
goto out_free;
}
if (opaque) {
set_dbend(dentry, bindex);
set_dbopaque(dentry, bindex);
break;
}
}
if (dentry_count)
goto out_positive;
else
goto out_negative;
out_negative:
if (lookupmode == INTERPOSE_PARTIAL)
goto out;
/* If we've only got negative dentries, then use the leftmost one. */
if (lookupmode == INTERPOSE_REVAL) {
if (dentry->d_inode) {
itopd(dentry->d_inode)->uii_stale = 1;
}
goto out;
}
/* This should only happen if we found a whiteout. */
if (first_dentry_offset == -1) {
first_hidden_dentry = LOOKUP_ONE_LEN(name, hidden_dir_dentry,
namelen);
first_dentry_offset = bindex;
if (IS_ERR(first_hidden_dentry)) {
err = PTR_ERR(first_hidden_dentry);
goto out;
}
}
set_dtohd_index(dentry, first_dentry_offset, first_hidden_dentry);
set_dbstart(dentry, first_dentry_offset);
set_dbend(dentry, first_dentry_offset);
if (lookupmode == INTERPOSE_REVAL_NEG)
BUG_ON(dentry->d_inode != NULL);
else
d_add(dentry, NULL);
goto out;
/* This part of the code is for positive dentries. */
out_positive:
BUG_ON(dentry_count <= 0);
/* If we're holding onto the first negative dentry throw it out. */
DPUT(first_hidden_dentry);
/* Partial lookups need to reinterpose, or throw away older negs. */
if (lookupmode == INTERPOSE_PARTIAL) {
if (dentry->d_inode) {
unionfs_reinterpose(dentry);
goto out;
}
/* This somehow turned positive, so it is as if we had a
* negative revalidation. */
lookupmode = INTERPOSE_REVAL_NEG;
update_bstart(dentry);
bstart = dbstart(dentry);
bend = dbend(dentry);
}
err = unionfs_interpose(dentry, dentry->d_sb, lookupmode);
if (err)
goto out_drop;
fist_checkinode(dentry->d_inode, "unionfs_lookup OUT: child");
fist_checkinode(parent_dentry->d_inode, "unionfs_lookup OUT: dir");
goto out;
out_drop:
d_drop(dentry);
out_free:
/* should dput all the underlying dentries on error condition */
bstart = dbstart(dentry);
if (bstart >= 0) {
bend = dbend(dentry);
for (bindex = bstart; bindex <= bend; bindex++)
DPUT(dtohd_index(dentry, bindex));
}
KFREE(dtohd_ptr(dentry));
dtohd_ptr(dentry) = NULL;
set_dbstart(dentry, -1);
set_dbend(dentry, -1);
out:
if (!err && dtopd(dentry)) {
BUG_ON(dbend(dentry) > dtopd(dentry)->udi_bcount);
BUG_ON(dbend(dentry) > sbmax(dentry->d_sb));
BUG_ON(dbstart(dentry) < 0);
}
KFREE(whname);
fist_print_dentry("OUT unionfs_lookup (parent)", parent_dentry);
fist_print_dentry("OUT unionfs_lookup (child)", dentry);
if (locked_parent)
unlock_dentry(parent_dentry);
DPUT(parent_dentry);
if (locked_child)
unlock_dentry(dentry);
print_exit_status(err);
return ERR_PTR(err);
}
int unionfs_ioctl_addbranch(struct inode *inode, unsigned int cmd,
unsigned long arg)
{
int err;
struct unionfs_addbranch_args *addargs = NULL;
struct nameidata nd;
char *path = NULL;
int gen;
int i;
int pobjects;
struct unionfs_usi_data *new_data = NULL;
struct dentry **new_udi_dentry = NULL;
struct inode **new_uii_inode = NULL;
struct dentry *root = NULL;
struct dentry *hidden_root = NULL;
print_entry_location();
err = -ENOMEM;
addargs = KMALLOC(sizeof(struct unionfs_addbranch_args), GFP_KERNEL);
if (!addargs)
goto out;
err = -EFAULT;
if (copy_from_user
(addargs, (const void __user *)arg,
sizeof(struct unionfs_addbranch_args)))
goto out;
err = -EINVAL;
if (addargs->ab_perms & ~(MAY_READ | MAY_WRITE | MAY_NFSRO))
goto out;
if (!(addargs->ab_perms & MAY_READ))
goto out;
err = -E2BIG;
if (sbend(inode->i_sb) > FD_SETSIZE)
goto out;
err = -ENOMEM;
if (!(path = getname((const char __user *)addargs->ab_path)))
goto out;
err = path_lookup(path, LOOKUP_FOLLOW, &nd);
RECORD_PATH_LOOKUP(&nd);
if (err)
goto out;
if ((err = check_branch(&nd))) {
path_release(&nd);
RECORD_PATH_RELEASE(&nd);
goto out;
}
unionfs_write_lock(inode->i_sb);
lock_dentry(inode->i_sb->s_root);
root = inode->i_sb->s_root;
for (i = dbstart(inode->i_sb->s_root); i <= dbend(inode->i_sb->s_root);
i++) {
hidden_root = dtohd_index(root, i);
if (is_branch_overlap(hidden_root, nd.dentry)) {
err = -EINVAL;
goto out;
}
}
err = -EINVAL;
if (addargs->ab_branch < 0
|| (addargs->ab_branch > (sbend(inode->i_sb) + 1)))
goto out;
if ((err = newputmap(inode->i_sb)))
goto out;
stopd(inode->i_sb)->b_end++;
dtopd(inode->i_sb->s_root)->udi_bcount++;
set_dbend(inode->i_sb->s_root, dbend(inode->i_sb->s_root) + 1);
itopd(inode->i_sb->s_root->d_inode)->b_end++;
atomic_inc(&stopd(inode->i_sb)->usi_generation);
gen = atomic_read(&stopd(inode->i_sb)->usi_generation);
pobjects = sbend(inode->i_sb) + 1;
/* Reallocate the dynamic structures. */
new_data = alloc_new_data(pobjects);
new_udi_dentry = alloc_new_dentries(pobjects);
new_uii_inode = KZALLOC(sizeof(struct inode *) * pobjects, GFP_KERNEL);
if (!new_udi_dentry || !new_uii_inode || !new_data) {
err = -ENOMEM;
goto out;
}
/* Copy the in-place values to our new structure. */
for (i = 0; i < addargs->ab_branch; i++) {
atomic_set(&(new_data[i].sbcount),
branch_count(inode->i_sb, i));
new_data[i].branchperms = branchperms(inode->i_sb, i);
new_data[i].hidden_mnt = stohiddenmnt_index(inode->i_sb, i);
new_data[i].sb = stohs_index(inode->i_sb, i);
new_udi_dentry[i] = dtohd_index(inode->i_sb->s_root, i);
new_uii_inode[i] = itohi_index(inode->i_sb->s_root->d_inode, i);
}
/* Shift the ends to the right (only handle reallocated bits). */
for (i = sbend(inode->i_sb) - 1; i >= (int)addargs->ab_branch; i--) {
int j = i + 1;
int pmindex;
atomic_set(&new_data[j].sbcount, branch_count(inode->i_sb, i));
new_data[j].branchperms = branchperms(inode->i_sb, i);
new_data[j].hidden_mnt = stohiddenmnt_index(inode->i_sb, i);
new_data[j].sb = stohs_index(inode->i_sb, i);
new_udi_dentry[j] = dtohd_index(inode->i_sb->s_root, i);
new_uii_inode[j] = itohi_index(inode->i_sb->s_root->d_inode, i);
/* Update the newest putmap, so it is correct for later. */
pmindex = stopd(inode->i_sb)->usi_lastputmap;
pmindex -= stopd(inode->i_sb)->usi_firstputmap;
stopd(inode->i_sb)->usi_putmaps[pmindex]->map[i] = j;
}
/* Now we can free the old ones. */
KFREE(dtopd(inode->i_sb->s_root)->udi_dentry);
KFREE(itopd(inode->i_sb->s_root->d_inode)->uii_inode);
KFREE(stopd(inode->i_sb)->usi_data);
/* Update the real pointers. */
dtohd_ptr(inode->i_sb->s_root) = new_udi_dentry;
itohi_ptr(inode->i_sb->s_root->d_inode) = new_uii_inode;
stopd(inode->i_sb)->usi_data = new_data;
/* Re-NULL the new ones so we don't try to free them. */
new_data = NULL;
new_udi_dentry = NULL;
new_uii_inode = NULL;
/* Put the new dentry information into it's slot. */
set_dtohd_index(inode->i_sb->s_root, addargs->ab_branch, nd.dentry);
set_itohi_index(inode->i_sb->s_root->d_inode, addargs->ab_branch,
IGRAB(nd.dentry->d_inode));
set_branchperms(inode->i_sb, addargs->ab_branch, addargs->ab_perms);
set_branch_count(inode->i_sb, addargs->ab_branch, 0);
set_stohiddenmnt_index(inode->i_sb, addargs->ab_branch, nd.mnt);
set_stohs_index(inode->i_sb, addargs->ab_branch, nd.dentry->d_sb);
atomic_set(&dtopd(inode->i_sb->s_root)->udi_generation, gen);
atomic_set(&itopd(inode->i_sb->s_root->d_inode)->uii_generation, gen);
fixputmaps(inode->i_sb);
out:
unlock_dentry(inode->i_sb->s_root);
unionfs_write_unlock(inode->i_sb);
KFREE(new_udi_dentry);
KFREE(new_uii_inode);
KFREE(new_data);
KFREE(addargs);
if (path)
putname(path);
print_exit_status(err);
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;
}
