system/linux
system/linux
1
0
Fork 0
mirror of https://github.com/torvalds/linux synced 2024-09-24 13:31:12 +00:00
Code Issues Packages Projects Releases Wiki Activity

Staging: autofs: fix coding style issue in dirhash.c

Browse source 
This is a patch to the dirhash.c file that fixes up a number of issues
found by the checkpatch.pl tool

Signed-off-by: Tushar Mehta <tushariiitb@gmail.com>
Signed-off-by: Greg Kroah-Hartman <gregkh@suse.de>
This commit is contained in:
Tushar Mehta 2010-11-16 12:13:50 +05:30 committed by Greg Kroah-Hartman
parent 0ff36f69bd
commit defc19cebc
1 changed files with 49 additions and 38 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

87
drivers/staging/autofs/dirhash.c
View file

@ -30,7 +30,7 @@ void autofs_update_usage(struct autofs_dirhash *dh,
struct autofs_dir_ent *ent) struct autofs_dir_ent *ent)
{ {
autofs_delete_usage(ent); /* Unlink from current position */ autofs_delete_usage(ent); /* Unlink from current position */
autofs_init_usage(dh,ent); /* Relink at queue tail */ autofs_init_usage(dh, ent); /* Relink at queue tail */
} }
struct autofs_dir_ent *autofs_expire(struct super_block *sb, struct autofs_dir_ent *autofs_expire(struct super_block *sb,
@ -45,17 +45,18 @@ struct autofs_dir_ent *autofs_expire(struct super_block *sb,
struct path path; struct path path;
int umount_ok; int umount_ok;
if ( list_empty(&dh->expiry_head) || sbi->catatonic ) if (list_empty(&dh->expiry_head) || sbi->catatonic)
return NULL; /* No entries */ return NULL; /* No entries */
/* We keep the list sorted by last_usage and want old stuff */ /* We keep the list sorted by last_usage and want old stuff */
ent = list_entry(dh->expiry_head.next, struct autofs_dir_ent, exp); ent = list_entry(dh->expiry_head.next,
struct autofs_dir_ent, exp);
if (jiffies - ent->last_usage < timeout) if (jiffies - ent->last_usage < timeout)
break; break;
/* Move to end of list in case expiry isn't desirable */ /* Move to end of list in case expiry isn't desirable */
autofs_update_usage(dh, ent); autofs_update_usage(dh, ent);
/* Check to see that entry is expirable */ /* Check to see that entry is expirable */
if ( ent->ino < AUTOFS_FIRST_DIR_INO ) if (ent->ino < AUTOFS_FIRST_DIR_INO)
return ent; /* Symlinks are always expirable */ return ent; /* Symlinks are always expirable */
/* Get the dentry for the autofs subdirectory */ /* Get the dentry for the autofs subdirectory */
@ -63,14 +64,15 @@ struct autofs_dir_ent *autofs_expire(struct super_block *sb,
if (!path.dentry) { if (!path.dentry) {
/* Should only happen in catatonic mode */ /* Should only happen in catatonic mode */
printk("autofs: dentry == NULL but inode range is directory, entry %s\n", ent->name); printk(KERN_DEBUG "autofs: dentry == NULL but inode \
range is directory, entry %s\n", ent->name);
autofs_delete_usage(ent); autofs_delete_usage(ent);
continue; continue;
} }
if (!path.dentry->d_inode) { if (!path.dentry->d_inode) {
dput(path.dentry); dput(path.dentry);
printk("autofs: negative dentry on expiry queue: %s\n", printk(KERN_DEBUG "autofs: negative dentry on expiry queue: %s\n",
ent->name); ent->name);
autofs_delete_usage(ent); autofs_delete_usage(ent);
continue; continue;
@ -80,14 +82,16 @@ struct autofs_dir_ent *autofs_expire(struct super_block *sb,
point to the mounted-on-top root. */ point to the mounted-on-top root. */
if (!S_ISDIR(path.dentry->d_inode->i_mode) || if (!S_ISDIR(path.dentry->d_inode->i_mode) ||
!d_mountpoint(path.dentry)) { !d_mountpoint(path.dentry)) {
DPRINTK(("autofs: not expirable (not a mounted directory): %s\n", ent->name)); DPRINTK(("autofs: not expirable \
(not a mounted directory): %s\n", ent->name));
continue; continue;
} }
path.mnt = mnt; path.mnt = mnt;
path_get(&path); path_get(&path);
if (!follow_down(&path)) { if (!follow_down(&path)) {
path_put(&path); path_put(&path);
DPRINTK(("autofs: not expirable (not a mounted directory): %s\n", ent->name)); DPRINTK(("autofs: not expirable\
(not a mounted directory): %s\n", ent->name));
continue; continue;
} }
while (d_mountpoint(path.dentry) && follow_down(&path)) while (d_mountpoint(path.dentry) && follow_down(&path))
@ -96,30 +100,37 @@ struct autofs_dir_ent *autofs_expire(struct super_block *sb,
path_put(&path); path_put(&path);
if (umount_ok) { if (umount_ok) {
DPRINTK(("autofs: signaling expire on %s\n", ent->name)); DPRINTK(("autofs: signaling expire on %s\n",
ent->name));
return ent; /* Expirable! */ return ent; /* Expirable! */
} }
DPRINTK(("autofs: didn't expire due to may_umount: %s\n", ent->name));
DPRINTK(("autofs: didn't expire due to may_umount: %s\n",
ent->name));
} }
return NULL; /* No expirable entries */ return NULL; /* No expirable entries */
} }
void autofs_initialize_hash(struct autofs_dirhash *dh) { void autofs_initialize_hash(struct autofs_dirhash *dh)
{
memset(&dh->h, 0, AUTOFS_HASH_SIZE*sizeof(struct autofs_dir_ent *)); memset(&dh->h, 0, AUTOFS_HASH_SIZE*sizeof(struct autofs_dir_ent *));
INIT_LIST_HEAD(&dh->expiry_head); INIT_LIST_HEAD(&dh->expiry_head);
} }
struct autofs_dir_ent *autofs_hash_lookup(const struct autofs_dirhash *dh, struct qstr *name) struct autofs_dir_ent *autofs_hash_lookup(const struct autofs_dirhash *dh,
struct qstr *name)
{ {
struct autofs_dir_ent *dhn; struct autofs_dir_ent *dhn;
DPRINTK(("autofs_hash_lookup: hash = 0x%08x, name = ", name->hash)); DPRINTK(("autofs_hash_lookup: hash = 0x%08x, name = ", name->hash));
autofs_say(name->name,name->len); autofs_say(name->name, name->len);
for ( dhn = dh->h[(unsigned) name->hash % AUTOFS_HASH_SIZE] ; dhn ; dhn = dhn->next ) { for (dhn = dh->h[(unsigned) name->hash % AUTOFS_HASH_SIZE];
if ( name->hash == dhn->hash && dhn;
dhn = dhn->next) {
if (name->hash == dhn->hash &&
name->len == dhn->len && name->len == dhn->len &&
!memcmp(name->name, dhn->name, name->len) ) !memcmp(name->name, dhn->name, name->len))
break; break;
} }
@ -131,9 +142,9 @@ void autofs_hash_insert(struct autofs_dirhash *dh, struct autofs_dir_ent *ent)
struct autofs_dir_ent **dhnp; struct autofs_dir_ent **dhnp;
DPRINTK(("autofs_hash_insert: hash = 0x%08x, name = ", ent->hash)); DPRINTK(("autofs_hash_insert: hash = 0x%08x, name = ", ent->hash));
autofs_say(ent->name,ent->len); autofs_say(ent->name, ent->len);
autofs_init_usage(dh,ent); autofs_init_usage(dh, ent);
if (ent->dentry) if (ent->dentry)
dget(ent->dentry); dget(ent->dentry);
@ -141,19 +152,19 @@ void autofs_hash_insert(struct autofs_dirhash *dh, struct autofs_dir_ent *ent)
ent->next = *dhnp; ent->next = *dhnp;
ent->back = dhnp; ent->back = dhnp;
*dhnp = ent; *dhnp = ent;
if ( ent->next ) if (ent->next)
ent->next->back = &(ent->next); ent->next->back = &(ent->next);
} }
void autofs_hash_delete(struct autofs_dir_ent *ent) void autofs_hash_delete(struct autofs_dir_ent *ent)
{ {
*(ent->back) = ent->next; *(ent->back) = ent->next;
if ( ent->next ) if (ent->next)
ent->next->back = ent->back; ent->next->back = ent->back;
autofs_delete_usage(ent); autofs_delete_usage(ent);
if ( ent->dentry ) if (ent->dentry)
dput(ent->dentry); dput(ent->dentry);
kfree(ent->name); kfree(ent->name);
kfree(ent); kfree(ent);
@ -176,37 +187,37 @@ struct autofs_dir_ent *autofs_hash_enum(const struct autofs_dirhash *dh,
bucket = (*ptr >> 16) - 1; bucket = (*ptr >> 16) - 1;
ecount = *ptr & 0xffff; ecount = *ptr & 0xffff;
if ( bucket < 0 ) { if (bucket < 0)
bucket = ecount = 0; bucket = ecount = 0;
}
DPRINTK(("autofs_hash_enum: bucket %d, entry %d\n", bucket, ecount)); DPRINTK(("autofs_hash_enum: bucket %d, entry %d\n", bucket, ecount));
ent = last ? last->next : NULL; ent = last ? last->next : NULL;
if ( ent ) { if (ent) {
ecount++; ecount++;
} else { } else {
while ( bucket < AUTOFS_HASH_SIZE ) { while (bucket < AUTOFS_HASH_SIZE) {
ent = dh->h[bucket]; ent = dh->h[bucket];
for ( i = ecount ; ent && i ; i-- ) for (i = ecount ; ent && i ; i--)
ent = ent->next; ent = ent->next;
if (ent) { if (ent) {
ecount++; /* Point to *next* entry */ ecount++; /* Point to *next* entry */
break; break;
} }
bucket++; ecount = 0; bucket++; ecount = 0;
} }
} }
#ifdef DEBUG #ifdef DEBUG
if ( !ent ) if (!ent)
printk("autofs_hash_enum: nothing found\n"); printk(KERN_DEBUG "autofs_hash_enum: nothing found\n");
else { else {
printk("autofs_hash_enum: found hash %08x, name", ent->hash); printk(KERN_DEBUG "autofs_hash_enum: found hash %08x, name",
autofs_say(ent->name,ent->len); ent->hash);
autofs_say(ent->name, ent->len);
} }
#endif #endif
@ -221,9 +232,9 @@ void autofs_hash_dputall(struct autofs_dirhash *dh)
int i; int i;
struct autofs_dir_ent *ent; struct autofs_dir_ent *ent;
for ( i = 0 ; i < AUTOFS_HASH_SIZE ; i++ ) { for (i = 0 ; i < AUTOFS_HASH_SIZE ; i++) {
for ( ent = dh->h[i] ; ent ; ent = ent->next ) { for (ent = dh->h[i] ; ent ; ent = ent->next) {
if ( ent->dentry ) { if (ent->dentry) {
dput(ent->dentry); dput(ent->dentry);
ent->dentry = NULL; ent->dentry = NULL;
} }
@ -238,10 +249,10 @@ void autofs_hash_nuke(struct autofs_sb_info *sbi)
int i; int i;
struct autofs_dir_ent *ent, *nent; struct autofs_dir_ent *ent, *nent;
for ( i = 0 ; i < AUTOFS_HASH_SIZE ; i++ ) { for (i = 0 ; i < AUTOFS_HASH_SIZE ; i++) {
for ( ent = sbi->dirhash.h[i] ; ent ; ent = nent ) { for (ent = sbi->dirhash.h[i] ; ent ; ent = nent) {
nent = ent->next; nent = ent->next;
if ( ent->dentry ) if (ent->dentry)
dput(ent->dentry); dput(ent->dentry);
kfree(ent->name); kfree(ent->name);
kfree(ent); kfree(ent);