Fix some coding-style errors in autofs

Fix coding style errors (extra spaces, long lines) in autofs and autofs4 files
being modified for container/pidspace issues.

Signed-off-by: Sukadev Bhattiprolu <sukadev@us.ibm.com>
Cc: Cedric Le Goater <clg@fr.ibm.com>
Cc: Dave Hansen <haveblue@us.ibm.com>
Cc: Serge Hallyn <serue@us.ibm.com>
Cc: <containers@lists.osdl.org>
Cc: Eric W. Biederman <ebiederm@xmission.com>
Cc: Ian Kent <raven@themaw.net>
Signed-off-by: Andrew Morton <akpm@linux-foundation.org>
Signed-off-by: Linus Torvalds <torvalds@linux-foundation.org>

1 files changed, 38 insertions, 39 deletions

diff --git a/fs/autofs/root.c b/fs/autofs/root.c
index f2597205939d..6fa04dd6d167 100644
--- a/fs/autofs/root.c
+++ b/fs/autofs/root.c
@@ -67,8 +67,8 @@ static int autofs_root_readdir(struct file *filp, void *dirent, filldir_t filldi
                 filp->f_pos = ++nr;
                 /* fall through */
         default:
-                while ( onr = nr, ent = autofs_hash_enum(dirhash,&nr,ent) ) {
-                        if ( !ent->dentry || d_mountpoint(ent->dentry) ) {
+                while (onr = nr, ent = autofs_hash_enum(dirhash,&nr,ent)) {
+                        if (!ent->dentry || d_mountpoint(ent->dentry)) {
                                 if (filldir(dirent,ent->name,ent->len,onr,ent->ino,DT_UNKNOWN) < 0)
                                         goto out;
                                 filp->f_pos = nr;
@@ -88,10 +88,10 @@ static int try_to_fill_dentry(struct dentry *dentry, struct super_block *sb, str
         struct autofs_dir_ent *ent;
         int status = 0;
 
-        if ( !(ent = autofs_hash_lookup(&sbi->dirhash, &dentry->d_name)) ) {
+        if (!(ent = autofs_hash_lookup(&sbi->dirhash, &dentry->d_name))) {
                 do {
-                        if ( status && dentry->d_inode ) {
-                                if ( status != -ENOENT )
+                        if (status && dentry->d_inode) {
+                                if (status != -ENOENT)
                                         printk("autofs warning: lookup failure on positive dentry, status = %d, name = %s\n", status, dentry->d_name.name);
                                 return 0; /* Try to get the kernel to invalidate this dentry */
                         }
@@ -106,7 +106,7 @@ static int try_to_fill_dentry(struct dentry *dentry, struct super_block *sb, str
                                 return 1;
                         }
                         status = autofs_wait(sbi, &dentry->d_name);
-                } while (!(ent = autofs_hash_lookup(&sbi->dirhash, &dentry->d_name)) );
+                } while (!(ent = autofs_hash_lookup(&sbi->dirhash, &dentry->d_name)));
         }
 
         /* Abuse this field as a pointer to the directory entry, used to
@@ -124,13 +124,13 @@ static int try_to_fill_dentry(struct dentry *dentry, struct super_block *sb, str
 
         /* If this is a directory that isn't a mount point, bitch at the
            daemon and fix it in user space */
-        if ( S_ISDIR(dentry->d_inode->i_mode) && !d_mountpoint(dentry) ) {
+        if (S_ISDIR(dentry->d_inode->i_mode) && !d_mountpoint(dentry)) {
                 return !autofs_wait(sbi, &dentry->d_name);
         }
 
         /* We don't update the usages for the autofs daemon itself, this
            is necessary for recursive autofs mounts */
-        if ( !autofs_oz_mode(sbi) ) {
+        if (!autofs_oz_mode(sbi)) {
                 autofs_update_usage(&sbi->dirhash,ent);
         }
 
@@ -157,7 +157,7 @@ static int autofs_revalidate(struct dentry * dentry, struct nameidata *nd)
         sbi = autofs_sbi(dir->i_sb);
 
         /* Pending dentry */
-        if ( dentry->d_flags & DCACHE_AUTOFS_PENDING ) {
+        if (dentry->d_flags & DCACHE_AUTOFS_PENDING) {
                 if (autofs_oz_mode(sbi))
                         res = 1;
                 else
@@ -173,7 +173,7 @@ static int autofs_revalidate(struct dentry * dentry, struct nameidata *nd)
         }
                 
         /* Check for a non-mountpoint directory */
-        if ( S_ISDIR(dentry->d_inode->i_mode) && !d_mountpoint(dentry) ) {
+        if (S_ISDIR(dentry->d_inode->i_mode) && !d_mountpoint(dentry)) {
                 if (autofs_oz_mode(sbi))
                         res = 1;
                 else
@@ -183,9 +183,9 @@ static int autofs_revalidate(struct dentry * dentry, struct nameidata *nd)
         }
 
         /* Update the usage list */
-        if ( !autofs_oz_mode(sbi) ) {
+        if (!autofs_oz_mode(sbi)) {
                 ent = (struct autofs_dir_ent *) dentry->d_time;
-                if ( ent )
+                if (ent)
                         autofs_update_usage(&sbi->dirhash,ent);
         }
         unlock_kernel();
@@ -258,7 +258,7 @@ static struct dentry *autofs_root_lookup(struct inode *dir, struct dentry *dentr
          * doesn't do the right thing for all system calls, but it should
          * be OK for the operations we permit from an autofs.
          */
-        if ( dentry->d_inode && d_unhashed(dentry) )
+        if (dentry->d_inode && d_unhashed(dentry))
                 return ERR_PTR(-ENOENT);
 
         return NULL;
@@ -277,18 +277,18 @@ static int autofs_root_symlink(struct inode *dir, struct dentry *dentry, const c
         autofs_say(dentry->d_name.name,dentry->d_name.len);
 
         lock_kernel();
-        if ( !autofs_oz_mode(sbi) ) {
+        if (!autofs_oz_mode(sbi)) {
                 unlock_kernel();
                 return -EACCES;
         }
 
-        if ( autofs_hash_lookup(dh, &dentry->d_name) ) {
+        if (autofs_hash_lookup(dh, &dentry->d_name)) {
                 unlock_kernel();
                 return -EEXIST;
         }
 
         n = find_first_zero_bit(sbi->symlink_bitmap,AUTOFS_MAX_SYMLINKS);
-        if ( n >= AUTOFS_MAX_SYMLINKS ) {
+        if (n >= AUTOFS_MAX_SYMLINKS) {
                 unlock_kernel();
                 return -ENOSPC;
         }
@@ -297,14 +297,14 @@ static int autofs_root_symlink(struct inode *dir, struct dentry *dentry, const c
         sl = &sbi->symlink[n];
         sl->len = strlen(symname);
         sl->data = kmalloc(slsize = sl->len+1, GFP_KERNEL);
-        if ( !sl->data ) {
+        if (!sl->data) {
                 clear_bit(n,sbi->symlink_bitmap);
                 unlock_kernel();
                 return -ENOSPC;
         }
 
         ent = kmalloc(sizeof(struct autofs_dir_ent), GFP_KERNEL);
-        if ( !ent ) {
+        if (!ent) {
                 kfree(sl->data);
                 clear_bit(n,sbi->symlink_bitmap);
                 unlock_kernel();
@@ -312,7 +312,7 @@ static int autofs_root_symlink(struct inode *dir, struct dentry *dentry, const c
         }
 
         ent->name = kmalloc(dentry->d_name.len+1, GFP_KERNEL);
-        if ( !ent->name ) {
+        if (!ent->name) {
                 kfree(sl->data);
                 kfree(ent);
                 clear_bit(n,sbi->symlink_bitmap);
@@ -354,23 +354,23 @@ static int autofs_root_unlink(struct inode *dir, struct dentry *dentry)
 
         /* This allows root to remove symlinks */
         lock_kernel();
-        if ( !autofs_oz_mode(sbi) && !capable(CAP_SYS_ADMIN) ) {
+        if (!autofs_oz_mode(sbi) && !capable(CAP_SYS_ADMIN)) {
                 unlock_kernel();
                 return -EACCES;
         }
 
         ent = autofs_hash_lookup(dh, &dentry->d_name);
-        if ( !ent ) {
+        if (!ent) {
                 unlock_kernel();
                 return -ENOENT;
         }
 
         n = ent->ino - AUTOFS_FIRST_SYMLINK;
-        if ( n >= AUTOFS_MAX_SYMLINKS ) {
+        if (n >= AUTOFS_MAX_SYMLINKS) {
                 unlock_kernel();
                 return -EISDIR; /* It's a directory, dummy */
         }
-        if ( !test_bit(n,sbi->symlink_bitmap) ) {
+        if (!test_bit(n,sbi->symlink_bitmap)) {
                 unlock_kernel();
                 return -EINVAL; /* Nonexistent symlink?  Shouldn't happen */
         }
@@ -392,23 +392,23 @@ static int autofs_root_rmdir(struct inode *dir, struct dentry *dentry)
         struct autofs_dir_ent *ent;
 
         lock_kernel();
-        if ( !autofs_oz_mode(sbi) ) {
+        if (!autofs_oz_mode(sbi)) {
                 unlock_kernel();
                 return -EACCES;
         }
 
         ent = autofs_hash_lookup(dh, &dentry->d_name);
-        if ( !ent ) {
+        if (!ent) {
                 unlock_kernel();
                 return -ENOENT;
         }
 
-        if ( (unsigned int)ent->ino < AUTOFS_FIRST_DIR_INO ) {
+        if ((unsigned int)ent->ino < AUTOFS_FIRST_DIR_INO) {
                 unlock_kernel();
                 return -ENOTDIR; /* Not a directory */
         }
 
-        if ( ent->dentry != dentry ) {
+        if (ent->dentry != dentry) {
                 printk("autofs_rmdir: odentry != dentry for entry %s\n", dentry->d_name.name);
         }
 
@@ -429,18 +429,18 @@ static int autofs_root_mkdir(struct inode *dir, struct dentry *dentry, int mode)
         ino_t ino;
 
         lock_kernel();
-        if ( !autofs_oz_mode(sbi) ) {
+        if (!autofs_oz_mode(sbi)) {
                 unlock_kernel();
                 return -EACCES;
         }
 
         ent = autofs_hash_lookup(dh, &dentry->d_name);
-        if ( ent ) {
+        if (ent) {
                 unlock_kernel();
                 return -EEXIST;
         }
 
-        if ( sbi->next_dir_ino < AUTOFS_FIRST_DIR_INO ) {
+        if (sbi->next_dir_ino < AUTOFS_FIRST_DIR_INO) {
                 printk("autofs: Out of inode numbers -- what the heck did you do??\n");
                 unlock_kernel();
                 return -ENOSPC;
@@ -448,13 +448,13 @@ static int autofs_root_mkdir(struct inode *dir, struct dentry *dentry, int mode)
         ino = sbi->next_dir_ino++;
 
         ent = kmalloc(sizeof(struct autofs_dir_ent), GFP_KERNEL);
-        if ( !ent ) {
+        if (!ent) {
                 unlock_kernel();
                 return -ENOSPC;
         }
 
         ent->name = kmalloc(dentry->d_name.len+1, GFP_KERNEL);
-        if ( !ent->name ) {
+        if (!ent->name) {
                 kfree(ent);
                 unlock_kernel();
                 return -ENOSPC;
@@ -483,7 +483,7 @@ static inline int autofs_get_set_timeout(struct autofs_sb_info *sbi,
             put_user(sbi->exp_timeout / HZ, p))
                 return -EFAULT;
 
-        if ( ntimeout > ULONG_MAX/HZ )
+        if (ntimeout > ULONG_MAX/HZ)
                 sbi->exp_timeout = 0;
         else
                 sbi->exp_timeout = ntimeout * HZ;
@@ -511,15 +511,14 @@ static inline int autofs_expire_run(struct super_block *sb,
         pkt.hdr.proto_version = AUTOFS_PROTO_VERSION;
         pkt.hdr.type = autofs_ptype_expire;
 
-        if ( !sbi->exp_timeout ||
-             !(ent = autofs_expire(sb,sbi,mnt)) )
+        if (!sbi->exp_timeout || !(ent = autofs_expire(sb,sbi,mnt)))
                 return -EAGAIN;
 
         pkt.len = ent->len;
         memcpy(pkt.name, ent->name, pkt.len);
         pkt.name[pkt.len] = '\0';
 
-        if ( copy_to_user(pkt_p, &pkt, sizeof(struct autofs_packet_expire)) )
+        if (copy_to_user(pkt_p, &pkt, sizeof(struct autofs_packet_expire)))
                 return -EFAULT;
 
         return 0;
@@ -537,11 +536,11 @@ static int autofs_root_ioctl(struct inode *inode, struct file *filp,
 
         DPRINTK(("autofs_ioctl: cmd = 0x%08x, arg = 0x%08lx, sbi = %p, pgrp = %u\n",cmd,arg,sbi,process_group(current)));
 
-        if ( _IOC_TYPE(cmd) != _IOC_TYPE(AUTOFS_IOC_FIRST) ||
-             _IOC_NR(cmd) - _IOC_NR(AUTOFS_IOC_FIRST) >= AUTOFS_IOC_COUNT )
+        if (_IOC_TYPE(cmd) != _IOC_TYPE(AUTOFS_IOC_FIRST) ||
+             _IOC_NR(cmd) - _IOC_NR(AUTOFS_IOC_FIRST) >= AUTOFS_IOC_COUNT)
                 return -ENOTTY;
         
-        if ( !autofs_oz_mode(sbi) && !capable(CAP_SYS_ADMIN) )
+        if (!autofs_oz_mode(sbi) && !capable(CAP_SYS_ADMIN))
                 return -EPERM;
         
         switch(cmd) {