Skip to content

Commit

Permalink
Fix some coding-style errors in autofs
Browse files Browse the repository at this point in the history 
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>
  • Loading branch information
Sukadev Bhattiprolu authored and Linus Torvalds committed May 11, 2007
1 parent 93ba088 commit d78e53c
Show file tree
Hide file tree
Showing 4 changed files with 70 additions and 70 deletions.
29 changes: 16 additions & 13 deletions fs/autofs/inode.c
View file
Original file line number Diff line number Diff line change
Expand Up @@ -34,12 +34,12 @@ void autofs_kill_sb(struct super_block *sb)
if (!sbi)
goto out_kill_sb;

if ( !sbi->catatonic )
if (!sbi->catatonic)
autofs_catatonic_mode(sbi); /* Free wait queues, close pipe */

autofs_hash_nuke(sbi);
for ( n = 0 ; n < AUTOFS_MAX_SYMLINKS ; n++ ) {
if ( test_bit(n, sbi->symlink_bitmap) )
for (n = 0; n < AUTOFS_MAX_SYMLINKS; n++) {
if (test_bit(n, sbi->symlink_bitmap))
kfree(sbi->symlink[n].data);
}

Expand Down Expand Up @@ -69,7 +69,8 @@ static match_table_t autofs_tokens = {
{Opt_err, NULL}
};

static int parse_options(char *options, int *pipefd, uid_t *uid, gid_t *gid, pid_t *pgrp, int *minproto, int *maxproto)
static int parse_options(char *options, int *pipefd, uid_t *uid, gid_t *gid,
pid_t *pgrp, int *minproto, int *maxproto)
{
char *p;
substring_t args[MAX_OPT_ARGS];
Expand Down Expand Up @@ -140,7 +141,7 @@ int autofs_fill_super(struct super_block *s, void *data, int silent)
int minproto, maxproto;

sbi = kzalloc(sizeof(*sbi), GFP_KERNEL);
if ( !sbi )
if (!sbi)
goto fail_unlock;
DPRINTK(("autofs: starting up, sbi = %p\n",sbi));

Expand Down Expand Up @@ -169,26 +170,28 @@ int autofs_fill_super(struct super_block *s, void *data, int silent)
goto fail_iput;

/* Can this call block? - WTF cares? s is locked. */
if ( parse_options(data,&pipefd,&root_inode->i_uid,&root_inode->i_gid,&sbi->oz_pgrp,&minproto,&maxproto) ) {
if (parse_options(data, &pipefd, &root_inode->i_uid,
&root_inode->i_gid, &sbi->oz_pgrp, &minproto,
&maxproto)) {
printk("autofs: called with bogus options\n");
goto fail_dput;
}

/* Couldn't this be tested earlier? */
if ( minproto > AUTOFS_PROTO_VERSION ||
maxproto < AUTOFS_PROTO_VERSION ) {
if (minproto > AUTOFS_PROTO_VERSION ||
maxproto < AUTOFS_PROTO_VERSION) {
printk("autofs: kernel does not match daemon version\n");
goto fail_dput;
}

DPRINTK(("autofs: pipe fd = %d, pgrp = %u\n", pipefd, sbi->oz_pgrp));
pipe = fget(pipefd);

if ( !pipe ) {
if (!pipe) {
printk("autofs: could not open pipe file descriptor\n");
goto fail_dput;
}
if ( !pipe->f_op || !pipe->f_op->write )
if (!pipe->f_op || !pipe->f_op->write)
goto fail_fput;
sbi->pipe = pipe;
sbi->catatonic = 0;
Expand Down Expand Up @@ -230,7 +233,7 @@ static void autofs_read_inode(struct inode *inode)
inode->i_mtime = inode->i_atime = inode->i_ctime = CURRENT_TIME;
inode->i_blocks = 0;

if ( ino == AUTOFS_ROOT_INO ) {
if (ino == AUTOFS_ROOT_INO) {
inode->i_mode = S_IFDIR | S_IRUGO | S_IXUGO | S_IWUSR;
inode->i_op = &autofs_root_inode_operations;
inode->i_fop = &autofs_root_operations;
Expand All @@ -241,12 +244,12 @@ static void autofs_read_inode(struct inode *inode)
inode->i_uid = inode->i_sb->s_root->d_inode->i_uid;
inode->i_gid = inode->i_sb->s_root->d_inode->i_gid;

if ( ino >= AUTOFS_FIRST_SYMLINK && ino < AUTOFS_FIRST_DIR_INO ) {
if (ino >= AUTOFS_FIRST_SYMLINK && ino < AUTOFS_FIRST_DIR_INO) {
/* Symlink inode - should be in symlink list */
struct autofs_symlink *sl;

n = ino - AUTOFS_FIRST_SYMLINK;
if ( n >= AUTOFS_MAX_SYMLINKS || !test_bit(n,sbi->symlink_bitmap)) {
if (n >= AUTOFS_MAX_SYMLINKS || !test_bit(n,sbi->symlink_bitmap)) {
printk("autofs: Looking for bad symlink inode %u\n", (unsigned int) ino);
return;
}
Expand Down
77 changes: 38 additions & 39 deletions fs/autofs/root.c
View file
Original file line number Diff line number Diff line change
Expand Up @@ -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;
Expand All @@ -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 */
}
Expand All @@ -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
Expand All @@ -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);
}

Expand All @@ -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
Expand All @@ -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
Expand All @@ -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();
Expand Down Expand Up @@ -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;
Expand All @@ -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;
}
Expand All @@ -297,22 +297,22 @@ 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();
return -ENOSPC;
}

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);
Expand Down Expand Up @@ -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 */
}
Expand All @@ -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);
}

Expand All @@ -429,32 +429,32 @@ 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;
}
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;
Expand Down Expand Up @@ -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;
Expand Down Expand Up @@ -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;
Expand All @@ -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) {
Expand Down
Loading

0 comments on commit d78e53c

Please sign in to comment.