commit 307c3c93e5c7aa123b9c74f5c15da8e202eac18a
Author: Erez_Zadok <[EMAIL PROTECTED]>
Date: Thu May 31 23:34:56 2007 -0400
reformat all lines longer than 80 characters
Signed-off-by: Erez Zadok <[EMAIL PROTECTED]>
diff --git a/fs/unionfs/commonfops.c b/fs/unionfs/commonfops.c
index 1644de5..cf7e8cf 100644
--- a/fs/unionfs/commonfops.c
+++ b/fs/unionfs/commonfops.c
@@ -495,7 +495,8 @@ static int __open_dir(struct inode *inode, struct file
*file)
unionfs_set_lower_file_idx(file, bindex, hidden_file);
- if (timespec_compare(newest, &hidden_dentry->d_inode->i_mtime)
< 0)
+ if (timespec_compare(newest, &hidden_dentry->d_inode->i_mtime)
+ < 0)
newest = &hidden_dentry->d_inode->i_mtime;
/* The branchget goes after the open, because otherwise
diff --git a/fs/unionfs/config.c b/fs/unionfs/config.c
index 63121ac..aaa48ff 100644
--- a/fs/unionfs/config.c
+++ b/fs/unionfs/config.c
@@ -127,16 +127,16 @@ static ssize_t unionfs_write_num(struct
unionfs_config_attr *attr,
case DEPEND_MAX:
if (tmp >= attr->depended->val) {
- printk("unionfs: the value must be lower than the value
of %s\n",
- attr->depended->name);
+ printk("unionfs: the value must be lower than the "
+ "value of %s\n", attr->depended->name);
return -ERANGE;
}
break;
case DEPEND_MIN:
if (tmp <= attr->depended->val) {
- printk("unionfs: the value must be higher than the
value of %s\n",
- attr->depended->name);
+ printk("unionfs: the value must be higher than the "
+ "value of %s\n", attr->depended->name);
return -ERANGE;
}
break;
diff --git a/fs/unionfs/copyup.c b/fs/unionfs/copyup.c
index d1cd68c..e1a00eb 100644
--- a/fs/unionfs/copyup.c
+++ b/fs/unionfs/copyup.c
@@ -856,7 +856,8 @@ void unionfs_purge_extras(struct dentry *dentry)
dput(unionfs_lower_dentry_idx(dentry, bindex));
unionfs_set_lower_dentry_idx(dentry, bindex, NULL);
iput(unionfs_lower_inode_idx(dentry->d_inode, bindex));
- unionfs_set_lower_inode_idx(dentry->d_inode, bindex,
NULL);
+ unionfs_set_lower_inode_idx(dentry->d_inode, bindex,
+ NULL);
}
}
bindex = dbstart(dentry);
diff --git a/fs/unionfs/debug.c b/fs/unionfs/debug.c
index b99bc46..2bfbd80 100644
--- a/fs/unionfs/debug.c
+++ b/fs/unionfs/debug.c
@@ -359,7 +359,8 @@ void __unionfs_check_file(const struct file *file,
if (lower_file) {
if (bindex < fstart || bindex > fend) {
PRINT_CALLER();
- printk(" CF5: file/lower=%p:%p bindex=%d
fstart/end=%d:%d\n",
+ printk(" CF5: file/lower=%p:%p bindex=%d "
+ "fstart/end=%d:%d\n",
file, lower_file, bindex, fstart, fend);
}
} else { /* lower_file == NULL */
diff --git a/fs/unionfs/dirfops.c b/fs/unionfs/dirfops.c
index 3df2c27..b384de2 100644
--- a/fs/unionfs/dirfops.c
+++ b/fs/unionfs/dirfops.c
@@ -50,7 +50,10 @@ static int unionfs_readdir(struct file *file, void *dirent,
filldir_t filldir)
/* check if cached dir does not exist */
if (!odf_cache->d_inode || !odf_cache->d_inode->i_size) {
- /* odf cache dir calls partial lookup which expects a locked
dentry */
+ /*
+ * odf cache dir calls partial lookup which expects a locked
+ * dentry
+ */
unionfs_lock_dentry(file->f_dentry);
err = odf_cache_dir(file->f_dentry, odf_cache,
&file->f_dentry->d_inode->i_mtime);
@@ -90,14 +93,16 @@ static int unionfs_readdir(struct file *file, void *dirent,
filldir_t filldir)
pos = odf_file->f_pos;
/* read the next dirent */
- err = odf_read_dirent(odf_file, &name, &namelen, &ino, &d_type);
+ err = odf_read_dirent(odf_file, &name, &namelen, &ino,
+ &d_type);
if (err)
goto out;
/* filldir */
overflow = filldir(dirent, name, namelen, pos, ino, d_type);
+ /* so the caller can re-read this dirent */
if (overflow)
- odf_file->f_pos = pos; /* so the caller can re-read
this dirent*/
+ odf_file->f_pos = pos;
}
/* Copy the atime. */
diff --git a/fs/unionfs/dirhelper.c b/fs/unionfs/dirhelper.c
index e0690b5..6f34d11 100644
--- a/fs/unionfs/dirhelper.c
+++ b/fs/unionfs/dirhelper.c
@@ -395,7 +395,8 @@ retry:
mntget(unionfs_lower_mnt_idx(d_upper, bindex));
branchget(sb, bindex);
hidden_file =
- dentry_open(hidden_dentry,
unionfs_lower_mnt_idx(d_upper, bindex),
+ dentry_open(hidden_dentry,
+ unionfs_lower_mnt_idx(d_upper, bindex),
O_RDONLY);
if (IS_ERR(hidden_file)) {
err = PTR_ERR(hidden_file);
@@ -523,7 +524,8 @@ int unionfs_force_rm(struct dentry *dentry, struct dentry
**hidden_dentry,
branchput(sb, bindex);
if (err == 0)
- err = vfs_rmdir((*hidden_dentry)->d_parent->d_inode,
*hidden_dentry);
+ err = vfs_rmdir((*hidden_dentry)->d_parent->d_inode,
+ *hidden_dentry);
else if (err == -ENOTEMPTY)
err = unionfs_silly_rename(dentry, *hidden_dentry);
@@ -647,7 +649,8 @@ cleanup_loop:
}
buf->blocks += blocks + 1;
buf->inodes++;
- err = vfs_rmdir(dentry->d_parent->d_inode,
dentry);
+ err = vfs_rmdir(dentry->d_parent->d_inode,
+ dentry);
BUG_ON(err == -ENOTEMPTY);
}
dput(dentry);
@@ -663,7 +666,8 @@ cleanup_loop:
if (err < 0)
goto out;
- if (!success && ((mode & ODF_CLEAN_DEFAULT) || (mode &
ODF_CLEAN_FULL))) {
+ if (!success && ((mode & ODF_CLEAN_DEFAULT) ||
+ (mode & ODF_CLEAN_FULL))) {
BUG_ON(stack.n);
/* if we did not succeed, clean up odf/reclaim as well */
diff --git a/fs/unionfs/export.c b/fs/unionfs/export.c
index 2b5ea27..97e1e87 100644
--- a/fs/unionfs/export.c
+++ b/fs/unionfs/export.c
@@ -70,8 +70,10 @@ static struct dentry *__get_parent(struct super_block *sb,
}
} while (d != odf_root);
- /* now we start from the root and lookup in the union using the names
of the
- * odf_dentries we have on our dentry_stack until we get to our target
+ /*
+ * now we start from the root and lookup in the union using the
+ * names of the odf_dentries we have on our dentry_stack until we
+ * get to our target
*/
parent = sb->s_root;
dget(parent);
@@ -80,14 +82,17 @@ static struct dentry *__get_parent(struct super_block *sb,
memset(name, 0, NAME_MAX + 1);
if (is_anon(d)) {
- /* If this dentry is disconnected, then it is
anonymous, so we
- * have to get its name using get_name. However since
it is
- * disconnected it doesn't know its parent. Thankfully
since
- * we already looked up its parent in this loop we have
its
- * parent in the union dentry's parent odf_info struct
+ /*
+ * If this dentry is disconnected, then it is
+ * anonymous, so we have to get its name using
+ * get_name. However since it is disconnected it
+ * doesn't know its parent. Thankfully since we
+ * already looked up its parent in this loop we have
+ * its parent in the union dentry's parent odf_info
+ * struct
*/
- /* our odf root can never be disconnected*/
+ /* our odf root can never be disconnected */
BUG_ON(d == odf_root);
if (odf_root->d_sb->s_export_op->get_name)
res = odf_root->d_sb->s_export_op->get_name(
@@ -211,7 +216,8 @@ static int unionfs_get_name(struct dentry *dentry, char
*name,
/* reconstruct the cached dir if necessary */
if (!odf_cache->d_inode || !odf_cache->d_inode->i_size) {
unionfs_lock_dentry(dentry);
- err = odf_cache_dir(dentry, odf_cache,
&dentry->d_inode->i_mtime);
+ err = odf_cache_dir(dentry, odf_cache,
+ &dentry->d_inode->i_mtime);
unionfs_unlock_dentry(dentry);
if (err)
goto out;
@@ -219,7 +225,8 @@ static int unionfs_get_name(struct dentry *dentry, char
*name,
dget(odf_cache);
mntget(UNIONFS_SB(dentry->d_sb)->odf.mnt);
- file = dentry_open(odf_cache, UNIONFS_SB(dentry->d_sb)->odf.mnt,
O_RDONLY);
+ file = dentry_open(odf_cache, UNIONFS_SB(dentry->d_sb)->odf.mnt,
+ O_RDONLY);
if (IS_ERR(file)){
err = PTR_ERR(file);
mntput(UNIONFS_SB(dentry->d_sb)->odf.mnt);
@@ -231,7 +238,8 @@ static int unionfs_get_name(struct dentry *dentry, char
*name,
/* search for the inode in the dir */
file->f_pos = 0;
while (file->f_pos < file->f_dentry->d_inode->i_size) {
- err = odf_read_dirent(file, &tmp_name, &namelen, &ino, &d_type);
+ err = odf_read_dirent(file, &tmp_name, &namelen, &ino,
+ &d_type);
if (err)
break;
if (ino == child->d_inode->i_ino) {
diff --git a/fs/unionfs/inode.c b/fs/unionfs/inode.c
index 0896626..49c3e0e 100644
--- a/fs/unionfs/inode.c
+++ b/fs/unionfs/inode.c
@@ -99,8 +99,12 @@ static int unionfs_create(struct inode *parent, struct
dentry *dentry,
if (!err)
err = odf_purge_dir_cache(dentry->d_parent);
if (!err)
- /* only INTERPOSE_LOOKUP can return a value other than
0 or err */
- err = PTR_ERR(unionfs_interpose(dentry, parent->i_sb,
0));
+ /*
+ * only INTERPOSE_LOOKUP can return a value other
+ * than 0 or err
+ */
+ err = PTR_ERR(unionfs_interpose(dentry, parent->i_sb,
+ 0));
if (!err) {
fsstack_copy_attr_times(parent,
hidden_parent_dentry->d_inode);
@@ -220,8 +224,10 @@ static int unionfs_link(struct dentry *old_dentry, struct
inode *dir,
hidden_new_dentry = unionfs_lower_dentry(new_dentry);
hidden_old_dentry = unionfs_lower_dentry(old_dentry);
- if (hidden_new_dentry->d_inode && UNIONFS_D(new_dentry)->odf.whiteout) {
- err = unionfs_force_rm(new_dentry, &hidden_new_dentry,
dbstart(old_dentry));
+ if (hidden_new_dentry->d_inode &&
+ UNIONFS_D(new_dentry)->odf.whiteout) {
+ err = unionfs_force_rm(new_dentry, &hidden_new_dentry,
+ dbstart(old_dentry));
if (err)
goto out;
}
@@ -246,7 +252,8 @@ docopyup:
if (!err) {
hidden_new_dentry =
create_parents(dir, new_dentry,
- new_dentry->d_name.name, bindex);
+ new_dentry->d_name.name,
+ bindex);
hidden_old_dentry = unionfs_lower_dentry(old_dentry);
if (hidden_new_dentry->d_inode &&
UNIONFS_D(new_dentry)->odf.whiteout) {
@@ -366,7 +373,10 @@ static int unionfs_symlink(struct inode *dir, struct
dentry *dentry,
err = odf_lookup(dentry->d_parent, dentry,
ODF_LOOKUP_FILE|ODF_LOOKUP_RMV_WH);
if (!err)
- /* only INTERPOSE_LOOKUP can return a value other than
0 or err */
+ /*
+ * only INTERPOSE_LOOKUP can return a value other
+ * than 0 or err
+ */
err = PTR_ERR(unionfs_interpose(dentry, dir->i_sb, 0));
if (!err)
err = odf_purge_dir_cache(dentry->d_parent);
@@ -557,7 +567,10 @@ static int unionfs_mknod(struct inode *dir, struct dentry
*dentry, int mode,
if (!err)
err = odf_purge_dir_cache(dentry->d_parent);
if (!err)
- /* only INTERPOSE_LOOKUP can return a value other than 0 or err
*/
+ /*
+ * only INTERPOSE_LOOKUP can return a value other than 0 or
+ * err
+ */
err = PTR_ERR(unionfs_interpose(dentry, dir->i_sb, 0));
if (!err) {
fsstack_copy_attr_times(dir,
diff --git a/fs/unionfs/lookup.c b/fs/unionfs/lookup.c
index 0e69ade..0e50f49 100644
--- a/fs/unionfs/lookup.c
+++ b/fs/unionfs/lookup.c
@@ -102,7 +102,8 @@ struct dentry *unionfs_lookup_backend(struct dentry *dentry,
goto out_negative;
}
/* if opaque dir lookup only until opaque branch */
- else if
(S_ISDIR(UNIONFS_D(dentry)->odf.dentry->d_inode->i_mode)) {
+ else if (S_ISDIR(UNIONFS_D(dentry)->odf.dentry->
+ d_inode->i_mode)) {
bopaque = odf_get_opaque(dentry);
if (bopaque != -1)
bend = bopaque;
@@ -229,10 +230,12 @@ out_negative:
nd->dentry = dentry;
/* FIXME: fix following line for mount point crossing */
nd->mnt = unionfs_lower_mnt_idx(parent_dentry, bindex);
- hidden_dir_dentry = unionfs_lower_dentry_idx(parent_dentry,
bindex);
+ hidden_dir_dentry = unionfs_lower_dentry_idx(parent_dentry,
+ bindex);
if (hidden_dir_dentry && hidden_dir_dentry->d_inode)
- first_hidden_dentry = lookup_one_len_nd(name,
-
hidden_dir_dentry, namelen, nd);
+ first_hidden_dentry =
+ lookup_one_len_nd(name, hidden_dir_dentry,
+ namelen, nd);
else
first_hidden_dentry = NULL;
first_dentry_offset = bindex;
@@ -246,7 +249,8 @@ out_negative:
* mount-point crossing
*/
first_dentry = dentry;
- first_hidden_mnt = unionfs_mntget(dentry->d_sb->s_root, bindex);
+ first_hidden_mnt =
+ unionfs_mntget(dentry->d_sb->s_root, bindex);
}
unionfs_set_lower_dentry_idx(dentry, first_dentry_offset,
first_hidden_dentry);
@@ -264,7 +268,8 @@ out_negative:
/* This part of the code is for positive dentries. */
out_positive:
BUG_ON(dentry_count <= 0);
- BUG_ON(UNIONFS_D(dentry)->odf.dentry &&
UNIONFS_D(dentry)->odf.whiteout);
+ BUG_ON(UNIONFS_D(dentry)->odf.dentry &&
+ UNIONFS_D(dentry)->odf.whiteout);
/*
* If we're holding onto the first negative dentry & corresponding
@@ -297,7 +302,10 @@ out_positive:
bend = dbend(dentry);
}
- /* interpose can return a dentry if d_splice returned a different
dentry */
+ /*
+ * interpose can return a dentry if d_splice returned a different
+ * dentry
+ */
d_interposed = unionfs_interpose(dentry, dentry->d_sb, lookupmode);
if (IS_ERR(d_interposed))
err = PTR_ERR(d_interposed);
@@ -308,7 +316,8 @@ out_positive:
goto out_drop;
/* check for whiteout */
- if (UNIONFS_D(dentry)->odf.dentry && (UNIONFS_D(dentry)->odf.whiteout))
{
+ if (UNIONFS_D(dentry)->odf.dentry &&
+ (UNIONFS_D(dentry)->odf.whiteout)) {
err = -ENOENT;
goto out_drop;
}
diff --git a/fs/unionfs/main.c b/fs/unionfs/main.c
index 9da54ef..cb49008 100644
--- a/fs/unionfs/main.c
+++ b/fs/unionfs/main.c
@@ -48,7 +48,8 @@ struct dentry *unionfs_interpose(struct dentry *dentry,
struct super_block *sb,
if (unionfs_lower_dentry_idx(dentry, bindex) &&
unionfs_lower_dentry_idx(dentry, bindex)->d_inode) {
is_negative_dentry = 0;
- if (S_ISDIR(unionfs_lower_dentry_idx(dentry,
bindex)->d_inode->i_mode))
+ if (S_ISDIR(unionfs_lower_dentry_idx(dentry, bindex)->
+ d_inode->i_mode))
odf_flag = ODF_LOOKUP_DIR;
break;
}
@@ -84,8 +85,8 @@ struct dentry *unionfs_interpose(struct dentry *dentry,
struct super_block *sb,
if (!UNIONFS_D(dentry)->odf.dentry)
err = odf_lookup(dentry->d_parent, dentry, odf_flag);
if (err){
- printk("unionfs_interpose: odf failed to create dentry:
%s, %d\n",
- dentry->d_name.name, err);
+ printk("unionfs_interpose: odf failed to create "
+ "dentry: %s, %d\n", dentry->d_name.name, err);
goto out;
}
/* check whiteouts and opaqueness */
@@ -625,8 +626,9 @@ static int unionfs_read_super(struct super_block *sb, void
*raw_data,
goto out_free;
odf = &UNIONFS_SB(sb)->odf;
- /* if this is an old odf reconstruct the dirs part of the mount time
options
- * from the odf data on disk and discard the old options
+ /*
+ * if this is an old odf reconstruct the dirs part of the mount time
+ * options from the odf data on disk and discard the old options
*/
if (!odf_is_new(odf)) {
odf_options = odf_read_sb_data(odf, &bid);
@@ -660,13 +662,15 @@ static int unionfs_read_super(struct super_block *sb,
void *raw_data,
/* generate new uuids */
err = odf_update_uuids(odf, NULL, 0,
hidden_root_info->lower_paths,
- hidden_root_info->bend -
hidden_root_info->bstart + 1);
+ hidden_root_info->bend -
+ hidden_root_info->bstart + 1);
if (err)
goto out_free_odf;
err = odf_write_sb_data(odf,UNIONFS_SB(sb)->data,
hidden_root_info->lower_paths,
- hidden_root_info->bend -
hidden_root_info->bstart + 1);
+ hidden_root_info->bend -
+ hidden_root_info->bstart + 1);
if (err)
goto out_free_odf;
}
@@ -686,8 +690,10 @@ static int unionfs_read_super(struct super_block *sb, void
*raw_data,
unionfs_write_unlock(sb);
if (bid) {
- /* we need to update the branch ids to whatever was
stored in
- * the odf and set high_branch_id to the greatest
+ /*
+ * we need to update the branch ids to whatever was
+ * stored in the odf and set high_branch_id to the
+ * greatest
*/
set_branch_id(sb, bindex, bid[bindex]);
if (bid[bindex] > high_bid)
@@ -747,7 +753,8 @@ static int unionfs_read_super(struct super_block *sb, void
*raw_data,
if (!err) {
/* its now ok to start the cleanup thread */
run_sioa(odf->cleanup, __odf_cleanup,
-
msecs_to_jiffies(odf->cleanup->cleanup.attr->timeout->val));
+ msecs_to_jiffies(odf->cleanup->cleanup.attr->timeout->
+ val));
goto out;
}
/* else fall through */
diff --git a/fs/unionfs/mmap.c b/fs/unionfs/mmap.c
index 1c90f15..596fc01 100644
--- a/fs/unionfs/mmap.c
+++ b/fs/unionfs/mmap.c
@@ -94,7 +94,8 @@ int unionfs_writepage(struct page *page, struct
writeback_control *wbc)
*/
lower_inode->i_mtime = lower_inode->i_ctime = CURRENT_TIME;
- page_cache_release(lower_page); /* b/c grab_cache_page increased refcnt
*/
+ /* b/c grab_cache_page increased refcnt */
+ page_cache_release(lower_page);
if (err)
ClearPageUptodate(page);
@@ -335,7 +336,8 @@ void unionfs_sync_page(struct page *page)
mapping->a_ops->sync_page(lower_page);
unlock_page(lower_page); /* b/c grab_cache_page locked it */
- page_cache_release(lower_page); /* b/c grab_cache_page increased refcnt
*/
+ /* b/c grab_cache_page increased refcnt */
+ page_cache_release(lower_page);
out:
return;
diff --git a/fs/unionfs/odf.c b/fs/unionfs/odf.c
index a8fe3e4..5355452 100644
--- a/fs/unionfs/odf.c
+++ b/fs/unionfs/odf.c
@@ -185,7 +185,8 @@ int odf_read_super(struct super_block *sb, char *data)
goto out_free;
}
if (!osi->whiteout->d_inode) {
- printk(KERN_ERR "unionfs: Whiteout file in odf does not
exist\n");
+ printk(KERN_ERR "unionfs: Whiteout file in odf does not "
+ "exist\n");
err = -EINVAL;
goto out_free;
}
@@ -314,9 +315,8 @@ int odf_parse_options(const char *options, char **odf_path)
if (!strcmp("odf_keepcache", optname)) {
if (optarg) {
- printk(KERN_WARNING
- "unionfs: %s does not take an
argument.\n",
- optname);
+ printk(KERN_WARNING "unionfs: %s does not take"
+ "an argument.\n", optname);
err = -EINVAL;
goto out_error;
}
@@ -406,7 +406,8 @@ int odf_reclaim(struct dentry *dentry, int sr)
vfs_unlink(old_dir, odf_dentry);
else {
lock_rename(old_dentry->d_parent, new_dentry->d_parent);
- err = vfs_rename(old_dir, old_dentry, new_dir->d_inode,
new_dentry);
+ err = vfs_rename(old_dir, old_dentry, new_dir->d_inode,
+ new_dentry);
unlock_rename(old_dentry->d_parent, new_dentry->d_parent);
}
dput(new_dentry);
@@ -591,7 +592,8 @@ struct dentry *__link_add_dirent(struct file *link_file,
struct dentry *dentry)
link_file->f_pos = 0;
le32 = 0;
err = link_file->f_op->write(link_file, (char*)&le32,
- sizeof(__le32), &link_file->f_pos);
+ sizeof(__le32),
+ &link_file->f_pos);
if (err != sizeof(__le32)){
err = -EIO;
goto out;
@@ -599,7 +601,8 @@ struct dentry *__link_add_dirent(struct file *link_file,
struct dentry *dentry)
le64 = 0;
err = link_file->f_op->write(link_file, (char*)&le64,
- sizeof(__le64), &link_file->f_pos);
+ sizeof(__le64),
+ &link_file->f_pos);
if (err != sizeof(__le64)){
err = -EIO;
goto out;
@@ -613,7 +616,8 @@ struct dentry *__link_add_dirent(struct file *link_file,
struct dentry *dentry)
while (link_file->f_pos < size) {
err = link_file->f_op->read(link_file, (char*)&le32,
- sizeof(__le32),
&link_file->f_pos);
+ sizeof(__le32),
+ &link_file->f_pos);
if (err != sizeof(__le32)){
err = -EIO;
goto out;
@@ -634,7 +638,8 @@ struct dentry *__link_add_dirent(struct file *link_file,
struct dentry *dentry)
}
err = link_file->f_op->read(link_file, (char*)&le64,
- sizeof(__le64),
&link_file->f_pos);
+ sizeof(__le64),
+ &link_file->f_pos);
if (err != sizeof(__le64)){
err = -EIO;
goto out;
@@ -719,7 +724,8 @@ int odf_copyup_link(struct super_block *sb, struct dentry
*old_dentry,
*(unsigned int *) uuid + 4,
*(unsigned int *) uuid + 8,
*(unsigned int *) uuid + 12);
- links = odf_ic_dentry(osi, old_dentry->d_inode->i_ino, name,
strlen(name));
+ links = odf_ic_dentry(osi, old_dentry->d_inode->i_ino, name,
+ strlen(name));
if (IS_ERR(links)) {
err = PTR_ERR(links);
links = NULL;
@@ -850,7 +856,8 @@ skip:
link_file->f_pos = 0;
le32 = 0;
err = link_file->f_op->write(link_file, (char*)&le32,
- sizeof(__le32), &link_file->f_pos);
+ sizeof(__le32),
+ &link_file->f_pos);
if (err != sizeof(__le32)){
set_fs(oldfs);
err = -EIO;
@@ -859,7 +866,8 @@ skip:
le64 = 0;
err = link_file->f_op->write(link_file, (char*)&le64,
- sizeof(__le64), &link_file->f_pos);
+ sizeof(__le64),
+ &link_file->f_pos);
if (err != sizeof(__le64)){
set_fs(oldfs);
err = -EIO;
@@ -880,7 +888,8 @@ skip:
BUG_ON(unionfs_lower_dentry_idx(dentry, branch_dst));
verify_locked(dentry->d_parent);
- unionfs_unlock_dentry(dentry->d_parent); /*XXX: this is VERY
nasty */
+ /* XXX: this is VERY nasty (FIXME: why?) */
+ unionfs_unlock_dentry(dentry->d_parent);
lower_dentry = create_parents(dentry->d_parent->d_inode,
dentry, dentry->d_name.name,
branch_dst);
@@ -981,7 +990,8 @@ int odf_lookup(struct dentry *parent, struct dentry
*dentry, int flags)
/* this might be called before interpose */
if (dbstart(dentry) == dbend(dentry) && dbstart(dentry) == 0) {
for (bstart = 0; bstart <= dbend(dentry); bstart++) {
- lower_dentry = unionfs_lower_dentry_idx(dentry, bstart);
+ lower_dentry =
+ unionfs_lower_dentry_idx(dentry, bstart);
if (lower_dentry)
break;
}
@@ -1027,10 +1037,14 @@ int odf_lookup(struct dentry *parent, struct dentry
*dentry, int flags)
/* check if link was copied up and act appropriately */
- /* XXX: Leave this out until Jeff's modifications to path_lookup
- __check_link_copyup(link_file, dentry, bstart);
- __link_add_dirent(link_file, dentry);
- */
+#if 0
+ /*
+ * XXX: Leave this out until Jeff's modifications to
+ * path_lookup (FIXME)
+ */
+ __check_link_copyup(link_file, dentry, bstart);
+ __link_add_dirent(link_file, dentry);
+#endif
}
ret = __odf_lookup(parent, dentry, dentry->d_name.name,
@@ -1083,8 +1097,8 @@ struct dentry *odf_lookup_name(struct dentry *parent,
const char *name,
* links. If this is not NULL, lookup will make sure the looked
* up dentry is linked to the given link in the odf
*
- * XXX: whether link should be an odf or unionfs dentry should be
- * decided when hardlinks are actually implemented
+ * XXX: whether link should be an odf or unionfs dentry should
+ * be decided when hardlinks are actually implemented
*/
struct dentry *__odf_lookup(struct dentry *parent,
struct dentry *target,
@@ -1141,7 +1155,8 @@ struct dentry *__odf_lookup(struct dentry *parent,
/* FIXME need to check hardlinks before create */
if (link && (flags & ODF_LOOKUP_FILE)) {
/* link to the given dentry */
- vfs_link(link, odf_dentry->d_parent->d_inode,
odf_dentry);
+ vfs_link(link, odf_dentry->d_parent->d_inode,
+ odf_dentry);
}
else if (flags & ODF_LOOKUP_FILE) {
current->fsuid = 0;
@@ -1169,21 +1184,24 @@ struct dentry *__odf_lookup(struct dentry *parent,
if (err) {
if (err == -ENOSPC && !cleaned) {
- /* let the cleanup thread do its work and retry
once */
+ /*
+ * let the cleanup thread do its work and
+ * retry once
+ */
cleaned = 1;
wake_up_and_wait_sioa(osi->cleanup);
goto retry;
}
- printk(KERN_WARNING
- "odf_lookup: could not create odf dentry %s,
%d\n",
- name, err);
+ printk(KERN_WARNING "odf_lookup: could not create odf"
+ " dentry %s, %d\n", name, err);
dput(odf_dentry);
odf_dentry = ERR_PTR(err);
goto out;
}
/* set opaqueness to 0 or -1 */
- opaque = (flags & ODF_LOOKUP_OPQ)?branch_id(parent->d_sb, 0):-1;
+ opaque = (flags & ODF_LOOKUP_OPQ) ?
+ branch_id(parent->d_sb, 0) : -1;
odf_set_opaque(odf_dentry, opaque);
}
else {
@@ -1278,14 +1296,16 @@ struct dentry *odf_ic_dentry(struct odf_sb_info *osi,
u64 ino, char *name,
for (i = 1; i < 4; i++) {
memset(tmp_name,0,6);
sprintf(tmp_name, "%x", breakdown[i]);
- dirs[i] = lookup_one_len(tmp_name, dirs[i-1], strlen(tmp_name));
+ dirs[i] = lookup_one_len(tmp_name, dirs[i-1],
+ strlen(tmp_name));
if (IS_ERR(dirs[i])) {
err = PTR_ERR(dirs[i]);
dirs[i] = NULL;
goto out;
}
if (!dirs[i]->d_inode) {
- err = vfs_mkdir(dirs[i-1]->d_inode, dirs[i], S_IRWXUGO);
+ err = vfs_mkdir(dirs[i-1]->d_inode, dirs[i],
+ S_IRWXUGO);
if (err)
goto out;
}
@@ -1555,7 +1575,8 @@ int odf_remove(struct dentry *dentry, int flags)
else {
if (!dentry->d_inode ||
atomic_read(&dentry->d_inode->i_count) <= 1)
- err = vfs_unlink(odf_dentry->d_parent->d_inode,
odf_dentry);
+ err = vfs_unlink(odf_dentry->d_parent->d_inode,
+ odf_dentry);
else
/* silly rename open files, so their ino does
* not get recycled while still open
@@ -1668,7 +1689,11 @@ int odf_update_uuids(struct odf_sb_info *odf, struct
path *old_paths,
memcpy(new_uuids + bindex * UUID_LEN,
new_uuids + i * UUID_LEN, UUID_LEN);
- else /* if this is a new fs in the union give it a new UUID
*/
+ else
+ /*
+ * if this is a new fs in the union give it a new
+ * UUID
+ */
generate_random_uuid(new_uuids + bindex * UUID_LEN);
}
@@ -1726,7 +1751,8 @@ int odf_write_sb_data(struct odf_sb_info *osi, struct
unionfs_data *data,
}
}
else {
- err = vfs_create(d_content->d_parent->d_inode, d_content,
S_IRWXUGO, NULL);
+ err = vfs_create(d_content->d_parent->d_inode, d_content,
+ S_IRWXUGO, NULL);
if (err)
goto out;
}
@@ -1747,7 +1773,8 @@ int odf_write_sb_data(struct odf_sb_info *osi, struct
unionfs_data *data,
/* version */
le32 = ODF_VERSION;
le32 = cpu_to_le32(le32);
- err = file->f_op->write(file, (char*)&le32, sizeof(__le32),
&file->f_pos);
+ err = file->f_op->write(file, (char*)&le32, sizeof(__le32),
+ &file->f_pos);
if (err != sizeof(__le32)) {
err = -EIO;
goto out_close;
@@ -1755,7 +1782,8 @@ int odf_write_sb_data(struct odf_sb_info *osi, struct
unionfs_data *data,
/* number of branches */
le32 = cpu_to_le32(branches);
- err = file->f_op->write(file, (char*)&le32, sizeof(__le32),
&file->f_pos);
+ err = file->f_op->write(file, (char*)&le32, sizeof(__le32),
+ &file->f_pos);
if (err != sizeof(__le32)) {
err = -EIO;
goto out_close;
@@ -1774,7 +1802,8 @@ int odf_write_sb_data(struct odf_sb_info *osi, struct
unionfs_data *data,
/* write branch ids */
le32 = cpu_to_le32(data[bindex].branch_id);
- err = file->f_op->write(file, (char*)&le32, sizeof(__le32),
&file->f_pos);
+ err = file->f_op->write(file, (char*)&le32, sizeof(__le32),
+ &file->f_pos);
if (err != sizeof(__le32)) {
err = -EIO;
goto out_close;
@@ -1782,7 +1811,8 @@ int odf_write_sb_data(struct odf_sb_info *osi, struct
unionfs_data *data,
/* path length */
le32 = cpu_to_le32(len);
- err = file->f_op->write(file, (char*)&le32, sizeof(__le32),
&file->f_pos);
+ err = file->f_op->write(file, (char*)&le32, sizeof(__le32),
+ &file->f_pos);
if (err != sizeof(__le32)) {
err = -EIO;
goto out_close;
@@ -1797,7 +1827,8 @@ int odf_write_sb_data(struct odf_sb_info *osi, struct
unionfs_data *data,
/* permissions */
le32 = cpu_to_le32(data[bindex].branchperms);
- err = file->f_op->write(file, (char*)&le32, sizeof(__le32),
&file->f_pos);
+ err = file->f_op->write(file, (char*)&le32, sizeof(__le32),
+ &file->f_pos);
if (err != sizeof(__le32)) {
err = -EIO;
goto out_close;
@@ -1876,7 +1907,8 @@ char *odf_read_sb_data(struct odf_sb_info *odf_sb, int
**bid)
set_fs(KERNEL_DS);
/* version */
- err = file->f_op->read(file, (char*)&le32, sizeof(__le32),
&file->f_pos);
+ err = file->f_op->read(file, (char*)&le32, sizeof(__le32),
+ &file->f_pos);
if (err != sizeof(__le32)) {
err = -EIO;
goto out_close;
@@ -1894,7 +1926,8 @@ char *odf_read_sb_data(struct odf_sb_info *odf_sb, int
**bid)
}
/* branch count */
- err = file->f_op->read(file, (char*)&le32, sizeof(__le32),
&file->f_pos);
+ err = file->f_op->read(file, (char*)&le32, sizeof(__le32),
+ &file->f_pos);
if (err != sizeof(__le32)) {
err = -EIO;
goto out_close;
@@ -1922,7 +1955,8 @@ char *odf_read_sb_data(struct odf_sb_info *odf_sb, int
**bid)
i = 0;
while (i < count) {
/* branch id */
- err = file->f_op->read(file, (char*)&le32, sizeof(__le32),
&file->f_pos);
+ err = file->f_op->read(file, (char*)&le32, sizeof(__le32),
+ &file->f_pos);
if (err != sizeof(__le32)) {
err = -EIO;
goto out_close;
@@ -1930,7 +1964,8 @@ char *odf_read_sb_data(struct odf_sb_info *odf_sb, int
**bid)
(*bid)[i] = le32_to_cpu(le32);
/* path length */
- err = file->f_op->read(file, (char*)&le32, sizeof(__le32),
&file->f_pos);
+ err = file->f_op->read(file, (char*)&le32, sizeof(__le32),
+ &file->f_pos);
if (err != sizeof(__le32)) {
err = -EIO;
goto out_close;
@@ -1949,7 +1984,8 @@ char *odf_read_sb_data(struct odf_sb_info *odf_sb, int
**bid)
}
/* permissions*/
- err = file->f_op->read(file, (char*)&le32, sizeof(__le32),
&file->f_pos);
+ err = file->f_op->read(file, (char*)&le32, sizeof(__le32),
+ &file->f_pos);
if (err != sizeof(__le32)) {
err = -EIO;
goto out_close;
@@ -1957,7 +1993,8 @@ char *odf_read_sb_data(struct odf_sb_info *odf_sb, int
**bid)
perms = le32_to_cpu(le32);
/* branch UUID*/
- err = file->f_op->read(file, (char*)uuid, UUID_LEN,
&file->f_pos);
+ err = file->f_op->read(file, (char*)uuid, UUID_LEN,
+ &file->f_pos);
if (err != UUID_LEN) {
err = -EIO;
goto out_close;
@@ -2039,8 +2076,8 @@ void __odf_cleanup(void *args)
if (err < 0)
printk(KERN_WARNING "unionfs cleanup thread: error %d\n", err);
else if (err == 0 && cl->success == 1)
- printk(KERN_WARNING
- "unionfs: cleanup failed to bring odf below
threshold\n");
+ printk(KERN_WARNING "unionfs: cleanup failed to bring odf "
+ "below threshold\n");
cl->success = err;
cl->flags = ODF_CLEAN_DEFAULT;
}
diff --git a/fs/unionfs/rename.c b/fs/unionfs/rename.c
index ca7bd24..527b5f0 100644
--- a/fs/unionfs/rename.c
+++ b/fs/unionfs/rename.c
@@ -184,7 +184,8 @@ static int do_unionfs_rename(struct inode *old_dir,
/* Rename source to destination. */
for (bindex = old_bstart; bindex <= old_bend; bindex++) {
- err = __unionfs_rename(old_dir, old_dentry, new_dir,
new_dentry, bindex);
+ err = __unionfs_rename(old_dir, old_dentry, new_dir,
+ new_dentry, bindex);
if (err)
break;
}
@@ -221,8 +222,9 @@ static int do_unionfs_rename(struct inode *old_dir,
old_dentry->d_name.len,
NULL, old_dentry->d_inode->i_size);
if (!err)
- err = __unionfs_rename(old_dir, old_dentry,
new_dir,
- new_dentry, bindex);
+ err = __unionfs_rename(old_dir, old_dentry,
+ new_dir, new_dentry,
+ bindex);
if (err)
goto revert;
}
@@ -424,15 +426,17 @@ out:
else
unionfs_purge_extras(old_dentry);
- /* If the dentry already existed before the rename and is not
used
- * by anyone else, we must purge its lower pointers, since it
might
- * remain in the cache for a while and the odf might give the
same
- * inode number to a new inode, so we don't want the new inode
to
- * have the old inode's pointers.
+ /*
+ * If the dentry already existed before the rename and is
+ * not used by anyone else, we must purge its lower
+ * pointers, since it might remain in the cache for a while
+ * and the odf might give the same inode number to a new
+ * inode, so we don't want the new inode to have the old
+ * inode's pointers.
*
- * If its i_count >= 2 we must not modify its lower pointers.
The
- * odf will silly rename this inode so it doesn't give it to
another
- * inode
+ * If its i_count >= 2 we must not modify its lower
+ * pointers. The odf will silly rename this inode so it
+ * doesn't give it to another inode
*/
if (new_dentry->d_inode &&
atomic_read(&new_dentry->d_inode->i_count) < 2) {
@@ -440,7 +444,8 @@ out:
struct inode *i = new_dentry->d_inode;
for (bindex = ibstart(i); bindex <= ibend(i); bindex++)
{
if (unionfs_lower_inode_idx(i, bindex))
- iput(unionfs_lower_inode_idx(i,
bindex));
+ iput(unionfs_lower_inode_idx(i,
+ bindex));
unionfs_set_lower_inode_idx(i, bindex, NULL);
}
}
diff --git a/fs/unionfs/sioq.c b/fs/unionfs/sioq.c
index e263f5e..c1b1455 100644
--- a/fs/unionfs/sioq.c
+++ b/fs/unionfs/sioq.c
@@ -120,9 +120,12 @@ void wake_up_and_wait_sioa(struct sioa_args *args)
/* Asynchronously wake up an sioa thread */
void wake_up_sioa(struct sioa_args *args)
{
- /* if the lock is being held by another thread, then this is most likely
- * because of a synchronous call to wake_up_sioa, so if we wait for the
- * lock here we'll end being a synchronous call as well. */
+ /*
+ * if the lock is being held by another thread, then this is most
+ * likely because of a synchronous call to wake_up_sioa, so if we
+ * wait for the lock here we'll end being a synchronous call as
+ * well.
+ */
if (!mutex_trylock(&args->lock))
return;
wake_up_process(args->process);
diff --git a/fs/unionfs/super.c b/fs/unionfs/super.c
index 9f7a6c6..5b5b1fc 100644
--- a/fs/unionfs/super.c
+++ b/fs/unionfs/super.c
@@ -432,7 +432,7 @@ static int unionfs_remount_fs(struct super_block *sb, int
*flags,
struct inode **new_lower_inodes = NULL;
int new_high_branch_id; /* new high branch ID */
struct odf_sb_info *odf = &UNIONFS_SB(sb)->odf;
- int odf_keepcache = 0 ; /* whether the odf_keepcache option was
provided */
+ int odf_keepcache = 0 ; /* was the odf_keepcache option provided? */
int old_ibstart, old_ibend;
int size; /* memory allocation size, temp var */
@@ -567,7 +567,8 @@ static int unionfs_remount_fs(struct super_block *sb, int
*flags,
if (!strcmp("odf_keepcache", optname)) {
if (optarg) {
- printk("unionfs: %s does not take an
argument\n", optname);
+ printk("unionfs: %s does not take an "
+ "argument\n", optname);
err = -EINVAL;
goto out_release;
}
diff --git a/fs/unionfs/union.h b/fs/unionfs/union.h
index f5b0344..0e06a17 100644
--- a/fs/unionfs/union.h
+++ b/fs/unionfs/union.h
@@ -111,7 +111,8 @@ struct odf_sb_info {
struct dentry *sb; /* superblock file (/odf/sb) */
struct dentry *whiteout; /* file whiteouts are linked to */
struct sioa_args *cleanup; /* our cleanup thread */
- char *branch_uuids; /* not null terminated string of all branch UUIDs
*/
+ /* non-null terminated string of all branch UUIDs */
+ char *branch_uuids;
};
/* unionfs inode data in memory */
@@ -226,8 +227,9 @@ extern void free_rdstate(struct unionfs_dir_state *state);
extern int add_filldir_node(struct unionfs_dir_state *rdstate,
const char *name, int namelen, int bindex,
int whiteout);
-extern struct filldir_node *find_filldir_node(struct unionfs_dir_state
*rdstate,
- const char *name, int namelen);
+extern struct filldir_node *find_filldir_node(
+ struct unionfs_dir_state *rdstate,
+ const char *name, int namelen);
#define MAXRDCOOKIE (0xfff)
#define DIREOF (0xffffff)
@@ -497,7 +499,8 @@ static inline void unionfs_mntput(struct dentry *dentry,
int bindex)
* know that this couldn't have been a regular file:
* it had to have been a directory.
*/
- if (!(bindex > dbstart(dentry) && bindex <
dbend(dentry)))
+ if (!(bindex > dbstart(dentry) &&
+ bindex < dbend(dentry)))
printk(KERN_WARNING
"unionfs_mntput: mnt=%p bindex=%d\n",
mnt, bindex);
@@ -524,7 +527,8 @@ static inline void __odf_dstack_init(struct dentry_stack
*stack, int size)
{
stack->size = size;
stack->n = 0;
- stack->item = kmalloc(stack->size * sizeof(struct dentry *),
GFP_KERNEL);
+ stack->item = kmalloc(stack->size * sizeof(struct dentry *),
+ GFP_KERNEL);
}
static inline int __odf_dstack_push(struct dentry_stack *stack,
diff --git a/fs/unionfs/unlink.c b/fs/unionfs/unlink.c
index db8644e..d9d8bd3 100644
--- a/fs/unionfs/unlink.c
+++ b/fs/unionfs/unlink.c
@@ -45,7 +45,8 @@ static int unionfs_do_unlink(struct inode *dir, struct dentry
*dentry)
/* avoid destroying the hidden inode if the file is in use */
dget(hidden_dentry);
if (!(err = is_robranch_super(dentry->d_sb, bindex)))
- err = vfs_unlink(hidden_dir_dentry->d_inode,
hidden_dentry);
+ err = vfs_unlink(hidden_dir_dentry->d_inode,
+ hidden_dentry);
else
err = -EROFS;
dput(hidden_dentry);
@@ -58,9 +59,8 @@ static int unionfs_do_unlink(struct inode *dir, struct dentry
*dentry)
if (err) {
if (err == -EIO)
- printk(KERN_WARNING
- "unionfs_unlink: IO error unlinking from branch
%d\n",
- bindex);
+ printk(KERN_WARNING "unionfs_unlink: IO error "
+ "unlinking from branch %d\n", bindex);
err = odf_create_wh(dentry);
if (err)
goto out;
@@ -152,7 +152,8 @@ static int unionfs_do_rmdir(struct inode *dir, struct
dentry *dentry)
/* avoid destroying the hidden inode if the file is in use */
dget(hidden_dentry);
if (!(err = is_robranch_super(dentry->d_sb, bindex)))
- err = vfs_rmdir(hidden_dir_dentry->d_inode,
hidden_dentry);
+ err = vfs_rmdir(hidden_dir_dentry->d_inode,
+ hidden_dentry);
else
err = -EROFS;
dput(hidden_dentry);
@@ -172,9 +173,8 @@ static int unionfs_do_rmdir(struct inode *dir, struct
dentry *dentry)
*/
if (err || odf_get_opaque(dentry) != 1) {
if (err == -EIO)
- printk(KERN_WARNING
- "unionfs_rmdir: IO error removing from branch
%d\n",
- bindex);
+ printk(KERN_WARNING "unionfs_rmdir: IO error "
+ "removing from branch %d\n", bindex);
err = odf_create_wh(dentry);
if (err)
goto out;
_______________________________________________
unionfs-cvs mailing list: http://unionfs.filesystems.org/
[email protected]
http://www.fsl.cs.sunysb.edu/mailman/listinfo/unionfs-cvs
