commit f2bc0a35fb10cbffe1e0b7194287b8761a68a824
Author: Yiannis Pericleous <[EMAIL PROTECTED]>
Date: Sat Apr 21 11:46:07 2007 -0400
coding-style: reformat lines longer than 80 chars (accounting for TABs)
Conflicts:
fs/unionfs/dirfops.c
fs/unionfs/dirhelper.c
fs/unionfs/inode.c
fs/unionfs/lookup.c
fs/unionfs/rename.c
fs/unionfs/subr.c
diff --git a/fs/unionfs/commonfops.c b/fs/unionfs/commonfops.c
index 53cafa8..1cb03f1 100644
--- a/fs/unionfs/commonfops.c
+++ b/fs/unionfs/commonfops.c
@@ -195,15 +195,15 @@ static void cleanup_file(struct file *file)
int i; /* holds (possibly) updated branch index */
i = find_new_branch_index(file, bindex, sb);
if (i < 0)
- printk(KERN_ERR "unionfs: no supberlock for
file %p\n",
- file);
+ printk(KERN_ERR "unionfs: no supberlock for "
+ "file %p\n", file);
else {
unionfs_read_lock(sb);
branchput(sb, i);
unionfs_read_unlock(sb);
- /* XXX: is it correct to use sb->s_root here? */
+ /* XXX: is it OK to use sb->s_root here? */
unionfs_mntput(sb->s_root, i);
- /* XXX: mntget b/c fput below will call mntput
*/
+ /* mntget b/c fput below will call mntput */
unionfs_mntget(sb->s_root, bindex);
}
fput(unionfs_lower_file_idx(file, bindex));
@@ -240,9 +240,10 @@ static int open_all_files(struct file *file)
branchget(sb, bindex);
unionfs_read_unlock(sb);
- hidden_file = dentry_open(hidden_dentry,
- unionfs_lower_mnt_idx(dentry, bindex),
- file->f_flags);
+ hidden_file =
+ dentry_open(hidden_dentry,
+ unionfs_lower_mnt_idx(dentry, bindex),
+ file->f_flags);
if (IS_ERR(hidden_file)) {
err = PTR_ERR(hidden_file);
goto out;
@@ -277,7 +278,8 @@ static int open_highest_file(struct file *file, int
willwrite)
break;
}
atomic_set(&UNIONFS_F(file)->generation,
-
atomic_read(&UNIONFS_I(dentry->d_inode)->generation));
+ atomic_read(&UNIONFS_I(dentry->d_inode)->
+ generation));
goto out;
}
@@ -287,7 +289,8 @@ static int open_highest_file(struct file *file, int
willwrite)
branchget(sb, bstart);
unionfs_read_unlock(sb);
hidden_file = dentry_open(hidden_dentry,
- unionfs_lower_mnt_idx(dentry, bstart),
file->f_flags);
+ unionfs_lower_mnt_idx(dentry, bstart),
+ file->f_flags);
if (IS_ERR(hidden_file)) {
err = PTR_ERR(hidden_file);
goto out;
@@ -317,7 +320,8 @@ static int do_delayed_copyup(struct file *file, struct
dentry *dentry)
err = copyup_file(parent_inode, file, bstart,
bindex, inode_size);
else
- err = copyup_deleted_file(file, dentry, bstart, bindex);
+ err = copyup_deleted_file(file, dentry, bstart,
+ bindex);
if (!err)
break;
@@ -358,7 +362,8 @@ int unionfs_file_revalidate(struct file *file, int
willwrite)
sb = dentry->d_sb;
/* first revalidate the dentry inside struct file */
- if (!__unionfs_d_revalidate_chain(dentry, NULL) && !d_deleted(dentry)) {
+ if (!__unionfs_d_revalidate_chain(dentry, NULL) &&
+ !d_deleted(dentry)) {
err = -ESTALE;
goto out_nofree;
}
@@ -446,14 +451,16 @@ static int __open_dir(struct inode *inode, struct file
*file)
newest = &file->f_dentry->d_inode->i_mtime;
for (bindex = bstart; bindex <= bend; bindex++) {
- hidden_dentry = unionfs_lower_dentry_idx(file->f_dentry,
bindex);
+ hidden_dentry =
+ unionfs_lower_dentry_idx(file->f_dentry, bindex);
if (!hidden_dentry)
continue;
dget(hidden_dentry);
unionfs_mntget(file->f_dentry, bindex);
hidden_file = dentry_open(hidden_dentry,
- unionfs_lower_mnt_idx(file->f_dentry,
bindex),
+ unionfs_lower_mnt_idx(file->f_dentry,
+ bindex),
file->f_flags);
if (IS_ERR(hidden_file))
return PTR_ERR(hidden_file);
@@ -494,8 +501,8 @@ static int __open_file(struct inode *inode, struct file
*file)
bstart = fbstart(file) = dbstart(file->f_dentry);
bend = fbend(file) = dbend(file->f_dentry);
- /* check for the permission for hidden file. If the error is
COPYUP_ERR,
- * copyup the file.
+ /* check for the permission for hidden file. If the error is
+ * COPYUP_ERR, copyup the file.
*/
if (hidden_dentry->d_inode && is_robranch(file->f_dentry)) {
/* if the open will change the file, copy it up otherwise
@@ -507,8 +514,9 @@ static int __open_file(struct inode *inode, struct file
*file)
/* copyup the file */
for (bindex = bstart - 1; bindex >= 0; bindex--) {
- err =
copyup_file(file->f_dentry->d_parent->d_inode,
- file, bstart, bindex, size);
+ err = copyup_file(
+ file->f_dentry->d_parent->d_inode,
+ file, bstart, bindex, size);
if (!err)
break;
}
@@ -523,9 +531,10 @@ static int __open_file(struct inode *inode, struct file
*file)
* otherwise fput() will do an mntput() for us upon file close.
*/
unionfs_mntget(file->f_dentry, bstart);
- hidden_file = dentry_open(hidden_dentry,
- unionfs_lower_mnt_idx(file->f_dentry, bstart),
- hidden_flags);
+ hidden_file =
+ dentry_open(hidden_dentry,
+ unionfs_lower_mnt_idx(file->f_dentry, bstart),
+ hidden_flags);
if (IS_ERR(hidden_file))
return PTR_ERR(hidden_file);
@@ -546,7 +555,8 @@ int unionfs_open(struct inode *inode, struct file *file)
int size;
unionfs_read_lock(inode->i_sb);
- file->private_data = kzalloc(sizeof(struct unionfs_file_info),
GFP_KERNEL);
+ file->private_data =
+ kzalloc(sizeof(struct unionfs_file_info), GFP_KERNEL);
if (!UNIONFS_F(file)) {
err = -ENOMEM;
goto out_nofree;
@@ -704,7 +714,8 @@ long unionfs_ioctl(struct file *file, unsigned int cmd,
unsigned long arg)
switch (cmd) {
case UNIONFS_IOCTL_INCGEN:
/* Increment the superblock generation count */
- printk("unionfs: incgen ioctl deprecated; use \"-o
remount,incgen\"\n");
+ printk("unionfs: incgen ioctl deprecated; "
+ "use \"-o remount,incgen\"\n");
err = -ENOSYS;
break;
@@ -745,15 +756,17 @@ int unionfs_flush(struct file *file, fl_owner_t id)
for (bindex = bstart; bindex <= bend; bindex++) {
hidden_file = unionfs_lower_file_idx(file, bindex);
- if (hidden_file && hidden_file->f_op &&
hidden_file->f_op->flush) {
+ if (hidden_file && hidden_file->f_op &&
+ hidden_file->f_op->flush) {
err = hidden_file->f_op->flush(hidden_file, id);
if (err)
goto out_lock;
- /* if there are no more references to the dentry, dput
it */
+ /* if there are no more refs to the dentry, dput it */
if (d_deleted(dentry)) {
dput(unionfs_lower_dentry_idx(dentry, bindex));
- unionfs_set_lower_dentry_idx(dentry, bindex,
NULL);
+ unionfs_set_lower_dentry_idx(dentry, bindex,
+ NULL);
}
}
diff --git a/fs/unionfs/copyup.c b/fs/unionfs/copyup.c
index 03c00ce..da23ad3 100644
--- a/fs/unionfs/copyup.c
+++ b/fs/unionfs/copyup.c
@@ -362,7 +362,8 @@ static int copyup_named_dentry(struct inode *dir, struct
dentry *dentry,
goto out;
/* Create the directory structure above this dentry. */
- new_hidden_dentry = create_parents_named(dir, dentry, name, new_bindex);
+ new_hidden_dentry =
+ create_parents_named(dir, dentry, name, new_bindex);
if (IS_ERR(new_hidden_dentry)) {
err = PTR_ERR(new_hidden_dentry);
goto out;
@@ -417,12 +418,14 @@ static int copyup_named_dentry(struct inode *dir, struct
dentry *dentry,
/* We actually copyup the file here. */
if (S_ISREG(old_hidden_dentry->d_inode->i_mode))
err = __copyup_reg_data(dentry, new_hidden_dentry, new_bindex,
- old_hidden_dentry, old_bindex,
copyup_file, len);
+ old_hidden_dentry, old_bindex,
+ copyup_file, len);
if (err)
goto out_unlink;
/* Set permissions. */
- if ((err = copyup_permissions(sb, old_hidden_dentry,
new_hidden_dentry)))
+ if ((err = copyup_permissions(sb, old_hidden_dentry,
+ new_hidden_dentry)))
goto out_unlink;
#ifdef CONFIG_UNION_FS_XATTR
@@ -666,7 +669,8 @@ static struct dentry *create_parents_named(struct inode
*dir,
unionfs_lock_dentry(parent_dentry);
/* find out the hidden_parent_dentry in the given branch */
- hidden_parent_dentry = unionfs_lower_dentry_idx(parent_dentry,
bindex);
+ hidden_parent_dentry =
+ unionfs_lower_dentry_idx(parent_dentry, bindex);
/* grow path table */
if (count == nr_dentry) {
@@ -693,7 +697,8 @@ static struct dentry *create_parents_named(struct inode
*dir,
*/
while (1) {
/* get hidden parent dir in the current branch */
- hidden_parent_dentry = unionfs_lower_dentry_idx(parent_dentry,
bindex);
+ hidden_parent_dentry =
+ unionfs_lower_dentry_idx(parent_dentry, bindex);
unionfs_unlock_dentry(parent_dentry);
/* init the values to lookup */
@@ -710,7 +715,8 @@ static struct dentry *create_parents_named(struct inode
*dir,
} else {
/* is the name a whiteout of the childname ?
- * lookup the whiteout child in the underlying file
system
+ * lookup the whiteout child in the underlying file
+ * system
*/
hidden_dentry =
lookup_one_len(name, hidden_parent_dentry,
@@ -718,9 +724,13 @@ static struct dentry *create_parents_named(struct inode
*dir,
if (IS_ERR(hidden_dentry))
goto out;
- /* Replace the current dentry (if any) with the new
one. */
+ /*
+ * Replace the current dentry (if any) with the new
+ * one.
+ */
dput(unionfs_lower_dentry_idx(dentry, bindex));
- unionfs_set_lower_dentry_idx(dentry, bindex,
hidden_dentry);
+ unionfs_set_lower_dentry_idx(dentry, bindex,
+ hidden_dentry);
__cleanup_dentry(dentry, bindex, old_bstart, old_bend);
break;
@@ -746,7 +756,8 @@ static struct dentry *create_parents_named(struct inode
*dir,
if (!err)
err = copyup_permissions(dir->i_sb,
- child_dentry,
hidden_dentry);
+ child_dentry,
+ hidden_dentry);
unlock_dir(hidden_parent_dentry);
if (err) {
dput(hidden_dentry);
diff --git a/fs/unionfs/dentry.c b/fs/unionfs/dentry.c
index 07c67da..463cf4c 100644
--- a/fs/unionfs/dentry.c
+++ b/fs/unionfs/dentry.c
@@ -81,7 +81,8 @@ static int __unionfs_d_revalidate_one(struct dentry *dentry,
struct dentry *hidden_dentry;
for (bindex = bstart; bindex <= bend; bindex++) {
hidden_dentry =
- unionfs_lower_dentry_idx(dentry,
bindex);
+ unionfs_lower_dentry_idx(dentry,
+ bindex);
dput(hidden_dentry);
}
}
@@ -106,10 +107,12 @@ static int __unionfs_d_revalidate_one(struct dentry
*dentry,
bend = ibend(dentry->d_inode);
if (bstart >= 0) {
struct inode *hidden_inode;
- for (bindex = bstart; bindex <= bend; bindex++)
{
+ for (bindex = bstart; bindex <= bend;
+ bindex++) {
hidden_inode =
-
unionfs_lower_inode_idx(dentry->d_inode,
- bindex);
+ unionfs_lower_inode_idx(
+ dentry->d_inode,
+ bindex);
iput(hidden_inode);
}
}
@@ -121,7 +124,8 @@ static int __unionfs_d_revalidate_one(struct dentry *dentry,
mutex_unlock(&dentry->d_inode->i_mutex);
}
- result = unionfs_lookup_backend(dentry, &lowernd,
interpose_flag);
+ result = unionfs_lookup_backend(dentry, &lowernd,
+ interpose_flag);
if (result) {
if (IS_ERR(result)) {
valid = 0;
@@ -152,7 +156,8 @@ static int __unionfs_d_revalidate_one(struct dentry *dentry,
if (!hidden_dentry || !hidden_dentry->d_op
|| !hidden_dentry->d_op->d_revalidate)
continue;
- if (!hidden_dentry->d_op->d_revalidate(hidden_dentry, &lowernd))
+ if (!hidden_dentry->d_op->d_revalidate(hidden_dentry,
+ &lowernd))
valid = 0;
}
@@ -237,7 +242,8 @@ int __unionfs_d_revalidate_chain(struct dentry *dentry,
struct nameidata *nd)
if (valid && chain_len > 0 &&
sbgen != dgen && chain[i]->d_inode &&
S_ISDIR(chain[i]->d_inode->i_mode)) {
- for (bindex = saved_bstart; bindex <= saved_bend;
bindex++)
+ for (bindex = saved_bstart; bindex <= saved_bend;
+ bindex++)
unionfs_mntput(chain[i], bindex);
}
unionfs_unlock_dentry(chain[i]);
diff --git a/fs/unionfs/dirhelper.c b/fs/unionfs/dirhelper.c
index e329d1d..f839e11 100644
--- a/fs/unionfs/dirhelper.c
+++ b/fs/unionfs/dirhelper.c
@@ -274,7 +274,8 @@ int check_empty(struct dentry *dentry, struct
unionfs_dir_state **namelist)
branchget(sb, bindex);
unionfs_read_unlock(sb);
hidden_file =
- dentry_open(hidden_dentry,
unionfs_lower_mnt_idx(dentry, bindex),
+ dentry_open(hidden_dentry,
+ unionfs_lower_mnt_idx(dentry, bindex),
O_RDONLY);
if (IS_ERR(hidden_file)) {
err = PTR_ERR(hidden_file);
diff --git a/fs/unionfs/inode.c b/fs/unionfs/inode.c
index 78c1e35..b0ef568 100644
--- a/fs/unionfs/inode.c
+++ b/fs/unionfs/inode.c
@@ -525,9 +525,11 @@ static int unionfs_readlink(struct dentry *dentry, char
__user * buf,
goto out;
}
- err = hidden_dentry->d_inode->i_op->readlink(hidden_dentry, buf,
bufsiz);
+ err = hidden_dentry->d_inode->i_op->readlink(hidden_dentry,
+ buf, bufsiz);
if (err > 0)
- fsstack_copy_attr_atime(dentry->d_inode,
hidden_dentry->d_inode);
+ fsstack_copy_attr_atime(dentry->d_inode,
+ hidden_dentry->d_inode);
out:
unionfs_unlock_dentry(dentry);
@@ -616,7 +618,8 @@ static int inode_permission(struct inode *inode, int mask,
perms = branchperms(nd->mnt->mnt_sb, bindex);
unionfs_read_unlock(nd->mnt->mnt_sb);
if (perms & MAY_NFSRO)
- retval = generic_permission(inode, submask,
NULL);
+ retval = generic_permission(inode, submask,
+ NULL);
}
} else
retval = generic_permission(inode, submask, NULL);
@@ -709,7 +712,8 @@ static int unionfs_setattr(struct dentry *dentry, struct
iattr *ia)
bend = dbend(dentry);
inode = dentry->d_inode;
- for (bindex = bstart; (bindex <= bend) || (bindex == bstart); bindex++)
{
+ for (bindex = bstart; (bindex <= bend) || (bindex == bstart);
+ bindex++) {
hidden_dentry = unionfs_lower_dentry_idx(dentry, bindex);
if (!hidden_dentry)
continue;
@@ -731,10 +735,14 @@ static int unionfs_setattr(struct dentry *dentry, struct
iattr *ia)
if (!err) {
copyup = 1;
- hidden_dentry =
unionfs_lower_dentry(dentry);
+ hidden_dentry =
+ unionfs_lower_dentry(dentry);
break;
}
- /* if error is in the leftmost branch, pass it
up */
+ /*
+ * if error is in the leftmost branch, pass
+ * it up.
+ */
if (i == 0)
goto out;
}
diff --git a/fs/unionfs/lookup.c b/fs/unionfs/lookup.c
index b16cf8d..9b67369 100644
--- a/fs/unionfs/lookup.c
+++ b/fs/unionfs/lookup.c
@@ -112,7 +112,8 @@ struct dentry *unionfs_lookup_backend(struct dentry
*dentry, struct nameidata *n
continue;
BUG_ON(hidden_dentry != NULL);
- hidden_dir_dentry = unionfs_lower_dentry_idx(parent_dentry,
bindex);
+ hidden_dir_dentry =
+ unionfs_lower_dentry_idx(parent_dentry, bindex);
/* if the parent hidden dentry does not exist skip this */
if (!(hidden_dir_dentry && hidden_dir_dentry->d_inode))
@@ -146,7 +147,8 @@ struct dentry *unionfs_lookup_backend(struct dentry
*dentry, struct nameidata *n
* to allow mountpoint crossing
*/
first_dentry = parent_dentry;
- first_hidden_mnt =
unionfs_mntget(parent_dentry, bindex);
+ first_hidden_mnt =
+ unionfs_mntget(parent_dentry, bindex);
first_dentry_offset = bindex;
} else
dput(hidden_dentry);
@@ -165,7 +167,8 @@ struct dentry *unionfs_lookup_backend(struct dentry
*dentry, struct nameidata *n
* mountpoint crossing
*/
unionfs_set_lower_mnt_idx(dentry, bindex,
- unionfs_mntget(parent_dentry,
bindex));
+ unionfs_mntget(parent_dentry,
+ bindex));
set_dbend(dentry, bindex);
/* update parent directory's atime with the bindex */
@@ -179,7 +182,8 @@ struct dentry *unionfs_lookup_backend(struct dentry
*dentry, struct nameidata *n
if (dentry_count == 1)
goto out_positive;
/* This can only happen with mixed D-*-F-* */
-
BUG_ON(!S_ISDIR(unionfs_lower_dentry(dentry)->d_inode->i_mode));
+ BUG_ON(!S_ISDIR(unionfs_lower_dentry(dentry)->
+ d_inode->i_mode));
continue;
}
}
@@ -348,9 +352,10 @@ int unionfs_partial_lookup(struct dentry *dentry)
static struct kmem_cache *unionfs_dentry_cachep;
int unionfs_init_dentry_cache(void)
{
- unionfs_dentry_cachep = kmem_cache_create("unionfs_dentry",
- sizeof(struct
unionfs_dentry_info), 0,
- SLAB_RECLAIM_ACCOUNT, NULL,
NULL);
+ unionfs_dentry_cachep =
+ kmem_cache_create("unionfs_dentry",
+ sizeof(struct unionfs_dentry_info),
+ 0, SLAB_RECLAIM_ACCOUNT, NULL, NULL);
return (unionfs_dentry_cachep ? 0 : -ENOMEM);
}
diff --git a/fs/unionfs/main.c b/fs/unionfs/main.c
index 5940c8b..f1060c5 100644
--- a/fs/unionfs/main.c
+++ b/fs/unionfs/main.c
@@ -286,15 +286,15 @@ static int parse_dirs_option(struct super_block *sb,
struct unionfs_dentry_info
branches++;
/* allocate space for underlying pointers to hidden dentry */
- UNIONFS_SB(sb)->data = kcalloc(branches,
- sizeof(struct unionfs_data), GFP_KERNEL);
+ UNIONFS_SB(sb)->data =
+ kcalloc(branches, sizeof(struct unionfs_data), GFP_KERNEL);
if (!UNIONFS_SB(sb)->data) {
err = -ENOMEM;
goto out;
}
- hidden_root_info->lower_paths = kcalloc(branches,
- sizeof(struct path),
GFP_KERNEL);
+ hidden_root_info->lower_paths =
+ kcalloc(branches, sizeof(struct path), GFP_KERNEL);
if (!hidden_root_info->lower_paths) {
err = -ENOMEM;
goto out;
@@ -324,7 +324,8 @@ static int parse_dirs_option(struct super_block *sb, struct
unionfs_dentry_info
err = path_lookup(name, LOOKUP_FOLLOW, &nd);
if (err) {
printk(KERN_WARNING "unionfs: error accessing "
- "hidden directory '%s' (error %d)\n", name, err);
+ "hidden directory '%s' (error %d)\n",
+ name, err);
goto out;
}
@@ -378,7 +379,7 @@ out:
for (i = 0; i < branches; i++)
if (hidden_root_info->lower_paths[i].dentry) {
dput(hidden_root_info->lower_paths[i].dentry);
- /* initializing: can't use unionfs_mntput here
*/
+ /* initialize: can't use unionfs_mntput here */
mntput(hidden_root_info->lower_paths[i].mnt);
}
@@ -656,7 +657,7 @@ static int unionfs_read_super(struct super_block *sb, void
*raw_data,
UNIONFS_SB(sb)->high_branch_id = high_bid;
odf->opaque_branch_id = branch_id(sb, 0);
- /* Unionfs: Max Bytes is the maximum bytes from highest priority branch
*/
+ /* max Bytes is the maximum bytes from highest priority branch */
unionfs_read_lock(sb);
sb->s_maxbytes = unionfs_lower_super_idx(sb, 0)->s_maxbytes;
unionfs_read_unlock(sb);
diff --git a/fs/unionfs/rdstate.c b/fs/unionfs/rdstate.c
index 3dc1dc2..e84161d 100644
--- a/fs/unionfs/rdstate.c
+++ b/fs/unionfs/rdstate.c
@@ -34,7 +34,8 @@ static struct kmem_cache *unionfs_filldir_cachep;
int unionfs_init_filldir_cache(void)
{
unionfs_filldir_cachep =
- kmem_cache_create("unionfs_filldir", sizeof(struct
filldir_node), 0,
+ kmem_cache_create("unionfs_filldir",
+ sizeof(struct filldir_node), 0,
SLAB_RECLAIM_ACCOUNT, NULL, NULL);
return (unionfs_filldir_cachep ? 0 : -ENOMEM);
@@ -74,7 +75,8 @@ static int guesstimate_hash_size(struct inode *inode)
if (hidden_inode->i_size == DENTPAGE)
hashsize += DENTPERONEPAGE;
else
- hashsize += (hidden_inode->i_size / DENTPAGE) *
DENTPERPAGE;
+ hashsize += (hidden_inode->i_size / DENTPAGE) *
+ DENTPERPAGE;
}
return hashsize;
@@ -82,7 +84,8 @@ static int guesstimate_hash_size(struct inode *inode)
int init_rdstate(struct file *file)
{
- BUG_ON(sizeof(loff_t) != (sizeof(unsigned int) + sizeof(unsigned int)));
+ BUG_ON(sizeof(loff_t) !=
+ (sizeof(unsigned int) + sizeof(unsigned int)));
BUG_ON(UNIONFS_F(file)->rdstate != NULL);
UNIONFS_F(file)->rdstate = alloc_rdstate(file->f_dentry->d_inode,
@@ -126,8 +129,8 @@ struct unionfs_dir_state *alloc_rdstate(struct inode
*inode, int bindex)
if (mallocsize > PAGE_SIZE)
mallocsize = PAGE_SIZE;
- hashsize = (mallocsize -
- sizeof(struct unionfs_dir_state)) / sizeof(struct
list_head);
+ hashsize = (mallocsize - sizeof(struct unionfs_dir_state)) /
+ sizeof(struct list_head);
rdstate = kmalloc(mallocsize, GFP_KERNEL);
if (!rdstate)
diff --git a/fs/unionfs/rename.c b/fs/unionfs/rename.c
index 950b557..b05f0bb 100644
--- a/fs/unionfs/rename.c
+++ b/fs/unionfs/rename.c
@@ -83,7 +83,8 @@ static int do_rename(struct inode *old_dir, struct dentry
*old_dentry,
if (!hidden_new_dentry) {
hidden_new_dentry =
- create_parents(new_dentry->d_parent->d_inode,
new_dentry, bindex);
+ create_parents(new_dentry->d_parent->d_inode,
+ new_dentry, bindex);
if (IS_ERR(hidden_new_dentry)) {
printk(KERN_DEBUG "unionfs: error creating directory "
"tree for rename, bindex = %d, err = %ld\n",
diff --git a/fs/unionfs/super.c b/fs/unionfs/super.c
index b817086..c250a22 100644
--- a/fs/unionfs/super.c
+++ b/fs/unionfs/super.c
@@ -258,7 +258,8 @@ static noinline int do_remount_del_option(char *optarg, int
cur_branches,
if (idx < cur_branches - 1) {
/* if idx==cur_branches-1, we delete last branch: easy */
memmove(&new_data[idx], &new_data[idx+1],
- (cur_branches - 1 - idx) * sizeof(struct unionfs_data));
+ (cur_branches - 1 - idx) *
+ sizeof(struct unionfs_data));
memmove(&new_lower_paths[idx], &new_lower_paths[idx+1],
(cur_branches - 1 - idx) * sizeof(struct path));
}
@@ -585,8 +586,8 @@ static int unionfs_remount_fs(struct super_block *sb, int
*flags,
goto out_release;
new_branches++;
if (new_branches > UNIONFS_MAX_BRANCHES) {
- printk("unionfs: command exceeds %d branches\n",
- UNIONFS_MAX_BRANCHES);
+ printk("unionfs: command exceeds "
+ "%d branches\n", UNIONFS_MAX_BRANCHES);
err = -E2BIG;
goto out_release;
}
@@ -960,8 +961,8 @@ static int unionfs_show_options(struct seq_file *m, struct
vfsmount *mnt)
seq_printf(m, ",dirs=");
for (bindex = bstart; bindex <= bend; bindex++) {
path = d_path(unionfs_lower_dentry_idx(sb->s_root, bindex),
- unionfs_lower_mnt_idx(sb->s_root, bindex),
tmp_page,
- PAGE_SIZE);
+ unionfs_lower_mnt_idx(sb->s_root, bindex),
+ tmp_page, PAGE_SIZE);
if (IS_ERR(path)) {
ret = PTR_ERR(path);
goto out;
diff --git a/fs/unionfs/union.h b/fs/unionfs/union.h
index 4fd11f0..4cd0961 100644
--- a/fs/unionfs/union.h
+++ b/fs/unionfs/union.h
@@ -205,10 +205,10 @@ struct filldir_node {
/* Directory hash table. */
struct unionfs_dir_state {
- unsigned int cookie; /* The cookie, which is based off of rdversion
*/
+ unsigned int cookie; /* the cookie, based off of rdversion */
unsigned int offset; /* The entry we have returned. */
int bindex;
- loff_t dirpos; /* The offset within the lower level directory.
*/
+ loff_t dirpos; /* offset within the lower level directory */
int size; /* How big is the hash table? */
int hashentries; /* How many entries have been inserted? */
unsigned long access;
@@ -295,7 +295,8 @@ extern int copyup_named_file(struct inode *dir, struct file
*file,
loff_t len);
/* copies a dentry from dbstart to newbindex branch */
extern int copyup_dentry(struct inode *dir, struct dentry *dentry, int bstart,
- int new_bindex, struct file **copyup_file, loff_t len);
+ int new_bindex, struct file **copyup_file,
+ loff_t len);
extern int unionfs_get_nlinks(struct inode *inode);
diff --git a/fs/unionfs/xattr.c b/fs/unionfs/xattr.c
index b8f8fe6..9d3073b 100644
--- a/fs/unionfs/xattr.c
+++ b/fs/unionfs/xattr.c
@@ -82,7 +82,8 @@ int unionfs_setxattr(struct dentry *dentry, const char *name,
unionfs_lock_dentry(dentry);
hidden_dentry = unionfs_lower_dentry(dentry);
- err = vfs_setxattr(hidden_dentry, (char*) name, (void*) value, size,
flags);
+ err = vfs_setxattr(hidden_dentry, (char*) name, (void*) value,
+ size, flags);
unionfs_unlock_dentry(dentry);
return err;
_______________________________________________
unionfs-cvs mailing list: http://unionfs.filesystems.org/
[email protected]
http://www.fsl.cs.sunysb.edu/mailman/listinfo/unionfs-cvs
