commit 610ed930a76d7d3cd149636653f7ce0dfa34bb18
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
53cafa8a6ddb3fc52ba722dbde181beb381bcd1e..1cb03f1383977093ff7500570b081898b025f7a7
100644
--- a/fs/unionfs/commonfops.c
+++ b/fs/unionfs/commonfops.c
@@ -195,15 +195,15 @@ static void cleanup_file(struct file *fi
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 *f
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
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
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
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
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 *inod
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 *ino
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 *ino
/* 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 *ino
* 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, st
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, un
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_
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
1225cddac02908e4b73e8b7be7a39c61f36a0410..450b1048f73ef54ab042fd14f05a0f6e1768a094
100644
--- a/fs/unionfs/copyup.c
+++ b/fs/unionfs/copyup.c
@@ -362,7 +362,8 @@ static int copyup_named_dentry(struct in
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 in
/* 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
@@ -670,7 +673,8 @@ static struct dentry *create_parents_nam
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);
/* store the child dentry */
path[count++] = child_dentry;
@@ -702,7 +706,8 @@ static struct dentry *create_parents_nam
*/
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 */
@@ -719,7 +724,8 @@ static struct dentry *create_parents_nam
} 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,
@@ -727,9 +733,13 @@ static struct dentry *create_parents_nam
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;
@@ -755,7 +765,8 @@ static struct dentry *create_parents_nam
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
07c67da9e086d24a0613fc5970dd7282935c3572..463cf4cd3d9c484b6711817055518cc578768554
100644
--- a/fs/unionfs/dentry.c
+++ b/fs/unionfs/dentry.c
@@ -81,7 +81,8 @@ static int __unionfs_d_revalidate_one(st
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(st
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(st
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(st
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
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
d3daa6e7daddc477c5b367d32eb49783f8376277..480a8b0d98cf61b91bcaac1b84084de6583348d5
100644
--- a/fs/unionfs/dirhelper.c
+++ b/fs/unionfs/dirhelper.c
@@ -249,7 +249,8 @@ int check_empty(struct dentry *dentry, s
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
ffe6b1f999cffcece8132bca3901343dfdb0be90..31131af34d10d5c40fc7b995de47e2e86ef13c4f
100644
--- a/fs/unionfs/inode.c
+++ b/fs/unionfs/inode.c
@@ -526,9 +526,11 @@ static int unionfs_readlink(struct dentr
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);
@@ -617,7 +619,8 @@ static int inode_permission(struct inode
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);
@@ -710,7 +713,8 @@ static int unionfs_setattr(struct dentry
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;
@@ -732,10 +736,14 @@ static int unionfs_setattr(struct dentry
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
c23e3d88d437d173f9c527ee8510e3684f989fda..bf1723591123339e4df6f9a487b2b662086b833c
100644
--- a/fs/unionfs/lookup.c
+++ b/fs/unionfs/lookup.c
@@ -112,7 +112,8 @@ struct dentry *unionfs_lookup_backend(st
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(st
* 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(st
* 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(st
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
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
5940c8b0455dd37f3cc4152825f8968b15c35104..f1060c53312eb2dee82162283bd2ad1fc3b51465
100644
--- a/fs/unionfs/main.c
+++ b/fs/unionfs/main.c
@@ -286,15 +286,15 @@ static int parse_dirs_option(struct supe
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 supe
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 sup
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
3dc1dc2eab9348103651a18a036c3a2b8c6810f6..e84161d8e00a68bd3449d53ccadd66b2cac5e818
100644
--- a/fs/unionfs/rdstate.c
+++ b/fs/unionfs/rdstate.c
@@ -34,7 +34,8 @@ static struct kmem_cache *unionfs_filldi
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
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
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(
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
950b557351ccc655bf271e41d76e0871c267c75c..b05f0bb322cd694654f97e463313d9e6b84021cf
100644
--- a/fs/unionfs/rename.c
+++ b/fs/unionfs/rename.c
@@ -83,7 +83,8 @@ static int do_rename(struct inode *old_d
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
b56b5360ef20a72e91a2552bfe6105ee57a9def5..bd91fcb104898aea8a27179cc0e11cb7de64c116
100644
--- a/fs/unionfs/super.c
+++ b/fs/unionfs/super.c
@@ -258,7 +258,8 @@ static noinline int do_remount_del_optio
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));
}
@@ -584,8 +585,8 @@ static int unionfs_remount_fs(struct sup
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 s
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
7768808c43f3b702e695971120f6988bf1578295..cfb504e4616d37346fe0a4a7e9d8dfec3c2cc76a
100644
--- a/fs/unionfs/union.h
+++ b/fs/unionfs/union.h
@@ -194,10 +194,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;
@@ -284,7 +284,8 @@ extern int copyup_named_file(struct inod
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
b8f8fe6aa0a6009993d2231016f6d8e25aa957b1..9d3073bf4ee0da7c144d62611bb42852addf178c
100644
--- a/fs/unionfs/xattr.c
+++ b/fs/unionfs/xattr.c
@@ -82,7 +82,8 @@ int unionfs_setxattr(struct dentry *dent
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
