lkml.org 
[lkml]   [2011]   [Nov]   [29]   [last100]   RSS Feed
Views: [wrap][no wrap]   [headers]  [forward] 
 
Messages in this thread
Patch in this message
/
From
Subject[PATCH 18/28] dcache: checkpatch wanking
Date
Style fixing, trivial 80 col and a kstrtoul checkpatch errors remain.

$ ./scripts/checkpatch.pl -f --terse --nosummary fs/dcache.c | \
cut -f3- -d":" | sort | uniq -c
10 ERROR: code indent should use tabs where possible
15 ERROR: "foo * bar" should be "foo *bar"
1 ERROR: space prohibited before that close parenthesis ')'
21 ERROR: trailing whitespace
1 WARNING: braces {} are not necessary for single statement blocks
3 WARNING: EXPORT_SYMBOL(foo); should immediately follow its function/variable
1 WARNING: externs should be avoided in .c files
8 WARNING: line over 80 characters
5 WARNING: please, no space before tabs
20 WARNING: please, no spaces at the start of a line
1 WARNING: simple_strtoul is obsolete, use kstrtoul instead
1 WARNING: Use #include <linux/uaccess.h> instead of <asm/uaccess.h>
Signed-off-by: Joe Perches <joe@perches.com>
---
fs/dcache.c | 128 ++++++++++++++++++++++++++++++-----------------------------
1 files changed, 65 insertions(+), 63 deletions(-)
diff --git a/fs/dcache.c b/fs/dcache.c
index 6055631..1d62cf7 100644
--- a/fs/dcache.c
+++ b/fs/dcache.c
@@ -28,7 +28,7 @@
#include <linux/module.h>
#include <linux/mount.h>
#include <linux/file.h>
-#include <asm/uaccess.h>
+#include <linux/uaccess.h>
#include <linux/security.h>
#include <linux/seqlock.h>
#include <linux/swap.h>
@@ -84,7 +84,6 @@ EXPORT_SYMBOL_GPL(sysctl_vfs_cache_pressure);

static __cacheline_aligned_in_smp DEFINE_SPINLOCK(dcache_lru_lock);
__cacheline_aligned_in_smp DEFINE_SEQLOCK(rename_lock);
-
EXPORT_SYMBOL(rename_lock);

static struct kmem_cache *dentry_cache __read_mostly;
@@ -145,7 +144,7 @@ static void __d_free(struct rcu_head *head)
WARN_ON(!list_empty(&dentry->d_alias));
if (dname_external(dentry))
kfree(dentry->d_name.name);
- kmem_cache_free(dentry_cache, dentry);
+ kmem_cache_free(dentry_cache, dentry);
}

/*
@@ -184,7 +183,7 @@ static inline void dentry_rcuwalk_barrier(struct dentry *dentry)
* d_iput() operation if defined. Dentry has no refcount
* and is unhashed.
*/
-static void dentry_iput(struct dentry * dentry)
+static void dentry_iput(struct dentry *dentry)
__releases(dentry->d_lock)
__releases(dentry->d_inode->i_lock)
{
@@ -209,7 +208,7 @@ static void dentry_iput(struct dentry * dentry)
* Release the dentry's inode, using the filesystem
* d_iput() operation if defined. dentry remains in-use.
*/
-static void dentry_unlink_inode(struct dentry * dentry)
+static void dentry_unlink_inode(struct dentry *dentry)
__releases(dentry->d_lock)
__releases(dentry->d_inode->i_lock)
{
@@ -437,7 +436,7 @@ relock:
return d_kill(dentry, parent);
}

-/*
+/*
* This is dput
*
* This is complicated by the fact that we do not want to put
@@ -456,7 +455,7 @@ relock:

/*
* dput - release a dentry
- * @dentry: dentry to release
+ * @dentry: dentry to release
*
* Release a dentry. This will drop the usage count and if appropriate
* call the dentry unlink method as well as removing it from the queues and
@@ -485,7 +484,7 @@ repeat:
}

/* Unreachable? Get rid of it */
- if (d_unhashed(dentry))
+ if (d_unhashed(dentry))
goto kill_it;

/*
@@ -519,8 +518,8 @@ EXPORT_SYMBOL(dput);
*
* no dcache lock.
*/
-
-int d_invalidate(struct dentry * dentry)
+
+int d_invalidate(struct dentry *dentry)
{
/*
* If it's already been dropped, return OK.
@@ -627,7 +626,7 @@ again:
discon_alias = NULL;
list_for_each_entry(alias, &inode->i_dentry, d_alias) {
spin_lock(&alias->d_lock);
- if (S_ISDIR(inode->i_mode) || !d_unhashed(alias)) {
+ if (S_ISDIR(inode->i_mode) || !d_unhashed(alias)) {
if (IS_ROOT(alias) &&
(alias->d_flags & DCACHE_DISCONNECTED)) {
discon_alias = alias;
@@ -960,7 +959,8 @@ void shrink_dcache_for_umount(struct super_block *sb)
shrink_dcache_for_umount_subtree(dentry);

while (!hlist_bl_empty(&sb->s_anon)) {
- dentry = hlist_bl_entry(hlist_bl_first(&sb->s_anon), struct dentry, d_hash);
+ dentry = hlist_bl_entry(hlist_bl_first(&sb->s_anon),
+ struct dentry, d_hash);
shrink_dcache_for_umount_subtree(dentry);
}
}
@@ -971,7 +971,8 @@ void shrink_dcache_for_umount(struct super_block *sb)
* the parenthood after dropping the lock and check
* that the sequence number still matches.
*/
-static struct dentry *try_to_ascend(struct dentry *old, int locked, unsigned seq)
+static struct dentry *
+try_to_ascend(struct dentry *old, int locked, unsigned seq)
{
struct dentry *new = old->d_parent;

@@ -999,7 +1000,7 @@ static struct dentry *try_to_ascend(struct dentry *old, int locked, unsigned seq
* We descend to the next level whenever the d_subdirs
* list is non-empty and continue searching.
*/
-
+
/**
* have_submounts - check for mounts over a dentry
* @parent: dentry to check.
@@ -1026,7 +1027,8 @@ repeat:
resume:
while (next != &this_parent->d_subdirs) {
struct list_head *tmp = next;
- struct dentry *dentry = list_entry(tmp, struct dentry, d_u.d_child);
+ struct dentry *dentry = list_entry(tmp, struct dentry,
+ d_u.d_child);
next = tmp->next;

spin_lock_nested(&dentry->d_lock, DENTRY_D_LOCK_NESTED);
@@ -1090,7 +1092,7 @@ EXPORT_SYMBOL(have_submounts);
* drop the lock and return early due to latency
* constraints.
*/
-static int select_parent(struct dentry * parent)
+static int select_parent(struct dentry *parent)
{
struct dentry *this_parent;
struct list_head *next;
@@ -1107,13 +1109,14 @@ repeat:
resume:
while (next != &this_parent->d_subdirs) {
struct list_head *tmp = next;
- struct dentry *dentry = list_entry(tmp, struct dentry, d_u.d_child);
+ struct dentry *dentry = list_entry(tmp, struct dentry,
+ d_u.d_child);
next = tmp->next;

spin_lock_nested(&dentry->d_lock, DENTRY_D_LOCK_NESTED);

- /*
- * move only zero ref count dentries to the end
+ /*
+ * move only zero ref count dentries to the end
* of the unused list for prune_dcache
*/
if (!dentry->d_count) {
@@ -1179,8 +1182,8 @@ rename_retry:
*
* Prune the dcache to remove unused children of the parent dentry.
*/
-
-void shrink_dcache_parent(struct dentry * parent)
+
+void shrink_dcache_parent(struct dentry *parent)
{
struct super_block *sb = parent->d_sb;
int found;
@@ -1199,7 +1202,7 @@ EXPORT_SYMBOL(shrink_dcache_parent);
* available. On a success the dentry is returned. The name passed in is
* copied and the copy passed in may be reused after this call.
*/
-
+
struct dentry *__d_alloc(struct super_block *sb, const struct qstr *name)
{
struct dentry *dentry;
@@ -1212,12 +1215,12 @@ struct dentry *__d_alloc(struct super_block *sb, const struct qstr *name)
if (name->len > DNAME_INLINE_LEN-1) {
dname = kmalloc(name->len + 1, GFP_KERNEL);
if (!dname) {
- kmem_cache_free(dentry_cache, dentry);
+ kmem_cache_free(dentry_cache, dentry);
return NULL;
}
} else {
dname = dentry->d_iname;
- }
+ }
dentry->d_name.name = dname;

dentry->d_name.len = name->len;
@@ -1298,10 +1301,10 @@ EXPORT_SYMBOL(d_alloc_name);
void d_set_d_op(struct dentry *dentry, const struct dentry_operations *op)
{
WARN_ON_ONCE(dentry->d_op);
- WARN_ON_ONCE(dentry->d_flags & (DCACHE_OP_HASH |
- DCACHE_OP_COMPARE |
- DCACHE_OP_REVALIDATE |
- DCACHE_OP_DELETE ));
+ WARN_ON_ONCE(dentry->d_flags & (DCACHE_OP_HASH |
+ DCACHE_OP_COMPARE |
+ DCACHE_OP_REVALIDATE |
+ DCACHE_OP_DELETE));
dentry->d_op = op;
if (!op)
return;
@@ -1347,7 +1350,7 @@ static void __d_instantiate(struct dentry *dentry, struct inode *inode)
* (or otherwise set) by the caller to indicate that it is now
* in use by the dcache.
*/
-
+
void d_instantiate(struct dentry *entry, struct inode * inode)
{
BUG_ON(!list_empty(&entry->d_alias));
@@ -1432,7 +1435,6 @@ struct dentry *d_instantiate_unique(struct dentry *entry, struct inode *inode)
iput(inode);
return result;
}
-
EXPORT_SYMBOL(d_instantiate_unique);

/**
@@ -1443,8 +1445,8 @@ EXPORT_SYMBOL(d_instantiate_unique);
* instantiated and returned. %NULL is returned if there is insufficient
* memory or the inode passed is %NULL.
*/
-
-struct dentry * d_alloc_root(struct inode * root_inode)
+
+struct dentry *d_alloc_root(struct inode *root_inode)
{
struct dentry *res = NULL;

@@ -1459,7 +1461,7 @@ struct dentry * d_alloc_root(struct inode * root_inode)
}
EXPORT_SYMBOL(d_alloc_root);

-static struct dentry * __d_find_any_alias(struct inode *inode)
+static struct dentry *__d_find_any_alias(struct inode *inode)
{
struct dentry *alias;

@@ -1470,7 +1472,7 @@ static struct dentry * __d_find_any_alias(struct inode *inode)
return alias;
}

-static struct dentry * d_find_any_alias(struct inode *inode)
+static struct dentry *d_find_any_alias(struct inode *inode)
{
struct dentry *de;

@@ -1798,10 +1800,10 @@ struct dentry *d_lookup(struct dentry *parent, struct qstr *name)
struct dentry *dentry;
unsigned seq;

- do {
- seq = read_seqbegin(&rename_lock);
- dentry = __d_lookup(parent, name);
- if (dentry)
+ do {
+ seq = read_seqbegin(&rename_lock);
+ dentry = __d_lookup(parent, name);
+ if (dentry)
break;
} while (read_seqretry(&rename_lock, seq));
return dentry;
@@ -1854,7 +1856,7 @@ struct dentry *__d_lookup(struct dentry *parent, struct qstr *name)
* See Documentation/filesystems/path-lookup.txt for more details.
*/
rcu_read_lock();
-
+
hlist_bl_for_each_entry_rcu(dentry, node, b, d_hash) {
const char *tname;
int tlen;
@@ -1890,10 +1892,10 @@ struct dentry *__d_lookup(struct dentry *parent, struct qstr *name)
break;
next:
spin_unlock(&dentry->d_lock);
- }
- rcu_read_unlock();
+ }
+ rcu_read_unlock();

- return found;
+ return found;
}

/**
@@ -1965,7 +1967,7 @@ EXPORT_SYMBOL(d_validate);
* it from the hash queues and waiting for
* it to be deleted later when it has no users
*/
-
+
/**
* d_delete - delete a dentry
* @dentry: The dentry to delete
@@ -1973,8 +1975,8 @@ EXPORT_SYMBOL(d_validate);
* Turn the dentry into a negative dentry if possible, otherwise
* remove it from the hash queues so it can be deleted later
*/
-
-void d_delete(struct dentry * dentry)
+
+void d_delete(struct dentry *dentry)
{
struct inode *inode;
int isdir = 0;
@@ -2006,7 +2008,7 @@ again:
}
EXPORT_SYMBOL(d_delete);

-static void __d_rehash(struct dentry * entry, struct hlist_bl_head *b)
+static void __d_rehash(struct dentry *entry, struct hlist_bl_head *b)
{
BUG_ON(!d_unhashed(entry));
hlist_bl_lock(b);
@@ -2015,7 +2017,7 @@ static void __d_rehash(struct dentry * entry, struct hlist_bl_head *b)
hlist_bl_unlock(b);
}

-static void _d_rehash(struct dentry * entry)
+static void _d_rehash(struct dentry *entry)
{
__d_rehash(entry, d_hash(entry->d_parent, entry->d_name.hash));
}
@@ -2026,8 +2028,8 @@ static void _d_rehash(struct dentry * entry)
*
* Adds a dentry to the hash according to its name.
*/
-
-void d_rehash(struct dentry * entry)
+
+void d_rehash(struct dentry *entry)
{
spin_lock(&entry->d_lock);
_d_rehash(entry);
@@ -2160,7 +2162,7 @@ static void dentry_unlock_parents_for_move(struct dentry *dentry,
* rename_lock, the i_mutex of the source and target directories,
* and the sb->s_vfs_rename_mutex if they differ. See lock_rename().
*/
-static void __d_move(struct dentry * dentry, struct dentry * target)
+static void __d_move(struct dentry *dentry, struct dentry *target)
{
if (!dentry->d_inode)
pr_warn("VFS: moving negative dcache entry\n");
@@ -2457,13 +2459,12 @@ static int prepend_path(const struct path *path, struct path *root,

br_read_lock(&vfsmount_lock);
while (dentry != root->dentry || vfsmnt != root->mnt) {
- struct dentry * parent;
+ struct dentry *parent;

if (dentry == vfsmnt->mnt_root || IS_ROOT(dentry)) {
/* Global root? */
- if (vfsmnt->mnt_parent == vfsmnt) {
+ if (vfsmnt->mnt_parent == vfsmnt)
goto global_root;
- }
dentry = vfsmnt->mnt_mountpoint;
vfsmnt = vfsmnt->mnt_parent;
continue;
@@ -2808,7 +2809,7 @@ out:
* Returns 0 otherwise.
* Caller must ensure that "new_dentry" is pinned before calling is_subdir()
*/
-
+
int is_subdir(struct dentry *new_dentry, struct dentry *old_dentry)
{
int result;
@@ -2876,7 +2877,8 @@ repeat:
resume:
while (next != &this_parent->d_subdirs) {
struct list_head *tmp = next;
- struct dentry *dentry = list_entry(tmp, struct dentry, d_u.d_child);
+ struct dentry *dentry = list_entry(tmp, struct dentry,
+ d_u.d_child);
next = tmp->next;

spin_lock_nested(&dentry->d_lock, DENTRY_D_LOCK_NESTED);
@@ -2921,6 +2923,7 @@ rename_retry:
write_seqlock(&rename_lock);
goto again;
}
+EXPORT_SYMBOL(d_genocide);

/**
* find_inode_number - check for dentry with name
@@ -2935,10 +2938,10 @@ rename_retry:
* filesystems using synthetic inode numbers, and is necessary
* to keep getcwd() working.
*/
-
+
ino_t find_inode_number(struct dentry *dir, struct qstr *name)
{
- struct dentry * dentry;
+ struct dentry *dentry;
ino_t ino = 0;

dentry = d_hash_and_lookup(dir, name);
@@ -2989,10 +2992,10 @@ static void __init dcache_init(void)
{
int loop;

- /*
+ /*
* A constructor could be added for stable state like the lists,
* but it is probably not worth it because of the cache nature
- * of the dcache.
+ * of the dcache.
*/
dentry_cache = KMEM_CACHE(dentry,
SLAB_RECLAIM_ACCOUNT|SLAB_PANIC|SLAB_MEM_SPREAD);
@@ -3019,8 +3022,6 @@ static void __init dcache_init(void)
struct kmem_cache *names_cachep __read_mostly;
EXPORT_SYMBOL(names_cachep);

-EXPORT_SYMBOL(d_genocide);
-
void __init vfs_caches_init_early(void)
{
dcache_init_early();
@@ -3031,8 +3032,9 @@ void __init vfs_caches_init(unsigned long mempages)
{
unsigned long reserve;

- /* Base hash sizes on available memory, with a reserve equal to
- 150% of current kernel size */
+ /* Base hash sizes on available memory
+ * with a reserve equal to 150% of current kernel size
+ */

reserve = min((mempages - nr_free_pages()) * 3/2, mempages - 1);
mempages -= reserve;
--
1.7.6.405.gc1be0


\
 
 \ /
  Last update: 2011-11-30 03:21    [from the cache]
©2003-2011 Jasper Spaans