[PATCH 00/28] fs: Logging style neatening and checkpatch wanking...

[PATCH 00/28] fs: Logging style neatening and checkpatch wanking...

[Joe Perches]

Use the current logging styles.

Some messages now have prefixes that didn't previously.
buffer:, exec:, namespace: and a few others.

Neaten the file coding style while there.

Joe Perches (28):
  buffer: Use pr_<level>
  mbcache: Use current logging styles
  bio: Use current logging styles
  libfs: Use current logging styles
  super: Use current logging styles
  exec: Use current logging style
  namespace: Use current logging styles
  block_dev: Use current logging style
  dcache: Use current logging style
  fcntl: Use current logging style
  file: Use current logging style
  locks: Use current logging style
  open: Use current logging style
  stat: Use current logging style
  exec: checkpatch wanking
  namespace: checkpatch wanking
  block_dev: checkpatch wanking
  dcache: checkpatch wanking
  fcntl: checkpatch wanking
  file: checkpatch wanking
  locks: checkpatch wanking
  open: checkpatch wanking
  stat: checkpatch wanking
  super: checkpatch wanking
  libfs: checkpatch wanking
  bio: checkpatch wanking
  mbcache: checkpatch wanking.
  buffer: checkpatch wanking

 fs/bio.c       |   31 +++++---
 fs/block_dev.c |   81 ++++++++++-----------
 fs/buffer.c    |  143 ++++++++++++++++++-------------------
 fs/dcache.c    |  137 ++++++++++++++++++------------------
 fs/exec.c      |  106 ++++++++++++++--------------
 fs/fcntl.c     |  134 ++++++++++++++++++-----------------
 fs/file.c      |   25 ++++---
 fs/libfs.c     |  215 +++++++++++++++++++++++++++++---------------------------
 fs/locks.c     |  125 +++++++++++++++-----------------
 fs/mbcache.c   |   82 +++++++++------------
 fs/namespace.c |   61 ++++++++--------
 fs/open.c      |   41 ++++++-----
 fs/stat.c      |   33 ++++-----
 fs/super.c     |   60 ++++++---------
 14 files changed, 631 insertions(+), 643 deletions(-)

-- 
1.7.6.405.gc1be0

[PATCH 01/28] buffer: Use pr_<level>

[Joe Perches]

Use the current logging styles.
Add #define pr_fmt.
Convert bare printks to pr_notice.
Coalesce format strings.
Align arguments.
Convert %Lu to %llu.

Signed-off-by: Joe Perches <joe@perches.com>
---
 fs/buffer.c |   58 ++++++++++++++++++++++++++--------------------------------
 1 files changed, 26 insertions(+), 32 deletions(-)

diff --git a/fs/buffer.c b/fs/buffer.c
index 929d620..576a1ba 100644
--- a/fs/buffer.c
+++ b/fs/buffer.c
@@ -18,6 +18,8 @@
  * async buffer flushing, 1999 Andrea Arcangeli <andrea@suse.de>
  */
 
+#define pr_fmt(fmt) KBUILD_MODNAME ": " fmt
+
 #include <linux/kernel.h>
 #include <linux/syscalls.h>
 #include <linux/fs.h>
@@ -107,9 +109,8 @@ static int quiet_error(struct buffer_head *bh)
 static void buffer_io_error(struct buffer_head *bh)
 {
 	char b[BDEVNAME_SIZE];
-	printk(KERN_ERR "Buffer I/O error on device %s, logical block %Lu\n",
-			bdevname(bh->b_bdev, b),
-			(unsigned long long)bh->b_blocknr);
+	pr_err("Buffer I/O error on device %s, logical block %llu\n",
+	       bdevname(bh->b_bdev, b), (unsigned long long)bh->b_blocknr);
 }
 
 /*
@@ -151,9 +152,8 @@ void end_buffer_write_sync(struct buffer_head *bh, int uptodate)
 	} else {
 		if (!quiet_error(bh)) {
 			buffer_io_error(bh);
-			printk(KERN_WARNING "lost page write due to "
-					"I/O error on %s\n",
-				       bdevname(bh->b_bdev, b));
+			pr_warn("lost page write due to I/O error on %s\n",
+				bdevname(bh->b_bdev, b));
 		}
 		set_buffer_write_io_error(bh);
 		clear_buffer_uptodate(bh);
@@ -215,14 +215,13 @@ __find_get_block_slow(struct block_device *bdev, sector_t block)
 	if (all_mapped) {
 		char b[BDEVNAME_SIZE];
 
-		printk("__find_get_block_slow() failed. "
-			"block=%llu, b_blocknr=%llu\n",
-			(unsigned long long)block,
-			(unsigned long long)bh->b_blocknr);
-		printk("b_state=0x%08lx, b_size=%zu\n",
-			bh->b_state, bh->b_size);
-		printk("device %s blocksize: %d\n", bdevname(bdev, b),
-			1 << bd_inode->i_blkbits);
+		pr_notice("__find_get_block_slow() failed. block=%llu, b_blocknr=%llu\n",
+			  (unsigned long long)block,
+			  (unsigned long long)bh->b_blocknr);
+		pr_notice("b_state=0x%08lx, b_size=%zu\n",
+			  bh->b_state, bh->b_size);
+		pr_notice("device %s blocksize: %d\n",
+			  bdevname(bdev, b), 1 << bd_inode->i_blkbits);
 	}
 out_unlock:
 	spin_unlock(&bd_mapping->private_lock);
@@ -383,9 +382,8 @@ void end_buffer_async_write(struct buffer_head *bh, int uptodate)
 	} else {
 		if (!quiet_error(bh)) {
 			buffer_io_error(bh);
-			printk(KERN_WARNING "lost page write due to "
-					"I/O error on %s\n",
-			       bdevname(bh->b_bdev, b));
+			pr_warn("lost page write due to I/O error on %s\n",
+				bdevname(bh->b_bdev, b));
 		}
 		set_bit(AS_EIO, &page->mapping->flags);
 		set_buffer_write_io_error(bh);
@@ -565,15 +563,14 @@ static void do_thaw_one(struct super_block *sb, void *unused)
 {
 	char b[BDEVNAME_SIZE];
 	while (sb->s_bdev && !thaw_bdev(sb->s_bdev, sb))
-		printk(KERN_WARNING "Emergency Thaw on %s\n",
-		       bdevname(sb->s_bdev, b));
+		pr_warn("Emergency Thaw on %s\n", bdevname(sb->s_bdev, b));
 }
 
 static void do_thaw_all(struct work_struct *work)
 {
 	iterate_supers(do_thaw_one, NULL);
 	kfree(work);
-	printk(KERN_WARNING "Emergency Thaw complete\n");
+	pr_warn("Emergency Thaw complete\n");
 }
 
 /**
@@ -1066,10 +1063,9 @@ grow_buffers(struct block_device *bdev, sector_t block, int size)
 	if (unlikely(index != block >> sizebits)) {
 		char b[BDEVNAME_SIZE];
 
-		printk(KERN_ERR "%s: requested out-of-range block %llu for "
-			"device %s\n",
-			__func__, (unsigned long long)block,
-			bdevname(bdev, b));
+		pr_err("%s: requested out-of-range block %llu for device %s\n",
+		       __func__, (unsigned long long)block,
+		       bdevname(bdev, b));
 		return -EIO;
 	}
 	block = index << sizebits;
@@ -1088,10 +1084,9 @@ __getblk_slow(struct block_device *bdev, sector_t block, int size)
 	/* Size must be multiple of hard sectorsize */
 	if (unlikely(size & (bdev_logical_block_size(bdev)-1) ||
 			(size < 512 || size > PAGE_SIZE))) {
-		printk(KERN_ERR "getblk(): invalid block size %d requested\n",
-					size);
-		printk(KERN_ERR "logical block size: %d\n",
-					bdev_logical_block_size(bdev));
+		pr_err("getblk(): invalid block size %d requested\n", size);
+		pr_err("logical block size: %d\n",
+		       bdev_logical_block_size(bdev));
 
 		dump_stack();
 		return NULL;
@@ -3174,10 +3169,9 @@ SYSCALL_DEFINE2(bdflush, int, func, long, data)
 
 	if (msg_count < 5) {
 		msg_count++;
-		printk(KERN_INFO
-			"warning: process `%s' used the obsolete bdflush"
-			" system call\n", current->comm);
-		printk(KERN_INFO "Fix your initscripts?\n");
+		pr_info("warning: process `%s' used the obsolete bdflush system call\n",
+			current->comm);
+		pr_info("Fix your initscripts?\n");
 	}
 
 	if (func == 1)
-- 
1.7.6.405.gc1be0

[PATCH 02/28] mbcache: Use current logging styles

[Joe Perches]

Convert mb_<level> uses to current logging styles.
Add newlines to uses, remove from #define to consolidate
output and avoid possible message interleaving.
Add #define pr_fmt.
Align arguments.
Neaten macro defines.

Signed-off-by: Joe Perches <joe@perches.com>
---
 fs/mbcache.c |   40 ++++++++++++++++++++--------------------
 1 files changed, 20 insertions(+), 20 deletions(-)

diff --git a/fs/mbcache.c b/fs/mbcache.c
index 8c32ef3..a3c533c 100644
--- a/fs/mbcache.c
+++ b/fs/mbcache.c
@@ -26,6 +26,8 @@
  * back on the lru list.
  */
 
+#define pr_fmt(fmt) KBUILD_MODNAME ": " fmt
+
 #include <linux/kernel.h>
 #include <linux/module.h>
 
@@ -37,23 +39,22 @@
 #include <linux/init.h>
 #include <linux/mbcache.h>
 
-
 #ifdef MB_CACHE_DEBUG
-# define mb_debug(f...) do { \
-		printk(KERN_DEBUG f); \
-		printk("\n"); \
-	} while (0)
-#define mb_assert(c) do { if (!(c)) \
-		printk(KERN_ERR "assertion " #c " failed\n"); \
-	} while(0)
+# define mb_debug(fmt, ...)				\
+	pr_debug(fmt, ##__VA_ARGS__)
+# define mb_assert(c)					\
+do {							\
+	if (!(c))					\
+		pr_err("assertion " #c " failed\n");	\
+} while (0)
 #else
-# define mb_debug(f...) do { } while(0)
-# define mb_assert(c) do { } while(0)
+# define mb_debug(fmt, ...)				\
+	no_printk(fmt, ##__VA_ARGS__)
+# define mb_assert(c)					\
+	do { } while (0)
 #endif
-#define mb_error(f...) do { \
-		printk(KERN_ERR f); \
-		printk("\n"); \
-	} while(0)
+#define mb_err(fmt, ...)				\
+	pr_err(fmt, ##__VA_ARGS__)
 
 #define MB_CACHE_WRITER ((unsigned short)~0U >> 1)
 
@@ -171,7 +172,7 @@ mb_cache_shrink_fn(struct shrinker *shrink, struct shrink_control *sc)
 	int nr_to_scan = sc->nr_to_scan;
 	gfp_t gfp_mask = sc->gfp_mask;
 
-	mb_debug("trying to free %d entries", nr_to_scan);
+	mb_debug("trying to free %d entries\n", nr_to_scan);
 	spin_lock(&mb_cache_spinlock);
 	while (nr_to_scan-- && !list_empty(&mb_cache_lru_list)) {
 		struct mb_cache_entry *ce =
@@ -181,8 +182,8 @@ mb_cache_shrink_fn(struct shrinker *shrink, struct shrink_control *sc)
 		__mb_cache_entry_unhash(ce);
 	}
 	list_for_each_entry(cache, &mb_cache_list, c_cache_list) {
-		mb_debug("cache %s (%d)", cache->c_name,
-			  atomic_read(&cache->c_entry_count));
+		mb_debug("cache %s (%d)\n",
+			 cache->c_name, atomic_read(&cache->c_entry_count));
 		count += atomic_read(&cache->c_entry_count);
 	}
 	spin_unlock(&mb_cache_spinlock);
@@ -318,9 +319,8 @@ mb_cache_destroy(struct mb_cache *cache)
 	}
 
 	if (atomic_read(&cache->c_entry_count) > 0) {
-		mb_error("cache %s: %d orphaned entries",
-			  cache->c_name,
-			  atomic_read(&cache->c_entry_count));
+		mb_err("cache %s: %d orphaned entries\n",
+		       cache->c_name, atomic_read(&cache->c_entry_count));
 	}
 
 	kmem_cache_destroy(cache->c_entry_cache);
-- 
1.7.6.405.gc1be0

[PATCH 03/28] bio: Use current logging styles

[Joe Perches]

Add and use pr_fmt and pr_<level>

Signed-off-by: Joe Perches <joe@perches.com>
---
 fs/bio.c |    5 ++++-
 1 files changed, 4 insertions(+), 1 deletions(-)

diff --git a/fs/bio.c b/fs/bio.c
index b1fe82c..98acfb1 100644
--- a/fs/bio.c
+++ b/fs/bio.c
@@ -15,6 +15,9 @@
  * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-
  *
  */
+
+#define pr_fmt(fmt) KBUILD_MODNAME ": " fmt
+
 #include <linux/mm.h>
 #include <linux/swap.h>
 #include <linux/bio.h>
@@ -111,7 +114,7 @@ static struct kmem_cache *bio_find_or_create_slab(unsigned int extra_size)
 	if (!slab)
 		goto out_unlock;
 
-	printk(KERN_INFO "bio: create slab <%s> at %d\n", bslab->name, entry);
+	pr_info("create slab <%s> at %d\n", bslab->name, entry);
 	bslab->slab = slab;
 	bslab->slab_ref = 1;
 	bslab->slab_size = sz;
-- 
1.7.6.405.gc1be0

[PATCH 04/28] libfs: Use current logging styles

[Joe Perches]

Add and use pr_fmt and pr_<level>.
Coalesce long format strings.

Signed-off-by: Joe Perches <joe@perches.com>
---
 fs/libfs.c |    7 ++++---
 1 files changed, 4 insertions(+), 3 deletions(-)

diff --git a/fs/libfs.c b/fs/libfs.c
index f6d411e..ad1532f 100644
--- a/fs/libfs.c
+++ b/fs/libfs.c
@@ -3,6 +3,8 @@
  *	Library for filesystems writers.
  */
 
+#define pr_fmt(fmt) KBUILD_MODNAME ": " fmt
+
 #include <linux/module.h>
 #include <linux/pagemap.h>
 #include <linux/slab.h>
@@ -502,9 +504,8 @@ int simple_fill_super(struct super_block *s, unsigned long magic,
 
 		/* warn if it tries to conflict with the root inode */
 		if (unlikely(i == 1))
-			printk(KERN_WARNING "%s: %s passed in a files array"
-				"with an index of 1!\n", __func__,
-				s->s_type->name);
+			pr_warn("%s: %s passed in a files array with an index of 1!\n",
+				__func__, s->s_type->name);
 
 		dentry = d_alloc_name(root, files->name);
 		if (!dentry)
-- 
1.7.6.405.gc1be0

[PATCH 05/28] super: Use current logging styles

[Joe Perches]

Add and use pr_fmt and pr_<level>
Add printk level KERN_CRIT to "busy inodes after dismount" message.
Coalesce long format.

Signed-off-by: Joe Perches <joe@perches.com>
---
 fs/super.c |   20 ++++++++++----------
 1 files changed, 10 insertions(+), 10 deletions(-)

diff --git a/fs/super.c b/fs/super.c
index b83d1c1..23ff118 100644
--- a/fs/super.c
+++ b/fs/super.c
@@ -20,6 +20,8 @@
  *  Heavily rewritten for 'one fs - one tree' dcache architecture. AV, Mar 2000
  */
 
+#define pr_fmt(fmt) "VFS: " fmt
+
 #include <linux/module.h>
 #include <linux/slab.h>
 #include <linux/acct.h>
@@ -393,9 +395,8 @@ void generic_shutdown_super(struct super_block *sb)
 			sop->put_super(sb);
 
 		if (!list_empty(&sb->s_inodes)) {
-			printk("VFS: Busy inodes after unmount of %s. "
-			   "Self-destruct in 5 seconds.  Have a nice day...\n",
-			   sb->s_id);
+			pr_crit("Busy inodes after unmount of %s. Self-destruct in 5 seconds.  Have a nice day...\n",
+				sb->s_id);
 		}
 	}
 	spin_lock(&sb_lock);
@@ -777,7 +778,7 @@ static void do_emergency_remount(struct work_struct *work)
 		__put_super(p);
 	spin_unlock(&sb_lock);
 	kfree(work);
-	printk("Emergency Remount complete\n");
+	pr_info("Emergency Remount complete\n");
 }
 
 void emergency_remount(void)
@@ -1110,8 +1111,9 @@ mount_fs(struct file_system_type *type, int flags, const char *name, void *data)
 	 * this warning for a little while to try and catch filesystems that
 	 * violate this rule.
 	 */
-	WARN((sb->s_maxbytes < 0), "%s set sb->s_maxbytes to "
-		"negative value (%lld)\n", type->name, sb->s_maxbytes);
+	WARN((sb->s_maxbytes < 0),
+	     "%s set sb->s_maxbytes to negative value (%lld)\n",
+	     type->name, sb->s_maxbytes);
 
 	up_write(&sb->s_umount);
 	free_secdata(secdata);
@@ -1163,8 +1165,7 @@ int freeze_super(struct super_block *sb)
 	if (sb->s_op->freeze_fs) {
 		ret = sb->s_op->freeze_fs(sb);
 		if (ret) {
-			printk(KERN_ERR
-				"VFS:Filesystem freeze failed\n");
+			pr_err("Filesystem freeze failed\n");
 			sb->s_frozen = SB_UNFROZEN;
 			deactivate_locked_super(sb);
 			return ret;
@@ -1197,8 +1198,7 @@ int thaw_super(struct super_block *sb)
 	if (sb->s_op->unfreeze_fs) {
 		error = sb->s_op->unfreeze_fs(sb);
 		if (error) {
-			printk(KERN_ERR
-				"VFS:Filesystem thaw failed\n");
+			pr_err("Filesystem thaw failed\n");
 			sb->s_frozen = SB_FREEZE_TRANS;
 			up_write(&sb->s_umount);
 			return error;
-- 
1.7.6.405.gc1be0

[PATCH 06/28] exec: Use current logging style

[Joe Perches]

Convert printks to pr_<level>.
Add pr_fmt.

Signed-off-by: Joe Perches <joe@perches.com>
---
 fs/exec.c |   23 +++++++++++------------
 1 files changed, 11 insertions(+), 12 deletions(-)

diff --git a/fs/exec.c b/fs/exec.c
index 3625464..0839da4 100644
--- a/fs/exec.c
+++ b/fs/exec.c
@@ -22,6 +22,8 @@
  * formats. 
  */
 
+#define pr_fmt(fmt) KBUILD_MODNAME ": " fmt
+
 #include <linux/slab.h>
 #include <linux/file.h>
 #include <linux/fdtable.h>
@@ -2148,8 +2150,8 @@ void do_coredump(long signr, int exit_code, struct pt_regs *regs)
 		char **helper_argv;
 
 		if (ispipe < 0) {
-			printk(KERN_WARNING "format_corename failed\n");
-			printk(KERN_WARNING "Aborting core\n");
+			pr_warn("format_corename failed\n");
+			pr_warn("Aborting core\n");
 			goto fail_corename;
 		}
 
@@ -2168,26 +2170,24 @@ void do_coredump(long signr, int exit_code, struct pt_regs *regs)
 			 * right pid if a thread in a multi-threaded
 			 * core_pattern process dies.
 			 */
-			printk(KERN_WARNING
-				"Process %d(%s) has RLIMIT_CORE set to 1\n",
+			pr_warn("Process %d(%s) has RLIMIT_CORE set to 1\n",
 				task_tgid_vnr(current), current->comm);
-			printk(KERN_WARNING "Aborting core\n");
+			pr_warn("Aborting core\n");
 			goto fail_unlock;
 		}
 		cprm.limit = RLIM_INFINITY;
 
 		dump_count = atomic_inc_return(&core_dump_count);
 		if (core_pipe_limit && (core_pipe_limit < dump_count)) {
-			printk(KERN_WARNING "Pid %d(%s) over core_pipe_limit\n",
-			       task_tgid_vnr(current), current->comm);
-			printk(KERN_WARNING "Skipping core dump\n");
+			pr_warn("Pid %d(%s) over core_pipe_limit\n",
+				task_tgid_vnr(current), current->comm);
+			pr_warn("Skipping core dump\n");
 			goto fail_dropcount;
 		}
 
 		helper_argv = argv_split(GFP_KERNEL, cn.corename+1, NULL);
 		if (!helper_argv) {
-			printk(KERN_WARNING "%s failed to allocate memory\n",
-			       __func__);
+			pr_warn("%s failed to allocate memory\n", __func__);
 			goto fail_dropcount;
 		}
 
@@ -2196,8 +2196,7 @@ void do_coredump(long signr, int exit_code, struct pt_regs *regs)
 					NULL, &cprm);
 		argv_free(helper_argv);
 		if (retval) {
- 			printk(KERN_INFO "Core dump to %s pipe failed\n",
-			       cn.corename);
+			pr_info("Core dump to %s pipe failed\n", cn.corename);
 			goto close_fail;
  		}
 	} else {
-- 
1.7.6.405.gc1be0

[PATCH 07/28] namespace: Use current logging styles

[Joe Perches]

Add and use pr_fmt and pr_<level>.
This adds a "namespace: " prefix to logging output.

Signed-off-by: Joe Perches <joe@perches.com>
---
 fs/namespace.c |    9 +++++----
 1 files changed, 5 insertions(+), 4 deletions(-)

diff --git a/fs/namespace.c b/fs/namespace.c
index 874dc5c..f9a164d 100644
--- a/fs/namespace.c
+++ b/fs/namespace.c
@@ -8,6 +8,8 @@
  * Heavily rewritten.
  */
 
+#define pr_fmt(fmt) KBUILD_MODNAME ": " fmt
+
 #include <linux/syscalls.h>
 #include <linux/slab.h>
 #include <linux/sched.h>
@@ -2716,7 +2718,7 @@ void __init mnt_init(void)
 	if (!mount_hashtable)
 		panic("Failed to allocate mount hash table\n");
 
-	printk(KERN_INFO "Mount-cache hash table entries: %lu\n", HASH_SIZE);
+	pr_info("Mount-cache hash table entries: %lu\n", HASH_SIZE);
 
 	for (u = 0; u < HASH_SIZE; u++)
 		INIT_LIST_HEAD(&mount_hashtable[u]);
@@ -2725,11 +2727,10 @@ void __init mnt_init(void)
 
 	err = sysfs_init();
 	if (err)
-		printk(KERN_WARNING "%s: sysfs_init error: %d\n",
-			__func__, err);
+		pr_warn("%s: sysfs_init error: %d\n", __func__, err);
 	fs_kobj = kobject_create_and_add("fs", NULL);
 	if (!fs_kobj)
-		printk(KERN_WARNING "%s: kobj create error\n", __func__);
+		pr_warn("%s: kobj create error\n", __func__);
 	init_rootfs();
 	init_mount_tree();
 }
-- 
1.7.6.405.gc1be0

[PATCH 08/28] block_dev: Use current logging style

[Joe Perches]

Add and use pr_fmt and pr_<level>
Coalesce formats.

No change in output as pr_fmt is #define pr_fmt(fmt) fmt

Signed-off-by: Joe Perches <joe@perches.com>
---
 fs/block_dev.c |   11 ++++++-----
 1 files changed, 6 insertions(+), 5 deletions(-)

diff --git a/fs/block_dev.c b/fs/block_dev.c
index 3154fbe..20aa631 100644
--- a/fs/block_dev.c
+++ b/fs/block_dev.c
@@ -5,6 +5,8 @@
  *  Copyright (C) 2001  Andrea Arcangeli <andrea@suse.de> SuSE
  */
 
+#define pr_fmt(fmt) fmt
+
 #include <linux/init.h>
 #include <linux/mm.h>
 #include <linux/fcntl.h>
@@ -965,8 +967,8 @@ static void flush_disk(struct block_device *bdev, bool kill_dirty)
 
 		if (bdev->bd_disk)
 			disk_name(bdev->bd_disk, 0, name);
-		printk(KERN_WARNING "VFS: busy inodes on changed media or "
-		       "resized disk %s\n", name);
+		pr_warn("VFS: busy inodes on changed media or resized disk %s\n",
+			name);
 	}
 
 	if (!bdev->bd_disk)
@@ -993,9 +995,8 @@ void check_disk_size_change(struct gendisk *disk, struct block_device *bdev)
 		char name[BDEVNAME_SIZE];
 
 		disk_name(disk, 0, name);
-		printk(KERN_INFO
-		       "%s: detected capacity change from %lld to %lld\n",
-		       name, bdev_size, disk_size);
+		pr_info("%s: detected capacity change from %lld to %lld\n",
+			name, bdev_size, disk_size);
 		i_size_write(bdev->bd_inode, disk_size);
 		flush_disk(bdev, false);
 	}
-- 
1.7.6.405.gc1be0

[PATCH 09/28] dcache: Use current logging style

[Joe Perches]

Add and use pr_fmt and pr_<level>.
No change in output with #define pr_fmt(fmt) fmt

Signed-off-by: Joe Perches <joe@perches.com>
---
 fs/dcache.c |    9 ++++-----
 1 files changed, 4 insertions(+), 5 deletions(-)

diff --git a/fs/dcache.c b/fs/dcache.c
index 3abfec7..6055631 100644
--- a/fs/dcache.c
+++ b/fs/dcache.c
@@ -14,6 +14,8 @@
  * the dcache entry is deleted or garbage collected.
  */
 
+#define pr_fmt(fmt) fmt
+
 #include <linux/syscalls.h>
 #include <linux/string.h>
 #include <linux/mm.h>
@@ -890,10 +892,7 @@ static void shrink_dcache_for_umount_subtree(struct dentry *dentry)
 			__d_shrink(dentry);
 
 			if (dentry->d_count != 0) {
-				printk(KERN_ERR
-				       "BUG: Dentry %p{i=%lx,n=%s}"
-				       " still in use (%d)"
-				       " [unmount of %s %s]\n",
+				pr_err("BUG: Dentry %p{i=%lx,n=%s} still in use (%d) [unmount of %s %s]\n",
 				       dentry,
 				       dentry->d_inode ?
 				       dentry->d_inode->i_ino : 0UL,
@@ -2164,7 +2163,7 @@ static void dentry_unlock_parents_for_move(struct dentry *dentry,
 static void __d_move(struct dentry * dentry, struct dentry * target)
 {
 	if (!dentry->d_inode)
-		printk(KERN_WARNING "VFS: moving negative dcache entry\n");
+		pr_warn("VFS: moving negative dcache entry\n");
 
 	BUG_ON(d_ancestor(dentry, target));
 	BUG_ON(d_ancestor(target, dentry));
-- 
1.7.6.405.gc1be0

[PATCH 10/28] fcntl: Use current logging style

[Joe Perches]

Add and use pr_fmt and pr_<level>.
Output message now prefixed with "fcntl: " and
%s:, __func__, (kill_fasync_rcu) now used as well.

Signed-off-by: Joe Perches <joe@perches.com>
---
 fs/fcntl.c |    6 ++++--
 1 files changed, 4 insertions(+), 2 deletions(-)

diff --git a/fs/fcntl.c b/fs/fcntl.c
index 22764c7..5d16b1d 100644
--- a/fs/fcntl.c
+++ b/fs/fcntl.c
@@ -4,6 +4,8 @@
  *  Copyright (C) 1991, 1992  Linus Torvalds
  */
 
+#define pr_fmt(fmt) KBUILD_MODNAME ": " fmt
+
 #include <linux/syscalls.h>
 #include <linux/init.h>
 #include <linux/mm.h>
@@ -797,8 +799,8 @@ static void kill_fasync_rcu(struct fasync_struct *fa, int sig, int band)
 		unsigned long flags;
 
 		if (fa->magic != FASYNC_MAGIC) {
-			printk(KERN_ERR "kill_fasync: bad magic number in "
-			       "fasync_struct!\n");
+			pr_err("%s: bad magic number in fasync_struct!\n",
+			       __func__);
 			return;
 		}
 		spin_lock_irqsave(&fa->fa_lock, flags);
-- 
1.7.6.405.gc1be0

[PATCH 11/28] file: Use current logging style

[Joe Perches]

Add and use pr_fmt and pr_<level>
Now prefixed a single message with "file: " and
changed an embedded function name to "%s: ", __func__.

Signed-off-by: Joe Perches <joe@perches.com>
---
 fs/file.c |    4 +++-
 1 files changed, 3 insertions(+), 1 deletions(-)

diff --git a/fs/file.c b/fs/file.c
index 4c6992d..a88b110 100644
--- a/fs/file.c
+++ b/fs/file.c
@@ -6,6 +6,8 @@
  *  Manage the dynamic fd arrays in the process files_struct.
  */
 
+#define pr_fmt(fmt) KBUILD_MODNAME ": " fmt
+
 #include <linux/module.h>
 #include <linux/fs.h>
 #include <linux/mm.h>
@@ -469,7 +471,7 @@ repeat:
 #if 1
 	/* Sanity check */
 	if (rcu_dereference_raw(fdt->fd[fd]) != NULL) {
-		printk(KERN_WARNING "alloc_fd: slot %d not NULL!\n", fd);
+		pr_warn("%s: slot %d not NULL!\n", __func__, fd);
 		rcu_assign_pointer(fdt->fd[fd], NULL);
 	}
 #endif
-- 
1.7.6.405.gc1be0

[PATCH 12/28] locks: Use current logging style

[Joe Perches]

Add and use pr_fmt and pr_<level>.
Prefix message with "file: " and convert embedded function name
to "%s: ", __func__.

Signed-off-by: Joe Perches <joe@perches.com>
---
 fs/locks.c |    4 +++-
 1 files changed, 3 insertions(+), 1 deletions(-)

diff --git a/fs/locks.c b/fs/locks.c
index 3b0d05d..10f2bdb 100644
--- a/fs/locks.c
+++ b/fs/locks.c
@@ -114,6 +114,8 @@
  *  Stephen Rothwell <sfr@canb.auug.org.au>, June, 2000.
  */
 
+#define pr_fmt(fmt) KBUILD_MODNAME ": " fmt
+
 #include <linux/capability.h>
 #include <linux/file.h>
 #include <linux/fdtable.h>
@@ -581,7 +583,7 @@ static void locks_delete_lock(struct file_lock **thisfl_p)
 
 	fasync_helper(0, fl->fl_file, 0, &fl->fl_fasync);
 	if (fl->fl_fasync != NULL) {
-		printk(KERN_ERR "locks_delete_lock: fasync == %p\n", fl->fl_fasync);
+		pr_err("%s: fasync == %p\n", __func__, fl->fl_fasync);
 		fl->fl_fasync = NULL;
 	}
 
-- 
1.7.6.405.gc1be0

[PATCH 13/28] open: Use current logging style

[Joe Perches]

Add and use pr_fmt and pr_<level>
No change to output using #define pr_fmt(fmt) fmt

Signed-off-by: Joe Perches <joe@perches.com>
---
 fs/open.c |    4 +++-
 1 files changed, 3 insertions(+), 1 deletions(-)

diff --git a/fs/open.c b/fs/open.c
index 22c41b5..58c8d94 100644
--- a/fs/open.c
+++ b/fs/open.c
@@ -4,6 +4,8 @@
  *  Copyright (C) 1991, 1992  Linus Torvalds
  */
 
+#define pr_fmt(fmt) fmt
+
 #include <linux/string.h>
 #include <linux/mm.h>
 #include <linux/file.h>
@@ -1043,7 +1045,7 @@ int filp_close(struct file *filp, fl_owner_t id)
 	int retval = 0;
 
 	if (!file_count(filp)) {
-		printk(KERN_ERR "VFS: Close: file count is 0\n");
+		pr_err("VFS: Close: file count is 0\n");
 		return 0;
 	}
 
-- 
1.7.6.405.gc1be0

[PATCH 14/28] stat: Use current logging style

[Joe Perches]

Add and use pr_fmt and pr_<level>.
No change to output with #define pr_fmt(fmt) fmt

Signed-off-by: Joe Perches <joe@perches.com>
---
 fs/stat.c |    4 +++-
 1 files changed, 3 insertions(+), 1 deletions(-)

diff --git a/fs/stat.c b/fs/stat.c
index 8806b89..ff9be35 100644
--- a/fs/stat.c
+++ b/fs/stat.c
@@ -4,6 +4,8 @@
  *  Copyright (C) 1991, 1992  Linus Torvalds
  */
 
+#define pr_fmt(fmt) fmt
+
 #include <linux/module.h>
 #include <linux/mm.h>
 #include <linux/errno.h>
@@ -121,7 +123,7 @@ static int cp_old_stat(struct kstat *stat, struct __old_kernel_stat __user * sta
 	
 	if (warncount > 0) {
 		warncount--;
-		printk(KERN_WARNING "VFS: Warning: %s using old stat() call. Recompile your binary.\n",
+		pr_warn("VFS: Warning: %s using old stat() call. Recompile your binary.\n",
 			current->comm);
 	} else if (warncount < 0) {
 		/* it's laughable, but... */
-- 
1.7.6.405.gc1be0

[PATCH 15/28] exec: checkpatch wanking

[Joe Perches]

Fix a few style things, all but 1 false positive,
the #include <asm/mmu_context.h> warning, has been
cleaned.

$ ./scripts/checkpatch.pl --terse -f fs/exec.c | cut -f3- -d":" |sort|uniq -c
      4  ERROR: code indent should use tabs where possible
      1  ERROR: do not initialise globals to 0 or NULL
      2  ERROR: do not use assignment in if condition
     10  ERROR: "foo * bar" should be "foo *bar"
      1  ERROR: space required after that ',' (ctx:OxV)
      3  ERROR: space required after that ',' (ctx:VxV)
      1  ERROR: space required before the open parenthesis '('
      2  ERROR: spaces required around that '<=' (ctx:VxV)
      1  ERROR: spaces required around that '<' (ctx:VxV)
      2  ERROR: spaces required around that '==' (ctx:VxV)
      2  ERROR: spaces required around that '=' (ctx:VxV)
      5  ERROR: trailing whitespace
      1  WARNING: braces {} are not necessary for single statement blocks
      6  WARNING: EXPORT_SYMBOL(foo); should immediately follow its function/variable
      3  WARNING: line over 80 characters
      4  WARNING: please, no space before tabs
      4  WARNING: please, no spaces at the start of a line
      1  WARNING: Use #include <linux/mmu_context.h> instead of <asm/mmu_context.h>
      1  WARNING: Use #include <linux/uaccess.h> instead of <asm/uaccess.h>

Signed-off-by: Joe Perches <joe@perches.com>
---
 fs/exec.c |   83 +++++++++++++++++++++++++++++++------------------------------
 1 files changed, 42 insertions(+), 41 deletions(-)

diff --git a/fs/exec.c b/fs/exec.c
index 0839da4..1365d02 100644
--- a/fs/exec.c
+++ b/fs/exec.c
@@ -19,7 +19,7 @@
  * current->executable is only used by the procfs.  This allows a dispatch
  * table to check for several different types  of binary formats.  We keep
  * trying until we recognize the file or we run out of supported binary
- * formats. 
+ * formats.
  */
 
 #define pr_fmt(fmt) KBUILD_MODNAME ": " fmt
@@ -58,7 +58,7 @@
 #include <linux/oom.h>
 #include <linux/compat.h>
 
-#include <asm/uaccess.h>
+#include <linux/uaccess.h>
 #include <asm/mmu_context.h>
 #include <asm/tlb.h>
 #include "internal.h"
@@ -66,7 +66,7 @@
 int core_uses_pid;
 char core_pattern[CORENAME_MAX_SIZE] = "core";
 unsigned int core_pipe_limit;
-int suid_dumpable = 0;
+int suid_dumpable;
 
 struct core_name {
 	char *corename;
@@ -79,7 +79,7 @@ static atomic_t call_count = ATOMIC_INIT(1);
 static LIST_HEAD(formats);
 static DEFINE_RWLOCK(binfmt_lock);
 
-int __register_binfmt(struct linux_binfmt * fmt, int insert)
+int __register_binfmt(struct linux_binfmt *fmt, int insert)
 {
 	if (!fmt)
 		return -EINVAL;
@@ -87,21 +87,19 @@ int __register_binfmt(struct linux_binfmt * fmt, int insert)
 	insert ? list_add(&fmt->lh, &formats) :
 		 list_add_tail(&fmt->lh, &formats);
 	write_unlock(&binfmt_lock);
-	return 0;	
+	return 0;
 }
-
 EXPORT_SYMBOL(__register_binfmt);
 
-void unregister_binfmt(struct linux_binfmt * fmt)
+void unregister_binfmt(struct linux_binfmt *fmt)
 {
 	write_lock(&binfmt_lock);
 	list_del(&fmt->lh);
 	write_unlock(&binfmt_lock);
 }
-
 EXPORT_SYMBOL(unregister_binfmt);
 
-static inline void put_binfmt(struct linux_binfmt * fmt)
+static inline void put_binfmt(struct linux_binfmt *fmt)
 {
 	module_put(fmt->module);
 }
@@ -143,8 +141,8 @@ SYSCALL_DEFINE1(uselib, const char __user *, library)
 	fsnotify_open(file);
 
 	error = -ENOEXEC;
-	if(file->f_op) {
-		struct linux_binfmt * fmt;
+	if (file->f_op) {
+		struct linux_binfmt *fmt;
 
 		read_lock(&binfmt_lock);
 		list_for_each_entry(fmt, &formats, lh) {
@@ -164,7 +162,7 @@ SYSCALL_DEFINE1(uselib, const char __user *, library)
 exit:
 	fput(file);
 out:
-  	return error;
+	return error;
 }
 
 #ifdef CONFIG_MMU
@@ -811,13 +809,12 @@ int kernel_read(struct file *file, loff_t offset,
 	set_fs(old_fs);
 	return result;
 }
-
 EXPORT_SYMBOL(kernel_read);
 
 static int exec_mmap(struct mm_struct *mm)
 {
 	struct task_struct *tsk;
-	struct mm_struct * old_mm, *active_mm;
+	struct mm_struct *old_mm, *active_mm;
 
 	/* Notify parent that we're no longer interested in the old VM */
 	tsk = current;
@@ -1012,7 +1009,7 @@ no_thread_group:
  * These functions flushes out all traces of the currently running executable
  * so that a new one can be started
  */
-static void flush_old_files(struct files_struct * files)
+static void flush_old_files(struct files_struct *files)
 {
 	long j = -1;
 	struct fdtable *fdt;
@@ -1031,10 +1028,9 @@ static void flush_old_files(struct files_struct * files)
 			continue;
 		fdt->close_on_exec->fds_bits[j] = 0;
 		spin_unlock(&files->file_lock);
-		for ( ; set ; i++,set >>= 1) {
-			if (set & 1) {
+		for (; set; i++, set >>= 1) {
+			if (set & 1)
 				sys_close(i);
-			}
 		}
 		spin_lock(&files->file_lock);
 
@@ -1069,7 +1065,7 @@ void set_task_comm(struct task_struct *tsk, char *buf)
 	perf_event_comm(tsk);
 }
 
-int flush_old_exec(struct linux_binprm * bprm)
+int flush_old_exec(struct linux_binprm *bprm)
 {
 	int retval;
 
@@ -1112,7 +1108,7 @@ void would_dump(struct linux_binprm *bprm, struct file *file)
 }
 EXPORT_SYMBOL(would_dump);
 
-void setup_new_exec(struct linux_binprm * bprm)
+void setup_new_exec(struct linux_binprm *bprm)
 {
 	int i, ch;
 	const char *name;
@@ -1131,7 +1127,7 @@ void setup_new_exec(struct linux_binprm * bprm)
 	name = bprm->filename;
 
 	/* Copies the binary name from after last slash */
-	for (i=0; (ch = *(name++)) != '\0';) {
+	for (i = 0; (ch = *(name++)) != '\0';) {
 		if (ch == '/')
 			i = 0; /* overwrite what we wrote */
 		else
@@ -1168,7 +1164,7 @@ void setup_new_exec(struct linux_binprm * bprm)
 	   group */
 
 	current->self_exec_id++;
-			
+
 	flush_signal_handlers(current, 0);
 	flush_old_files(current->files);
 }
@@ -1263,8 +1259,8 @@ int check_unsafe_exec(struct linux_binprm *bprm)
 	return res;
 }
 
-/* 
- * Fill the binprm structure from the inode. 
+/*
+ * Fill the binprm structure from the inode.
  * Check permissions, then read the first 128 (BINPRM_BUF_SIZE) bytes
  *
  * This may be called multiple times for binary chains (scripts for example).
@@ -1272,7 +1268,7 @@ int check_unsafe_exec(struct linux_binprm *bprm)
 int prepare_binprm(struct linux_binprm *bprm)
 {
 	umode_t mode;
-	struct inode * inode = bprm->file->f_path.dentry->d_inode;
+	struct inode *inode = bprm->file->f_path.dentry->d_inode;
 	int retval;
 
 	mode = inode->i_mode;
@@ -1311,7 +1307,6 @@ int prepare_binprm(struct linux_binprm *bprm)
 	memset(bprm->buf, 0, BINPRM_BUF_SIZE);
 	return kernel_read(bprm->file, 0, bprm->buf, BINPRM_BUF_SIZE);
 }
-
 EXPORT_SYMBOL(prepare_binprm);
 
 /*
@@ -1361,10 +1356,10 @@ EXPORT_SYMBOL(remove_arg_zero);
 /*
  * cycle the list of binary formats handler, until one recognizes the image
  */
-int search_binary_handler(struct linux_binprm *bprm,struct pt_regs *regs)
+int search_binary_handler(struct linux_binprm *bprm, struct pt_regs *regs)
 {
 	unsigned int depth = bprm->recursion_depth;
-	int try,retval;
+	int try, retval;
 	struct linux_binfmt *fmt;
 	pid_t old_pid;
 
@@ -1382,10 +1377,11 @@ int search_binary_handler(struct linux_binprm *bprm,struct pt_regs *regs)
 	rcu_read_unlock();
 
 	retval = -ENOENT;
-	for (try=0; try<2; try++) {
+	for (try = 0; try < 2; try++) {
 		read_lock(&binfmt_lock);
 		list_for_each_entry(fmt, &formats, lh) {
-			int (*fn)(struct linux_binprm *, struct pt_regs *) = fmt->load_binary;
+			int (*fn)(struct linux_binprm *, struct pt_regs *) =
+				fmt->load_binary;
 			if (!fn)
 				continue;
 			if (!try_module_get(fmt->module))
@@ -1425,7 +1421,10 @@ int search_binary_handler(struct linux_binprm *bprm,struct pt_regs *regs)
 		if (retval != -ENOEXEC || bprm->mm == NULL) {
 			break;
 		} else {
-#define printable(c) (((c)=='\t') || ((c)=='\n') || (0x20<=(c) && (c)<=0x7e))
+
+#define printable(c)							\
+	(((c) == '\t') || ((c) == '\n') || (0x20 <= (c) && (c) <= 0x7e))
+
 			if (printable(bprm->buf[0]) &&
 			    printable(bprm->buf[1]) &&
 			    printable(bprm->buf[2]) &&
@@ -1433,7 +1432,8 @@ int search_binary_handler(struct linux_binprm *bprm,struct pt_regs *regs)
 				break; /* -ENOEXEC */
 			if (try)
 				break; /* -ENOEXEC */
-			request_module("binfmt-%04x", *(unsigned short *)(&bprm->buf[2]));
+			request_module("binfmt-%04x",
+				       *(unsigned short *)(&bprm->buf[2]));
 		}
 #else
 		break;
@@ -1441,7 +1441,6 @@ int search_binary_handler(struct linux_binprm *bprm,struct pt_regs *regs)
 	}
 	return retval;
 }
-
 EXPORT_SYMBOL(search_binary_handler);
 
 /*
@@ -1510,11 +1509,13 @@ static int do_execve_common(const char *filename,
 		goto out_file;
 
 	bprm->argc = count(argv, MAX_ARG_STRINGS);
-	if ((retval = bprm->argc) < 0)
+	retval = bprm->argc;
+	if (retval < 0)
 		goto out;
 
 	bprm->envc = count(envp, MAX_ARG_STRINGS);
-	if ((retval = bprm->envc) < 0)
+	retval = bprm->envc;
+	if (retval < 0)
 		goto out;
 
 	retval = prepare_binprm(bprm);
@@ -1534,7 +1535,7 @@ static int do_execve_common(const char *filename,
 	if (retval < 0)
 		goto out;
 
-	retval = search_binary_handler(bprm,regs);
+	retval = search_binary_handler(bprm, regs);
 	if (retval < 0)
 		goto out;
 
@@ -1613,7 +1614,6 @@ void set_binfmt(struct linux_binfmt *new)
 	if (new)
 		__module_get(new->module);
 }
-
 EXPORT_SYMBOL(set_binfmt);
 
 static int expand_corename(struct core_name *cn)
@@ -2090,7 +2090,7 @@ void do_coredump(long signr, int exit_code, struct pt_regs *regs)
 	struct core_state core_state;
 	struct core_name cn;
 	struct mm_struct *mm = current->mm;
-	struct linux_binfmt * binfmt;
+	struct linux_binfmt *binfmt;
 	const struct cred *old_cred;
 	struct cred *cred;
 	int retval = 0;
@@ -2145,7 +2145,7 @@ void do_coredump(long signr, int exit_code, struct pt_regs *regs)
 
 	ispipe = format_corename(&cn, signr);
 
- 	if (ispipe) {
+	if (ispipe) {
 		int dump_count;
 		char **helper_argv;
 
@@ -2198,7 +2198,7 @@ void do_coredump(long signr, int exit_code, struct pt_regs *regs)
 		if (retval) {
 			pr_info("Core dump to %s pipe failed\n", cn.corename);
 			goto close_fail;
- 		}
+		}
 	} else {
 		struct inode *inode;
 
@@ -2264,7 +2264,8 @@ fail:
  */
 int dump_write(struct file *file, const void *addr, int nr)
 {
-	return access_ok(VERIFY_READ, addr, nr) && file->f_op->write(file, addr, nr, &file->f_pos) == nr;
+	return access_ok(VERIFY_READ, addr, nr) &&
+	       file->f_op->write(file, addr, nr, &file->f_pos) == nr;
 }
 EXPORT_SYMBOL(dump_write);
 
-- 
1.7.6.405.gc1be0

[PATCH 16/28] namespace: checkpatch wanking

[Joe Perches]

Fix a few style things.

$ ./scripts/checkpatch.pl -f --terse --nosummary fs/namespace.c | \
  cut -f3- -d":" | sort | uniq -c
      1  ERROR: do not initialise statics to 0 or NULL
      2  ERROR: do not use assignment in if condition
      1  ERROR: "foo * bar" should be "foo *bar"
      1  ERROR: need consistent spacing around '|' (ctx:VxW)
      1  WARNING: braces {} are not necessary for single statement blocks
      3  WARNING: EXPORT_SYMBOL(foo); should immediately follow its function/variable
      4  WARNING: line over 80 characters
      9  WARNING: please, no space before tabs
      1  WARNING: Use #include <linux/uaccess.h> instead of <asm/uaccess.h>
      1  WARNING: Use #include <linux/unistd.h> instead of <asm/unistd.h>

Signed-off-by: Joe Perches <joe@perches.com>
---
 fs/namespace.c |   52 +++++++++++++++++++++++++++-------------------------
 1 files changed, 27 insertions(+), 25 deletions(-)

diff --git a/fs/namespace.c b/fs/namespace.c
index f9a164d..30bc685 100644
--- a/fs/namespace.c
+++ b/fs/namespace.c
@@ -33,8 +33,8 @@
 #include <linux/idr.h>
 #include <linux/fs_struct.h>
 #include <linux/fsnotify.h>
-#include <asm/uaccess.h>
-#include <asm/unistd.h>
+#include <linux/uaccess.h>
+#include <linux/unistd.h>
 #include "pnode.h"
 #include "internal.h"
 
@@ -45,7 +45,7 @@ static int event;
 static DEFINE_IDA(mnt_id_ida);
 static DEFINE_IDA(mnt_group_ida);
 static DEFINE_SPINLOCK(mnt_id_lock);
-static int mnt_id_start = 0;
+static int mnt_id_start;
 static int mnt_group_start = 1;
 
 static struct list_head *mount_hashtable __read_mostly;
@@ -511,7 +511,8 @@ struct vfsmount *lookup_mnt(struct path *path)
 	struct vfsmount *child_mnt;
 
 	br_read_lock(&vfsmount_lock);
-	if ((child_mnt = __lookup_mnt(path->mnt, path->dentry, 1)))
+	child_mnt = __lookup_mnt(path->mnt, path->dentry, 1);
+	if (child_mnt)
 		mntget(child_mnt);
 	br_read_unlock(&vfsmount_lock);
 	return child_mnt;
@@ -671,7 +672,8 @@ static struct vfsmount *skip_mnt_tree(struct vfsmount *p)
 }
 
 struct vfsmount *
-vfs_kern_mount(struct file_system_type *type, int flags, const char *name, void *data)
+vfs_kern_mount(struct file_system_type *type, int flags, const char *name,
+	       void *data)
 {
 	struct vfsmount *mnt;
 	struct dentry *root;
@@ -1174,7 +1176,6 @@ int may_umount_tree(struct vfsmount *mnt)
 
 	return 1;
 }
-
 EXPORT_SYMBOL(may_umount_tree);
 
 /**
@@ -1201,7 +1202,6 @@ int may_umount(struct vfsmount *mnt)
 	up_read(&namespace_sem);
 	return ret;
 }
-
 EXPORT_SYMBOL(may_umount);
 
 void release_mounts(struct list_head *head)
@@ -1307,9 +1307,8 @@ static int do_umount(struct vfsmount *mnt, int flags)
 	 * about for the moment.
 	 */
 
-	if (flags & MNT_FORCE && sb->s_op->umount_begin) {
+	if (flags & MNT_FORCE && sb->s_op->umount_begin)
 		sb->s_op->umount_begin(sb);
-	}
 
 	/*
 	 * No sense to grab the lock for this test, but test itself looks
@@ -1541,8 +1540,8 @@ static int invent_group_ids(struct vfsmount *mnt, bool recurse)
  *  @source_mnt : mount tree to be attached
  *  @nd         : place the mount tree @source_mnt is attached
  *  @parent_nd  : if non-null, detach the source_mnt from its parent and
- *  		   store the parent mount and mountpoint dentry.
- *  		   (done when source_mnt is moved)
+ *		   store the parent mount and mountpoint dentry.
+ *		   (done when source_mnt is moved)
  *
  *  NOTE: in the table below explains the semantics when a source mount
  *  of a given type is attached to a destination mount of a given type.
@@ -1562,8 +1561,8 @@ static int invent_group_ids(struct vfsmount *mnt, bool recurse)
  * destination mount.
  *
  * (++)  the cloned mount is propagated to all the mounts in the propagation
- * 	 tree of the destination mount and the cloned mount is added to
- * 	 the peer group of the source mount.
+ *	 tree of the destination mount and the cloned mount is added to
+ *	 the peer group of the source mount.
  * (+)   the cloned mount is created under the destination mount and is marked
  *       as shared. The cloned mount is added to the peer group of the source
  *       mount.
@@ -1572,10 +1571,10 @@ static int invent_group_ids(struct vfsmount *mnt, bool recurse)
  *       of the same master as that of the source mount. The cloned mount
  *       is marked as 'shared and slave'.
  * (*)   the cloned mount is made a slave of the same master as that of the
- * 	 source mount.
+ *	 source mount.
  *
  * ---------------------------------------------------------------------------
- * |         		MOVE MOUNT OPERATION                                 |
+ * |			MOVE MOUNT OPERATION                                 |
  * |**************************************************************************
  * | source-->| shared        |       private  |       slave    | unbindable |
  * | dest     |               |                |                |            |
@@ -1588,11 +1587,11 @@ static int invent_group_ids(struct vfsmount *mnt, bool recurse)
  * ***************************************************************************
  *
  * (+)  the mount is moved to the destination. And is then propagated to
- * 	all the mounts in the propagation tree of the destination mount.
+ *	all the mounts in the propagation tree of the destination mount.
  * (+*)  the mount is moved to the destination.
  * (+++)  the mount is moved to the destination and is then propagated to
- * 	all the mounts belonging to the destination mount's propagation tree.
- * 	the mount is marked as 'shared and slave'.
+ *	all the mounts belonging to the destination mount's propagation tree.
+ *	the mount is marked as 'shared and slave'.
  * (*)	the mount continues to be a slave at the new location.
  *
  * if the source mount is a tree, the operations explained above is
@@ -1977,7 +1976,8 @@ EXPORT_SYMBOL_GPL(do_kern_mount);
 /*
  * add a mount into a namespace's mount tree
  */
-static int do_add_mount(struct vfsmount *newmnt, struct path *path, int mnt_flags)
+static int
+do_add_mount(struct vfsmount *newmnt, struct path *path, int mnt_flags)
 {
 	int err;
 
@@ -2123,7 +2123,6 @@ void mark_mounts_for_expiry(struct list_head *mounts)
 
 	release_mounts(&umounts);
 }
-
 EXPORT_SYMBOL_GPL(mark_mounts_for_expiry);
 
 /*
@@ -2132,7 +2131,8 @@ EXPORT_SYMBOL_GPL(mark_mounts_for_expiry);
  * search the list of submounts for a given mountpoint, and move any
  * shrinkable submounts to the 'graveyard' list.
  */
-static int select_submounts(struct vfsmount *parent, struct list_head *graveyard)
+static int
+select_submounts(struct vfsmount *parent, struct list_head *graveyard)
 {
 	struct vfsmount *this_parent = parent;
 	struct list_head *next;
@@ -2143,7 +2143,8 @@ repeat:
 resume:
 	while (next != &this_parent->mnt_mounts) {
 		struct list_head *tmp = next;
-		struct vfsmount *mnt = list_entry(tmp, struct vfsmount, mnt_child);
+		struct vfsmount *mnt = list_entry(tmp, struct vfsmount,
+						  mnt_child);
 
 		next = tmp->next;
 		if (!(mnt->mnt_flags & MNT_SHRINKABLE))
@@ -2222,7 +2223,7 @@ static long exact_copy_from_user(void *to, const void __user * from,
 	return n;
 }
 
-int copy_mount_options(const void __user * data, unsigned long *where)
+int copy_mount_options(const void __user *data, unsigned long *where)
 {
 	int i;
 	unsigned long page;
@@ -2232,7 +2233,8 @@ int copy_mount_options(const void __user * data, unsigned long *where)
 	if (!data)
 		return 0;
 
-	if (!(page = __get_free_page(GFP_KERNEL)))
+	page = __get_free_page(GFP_KERNEL);
+	if (!page)
 		return -ENOMEM;
 
 	/* We only care that *some* data at the address the user
@@ -2336,7 +2338,7 @@ long do_mount(char *dev_name, char *dir_name, char *type_page,
 		mnt_flags |= MNT_READONLY;
 
 	flags &= ~(MS_NOSUID | MS_NOEXEC | MS_NODEV | MS_ACTIVE | MS_BORN |
-		   MS_NOATIME | MS_NODIRATIME | MS_RELATIME| MS_KERNMOUNT |
+		   MS_NOATIME | MS_NODIRATIME | MS_RELATIME | MS_KERNMOUNT |
 		   MS_STRICTATIME);
 
 	if (flags & MS_REMOUNT)
-- 
1.7.6.405.gc1be0

Re: [PATCH 16/28] namespace: checkpatch wanking

[Al Viro]

On Tue, Nov 29, 2011 at 06:14:14PM -0800, Joe Perches wrote:
> Fix a few style things.
> 
> $ ./scripts/checkpatch.pl -f --terse --nosummary fs/namespace.c | \
>   cut -f3- -d":" | sort | uniq -c
>       1  ERROR: do not initialise statics to 0 or NULL
>       2  ERROR: do not use assignment in if condition
>       1  ERROR: "foo * bar" should be "foo *bar"
>       1  ERROR: need consistent spacing around '|' (ctx:VxW)
>       1  WARNING: braces {} are not necessary for single statement blocks
>       3  WARNING: EXPORT_SYMBOL(foo); should immediately follow its function/variable
>       4  WARNING: line over 80 characters
>       9  WARNING: please, no space before tabs
>       1  WARNING: Use #include <linux/uaccess.h> instead of <asm/uaccess.h>
>       1  WARNING: Use #include <linux/unistd.h> instead of <asm/unistd.h>

NAK.  First of all, wanking it certainly is; moreover, it creates shitloads
of conflicts with patches in vfs.git#vfsmount-guts

Re: [PATCH 16/28] namespace: checkpatch wanking

[Joe Perches]

On Wed, 2011-11-30 at 02:22 +0000, Al Viro wrote:
> On Tue, Nov 29, 2011 at 06:14:14PM -0800, Joe Perches wrote:
> > Fix a few style things.
> > $ ./scripts/checkpatch.pl -f --terse --nosummary fs/namespace.c | \
> >   cut -f3- -d":" | sort | uniq -c
> >       1  ERROR: do not initialise statics to 0 or NULL
> >       2  ERROR: do not use assignment in if condition
> >       1  ERROR: "foo * bar" should be "foo *bar"
> >       1  ERROR: need consistent spacing around '|' (ctx:VxW)
> >       1  WARNING: braces {} are not necessary for single statement blocks
> >       3  WARNING: EXPORT_SYMBOL(foo); should immediately follow its function/variable
> >       4  WARNING: line over 80 characters
> >       9  WARNING: please, no space before tabs
> >       1  WARNING: Use #include <linux/uaccess.h> instead of <asm/uaccess.h>
> >       1  WARNING: Use #include <linux/unistd.h> instead of <asm/unistd.h>
> NAK.  First of all, wanking it certainly is; moreover, it creates shitloads
> of conflicts with patches in vfs.git#vfsmount-guts

No worries.

I think patches 1 thru 14 are reasonable though
and do apply with a few offsets to vfsmount-guts.

Re: [PATCH 16/28] namespace: checkpatch wanking

[Al Viro]

On Tue, Nov 29, 2011 at 07:39:11PM -0800, Joe Perches wrote:

> No worries.
> 
> I think patches 1 thru 14 are reasonable though
> and do apply with a few offsets to vfsmount-guts.

OK...  BTW, speaking of this one:

-static int mnt_id_start = 0;
+static int mnt_id_start;
 static int mnt_group_start = 1;

this deserves a separate NAK; explicit init here is actually more clear -
the variable is more or less analogous to mnt_group_start and it's less
distracting to have initializers spelled out in similar way as well.

-	if ((child_mnt = __lookup_mnt(path->mnt, path->dentry, 1)))
+	child_mnt = __lookup_mnt(path->mnt, path->dentry, 1);
+	if (child_mnt)
 		mntget(child_mnt);
 	br_read_unlock(&vfsmount_lock);
 	return child_mnt;

Maybe, maybe not; in the #vfsmount-guts I seriously pondered turning that
into
	child_mnt = ...;
	if (child_mnt) {
		mnt_add_count(child_mnt);
		br_read_unlock(...);
		return &child_mnt->mnt;
	} else {
		br_read_unlock(...);
		return NULL;
	}
Hell knows...  Since __lookup_mnt() returns struct mount now *and* lookup_mnt()
returns struct vfsmount (much shrunk subset of the original; almost nothing
in there is needed for anything outside of core VFS code) we need if or ?:
after unlock as well.  So it might make sense to split the codepaths once...

-	if (flags & MNT_FORCE && sb->s_op->umount_begin) {
+	if (flags & MNT_FORCE && sb->s_op->umount_begin)
 		sb->s_op->umount_begin(sb);
-	}

Probably.  It used to be just a method call, then it had grown lock/unlock
around it, then lock went down into the method instances and the compound
statement stayed.
 
-static int do_add_mount(struct vfsmount *newmnt, struct path *path, int mnt_flags)
+static int
+do_add_mount(struct vfsmount *newmnt, struct path *path, int mnt_flags)

I don't mind BSD style like that, but again, check #vfsmount-guts; this
one takes struct mount * now, so that line happens to be below 80 cols.

-static int select_submounts(struct vfsmount *parent, struct list_head *graveyard)
+static int
+select_submounts(struct vfsmount *parent, struct list_head *graveyard)

Ditto.

-		struct vfsmount *mnt = list_entry(tmp, struct vfsmount, mnt_child);
+		struct vfsmount *mnt = list_entry(tmp, struct vfsmount,
+						  mnt_child);

Ditto (mnt_child moved into struct mount now)
 
-	if (!(page = __get_free_page(GFP_KERNEL)))
+	page = __get_free_page(GFP_KERNEL);
+	if (!page)
 		return -ENOMEM;

Not sure...  In general I'd agree, but in this case...

Re: [PATCH 16/28] namespace: checkpatch wanking

[Joe Perches]

On Wed, 2011-11-30 at 06:50 +0000, Al Viro wrote:
> -	if (!(page = __get_free_page(GFP_KERNEL)))
> +	page = __get_free_page(GFP_KERNEL);
> +	if (!page)
>  		return -ENOMEM;
> Not sure...  In general I'd agree, but in this case...

Shrug.  I'm not sure there's much of a case other than
line count for keeping this a one-liner.

If you want these sorts of changes to be redone after
vfsmount-guts gets promoted, let me know.

[PATCH 17/28] block_dev: checkpatch wanking

[Joe Perches]

Fix a few style things.  Now checkpatch clean.

$ ./scripts/checkpatch.pl -f --terse --nosummary fs/block_dev.c | \
  cut -f3- -d":" | sort | uniq -c
      1  ERROR: code indent should use tabs where possible
      1  ERROR: do not use assignment in if condition
      4  ERROR: "foo * bar" should be "foo *bar"
      1  ERROR: space prohibited after that open parenthesis '('
      1  ERROR: space prohibited before that close parenthesis ')'
      1  ERROR: space required after that ',' (ctx:VxV)
      1  ERROR: switch and case should be at the same indent
      4  ERROR: trailing whitespace
      2  WARNING: braces {} are not necessary for single statement blocks
      7  WARNING: EXPORT_SYMBOL(foo); should immediately follow its function/variable
      1  WARNING: line over 80 characters
      4  WARNING: please, no space before tabs
      2  WARNING: please, no spaces at the start of a line
      1  WARNING: Use #include <linux/uaccess.h> instead of <asm/uaccess.h>

Signed-off-by: Joe Perches <joe@perches.com>
---
 fs/block_dev.c |   70 +++++++++++++++++++++++++------------------------------
 1 files changed, 32 insertions(+), 38 deletions(-)

diff --git a/fs/block_dev.c b/fs/block_dev.c
index 20aa631..8b9bbf6 100644
--- a/fs/block_dev.c
+++ b/fs/block_dev.c
@@ -27,7 +27,7 @@
 #include <linux/namei.h>
 #include <linux/log2.h>
 #include <linux/kmemleak.h>
-#include <asm/uaccess.h>
+#include <linux/uaccess.h>
 #include "internal.h"
 
 struct bdev_inode {
@@ -90,7 +90,7 @@ static void kill_bdev(struct block_device *bdev)
 		return;
 	invalidate_bh_lrus();
 	truncate_inode_pages(bdev->bd_inode->i_mapping, 0);
-}	
+}
 
 int set_blocksize(struct block_device *bdev, int size)
 {
@@ -111,7 +111,6 @@ int set_blocksize(struct block_device *bdev, int size)
 	}
 	return 0;
 }
-
 EXPORT_SYMBOL(set_blocksize);
 
 int sb_set_blocksize(struct super_block *sb, int size)
@@ -124,7 +123,6 @@ int sb_set_blocksize(struct super_block *sb, int size)
 	sb->s_blocksize_bits = blksize_bits(size);
 	return sb->s_blocksize;
 }
-
 EXPORT_SYMBOL(sb_set_blocksize);
 
 int sb_min_blocksize(struct super_block *sb, int size)
@@ -134,7 +132,6 @@ int sb_min_blocksize(struct super_block *sb, int size)
 		size = minsize;
 	return sb_set_blocksize(sb, size);
 }
-
 EXPORT_SYMBOL(sb_min_blocksize);
 
 static int
@@ -321,7 +318,7 @@ static int blkdev_writepage(struct page *page, struct writeback_control *wbc)
 	return block_write_full_page(page, blkdev_get_block, wbc);
 }
 
-static int blkdev_readpage(struct file * file, struct page * page)
+static int blkdev_readpage(struct file *file, struct page *page)
 {
 	return block_read_full_page(page, blkdev_get_block);
 }
@@ -363,33 +360,32 @@ static loff_t block_llseek(struct file *file, loff_t offset, int origin)
 
 	retval = -EINVAL;
 	switch (origin) {
-		case SEEK_END:
-			offset += size;
-			break;
-		case SEEK_CUR:
-			offset += file->f_pos;
-		case SEEK_SET:
-			break;
-		default:
-			goto out;
+	case SEEK_END:
+		offset += size;
+		break;
+	case SEEK_CUR:
+		offset += file->f_pos;
+	case SEEK_SET:
+		break;
+	default:
+		goto out;
 	}
 	if (offset >= 0 && offset <= size) {
-		if (offset != file->f_pos) {
+		if (offset != file->f_pos)
 			file->f_pos = offset;
-		}
 		retval = offset;
 	}
 out:
 	mutex_unlock(&bd_inode->i_mutex);
 	return retval;
 }
-	
+
 int blkdev_fsync(struct file *filp, loff_t start, loff_t end, int datasync)
 {
 	struct inode *bd_inode = filp->f_mapping->host;
 	struct block_device *bdev = I_BDEV(bd_inode);
 	int error;
-	
+
 	error = filemap_write_and_wait_range(filp->f_mapping, start, end);
 	if (error)
 		return error;
@@ -412,7 +408,7 @@ EXPORT_SYMBOL(blkdev_fsync);
  */
 
 static  __cacheline_aligned_in_smp DEFINE_SPINLOCK(bdev_lock);
-static struct kmem_cache * bdev_cachep __read_mostly;
+static struct kmem_cache *bdev_cachep __read_mostly;
 
 static struct inode *bdev_alloc_inode(struct super_block *sb)
 {
@@ -468,9 +464,8 @@ static void bdev_evict_inode(struct inode *inode)
 	invalidate_inode_buffers(inode); /* is it needed here? */
 	end_writeback(inode);
 	spin_lock(&bdev_lock);
-	while ( (p = bdev->bd_inodes.next) != &bdev->bd_inodes ) {
+	while ((p = bdev->bd_inodes.next) != &bdev->bd_inodes)
 		__bd_forget(list_entry(p, struct inode, i_devices));
-	}
 	list_del_init(&bdev->bd_list);
 	spin_unlock(&bdev_lock);
 }
@@ -576,7 +571,6 @@ struct block_device *bdget(dev_t dev)
 	}
 	return bdev;
 }
-
 EXPORT_SYMBOL(bdget);
 
 /**
@@ -605,9 +599,8 @@ void bdput(struct block_device *bdev)
 {
 	iput(bdev->bd_inode);
 }
-
 EXPORT_SYMBOL(bdput);
- 
+
 static struct block_device *bd_acquire(struct inode *inode)
 {
 	struct block_device *bdev;
@@ -677,18 +670,19 @@ static bool bd_may_claim(struct block_device *bdev, struct block_device *whole,
 			 void *holder)
 {
 	if (bdev->bd_holder == holder)
-		return true;	 /* already a holder */
+		return true;	/* already a holder */
 	else if (bdev->bd_holder != NULL)
-		return false; 	 /* held by someone else */
+		return false;	/* held by someone else */
 	else if (bdev->bd_contains == bdev)
-		return true;  	 /* is a whole device which isn't held */
+		return true;	/* is a whole device which isn't held */
 
 	else if (whole->bd_holder == bd_may_claim)
-		return true; 	 /* is a partition of a device that is being partitioned */
+		return true;	/* is a partition of a device
+				 * that is being partitioned */
 	else if (whole->bd_holder != NULL)
-		return false;	 /* is a partition of a held device */
+		return false;	/* is a partition of a held device */
 	else
-		return true;	 /* is a partition of an un-held device */
+		return true;	/* is a partition of an un-held device */
 }
 
 /**
@@ -1056,7 +1050,6 @@ int check_disk_change(struct block_device *bdev)
 		bdops->revalidate_disk(bdev->bd_disk);
 	return 1;
 }
-
 EXPORT_SYMBOL(check_disk_change);
 
 void bd_set_size(struct block_device *bdev, loff_t size)
@@ -1149,7 +1142,8 @@ static int __blkdev_get(struct block_device *bdev, fmode_t mode, int for_part)
 			}
 
 			if (!ret && !bdev->bd_openers) {
-				bd_set_size(bdev,(loff_t)get_capacity(disk)<<9);
+				bd_set_size(bdev,
+					    (loff_t)get_capacity(disk) << 9);
 				bdi = blk_get_backing_dev_info(bdev);
 				if (bdi == NULL)
 					bdi = &default_backing_dev_info;
@@ -1393,7 +1387,7 @@ struct block_device *blkdev_get_by_dev(dev_t dev, fmode_t mode, void *holder)
 }
 EXPORT_SYMBOL(blkdev_get_by_dev);
 
-static int blkdev_open(struct inode * inode, struct file * filp)
+static int blkdev_open(struct inode *inode, struct file *filp)
 {
 	struct block_device *bdev;
 
@@ -1483,7 +1477,8 @@ int blkdev_put(struct block_device *bdev, fmode_t mode)
 		WARN_ON_ONCE(--bdev->bd_contains->bd_holders < 0);
 
 		/* bd_contains might point to self, check in a separate step */
-		if ((bdev_free = !bdev->bd_holders))
+		bdev_free = !bdev->bd_holders;
+		if (bdev_free)
 			bdev->bd_holder = NULL;
 		if (!bdev->bd_contains->bd_holders)
 			bdev->bd_contains->bd_holder = NULL;
@@ -1513,7 +1508,7 @@ int blkdev_put(struct block_device *bdev, fmode_t mode)
 }
 EXPORT_SYMBOL(blkdev_put);
 
-static int blkdev_close(struct inode * inode, struct file * filp)
+static int blkdev_close(struct inode *inode, struct file *filp)
 {
 	struct block_device *bdev = I_BDEV(filp->f_mapping->host);
 
@@ -1594,7 +1589,7 @@ const struct file_operations def_blk_fops = {
 	.llseek		= block_llseek,
 	.read		= do_sync_read,
 	.write		= do_sync_write,
-  	.aio_read	= generic_file_aio_read,
+	.aio_read	= generic_file_aio_read,
 	.aio_write	= blkdev_aio_write,
 	.mmap		= generic_file_mmap,
 	.fsync		= blkdev_fsync,
@@ -1615,7 +1610,6 @@ int ioctl_by_bdev(struct block_device *bdev, unsigned cmd, unsigned long arg)
 	set_fs(old_fs);
 	return res;
 }
-
 EXPORT_SYMBOL(ioctl_by_bdev);
 
 /**
-- 
1.7.6.405.gc1be0

[PATCH 18/28] dcache: checkpatch wanking

[Joe Perches]

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

[PATCH 19/28] fcntl: checkpatch wanking

[Joe Perches]

Now checkpatch clean.

$ ./scripts/checkpatch.pl -f --terse --nosummary fs/fcntl.c | \
  cut -f3- -d":" | sort | uniq -c
      5  ERROR: code indent should use tabs where possible
      6  ERROR: "foo * bar" should be "foo *bar"
      2  ERROR: switch and case should be at the same indent
      9  ERROR: trailing whitespace
      1  WARNING: braces {} are not necessary for single statement blocks
      1  WARNING: EXPORT_SYMBOL(foo); should immediately follow its function/variable
      4  WARNING: line over 80 characters
      1  WARNING: please, no space before tabs
      4  WARNING: please, no spaces at the start of a line
      1  WARNING: suspect code indent for conditional statements (15, 19)
      1  WARNING: suspect code indent for conditional statements (8, 15)
      1  WARNING: Use #include <linux/poll.h> instead of <asm/poll.h>
      1  WARNING: Use #include <linux/uaccess.h> instead of <asm/uaccess.h>

Signed-off-by: Joe Perches <joe@perches.com>
---
 fs/fcntl.c |  128 +++++++++++++++++++++++++++++++-----------------------------
 1 files changed, 66 insertions(+), 62 deletions(-)

diff --git a/fs/fcntl.c b/fs/fcntl.c
index 5d16b1d..cc887fd 100644
--- a/fs/fcntl.c
+++ b/fs/fcntl.c
@@ -22,10 +22,9 @@
 #include <linux/signal.h>
 #include <linux/rcupdate.h>
 #include <linux/pid_namespace.h>
-
-#include <asm/poll.h>
+#include <linux/poll.h>
+#include <linux/uaccess.h>
 #include <asm/siginfo.h>
-#include <asm/uaccess.h>
 
 void set_close_on_exec(unsigned int fd, int flag)
 {
@@ -55,8 +54,8 @@ static int get_close_on_exec(unsigned int fd)
 SYSCALL_DEFINE3(dup3, unsigned int, oldfd, unsigned int, newfd, int, flags)
 {
 	int err = -EBADF;
-	struct file * file, *tofree;
-	struct files_struct * files = current->files;
+	struct file *file, *tofree;
+	struct files_struct *files = current->files;
 	struct fdtable *fdt;
 
 	if ((flags & ~O_CLOEXEC) != 0)
@@ -147,9 +146,9 @@ SYSCALL_DEFINE1(dup, unsigned int, fildes)
 
 #define SETFL_MASK (O_APPEND | O_NONBLOCK | O_NDELAY | O_DIRECT | O_NOATIME)
 
-static int setfl(int fd, struct file * filp, unsigned long arg)
+static int setfl(int fd, struct file *filp, unsigned long arg)
 {
-	struct inode * inode = filp->f_path.dentry->d_inode;
+	struct inode *inode = filp->f_path.dentry->d_inode;
 	int error = 0;
 
 	/*
@@ -165,9 +164,10 @@ static int setfl(int fd, struct file * filp, unsigned long arg)
 			return -EPERM;
 
 	/* required for strict SunOS emulation */
-	if (O_NONBLOCK != O_NDELAY)
-	       if (arg & O_NDELAY)
-		   arg |= O_NONBLOCK;
+	if (O_NONBLOCK != O_NDELAY) {
+		if (arg & O_NDELAY)
+			arg |= O_NONBLOCK;
+	}
 
 	if (arg & O_DIRECT) {
 		if (!filp->f_mapping || !filp->f_mapping->a_ops ||
@@ -200,7 +200,7 @@ static int setfl(int fd, struct file * filp, unsigned long arg)
 }
 
 static void f_modown(struct file *filp, struct pid *pid, enum pid_type type,
-                     int force)
+		     int force)
 {
 	write_lock_irq(&filp->f_owner.lock);
 	if (force || !filp->f_owner.pid) {
@@ -403,9 +403,8 @@ static long do_fcntl(int fd, unsigned int cmd, unsigned long arg,
 		break;
 	case F_SETSIG:
 		/* arg == 0 restores default behaviour. */
-		if (!valid_signal(arg)) {
+		if (!valid_signal(arg))
 			break;
-		}
 		err = 0;
 		filp->f_owner.signum = arg;
 		break;
@@ -442,7 +441,7 @@ static int check_fcntl_cmd(unsigned cmd)
 }
 
 SYSCALL_DEFINE3(fcntl, unsigned int, fd, unsigned int, cmd, unsigned long, arg)
-{	
+{
 	struct file *filp;
 	long err = -EBADF;
 
@@ -465,7 +464,7 @@ SYSCALL_DEFINE3(fcntl, unsigned int, fd, unsigned int, cmd, unsigned long, arg)
 
 	err = do_fcntl(fd, cmd, arg, filp);
 
- 	fput(filp);
+	fput(filp);
 out:
 	return err;
 }
@@ -473,8 +472,8 @@ out:
 #if BITS_PER_LONG == 32
 SYSCALL_DEFINE3(fcntl64, unsigned int, fd, unsigned int, cmd,
 		unsigned long, arg)
-{	
-	struct file * filp;
+{
+	struct file *filp;
 	long err;
 
 	err = -EBADF;
@@ -495,19 +494,19 @@ SYSCALL_DEFINE3(fcntl64, unsigned int, fd, unsigned int, cmd,
 		return err;
 	}
 	err = -EBADF;
-	
+
 	switch (cmd) {
-		case F_GETLK64:
-			err = fcntl_getlk64(filp, (struct flock64 __user *) arg);
-			break;
-		case F_SETLK64:
-		case F_SETLKW64:
-			err = fcntl_setlk64(fd, filp, cmd,
-					(struct flock64 __user *) arg);
-			break;
-		default:
-			err = do_fcntl(fd, cmd, arg, filp);
-			break;
+	case F_GETLK64:
+		err = fcntl_getlk64(filp, (struct flock64 __user *)arg);
+		break;
+	case F_SETLK64:
+	case F_SETLKW64:
+		err = fcntl_setlk64(fd, filp, cmd,
+				    (struct flock64 __user *)arg);
+		break;
+	default:
+		err = do_fcntl(fd, cmd, arg, filp);
+		break;
 	}
 	fput(filp);
 out:
@@ -527,7 +526,7 @@ static const long band_table[NSIGPOLL] = {
 };
 
 static inline int sigio_perm(struct task_struct *p,
-                             struct fown_struct *fown, int sig)
+			     struct fown_struct *fown, int sig)
 {
 	const struct cred *cred;
 	int ret;
@@ -556,31 +555,33 @@ static void send_sigio_to_task(struct task_struct *p,
 		return;
 
 	switch (signum) {
+	default: {
 		siginfo_t si;
-		default:
-			/* Queue a rt signal with the appropriate fd as its
-			   value.  We use SI_SIGIO as the source, not 
-			   SI_KERNEL, since kernel signals always get 
-			   delivered even if we can't queue.  Failure to
-			   queue in this case _should_ be reported; we fall
-			   back to SIGIO in that case. --sct */
-			si.si_signo = signum;
-			si.si_errno = 0;
-		        si.si_code  = reason;
-			/* Make sure we are called with one of the POLL_*
-			   reasons, otherwise we could leak kernel stack into
-			   userspace.  */
-			BUG_ON((reason & __SI_MASK) != __SI_POLL);
-			if (reason - POLL_IN >= NSIGPOLL)
-				si.si_band  = ~0L;
-			else
-				si.si_band = band_table[reason - POLL_IN];
-			si.si_fd    = fd;
-			if (!do_send_sig_info(signum, &si, p, group))
-				break;
+
+		/* Queue a rt signal with the appropriate fd as its
+		   value.  We use SI_SIGIO as the source, not
+		   SI_KERNEL, since kernel signals always get
+		   delivered even if we can't queue.  Failure to
+		   queue in this case _should_ be reported; we fall
+		   back to SIGIO in that case. --sct */
+		si.si_signo = signum;
+		si.si_errno = 0;
+		si.si_code  = reason;
+		/* Make sure we are called with one of the POLL_*
+		   reasons, otherwise we could leak kernel stack into
+		   userspace.  */
+		BUG_ON((reason & __SI_MASK) != __SI_POLL);
+		if (reason - POLL_IN >= NSIGPOLL)
+			si.si_band  = ~0L;
+		else
+			si.si_band = band_table[reason - POLL_IN];
+		si.si_fd    = fd;
+		if (!do_send_sig_info(signum, &si, p, group))
+			break;
 		/* fall-through: fall back on the old plain SIGIO signal */
-		case 0:
-			do_send_sig_info(SIGIO, SEND_SIG_PRIV, p, group);
+	}
+	case 0:
+		do_send_sig_info(SIGIO, SEND_SIG_PRIV, p, group);
 	}
 }
 
@@ -590,7 +591,7 @@ void send_sigio(struct fown_struct *fown, int fd, int band)
 	enum pid_type type;
 	struct pid *pid;
 	int group = 1;
-	
+
 	read_lock(&fown->lock);
 
 	type = fown->pid_type;
@@ -602,7 +603,7 @@ void send_sigio(struct fown_struct *fown, int fd, int band)
 	pid = fown->pid;
 	if (!pid)
 		goto out_unlock_fown;
-	
+
 	read_lock(&tasklist_lock);
 	do_each_pid_task(pid, type, p) {
 		send_sigio_to_task(p, fown, fd, band, group);
@@ -626,7 +627,7 @@ int send_sigurg(struct fown_struct *fown)
 	struct pid *pid;
 	int group = 1;
 	int ret = 0;
-	
+
 	read_lock(&fown->lock);
 
 	type = fown->pid_type;
@@ -640,7 +641,7 @@ int send_sigurg(struct fown_struct *fown)
 		goto out_unlock_fown;
 
 	ret = 1;
-	
+
 	read_lock(&tasklist_lock);
 	do_each_pid_task(pid, type, p) {
 		send_sigurg_to_task(p, fown, group);
@@ -717,9 +718,11 @@ void fasync_free(struct fasync_struct *new)
  * NOTE! It is very important that the FASYNC flag always
  * match the state "is the filp on a fasync list".
  */
-struct fasync_struct *fasync_insert_entry(int fd, struct file *filp, struct fasync_struct **fapp, struct fasync_struct *new)
+struct fasync_struct *
+fasync_insert_entry(int fd, struct file *filp, struct fasync_struct **fapp,
+		    struct fasync_struct *new)
 {
-        struct fasync_struct *fa, **fp;
+	struct fasync_struct *fa, **fp;
 
 	spin_lock(&filp->f_lock);
 	spin_lock(&fasync_lock);
@@ -751,7 +754,8 @@ out:
  * Add a fasync entry. Return negative on error, positive if
  * added, and zero if did nothing but change an existing one.
  */
-static int fasync_add_entry(int fd, struct file *filp, struct fasync_struct **fapp)
+static int
+fasync_add_entry(int fd, struct file *filp, struct fasync_struct **fapp)
 {
 	struct fasync_struct *new;
 
@@ -780,13 +784,13 @@ static int fasync_add_entry(int fd, struct file *filp, struct fasync_struct **fa
  * lease code. It returns negative on error, 0 if it did no changes
  * and positive if it added/deleted the entry.
  */
-int fasync_helper(int fd, struct file * filp, int on, struct fasync_struct **fapp)
+int
+fasync_helper(int fd, struct file *filp, int on, struct fasync_struct **fapp)
 {
 	if (!on)
 		return fasync_remove_entry(filp, fapp);
 	return fasync_add_entry(fd, filp, fapp);
 }
-
 EXPORT_SYMBOL(fasync_helper);
 
 /*
-- 
1.7.6.405.gc1be0

[PATCH 20/28] file: checkpatch wanking

[Joe Perches]

Reflowed comments.  Now checkpatch clean.

$ ./scripts/checkpatch.pl -f --terse --nosummary fs/file.c | \
  cut -f3- -d":" | sort | uniq -c

      1  ERROR: "foo * bar" should be "foo *bar"
      1  ERROR: space required before the open parenthesis '('
      4  WARNING: line over 80 characters

Signed-off-by: Joe Perches <joe@perches.com>
---
 fs/file.c |   21 ++++++++++++---------
 1 files changed, 12 insertions(+), 9 deletions(-)

diff --git a/fs/file.c b/fs/file.c
index a88b110..7128878 100644
--- a/fs/file.c
+++ b/fs/file.c
@@ -45,8 +45,9 @@ static DEFINE_PER_CPU(struct fdtable_defer, fdtable_defer_list);
 static void *alloc_fdmem(unsigned int size)
 {
 	/*
-	 * Very large allocations can stress page reclaim, so fall back to
-	 * vmalloc() if the allocation size will be considered "large" by the VM.
+	 * Very large allocations can stress page reclaim so
+	 * fall back to vmalloc() if the allocation size will
+	 * be considered "large" by the VM.
 	 */
 	if (size <= (PAGE_SIZE << PAGE_ALLOC_COSTLY_ORDER)) {
 		void *data = kmalloc(size, GFP_KERNEL|__GFP_NOWARN);
@@ -78,7 +79,7 @@ static void free_fdtable_work(struct work_struct *work)
 	fdt = f->next;
 	f->next = NULL;
 	spin_unlock_bh(&f->lock);
-	while(fdt) {
+	while (fdt) {
 		struct fdtable *next = fdt->next;
 
 		__free_fdtable(fdt);
@@ -141,7 +142,7 @@ static void copy_fdtable(struct fdtable *nfdt, struct fdtable *ofdt)
 	memset((char *)(nfdt->close_on_exec) + cpy, 0, set);
 }
 
-static struct fdtable * alloc_fdtable(unsigned int nr)
+static struct fdtable *alloc_fdtable(unsigned int nr)
 {
 	struct fdtable *fdt;
 	char *data;
@@ -157,9 +158,10 @@ static struct fdtable * alloc_fdtable(unsigned int nr)
 	nr = roundup_pow_of_two(nr + 1);
 	nr *= (1024 / sizeof(struct file *));
 	/*
-	 * Note that this can drive nr *below* what we had passed if sysctl_nr_open
-	 * had been set lower between the check in expand_files() and here.  Deal
-	 * with that in caller, it's cheaper that way.
+	 * Note that this can drive nr *below* what we had passed
+	 * if sysctl_nr_open had been set lower between the check
+	 * in expand_files() and here.
+	 * Deal with that in caller, it's cheaper that way.
 	 *
 	 * We make sure that nr remains a multiple of BITS_PER_LONG - otherwise
 	 * bitmaps handling below becomes unpleasant, to put it mildly...
@@ -213,8 +215,9 @@ static int expand_fdtable(struct files_struct *files, int nr)
 	if (!new_fdt)
 		return -ENOMEM;
 	/*
-	 * extremely unlikely race - sysctl_nr_open decreased between the check in
-	 * caller and alloc_fdtable().  Cheaper to catch it here...
+	 * extremely unlikely race - sysctl_nr_open decreased
+	 * between the check in caller and alloc_fdtable().
+	 * Cheaper to catch it here...
 	 */
 	if (unlikely(new_fdt->max_fds <= nr)) {
 		__free_fdtable(new_fdt);
-- 
1.7.6.405.gc1be0

[PATCH 21/28] locks: checkpatch wanking

[Joe Perches]

Almost checkpatch clean, a couple long line warnings remain.

$ ./scripts/checkpatch.pl -f --terse --nosummary fs/locks.c | \
  cut -f3- -d":" | sort | uniq -c
      3  ERROR: code indent should use tabs where possible
      1  ERROR: else should follow close brace '}'
      2  ERROR: "foo * bar" should be "foo *bar"
      1  ERROR: open brace '{' following function declarations go on the next line
      4  ERROR: return is not a function, parentheses are not required
     14  ERROR: trailing whitespace
      1  WARNING: braces {} are not necessary for any arm of this statement
      2  WARNING: braces {} are not necessary for single statement blocks
     12  WARNING: EXPORT_SYMBOL(foo); should immediately follow its function/variable
      1  WARNING: labels should not be indented
      2  WARNING: %Ld/%Lu are not-standard C, use %lld/%llu
     11  WARNING: line over 80 characters
      3  WARNING: please, no space before tabs
      6  WARNING: please, no spaces at the start of a line
      1  WARNING: space prohibited between function name and open parenthesis '('
      1  WARNING: Use #include <linux/uaccess.h> instead of <asm/uaccess.h>

Signed-off-by: Joe Perches <joe@perches.com>
---
 fs/locks.c |  121 ++++++++++++++++++++++++++++--------------------------------
 1 files changed, 56 insertions(+), 65 deletions(-)

diff --git a/fs/locks.c b/fs/locks.c
index 10f2bdb..268da7c 100644
--- a/fs/locks.c
+++ b/fs/locks.c
@@ -11,11 +11,11 @@
  *
  *  Miscellaneous edits, and a total rewrite of posix_lock_file() code.
  *  Kai Petzke (wpp@marie.physik.tu-berlin.de), 1994
- *  
+ *
  *  Converted file_lock_table to a linked list from an array, which eliminates
  *  the limits on how many active file locks are open.
  *  Chad Page (pageone@netcom.com), November 27, 1994
- * 
+ *
  *  Removed dependency on file descriptors. dup()'ed file descriptors now
  *  get the same locks as the original file descriptors, and a close() on
  *  any file descriptor removes ALL the locks on the file for the current
@@ -41,7 +41,7 @@
  *  with a file pointer (filp). As a result they can be shared by a parent
  *  process and its children after a fork(). They are removed when the last
  *  file descriptor referring to the file pointer is closed (unless explicitly
- *  unlocked). 
+ *  unlocked).
  *
  *  FL_FLOCK locks never deadlock, an existing lock is always removed before
  *  upgrading from shared to exclusive (or vice versa). When this happens
@@ -50,7 +50,7 @@
  *  Andy Walker (andy@lysaker.kvaerner.no), June 09, 1995
  *
  *  Removed some race conditions in flock_lock_file(), marked other possible
- *  races. Just grep for FIXME to see them. 
+ *  races. Just grep for FIXME to see them.
  *  Dmitry Gorodchanin (pgmdsg@ibi.com), February 09, 1996.
  *
  *  Addressed Dmitry's concerns. Deadlock checking no longer recursive.
@@ -101,7 +101,8 @@
  *  Some adaptations for NFS support.
  *  Olaf Kirch (okir@monad.swb.de), Dec 1996,
  *
- *  Fixed /proc/locks interface so that we can't overrun the buffer we are handed.
+ *  Fixed /proc/locks interface so that we can't overrun the buffer
+ *  we are handed.
  *  Andy Walker (andy@lysaker.kvaerner.no), May 12, 1997.
  *
  *  Use slab allocator instead of kmalloc/kfree.
@@ -128,8 +129,7 @@
 #include <linux/time.h>
 #include <linux/rcupdate.h>
 #include <linux/pid_namespace.h>
-
-#include <asm/uaccess.h>
+#include <linux/uaccess.h>
 
 #define IS_POSIX(fl)	(fl->fl_flags & FL_POSIX)
 #define IS_FLOCK(fl)	(fl->fl_flags & FL_FLOCK)
@@ -152,8 +152,10 @@ static int target_leasetype(struct file_lock *fl)
 int leases_enable = 1;
 int lease_break_time = 45;
 
-#define for_each_lock(inode, lockp) \
-	for (lockp = &inode->i_flock; *lockp != NULL; lockp = &(*lockp)->fl_next)
+#define for_each_lock(inode, lockp)				\
+	for (lockp = &inode->i_flock;				\
+	     *lockp != NULL;					\
+	     lockp = &(*lockp)->fl_next)
 
 static LIST_HEAD(file_lock_list);
 static LIST_HEAD(blocked_list);
@@ -228,7 +230,6 @@ void locks_init_lock(struct file_lock *fl)
 	memset(fl, 0, sizeof(struct file_lock));
 	locks_init_lock_heads(fl);
 }
-
 EXPORT_SYMBOL(locks_init_lock);
 
 static void locks_copy_private(struct file_lock *new, struct file_lock *fl)
@@ -270,10 +271,10 @@ void locks_copy_lock(struct file_lock *new, struct file_lock *fl)
 
 	locks_copy_private(new, fl);
 }
-
 EXPORT_SYMBOL(locks_copy_lock);
 
-static inline int flock_translate_cmd(int cmd) {
+static inline int flock_translate_cmd(int cmd)
+{
 	if (cmd & LOCK_MAND)
 		return cmd & (LOCK_MAND | LOCK_RW);
 	switch (cmd) {
@@ -295,7 +296,7 @@ static int flock_make_lock(struct file *filp, struct file_lock **lock,
 	int type = flock_translate_cmd(cmd);
 	if (type < 0)
 		return type;
-	
+
 	fl = locks_alloc_lock();
 	if (fl == NULL)
 		return -ENOMEM;
@@ -305,7 +306,7 @@ static int flock_make_lock(struct file *filp, struct file_lock **lock,
 	fl->fl_flags = FL_FLOCK;
 	fl->fl_type = type;
 	fl->fl_end = OFFSET_MAX;
-	
+
 	*lock = fl;
 	return 0;
 }
@@ -365,7 +366,7 @@ static int flock_to_posix_lock(struct file *filp, struct file_lock *fl,
 	fl->fl_start = start;	/* we record the absolute position */
 	if (fl->fl_end < fl->fl_start)
 		return -EOVERFLOW;
-	
+
 	fl->fl_owner = current->files;
 	fl->fl_pid = current->tgid;
 	fl->fl_file = filp;
@@ -411,7 +412,7 @@ static int flock64_to_posix_lock(struct file *filp, struct file_lock *fl,
 	fl->fl_start = start;	/* we record the absolute position */
 	if (fl->fl_end < fl->fl_start)
 		return -EOVERFLOW;
-	
+
 	fl->fl_owner = current->files;
 	fl->fl_pid = current->tgid;
 	fl->fl_file = filp;
@@ -448,7 +449,7 @@ static const struct lock_manager_operations lease_manager_ops = {
  * Initialize a lease, use the default lock manager operations
  */
 static int lease_init(struct file *filp, int type, struct file_lock *fl)
- {
+{
 	if (assign_type(fl, type) != 0)
 		return -EINVAL;
 
@@ -524,7 +525,7 @@ static void locks_delete_block(struct file_lock *waiter)
  * the order they blocked. The documentation doesn't require this but
  * it seems like the reasonable thing to do.
  */
-static void locks_insert_block(struct file_lock *blocker, 
+static void locks_insert_block(struct file_lock *blocker,
 			       struct file_lock *waiter)
 {
 	BUG_ON(!list_empty(&waiter->fl_block));
@@ -611,35 +612,37 @@ static int locks_conflict(struct file_lock *caller_fl, struct file_lock *sys_fl)
 /* Determine if lock sys_fl blocks lock caller_fl. POSIX specific
  * checking before calling the locks_conflict().
  */
-static int posix_locks_conflict(struct file_lock *caller_fl, struct file_lock *sys_fl)
+static int posix_locks_conflict(struct file_lock *caller_fl,
+				struct file_lock *sys_fl)
 {
 	/* POSIX locks owned by the same process do not conflict with
 	 * each other.
 	 */
 	if (!IS_POSIX(sys_fl) || posix_same_owner(caller_fl, sys_fl))
-		return (0);
+		return 0;
 
 	/* Check whether they overlap */
 	if (!locks_overlap(caller_fl, sys_fl))
 		return 0;
 
-	return (locks_conflict(caller_fl, sys_fl));
+	return locks_conflict(caller_fl, sys_fl);
 }
 
 /* Determine if lock sys_fl blocks lock caller_fl. FLOCK specific
  * checking before calling the locks_conflict().
  */
-static int flock_locks_conflict(struct file_lock *caller_fl, struct file_lock *sys_fl)
+static int flock_locks_conflict(struct file_lock *caller_fl,
+				struct file_lock *sys_fl)
 {
 	/* FLOCK locks referring to the same filp do not conflict with
 	 * each other.
 	 */
 	if (!IS_FLOCK(sys_fl) || (caller_fl->fl_file == sys_fl->fl_file))
-		return (0);
+		return 0;
 	if ((caller_fl->fl_type & LOCK_MAND) || (sys_fl->fl_type & LOCK_MAND))
 		return 0;
 
-	return (locks_conflict(caller_fl, sys_fl));
+	return locks_conflict(caller_fl, sys_fl);
 }
 
 void
@@ -729,7 +732,7 @@ static int flock_lock_file(struct file *filp, struct file_lock *request)
 {
 	struct file_lock *new_fl = NULL;
 	struct file_lock **before;
-	struct inode * inode = filp->f_path.dentry->d_inode;
+	struct inode *inode = filp->f_path.dentry->d_inode;
 	int error = 0;
 	int found = 0;
 
@@ -804,7 +807,8 @@ out:
 	return error;
 }
 
-static int __posix_lock_file(struct inode *inode, struct file_lock *request, struct file_lock *conflock)
+static int __posix_lock_file(struct inode *inode, struct file_lock *request,
+			     struct file_lock *conflock)
 {
 	struct file_lock *fl;
 	struct file_lock *new_fl = NULL;
@@ -846,18 +850,15 @@ static int __posix_lock_file(struct inode *inode, struct file_lock *request, str
 			error = FILE_LOCK_DEFERRED;
 			locks_insert_block(fl, request);
 			goto out;
-  		}
-  	}
+		}
+	}
 
 	/* If we're just looking for a conflict, we're done. */
 	error = 0;
 	if (request->fl_flags & FL_ACCESS)
 		goto out;
 
-	/*
-	 * Find the first old lock with the same owner as the new lock.
-	 */
-	
+	/* Find the first old lock with the same owner as the new lock. */
 	before = &inode->i_flock;
 
 	/* First skip locks owned by other processes.  */
@@ -902,8 +903,7 @@ static int __posix_lock_file(struct inode *inode, struct file_lock *request, str
 			}
 			request = fl;
 			added = 1;
-		}
-		else {
+		} else {
 			/* Processing for different lock types is a bit
 			 * more complex.
 			 */
@@ -947,7 +947,7 @@ static int __posix_lock_file(struct inode *inode, struct file_lock *request, str
 		}
 		/* Go on to next lock.
 		 */
-	next_lock:
+next_lock:
 		before = &fl->fl_next;
 	}
 
@@ -1039,7 +1039,7 @@ EXPORT_SYMBOL(posix_lock_file);
 int posix_lock_file_wait(struct file *filp, struct file_lock *fl)
 {
 	int error;
-	might_sleep ();
+	might_sleep();
 	for (;;) {
 		error = posix_lock_file(filp, fl, NULL);
 		if (error != FILE_LOCK_DEFERRED)
@@ -1132,7 +1132,6 @@ int locks_mandatory_area(int read_write, struct inode *inode,
 
 	return error;
 }
-
 EXPORT_SYMBOL(locks_mandatory_area);
 
 static void lease_clear_pending(struct file_lock *fl, int arg)
@@ -1160,7 +1159,6 @@ int lease_modify(struct file_lock **before, int arg)
 		locks_delete_lock(before);
 	return 0;
 }
-
 EXPORT_SYMBOL(lease_modify);
 
 static bool past_time(unsigned long then)
@@ -1290,7 +1288,6 @@ out:
 		locks_free_lock(new_fl);
 	return error;
 }
-
 EXPORT_SYMBOL(__break_lease);
 
 /**
@@ -1310,7 +1307,6 @@ void lease_get_mtime(struct inode *inode, struct timespec *time)
 	else
 		*time = inode->i_mtime;
 }
-
 EXPORT_SYMBOL(lease_get_mtime);
 
 /**
@@ -1617,7 +1613,6 @@ int flock_lock_file_wait(struct file *filp, struct file_lock *fl)
 	}
 	return error;
 }
-
 EXPORT_SYMBOL(flock_lock_file_wait);
 
 /**
@@ -1634,7 +1629,8 @@ EXPORT_SYMBOL(flock_lock_file_wait);
  *
  *	%LOCK_UN -- remove an existing lock.
  *
- *	%LOCK_MAND -- a `mandatory' flock.  This exists to emulate Windows Share Modes.
+ *	%LOCK_MAND -- a `mandatory' flock.
+ *	This exists to emulate Windows Share Modes.
  *
  *	%LOCK_MAND can be combined with %LOCK_READ or %LOCK_WRITE to allow other
  *	processes read and write access respectively.
@@ -1758,7 +1754,7 @@ int fcntl_getlk(struct file *filp, struct flock __user *l)
 	error = vfs_test_lock(filp, &file_lock);
 	if (error)
 		goto out;
- 
+
 	flock.l_type = file_lock.fl_type;
 	if (file_lock.fl_type != F_UNLCK) {
 		error = posix_lock_to_flock(&flock, &file_lock);
@@ -1805,7 +1801,8 @@ out:
  * ->lm_grant() before returning to the caller with a FILE_LOCK_DEFERRED
  * return code.
  */
-int vfs_lock_file(struct file *filp, unsigned int cmd, struct file_lock *fl, struct file_lock *conf)
+int vfs_lock_file(struct file *filp, unsigned int cmd, struct file_lock *fl,
+		  struct file_lock *conf)
 {
 	if (filp->f_op && filp->f_op->lock)
 		return filp->f_op->lock(filp, cmd, fl);
@@ -1874,10 +1871,9 @@ again:
 	error = flock_to_posix_lock(filp, file_lock, &flock);
 	if (error)
 		goto out;
-	if (cmd == F_SETLKW) {
+	if (cmd == F_SETLKW)
 		file_lock->fl_flags |= FL_SLEEP;
-	}
-	
+
 	error = -EBADF;
 	switch (flock.l_type) {
 	case F_RDLCK:
@@ -1951,7 +1947,7 @@ int fcntl_getlk64(struct file *filp, struct flock64 __user *l)
 	error = -EFAULT;
 	if (!copy_to_user(l, &flock, sizeof(flock)))
 		error = 0;
-  
+
 out:
 	return error;
 }
@@ -1992,10 +1988,9 @@ again:
 	error = flock64_to_posix_lock(filp, file_lock, &flock);
 	if (error)
 		goto out;
-	if (cmd == F_SETLKW64) {
+	if (cmd == F_SETLKW64)
 		file_lock->fl_flags |= FL_SLEEP;
-	}
-	
+
 	error = -EBADF;
 	switch (flock.l_type) {
 	case F_RDLCK:
@@ -2065,7 +2060,6 @@ void locks_remove_posix(struct file *filp, fl_owner_t owner)
 	if (lock.fl_ops && lock.fl_ops->fl_release_private)
 		lock.fl_ops->fl_release_private(&lock);
 }
-
 EXPORT_SYMBOL(locks_remove_posix);
 
 /*
@@ -2073,7 +2067,7 @@ EXPORT_SYMBOL(locks_remove_posix);
  */
 void locks_remove_flock(struct file *filp)
 {
-	struct inode * inode = filp->f_path.dentry->d_inode;
+	struct inode *inode = filp->f_path.dentry->d_inode;
 	struct file_lock *fl;
 	struct file_lock **before;
 
@@ -2108,7 +2102,7 @@ void locks_remove_flock(struct file *filp)
 			}
 			/* What? */
 			BUG();
- 		}
+		}
 		before = &fl->fl_next;
 	}
 	unlock_flocks();
@@ -2134,7 +2128,6 @@ posix_unblock_lock(struct file *filp, struct file_lock *waiter)
 	unlock_flocks();
 	return status;
 }
-
 EXPORT_SYMBOL(posix_unblock_lock);
 
 /**
@@ -2150,7 +2143,6 @@ int vfs_cancel_lock(struct file *filp, struct file_lock *fl)
 		return filp->f_op->lock(filp, F_CANCELLK, fl);
 	return 0;
 }
-
 EXPORT_SYMBOL_GPL(vfs_cancel_lock);
 
 #ifdef CONFIG_PROC_FS
@@ -2178,11 +2170,10 @@ static void lock_get_status(struct seq_file *f, struct file_lock *fl,
 			     (inode == NULL) ? "*NOINODE*" :
 			     mandatory_lock(inode) ? "MANDATORY" : "ADVISORY ");
 	} else if (IS_FLOCK(fl)) {
-		if (fl->fl_type & LOCK_MAND) {
+		if (fl->fl_type & LOCK_MAND)
 			seq_printf(f, "FLOCK  MSNFS     ");
-		} else {
+		else
 			seq_printf(f, "FLOCK  ADVISORY  ");
-		}
 	} else if (IS_LEASE(fl)) {
 		seq_printf(f, "LEASE  ");
 		if (lease_breaking(fl))
@@ -2220,9 +2211,9 @@ static void lock_get_status(struct seq_file *f, struct file_lock *fl,
 	}
 	if (IS_POSIX(fl)) {
 		if (fl->fl_end == OFFSET_MAX)
-			seq_printf(f, "%Ld EOF\n", fl->fl_start);
+			seq_printf(f, "%lld EOF\n", fl->fl_start);
 		else
-			seq_printf(f, "%Ld %Ld\n", fl->fl_start, fl->fl_end);
+			seq_printf(f, "%lld %lld\n", fl->fl_start, fl->fl_end);
 	} else {
 		seq_printf(f, "0 EOF\n");
 	}
@@ -2312,7 +2303,8 @@ int lock_may_read(struct inode *inode, loff_t start, unsigned long len)
 		if (IS_POSIX(fl)) {
 			if (fl->fl_type == F_RDLCK)
 				continue;
-			if ((fl->fl_end < start) || (fl->fl_start > (start + len)))
+			if ((fl->fl_end < start) ||
+			    (fl->fl_start > (start + len)))
 				continue;
 		} else if (IS_FLOCK(fl)) {
 			if (!(fl->fl_type & LOCK_MAND))
@@ -2327,7 +2319,6 @@ int lock_may_read(struct inode *inode, loff_t start, unsigned long len)
 	unlock_flocks();
 	return result;
 }
-
 EXPORT_SYMBOL(lock_may_read);
 
 /**
@@ -2350,7 +2341,8 @@ int lock_may_write(struct inode *inode, loff_t start, unsigned long len)
 	lock_flocks();
 	for (fl = inode->i_flock; fl != NULL; fl = fl->fl_next) {
 		if (IS_POSIX(fl)) {
-			if ((fl->fl_end < start) || (fl->fl_start > (start + len)))
+			if ((fl->fl_end < start) ||
+			    (fl->fl_start > (start + len)))
 				continue;
 		} else if (IS_FLOCK(fl)) {
 			if (!(fl->fl_type & LOCK_MAND))
@@ -2365,7 +2357,6 @@ int lock_may_write(struct inode *inode, loff_t start, unsigned long len)
 	unlock_flocks();
 	return result;
 }
-
 EXPORT_SYMBOL(lock_may_write);
 
 static int __init filelock_init(void)
-- 
1.7.6.405.gc1be0

[PATCH 22/28] open: checkpatch wanking

[Joe Perches]

Now checkpatch clean.

$ ./scripts/checkpatch.pl -f --terse --nosummary fs/open.c | \
  cut -f3- -d":" | sort | uniq -c
      8  ERROR: "foo * bar" should be "foo *bar"
      5  WARNING: EXPORT_SYMBOL(foo); should immediately follow its function/variable
      4  WARNING: line over 80 characters
      1  WARNING: Use #include <linux/uaccess.h> instead of <asm/uaccess.h>

Signed-off-by: Joe Perches <joe@perches.com>
---
 fs/open.c |   37 ++++++++++++++++++-------------------
 1 files changed, 18 insertions(+), 19 deletions(-)

diff --git a/fs/open.c b/fs/open.c
index 58c8d94..bb3e0e5 100644
--- a/fs/open.c
+++ b/fs/open.c
@@ -21,7 +21,7 @@
 #include <linux/mount.h>
 #include <linux/fcntl.h>
 #include <linux/slab.h>
-#include <asm/uaccess.h>
+#include <linux/uaccess.h>
 #include <linux/fs.h>
 #include <linux/personality.h>
 #include <linux/pagemap.h>
@@ -134,9 +134,9 @@ SYSCALL_DEFINE2(truncate, const char __user *, path, long, length)
 
 static long do_sys_ftruncate(unsigned int fd, loff_t length, int small)
 {
-	struct inode * inode;
+	struct inode *inode;
 	struct dentry *dentry;
-	struct file * file;
+	struct file *file;
 	int error;
 
 	error = -EINVAL;
@@ -170,7 +170,8 @@ static long do_sys_ftruncate(unsigned int fd, loff_t length, int small)
 	if (!error)
 		error = security_path_truncate(&file->f_path);
 	if (!error)
-		error = do_truncate(dentry, length, ATTR_MTIME|ATTR_CTIME, file);
+		error = do_truncate(dentry, length, ATTR_MTIME | ATTR_CTIME,
+				    file);
 out_putf:
 	fput(file);
 out:
@@ -187,7 +188,7 @@ SYSCALL_DEFINE2(ftruncate, unsigned int, fd, unsigned long, length)
 
 /* LFS versions of truncate are only needed on 32 bit machines */
 #if BITS_PER_LONG == 32
-SYSCALL_DEFINE(truncate64)(const char __user * path, loff_t length)
+SYSCALL_DEFINE(truncate64)(const char __user *path, loff_t length)
 {
 	return do_sys_truncate(path, length);
 }
@@ -472,7 +473,7 @@ out_unlock:
 
 SYSCALL_DEFINE2(fchmod, unsigned int, fd, mode_t, mode)
 {
-	struct file * file;
+	struct file *file;
 	int err = -EBADF;
 
 	file = fget(fd);
@@ -575,7 +576,8 @@ out:
 	return error;
 }
 
-SYSCALL_DEFINE3(lchown, const char __user *, filename, uid_t, user, gid_t, group)
+SYSCALL_DEFINE3(lchown, const char __user *, filename, uid_t, user, gid_t,
+		group)
 {
 	struct path path;
 	int error;
@@ -596,9 +598,9 @@ out:
 
 SYSCALL_DEFINE3(fchown, unsigned int, fd, uid_t, user, gid_t, group)
 {
-	struct file * file;
+	struct file *file;
 	int error = -EBADF;
-	struct dentry * dentry;
+	struct dentry *dentry;
 
 	file = fget(fd);
 	if (!file)
@@ -648,7 +650,8 @@ static inline int __get_file_write_access(struct inode *inode,
 
 static struct file *__dentry_open(struct dentry *dentry, struct vfsmount *mnt,
 					struct file *f,
-					int (*open)(struct inode *, struct file *),
+					int (*open)(struct inode *,
+						    struct file *),
 					const struct cred *cred)
 {
 	static const struct file_operations empty_fops = {};
@@ -761,8 +764,9 @@ cleanup_file:
  * If the open callback is set to NULL, then the standard f_op->open()
  * filesystem callback is substituted.
  */
-struct file *lookup_instantiate_filp(struct nameidata *nd, struct dentry *dentry,
-		int (*open)(struct inode *, struct file *))
+struct file *lookup_instantiate_filp(struct nameidata *nd,
+				     struct dentry *dentry,
+				     int (*open)(struct inode *, struct file *))
 {
 	const struct cred *cred = current_cred();
 
@@ -850,7 +854,6 @@ void put_unused_fd(unsigned int fd)
 	__put_unused_fd(files, fd);
 	spin_unlock(&files->file_lock);
 }
-
 EXPORT_SYMBOL(put_unused_fd);
 
 /*
@@ -876,7 +879,6 @@ void fd_install(unsigned int fd, struct file *file)
 	rcu_assign_pointer(fdt->fd[fd], file);
 	spin_unlock(&files->file_lock);
 }
-
 EXPORT_SYMBOL(fd_install);
 
 static inline int build_open_flags(int flags, int mode, struct open_flags *op)
@@ -1059,7 +1061,6 @@ int filp_close(struct file *filp, fl_owner_t id)
 	fput(filp);
 	return retval;
 }
-
 EXPORT_SYMBOL(filp_close);
 
 /*
@@ -1069,7 +1070,7 @@ EXPORT_SYMBOL(filp_close);
  */
 SYSCALL_DEFINE1(close, unsigned int, fd)
 {
-	struct file * filp;
+	struct file *filp;
 	struct files_struct *files = current->files;
 	struct fdtable *fdt;
 	int retval;
@@ -1121,13 +1122,12 @@ SYSCALL_DEFINE0(vhangup)
  * the caller didn't specify O_LARGEFILE.  On 64bit systems we force
  * on this flag in sys_open.
  */
-int generic_file_open(struct inode * inode, struct file * filp)
+int generic_file_open(struct inode *inode, struct file *filp)
 {
 	if (!(filp->f_flags & O_LARGEFILE) && i_size_read(inode) > MAX_NON_LFS)
 		return -EOVERFLOW;
 	return 0;
 }
-
 EXPORT_SYMBOL(generic_file_open);
 
 /*
@@ -1141,5 +1141,4 @@ int nonseekable_open(struct inode *inode, struct file *filp)
 	filp->f_mode &= ~(FMODE_LSEEK | FMODE_PREAD | FMODE_PWRITE);
 	return 0;
 }
-
 EXPORT_SYMBOL(nonseekable_open);
-- 
1.7.6.405.gc1be0

[PATCH 23/28] stat: checkpatch wanking

[Joe Perches]

Now checkpatch clean.

$ ./scripts/checkpatch.pl -f --terse --nosummary fs/stat.c | \
  cut -f3- -d":" | sort | uniq -c
      3  ERROR: space required after that ',' (ctx:VxO)
      3  ERROR: space required after that ',' (ctx:VxV)
      3  ERROR: space required before that '&' (ctx:OxV)
      3  ERROR: trailing whitespace
      6  WARNING: EXPORT_SYMBOL(foo); should immediately follow its function/variable
      2  WARNING: line over 80 characters
      1  WARNING: Use #include <linux/uaccess.h> instead of <asm/uaccess.h>
      1  WARNING: Use #include <linux/unistd.h> instead of <asm/unistd.h>

Signed-off-by: Joe Perches <joe@perches.com>
---
 fs/stat.c |   29 ++++++++++++-----------------
 1 files changed, 12 insertions(+), 17 deletions(-)

diff --git a/fs/stat.c b/fs/stat.c
index ff9be35..829d9e9 100644
--- a/fs/stat.c
+++ b/fs/stat.c
@@ -16,9 +16,8 @@
 #include <linux/security.h>
 #include <linux/syscalls.h>
 #include <linux/pagemap.h>
-
-#include <asm/uaccess.h>
-#include <asm/unistd.h>
+#include <linux/uaccess.h>
+#include <linux/unistd.h>
 
 void generic_fillattr(struct inode *inode, struct kstat *stat)
 {
@@ -36,7 +35,6 @@ void generic_fillattr(struct inode *inode, struct kstat *stat)
 	stat->blksize = (1 << inode->i_blkbits);
 	stat->blocks = inode->i_blocks;
 }
-
 EXPORT_SYMBOL(generic_fillattr);
 
 int vfs_getattr(struct vfsmount *mnt, struct dentry *dentry, struct kstat *stat)
@@ -54,7 +52,6 @@ int vfs_getattr(struct vfsmount *mnt, struct dentry *dentry, struct kstat *stat)
 	generic_fillattr(inode, stat);
 	return 0;
 }
-
 EXPORT_SYMBOL(vfs_getattr);
 
 int vfs_fstat(unsigned int fd, struct kstat *stat)
@@ -116,11 +113,12 @@ EXPORT_SYMBOL(vfs_lstat);
  * For backward compatibility?  Maybe this should be moved
  * into arch/i386 instead?
  */
-static int cp_old_stat(struct kstat *stat, struct __old_kernel_stat __user * statbuf)
+static int cp_old_stat(struct kstat *stat,
+		       struct __old_kernel_stat __user *statbuf)
 {
 	static int warncount = 5;
 	struct __old_kernel_stat tmp;
-	
+
 	if (warncount > 0) {
 		warncount--;
 		pr_warn("VFS: Warning: %s using old stat() call. Recompile your binary.\n",
@@ -145,12 +143,12 @@ static int cp_old_stat(struct kstat *stat, struct __old_kernel_stat __user * sta
 #if BITS_PER_LONG == 32
 	if (stat->size > MAX_NON_LFS)
 		return -EOVERFLOW;
-#endif	
+#endif
 	tmp.st_size = stat->size;
 	tmp.st_atime = stat->atime.tv_sec;
 	tmp.st_mtime = stat->mtime.tv_sec;
 	tmp.st_ctime = stat->ctime.tv_sec;
-	return copy_to_user(statbuf,&tmp,sizeof(tmp)) ? -EFAULT : 0;
+	return copy_to_user(statbuf, &tmp, sizeof(tmp)) ? -EFAULT : 0;
 }
 
 SYSCALL_DEFINE2(stat, const char __user *, filename,
@@ -179,7 +177,8 @@ SYSCALL_DEFINE2(lstat, const char __user *, filename,
 	return cp_old_stat(&stat, statbuf);
 }
 
-SYSCALL_DEFINE2(fstat, unsigned int, fd, struct __old_kernel_stat __user *, statbuf)
+SYSCALL_DEFINE2(fstat, unsigned int, fd, struct __old_kernel_stat __user *,
+		statbuf)
 {
 	struct kstat stat;
 	int error = vfs_fstat(fd, &stat);
@@ -227,7 +226,7 @@ static int cp_new_stat(struct kstat *stat, struct stat __user *statbuf)
 #if BITS_PER_LONG == 32
 	if (stat->size > MAX_NON_LFS)
 		return -EOVERFLOW;
-#endif	
+#endif
 	tmp.st_size = stat->size;
 	tmp.st_atime = stat->atime.tv_sec;
 	tmp.st_mtime = stat->mtime.tv_sec;
@@ -239,7 +238,7 @@ static int cp_new_stat(struct kstat *stat, struct stat __user *statbuf)
 #endif
 	tmp.st_blocks = stat->blocks;
 	tmp.st_blksize = stat->blksize;
-	return copy_to_user(statbuf,&tmp,sizeof(tmp)) ? -EFAULT : 0;
+	return copy_to_user(statbuf, &tmp, sizeof(tmp)) ? -EFAULT : 0;
 }
 
 SYSCALL_DEFINE2(newstat, const char __user *, filename,
@@ -363,7 +362,7 @@ static long cp_new_stat64(struct kstat *stat, struct stat64 __user *statbuf)
 	tmp.st_size = stat->size;
 	tmp.st_blocks = stat->blocks;
 	tmp.st_blksize = stat->blksize;
-	return copy_to_user(statbuf,&tmp,sizeof(tmp)) ? -EFAULT : 0;
+	return copy_to_user(statbuf, &tmp, sizeof(tmp)) ? -EFAULT : 0;
 }
 
 SYSCALL_DEFINE2(stat64, const char __user *, filename,
@@ -432,7 +431,6 @@ void inode_add_bytes(struct inode *inode, loff_t bytes)
 	__inode_add_bytes(inode, bytes);
 	spin_unlock(&inode->i_lock);
 }
-
 EXPORT_SYMBOL(inode_add_bytes);
 
 void inode_sub_bytes(struct inode *inode, loff_t bytes)
@@ -447,7 +445,6 @@ void inode_sub_bytes(struct inode *inode, loff_t bytes)
 	inode->i_bytes -= bytes;
 	spin_unlock(&inode->i_lock);
 }
-
 EXPORT_SYMBOL(inode_sub_bytes);
 
 loff_t inode_get_bytes(struct inode *inode)
@@ -459,7 +456,6 @@ loff_t inode_get_bytes(struct inode *inode)
 	spin_unlock(&inode->i_lock);
 	return ret;
 }
-
 EXPORT_SYMBOL(inode_get_bytes);
 
 void inode_set_bytes(struct inode *inode, loff_t bytes)
@@ -469,5 +465,4 @@ void inode_set_bytes(struct inode *inode, loff_t bytes)
 	inode->i_blocks = bytes >> 9;
 	inode->i_bytes = bytes & 511;
 }
-
 EXPORT_SYMBOL(inode_set_bytes);
-- 
1.7.6.405.gc1be0

[PATCH 24/28] super: checkpatch wanking

[Joe Perches]

Now checkpatch clean.

$ ./scripts/checkpatch.pl -f --terse --nosummary fs/super.c | \
  cut -f3- -d":" | sort | uniq -c
      1  ERROR: code indent should use tabs where possible
      1  ERROR: do not initialise statics to 0 or NULL
      2  ERROR: "foo * bar" should be "foo *bar"
      2  ERROR: space required after that ',' (ctx:OxV)
      3  ERROR: trailing whitespace
     14  WARNING: EXPORT_SYMBOL(foo); should immediately follow its function/variable
      1  WARNING: line over 80 characters
      1  WARNING: please, no space before tabs
      2  WARNING: please, no spaces at the start of a line

Signed-off-by: Joe Perches <joe@perches.com>
---
 fs/super.c |   40 ++++++++++++++--------------------------
 1 files changed, 14 insertions(+), 26 deletions(-)

diff --git a/fs/super.c b/fs/super.c
index 23ff118..b550808 100644
--- a/fs/super.c
+++ b/fs/super.c
@@ -172,7 +172,8 @@ static struct super_block *alloc_super(struct file_system_type *type)
 		s->s_count = 1;
 		atomic_set(&s->s_active, 1);
 		mutex_init(&s->s_vfs_rename_mutex);
-		lockdep_set_class(&s->s_vfs_rename_mutex, &type->s_vfs_rename_key);
+		lockdep_set_class(&s->s_vfs_rename_mutex,
+				  &type->s_vfs_rename_key);
 		mutex_init(&s->s_dquot.dqio_mutex);
 		mutex_init(&s->s_dquot.dqonoff_mutex);
 		init_rwsem(&s->s_dquot.dqptr_sem);
@@ -267,7 +268,6 @@ void deactivate_locked_super(struct super_block *s)
 		up_write(&s->s_umount);
 	}
 }
-
 EXPORT_SYMBOL(deactivate_locked_super);
 
 /**
@@ -280,12 +280,11 @@ EXPORT_SYMBOL(deactivate_locked_super);
  */
 void deactivate_super(struct super_block *s)
 {
-        if (!atomic_add_unless(&s->s_active, -1, 1)) {
+	if (!atomic_add_unless(&s->s_active, -1, 1)) {
 		down_write(&s->s_umount);
 		deactivate_locked_super(s);
 	}
 }
-
 EXPORT_SYMBOL(deactivate_super);
 
 /**
@@ -293,7 +292,7 @@ EXPORT_SYMBOL(deactivate_super);
  *	@s: reference we are trying to make active
  *
  *	Tries to acquire an active reference.  grab_super() is used when we
- * 	had just found a superblock in super_blocks or fs_type->fs_supers
+ *	had just found a superblock in super_blocks or fs_type->fs_supers
  *	and want to turn it into a full-blown active reference.  grab_super()
  *	is called with sb_lock held and drops it.  Returns 1 in case of
  *	success, 0 if we had failed (superblock contents was already dead or
@@ -351,17 +350,16 @@ bool grab_super_passive(struct super_block *sb)
 /*
  * Superblock locking.  We really ought to get rid of these two.
  */
-void lock_super(struct super_block * sb)
+void lock_super(struct super_block *sb)
 {
 	mutex_lock(&sb->s_lock);
 }
+EXPORT_SYMBOL(lock_super);
 
-void unlock_super(struct super_block * sb)
+void unlock_super(struct super_block *sb)
 {
 	mutex_unlock(&sb->s_lock);
 }
-
-EXPORT_SYMBOL(lock_super);
 EXPORT_SYMBOL(unlock_super);
 
 /**
@@ -405,7 +403,6 @@ void generic_shutdown_super(struct super_block *sb)
 	spin_unlock(&sb_lock);
 	up_write(&sb->s_umount);
 }
-
 EXPORT_SYMBOL(generic_shutdown_super);
 
 /**
@@ -416,9 +413,9 @@ EXPORT_SYMBOL(generic_shutdown_super);
  *	@data:	argument to each of them
  */
 struct super_block *sget(struct file_system_type *type,
-			int (*test)(struct super_block *,void *),
-			int (*set)(struct super_block *,void *),
-			void *data)
+			 int (*test)(struct super_block *, void *),
+			 int (*set)(struct super_block *, void *),
+			 void *data)
 {
 	struct super_block *s = NULL;
 	struct super_block *old;
@@ -452,7 +449,7 @@ retry:
 			return ERR_PTR(-ENOMEM);
 		goto retry;
 	}
-		
+
 	err = set(s, data);
 	if (err) {
 		spin_unlock(&sb_lock);
@@ -469,7 +466,6 @@ retry:
 	register_shrinker(&s->s_shrink);
 	return s;
 }
-
 EXPORT_SYMBOL(sget);
 
 void drop_super(struct super_block *sb)
@@ -477,7 +473,6 @@ void drop_super(struct super_block *sb)
 	up_read(&sb->s_umount);
 	put_super(sb);
 }
-
 EXPORT_SYMBOL(drop_super);
 
 /**
@@ -587,13 +582,12 @@ void iterate_supers_type(struct file_system_type *type,
 		__put_super(p);
 	spin_unlock(&sb_lock);
 }
-
 EXPORT_SYMBOL(iterate_supers_type);
 
 /**
  *	get_super - get the superblock of a device
  *	@bdev: device to get the superblock for
- *	
+ *
  *	Scans the superblock list and finds the superblock of the file system
  *	mounted on the device given. %NULL is returned if no match is found.
  */
@@ -627,7 +621,6 @@ rescan:
 	spin_unlock(&sb_lock);
 	return NULL;
 }
-
 EXPORT_SYMBOL(get_super);
 
 /**
@@ -660,7 +653,7 @@ restart:
 	spin_unlock(&sb_lock);
 	return NULL;
 }
- 
+
 struct super_block *user_get_super(dev_t dev)
 {
 	struct super_block *sb;
@@ -799,7 +792,7 @@ void emergency_remount(void)
 
 static DEFINE_IDA(unnamed_dev_ida);
 static DEFINE_SPINLOCK(unnamed_dev_lock);/* protects the above */
-static int unnamed_dev_start = 0; /* don't bother trying below it */
+static int unnamed_dev_start;	/* don't bother trying below it */
 
 int get_anon_bdev(dev_t *p)
 {
@@ -851,7 +844,6 @@ int set_anon_super(struct super_block *s, void *data)
 		s->s_bdi = &noop_backing_dev_info;
 	return error;
 }
-
 EXPORT_SYMBOL(set_anon_super);
 
 void kill_anon_super(struct super_block *sb)
@@ -860,7 +852,6 @@ void kill_anon_super(struct super_block *sb)
 	generic_shutdown_super(sb);
 	free_anon_bdev(dev);
 }
-
 EXPORT_SYMBOL(kill_anon_super);
 
 void kill_litter_super(struct super_block *sb)
@@ -869,7 +860,6 @@ void kill_litter_super(struct super_block *sb)
 		d_genocide(sb->s_root);
 	kill_anon_super(sb);
 }
-
 EXPORT_SYMBOL(kill_litter_super);
 
 static int ns_test_super(struct super_block *sb, void *data)
@@ -906,7 +896,6 @@ struct dentry *mount_ns(struct file_system_type *fs_type, int flags,
 
 	return dget(sb->s_root);
 }
-
 EXPORT_SYMBOL(mount_ns);
 
 #ifdef CONFIG_BLOCK
@@ -1016,7 +1005,6 @@ void kill_block_super(struct super_block *sb)
 	WARN_ON_ONCE(!(mode & FMODE_EXCL));
 	blkdev_put(bdev, mode | FMODE_EXCL);
 }
-
 EXPORT_SYMBOL(kill_block_super);
 #endif
 
-- 
1.7.6.405.gc1be0

[PATCH 25/28] libfs: checkpatch wanking

[Joe Perches]

One warning for kstrtoll remains.

$ ./scripts/checkpatch.pl -f --terse --nosummary fs/libfs.c | \
  cut -f3- -d":" | sort | uniq -c
      1  ERROR: "foo * bar" should be "foo *bar"
      2  ERROR: spaces required around that '=' (ctx:VxV)
      2  ERROR: switch and case should be at the same indent
      3  ERROR: trailing whitespace
     34  WARNING: EXPORT_SYMBOL(foo); should immediately follow its function/variable
     11  WARNING: line over 80 characters
      7  WARNING: please, no space before tabs
      1  WARNING: simple_strtoll is obsolete, use kstrtoll instead
      1  WARNING: Use #include <linux/uaccess.h> instead of <asm/uaccess.h>

Signed-off-by: Joe Perches <joe@perches.com>
---
 fs/libfs.c |  208 +++++++++++++++++++++++++++++++-----------------------------
 1 files changed, 107 insertions(+), 101 deletions(-)

diff --git a/fs/libfs.c b/fs/libfs.c
index ad1532f..c224d14 100644
--- a/fs/libfs.c
+++ b/fs/libfs.c
@@ -15,8 +15,7 @@
 #include <linux/exportfs.h>
 #include <linux/writeback.h>
 #include <linux/buffer_head.h>
-
-#include <asm/uaccess.h>
+#include <linux/uaccess.h>
 
 #include "internal.h"
 
@@ -33,6 +32,7 @@ int simple_getattr(struct vfsmount *mnt, struct dentry *dentry,
 	stat->blocks = inode->i_mapping->nrpages << (PAGE_CACHE_SHIFT - 9);
 	return 0;
 }
+EXPORT_SYMBOL(simple_getattr);
 
 int simple_statfs(struct dentry *dentry, struct kstatfs *buf)
 {
@@ -41,6 +41,7 @@ int simple_statfs(struct dentry *dentry, struct kstatfs *buf)
 	buf->f_namelen = NAME_MAX;
 	return 0;
 }
+EXPORT_SYMBOL(simple_statfs);
 
 /*
  * Retaining negative dentries for an in-memory filesystem just wastes
@@ -55,7 +56,8 @@ static int simple_delete_dentry(const struct dentry *dentry)
  * Lookup the data. This is trivial - if the dentry didn't already
  * exist, we know it is negative.  Set d_op to delete negative dentries.
  */
-struct dentry *simple_lookup(struct inode *dir, struct dentry *dentry, struct nameidata *nd)
+struct dentry *simple_lookup(struct inode *dir, struct dentry *dentry,
+			     struct nameidata *nd)
 {
 	static const struct dentry_operations simple_dentry_operations = {
 		.d_delete = simple_delete_dentry,
@@ -67,6 +69,7 @@ struct dentry *simple_lookup(struct inode *dir, struct dentry *dentry, struct na
 	d_add(dentry, NULL);
 	return NULL;
 }
+EXPORT_SYMBOL(simple_lookup);
 
 int dcache_dir_open(struct inode *inode, struct file *file)
 {
@@ -76,26 +79,28 @@ int dcache_dir_open(struct inode *inode, struct file *file)
 
 	return file->private_data ? 0 : -ENOMEM;
 }
+EXPORT_SYMBOL(dcache_dir_open);
 
 int dcache_dir_close(struct inode *inode, struct file *file)
 {
 	dput(file->private_data);
 	return 0;
 }
+EXPORT_SYMBOL(dcache_dir_close);
 
 loff_t dcache_dir_lseek(struct file *file, loff_t offset, int origin)
 {
 	struct dentry *dentry = file->f_path.dentry;
 	mutex_lock(&dentry->d_inode->i_mutex);
 	switch (origin) {
-		case 1:
-			offset += file->f_pos;
-		case 0:
-			if (offset >= 0)
-				break;
-		default:
-			mutex_unlock(&dentry->d_inode->i_mutex);
-			return -EINVAL;
+	case 1:
+		offset += file->f_pos;
+	case 0:
+		if (offset >= 0)
+			break;
+	default:
+		mutex_unlock(&dentry->d_inode->i_mutex);
+		return -EINVAL;
 	}
 	if (offset != file->f_pos) {
 		file->f_pos = offset;
@@ -110,8 +115,10 @@ loff_t dcache_dir_lseek(struct file *file, loff_t offset, int origin)
 			p = dentry->d_subdirs.next;
 			while (n && p != &dentry->d_subdirs) {
 				struct dentry *next;
-				next = list_entry(p, struct dentry, d_u.d_child);
-				spin_lock_nested(&next->d_lock, DENTRY_D_LOCK_NESTED);
+				next = list_entry(p, struct dentry,
+						  d_u.d_child);
+				spin_lock_nested(&next->d_lock,
+						 DENTRY_D_LOCK_NESTED);
 				if (simple_positive(next))
 					n--;
 				spin_unlock(&next->d_lock);
@@ -124,6 +131,7 @@ loff_t dcache_dir_lseek(struct file *file, loff_t offset, int origin)
 	mutex_unlock(&dentry->d_inode->i_mutex);
 	return offset;
 }
+EXPORT_SYMBOL(dcache_dir_lseek);
 
 /* Relationship between i_mode and the DT_xxx types */
 static inline unsigned char dt_type(struct inode *inode)
@@ -137,7 +145,7 @@ static inline unsigned char dt_type(struct inode *inode)
  * both impossible due to the lock on directory.
  */
 
-int dcache_readdir(struct file * filp, void * dirent, filldir_t filldir)
+int dcache_readdir(struct file *filp, void *dirent, filldir_t filldir)
 {
 	struct dentry *dentry = filp->f_path.dentry;
 	struct dentry *cursor = filp->private_data;
@@ -146,58 +154,61 @@ int dcache_readdir(struct file * filp, void * dirent, filldir_t filldir)
 	int i = filp->f_pos;
 
 	switch (i) {
-		case 0:
-			ino = dentry->d_inode->i_ino;
-			if (filldir(dirent, ".", 1, i, ino, DT_DIR) < 0)
-				break;
-			filp->f_pos++;
-			i++;
-			/* fallthrough */
-		case 1:
-			ino = parent_ino(dentry);
-			if (filldir(dirent, "..", 2, i, ino, DT_DIR) < 0)
-				break;
-			filp->f_pos++;
-			i++;
-			/* fallthrough */
-		default:
-			spin_lock(&dentry->d_lock);
-			if (filp->f_pos == 2)
-				list_move(q, &dentry->d_subdirs);
-
-			for (p=q->next; p != &dentry->d_subdirs; p=p->next) {
-				struct dentry *next;
-				next = list_entry(p, struct dentry, d_u.d_child);
-				spin_lock_nested(&next->d_lock, DENTRY_D_LOCK_NESTED);
-				if (!simple_positive(next)) {
-					spin_unlock(&next->d_lock);
-					continue;
-				}
-
-				spin_unlock(&next->d_lock);
-				spin_unlock(&dentry->d_lock);
-				if (filldir(dirent, next->d_name.name, 
-					    next->d_name.len, filp->f_pos, 
-					    next->d_inode->i_ino, 
-					    dt_type(next->d_inode)) < 0)
-					return 0;
-				spin_lock(&dentry->d_lock);
-				spin_lock_nested(&next->d_lock, DENTRY_D_LOCK_NESTED);
-				/* next is still alive */
-				list_move(q, p);
+	case 0:
+		ino = dentry->d_inode->i_ino;
+		if (filldir(dirent, ".", 1, i, ino, DT_DIR) < 0)
+			break;
+		filp->f_pos++;
+		i++;
+		/* fallthrough */
+	case 1:
+		ino = parent_ino(dentry);
+		if (filldir(dirent, "..", 2, i, ino, DT_DIR) < 0)
+			break;
+		filp->f_pos++;
+		i++;
+		/* fallthrough */
+	default:
+		spin_lock(&dentry->d_lock);
+		if (filp->f_pos == 2)
+			list_move(q, &dentry->d_subdirs);
+
+		for (p = q->next; p != &dentry->d_subdirs; p = p->next) {
+			struct dentry *next;
+			next = list_entry(p, struct dentry, d_u.d_child);
+			spin_lock_nested(&next->d_lock, DENTRY_D_LOCK_NESTED);
+			if (!simple_positive(next)) {
 				spin_unlock(&next->d_lock);
-				p = q;
-				filp->f_pos++;
+				continue;
 			}
+
+			spin_unlock(&next->d_lock);
 			spin_unlock(&dentry->d_lock);
+			if (filldir(dirent, next->d_name.name,
+				    next->d_name.len, filp->f_pos,
+				    next->d_inode->i_ino,
+				    dt_type(next->d_inode)) < 0)
+				return 0;
+			spin_lock(&dentry->d_lock);
+			spin_lock_nested(&next->d_lock, DENTRY_D_LOCK_NESTED);
+			/* next is still alive */
+			list_move(q, p);
+			spin_unlock(&next->d_lock);
+			p = q;
+			filp->f_pos++;
+		}
+		spin_unlock(&dentry->d_lock);
 	}
 	return 0;
 }
+EXPORT_SYMBOL(dcache_readdir);
 
-ssize_t generic_read_dir(struct file *filp, char __user *buf, size_t siz, loff_t *ppos)
+ssize_t generic_read_dir(struct file *filp, char __user *buf, size_t siz,
+			 loff_t *ppos)
 {
 	return -EISDIR;
 }
+EXPORT_SYMBOL(generic_read_dir);
 
 const struct file_operations simple_dir_operations = {
 	.open		= dcache_dir_open,
@@ -207,10 +218,12 @@ const struct file_operations simple_dir_operations = {
 	.readdir	= dcache_readdir,
 	.fsync		= noop_fsync,
 };
+EXPORT_SYMBOL(simple_dir_operations);
 
 const struct inode_operations simple_dir_inode_operations = {
 	.lookup		= simple_lookup,
 };
+EXPORT_SYMBOL(simple_dir_inode_operations);
 
 static const struct super_operations simple_super_operations = {
 	.statfs		= simple_statfs,
@@ -265,8 +278,10 @@ Enomem:
 	deactivate_locked_super(s);
 	return ERR_PTR(-ENOMEM);
 }
+EXPORT_SYMBOL(mount_pseudo);
 
-int simple_link(struct dentry *old_dentry, struct inode *dir, struct dentry *dentry)
+int simple_link(struct dentry *old_dentry, struct inode *dir,
+		struct dentry *dentry)
 {
 	struct inode *inode = old_dentry->d_inode;
 
@@ -277,6 +292,7 @@ int simple_link(struct dentry *old_dentry, struct inode *dir, struct dentry *den
 	d_instantiate(dentry, inode);
 	return 0;
 }
+EXPORT_SYMBOL(simple_link);
 
 int simple_empty(struct dentry *dentry)
 {
@@ -297,6 +313,7 @@ out:
 	spin_unlock(&dentry->d_lock);
 	return ret;
 }
+EXPORT_SYMBOL(simple_empty);
 
 int simple_unlink(struct inode *dir, struct dentry *dentry)
 {
@@ -307,6 +324,7 @@ int simple_unlink(struct inode *dir, struct dentry *dentry)
 	dput(dentry);
 	return 0;
 }
+EXPORT_SYMBOL(simple_unlink);
 
 int simple_rmdir(struct inode *dir, struct dentry *dentry)
 {
@@ -318,6 +336,7 @@ int simple_rmdir(struct inode *dir, struct dentry *dentry)
 	drop_nlink(dir);
 	return 0;
 }
+EXPORT_SYMBOL(simple_rmdir);
 
 int simple_rename(struct inode *old_dir, struct dentry *old_dentry,
 		struct inode *new_dir, struct dentry *new_dentry)
@@ -344,6 +363,7 @@ int simple_rename(struct inode *old_dir, struct dentry *old_dentry,
 
 	return 0;
 }
+EXPORT_SYMBOL(simple_rename);
 
 /**
  * simple_setattr - setattr for simple filesystem
@@ -386,6 +406,7 @@ int simple_readpage(struct file *file, struct page *page)
 	unlock_page(page);
 	return 0;
 }
+EXPORT_SYMBOL(simple_readpage);
 
 int simple_write_begin(struct file *file, struct address_space *mapping,
 			loff_t pos, unsigned len, unsigned flags,
@@ -409,17 +430,18 @@ int simple_write_begin(struct file *file, struct address_space *mapping,
 	}
 	return 0;
 }
+EXPORT_SYMBOL(simple_write_begin);
 
 /**
  * simple_write_end - .write_end helper for non-block-device FSes
  * @available: See .write_end of address_space_operations
- * @file: 		"
- * @mapping: 		"
- * @pos: 		"
- * @len: 		"
- * @copied: 		"
- * @page: 		"
- * @fsdata: 		"
+ * @file:		"
+ * @mapping:		"
+ * @pos:		"
+ * @len:		"
+ * @copied:		"
+ * @page:		"
+ * @fsdata:		"
  *
  * simple_write_end does the minimum needed for updating a page after writing is
  * done. It has the same API signature as the .write_end of
@@ -460,6 +482,7 @@ int simple_write_end(struct file *file, struct address_space *mapping,
 
 	return copied;
 }
+EXPORT_SYMBOL(simple_write_end);
 
 /*
  * the inodes created here are not hashed. If you use iunique to generate
@@ -528,10 +551,12 @@ out:
 	dput(root);
 	return -ENOMEM;
 }
+EXPORT_SYMBOL(simple_fill_super);
 
 static DEFINE_SPINLOCK(pin_fs_lock);
 
-int simple_pin_fs(struct file_system_type *type, struct vfsmount **mount, int *count)
+int simple_pin_fs(struct file_system_type *type, struct vfsmount **mount,
+		  int *count)
 {
 	struct vfsmount *mnt = NULL;
 	spin_lock(&pin_fs_lock);
@@ -550,6 +575,7 @@ int simple_pin_fs(struct file_system_type *type, struct vfsmount **mount, int *c
 	mntput(mnt);
 	return 0;
 }
+EXPORT_SYMBOL(simple_pin_fs);
 
 void simple_release_fs(struct vfsmount **mount, int *count)
 {
@@ -561,6 +587,7 @@ void simple_release_fs(struct vfsmount **mount, int *count)
 	spin_unlock(&pin_fs_lock);
 	mntput(mnt);
 }
+EXPORT_SYMBOL(simple_release_fs);
 
 /**
  * simple_read_from_buffer - copy data from the buffer to user space
@@ -595,6 +622,7 @@ ssize_t simple_read_from_buffer(void __user *to, size_t count, loff_t *ppos,
 	*ppos = pos + count;
 	return count;
 }
+EXPORT_SYMBOL(simple_read_from_buffer);
 
 /**
  * simple_write_to_buffer - copy data from user space to the buffer
@@ -629,6 +657,7 @@ ssize_t simple_write_to_buffer(void *to, size_t available, loff_t *ppos,
 	*ppos = pos + count;
 	return count;
 }
+EXPORT_SYMBOL(simple_write_to_buffer);
 
 /**
  * memory_read_from_buffer - copy data from the buffer
@@ -660,6 +689,7 @@ ssize_t memory_read_from_buffer(void *to, size_t count, loff_t *ppos,
 
 	return count;
 }
+EXPORT_SYMBOL(memory_read_from_buffer);
 
 /*
  * Transaction based IO.
@@ -681,8 +711,10 @@ void simple_transaction_set(struct file *file, size_t n)
 	smp_mb();
 	ar->size = n;
 }
+EXPORT_SYMBOL(simple_transaction_set);
 
-char *simple_transaction_get(struct file *file, const char __user *buf, size_t size)
+char *simple_transaction_get(struct file *file, const char __user *buf,
+			     size_t size)
 {
 	struct simple_transaction_argresp *ar;
 	static DEFINE_SPINLOCK(simple_transaction_lock);
@@ -712,8 +744,10 @@ char *simple_transaction_get(struct file *file, const char __user *buf, size_t s
 
 	return ar->data;
 }
+EXPORT_SYMBOL(simple_transaction_get);
 
-ssize_t simple_transaction_read(struct file *file, char __user *buf, size_t size, loff_t *pos)
+ssize_t simple_transaction_read(struct file *file, char __user *buf,
+				size_t size, loff_t *pos)
 {
 	struct simple_transaction_argresp *ar = file->private_data;
 
@@ -721,12 +755,14 @@ ssize_t simple_transaction_read(struct file *file, char __user *buf, size_t size
 		return 0;
 	return simple_read_from_buffer(buf, size, pos, ar->data, ar->size);
 }
+EXPORT_SYMBOL(simple_transaction_read);
 
 int simple_transaction_release(struct inode *inode, struct file *file)
 {
 	free_page((unsigned long)file->private_data);
 	return 0;
 }
+EXPORT_SYMBOL(simple_transaction_release);
 
 /* Simple attribute files */
 
@@ -762,12 +798,14 @@ int simple_attr_open(struct inode *inode, struct file *file,
 
 	return nonseekable_open(inode, file);
 }
+EXPORT_SYMBOL_GPL(simple_attr_open);
 
 int simple_attr_release(struct inode *inode, struct file *file)
 {
 	kfree(file->private_data);
 	return 0;
 }
+EXPORT_SYMBOL_GPL(simple_attr_release);
 
 /* read from the buffer that is filled with the get function */
 ssize_t simple_attr_read(struct file *file, char __user *buf,
@@ -803,6 +841,7 @@ out:
 	mutex_unlock(&attr->mutex);
 	return ret;
 }
+EXPORT_SYMBOL_GPL(simple_attr_read);
 
 /* interpret the buffer as a number to call the set function with */
 ssize_t simple_attr_write(struct file *file, const char __user *buf,
@@ -835,6 +874,7 @@ out:
 	mutex_unlock(&attr->mutex);
 	return ret;
 }
+EXPORT_SYMBOL_GPL(simple_attr_write);
 
 /**
  * generic_fh_to_dentry - generic helper for the fh_to_dentry export operation
@@ -973,38 +1013,4 @@ int noop_fsync(struct file *file, loff_t start, loff_t end, int datasync)
 {
 	return 0;
 }
-
-EXPORT_SYMBOL(dcache_dir_close);
-EXPORT_SYMBOL(dcache_dir_lseek);
-EXPORT_SYMBOL(dcache_dir_open);
-EXPORT_SYMBOL(dcache_readdir);
-EXPORT_SYMBOL(generic_read_dir);
-EXPORT_SYMBOL(mount_pseudo);
-EXPORT_SYMBOL(simple_write_begin);
-EXPORT_SYMBOL(simple_write_end);
-EXPORT_SYMBOL(simple_dir_inode_operations);
-EXPORT_SYMBOL(simple_dir_operations);
-EXPORT_SYMBOL(simple_empty);
-EXPORT_SYMBOL(simple_fill_super);
-EXPORT_SYMBOL(simple_getattr);
-EXPORT_SYMBOL(simple_link);
-EXPORT_SYMBOL(simple_lookup);
-EXPORT_SYMBOL(simple_pin_fs);
-EXPORT_SYMBOL(simple_readpage);
-EXPORT_SYMBOL(simple_release_fs);
-EXPORT_SYMBOL(simple_rename);
-EXPORT_SYMBOL(simple_rmdir);
-EXPORT_SYMBOL(simple_statfs);
 EXPORT_SYMBOL(noop_fsync);
-EXPORT_SYMBOL(simple_unlink);
-EXPORT_SYMBOL(simple_read_from_buffer);
-EXPORT_SYMBOL(simple_write_to_buffer);
-EXPORT_SYMBOL(memory_read_from_buffer);
-EXPORT_SYMBOL(simple_transaction_set);
-EXPORT_SYMBOL(simple_transaction_get);
-EXPORT_SYMBOL(simple_transaction_read);
-EXPORT_SYMBOL(simple_transaction_release);
-EXPORT_SYMBOL_GPL(simple_attr_open);
-EXPORT_SYMBOL_GPL(simple_attr_release);
-EXPORT_SYMBOL_GPL(simple_attr_read);
-EXPORT_SYMBOL_GPL(simple_attr_write);
-- 
1.7.6.405.gc1be0

[PATCH 26/28] bio: checkpatch wanking

[Joe Perches]

One long line was ignored.

$ ./scripts/checkpatch.pl -f --terse --nosummary fs/bio.c | \
  cut -f3- -d":" | sort | uniq -c
      1  ERROR: code indent should use tabs where possible
      1  ERROR: space required before the open parenthesis '('
      1  ERROR: trailing whitespace
      4  WARNING: line over 80 characters
      5  WARNING: please, no space before tabs
      1  WARNING: please, no spaces at the start of a line

Signed-off-by: Joe Perches <joe@perches.com>
---
 fs/bio.c |   26 +++++++++++++++-----------
 1 files changed, 15 insertions(+), 11 deletions(-)

diff --git a/fs/bio.c b/fs/bio.c
index 98acfb1..6c62472 100644
--- a/fs/bio.c
+++ b/fs/bio.c
@@ -437,13 +437,13 @@ inline int bio_phys_segments(struct request_queue *q, struct bio *bio)
 EXPORT_SYMBOL(bio_phys_segments);
 
 /**
- * 	__bio_clone	-	clone a bio
- * 	@bio: destination bio
- * 	@bio_src: bio to clone
+ *	__bio_clone	-	clone a bio
+ *	@bio: destination bio
+ *	@bio_src: bio to clone
  *
  *	Clone a &bio. Caller will own the returned bio, but not
  *	the actual data it points to. Reference count of returned
- * 	bio will be one.
+ *	bio will be one.
  */
 void __bio_clone(struct bio *bio, struct bio *bio_src)
 {
@@ -469,11 +469,12 @@ EXPORT_SYMBOL(__bio_clone);
  *	@bio: bio to clone
  *	@gfp_mask: allocation priority
  *
- * 	Like __bio_clone, only also allocates the returned bio
+ *	Like __bio_clone, only also allocates the returned bio
  */
 struct bio *bio_clone(struct bio *bio, gfp_t gfp_mask)
 {
-	struct bio *b = bio_alloc_bioset(gfp_mask, bio->bi_max_vecs, fs_bio_set);
+	struct bio *b = bio_alloc_bioset(gfp_mask, bio->bi_max_vecs,
+					 fs_bio_set);
 
 	if (!b)
 		return NULL;
@@ -685,7 +686,8 @@ static void bio_set_map_data(struct bio_map_data *bmd, struct bio *bio,
 			     struct sg_iovec *iov, int iov_count,
 			     int is_our_pages)
 {
-	memcpy(bmd->iovecs, bio->bi_io_vec, sizeof(struct bio_vec) * bio->bi_vcnt);
+	memcpy(bmd->iovecs, bio->bi_io_vec,
+	       sizeof(struct bio_vec) * bio->bi_vcnt);
 	memcpy(bmd->sgvecs, iov, sizeof(struct sg_iovec) * iov_count);
 	bmd->nr_sgvecs = iov_count;
 	bmd->is_our_pages = is_our_pages;
@@ -909,7 +911,8 @@ struct bio *bio_copy_user_iov(struct request_queue *q,
 	 */
 	if ((!write_to_vm && (!map_data || !map_data->null_mapped)) ||
 	    (map_data && map_data->from_user)) {
-		ret = __bio_copy_iov(bio, bio->bi_io_vec, iov, iov_count, 0, 1, 0);
+		ret = __bio_copy_iov(bio, bio->bi_io_vec, iov,
+				     iov_count, 0, 1, 0);
 		if (ret)
 			goto cleanup;
 	}
@@ -1018,7 +1021,7 @@ static struct bio *__bio_map_user_iov(struct request_queue *q,
 
 			if (len <= 0)
 				break;
-			
+
 			if (bytes > len)
 				bytes = len;
 
@@ -1055,7 +1058,7 @@ static struct bio *__bio_map_user_iov(struct request_queue *q,
 
  out_unmap:
 	for (i = 0; i < nr_pages; i++) {
-		if(!pages[i])
+		if (!pages[i])
 			break;
 		page_cache_release(pages[i]);
 	}
@@ -1663,7 +1666,8 @@ static void __init biovec_init_slabs(void)
 
 		size = bvs->nr_vecs * sizeof(struct bio_vec);
 		bvs->slab = kmem_cache_create(bvs->name, size, 0,
-                                SLAB_HWCACHE_ALIGN|SLAB_PANIC, NULL);
+					      SLAB_HWCACHE_ALIGN | SLAB_PANIC,
+					      NULL);
 	}
 }
 
-- 
1.7.6.405.gc1be0

[PATCH 27/28] mbcache: checkpatch wanking.

[Joe Perches]

Now checkpatch clean.

$ ./scripts/checkpatch.pl -f --terse --nosummary fs/mbcache.c | cut -f3- -d":" | sort | uniq -c
      1  ERROR: code indent should use tabs where possible
      2  ERROR: spaces required around that '<' (ctx:VxV)
      2  ERROR: spaces required around that '=' (ctx:VxV)
      2  ERROR: trailing whitespace
      9  WARNING: EXPORT_SYMBOL(foo); should immediately follow its function/variable
      1  WARNING: please, no space before tabs

Signed-off-by: Joe Perches <joe@perches.com>
---
 fs/mbcache.c |   42 ++++++++++++++++--------------------------
 1 files changed, 16 insertions(+), 26 deletions(-)

diff --git a/fs/mbcache.c b/fs/mbcache.c
index a3c533c..a685b62 100644
--- a/fs/mbcache.c
+++ b/fs/mbcache.c
@@ -59,24 +59,11 @@ do {							\
 #define MB_CACHE_WRITER ((unsigned short)~0U >> 1)
 
 static DECLARE_WAIT_QUEUE_HEAD(mb_cache_queue);
-		
+
 MODULE_AUTHOR("Andreas Gruenbacher <a.gruenbacher@computer.org>");
 MODULE_DESCRIPTION("Meta block cache (for extended attributes)");
 MODULE_LICENSE("GPL");
 
-EXPORT_SYMBOL(mb_cache_create);
-EXPORT_SYMBOL(mb_cache_shrink);
-EXPORT_SYMBOL(mb_cache_destroy);
-EXPORT_SYMBOL(mb_cache_entry_alloc);
-EXPORT_SYMBOL(mb_cache_entry_insert);
-EXPORT_SYMBOL(mb_cache_entry_release);
-EXPORT_SYMBOL(mb_cache_entry_free);
-EXPORT_SYMBOL(mb_cache_entry_get);
-#if !defined(MB_CACHE_INDEXES_COUNT) || (MB_CACHE_INDEXES_COUNT > 0)
-EXPORT_SYMBOL(mb_cache_entry_find_first);
-EXPORT_SYMBOL(mb_cache_entry_find_next);
-#endif
-
 /*
  * Global data: list of all mbcache's, lru list, and a spinlock for
  * accessing cache data structures on SMP machines. The lru list is
@@ -218,16 +205,16 @@ mb_cache_create(const char *name, int bucket_bits)
 	atomic_set(&cache->c_entry_count, 0);
 	cache->c_bucket_bits = bucket_bits;
 	cache->c_block_hash = kmalloc(bucket_count * sizeof(struct list_head),
-	                              GFP_KERNEL);
+				      GFP_KERNEL);
 	if (!cache->c_block_hash)
 		goto fail;
-	for (n=0; n<bucket_count; n++)
+	for (n = 0; n < bucket_count; n++)
 		INIT_LIST_HEAD(&cache->c_block_hash[n]);
 	cache->c_index_hash = kmalloc(bucket_count * sizeof(struct list_head),
 				      GFP_KERNEL);
 	if (!cache->c_index_hash)
 		goto fail;
-	for (n=0; n<bucket_count; n++)
+	for (n = 0; n < bucket_count; n++)
 		INIT_LIST_HEAD(&cache->c_index_hash[n]);
 	cache->c_entry_cache = kmem_cache_create(name,
 		sizeof(struct mb_cache_entry), 0,
@@ -254,7 +241,7 @@ fail:
 	kfree(cache);
 	return NULL;
 }
-
+EXPORT_SYMBOL(mb_cache_create);
 
 /*
  * mb_cache_shrink()
@@ -286,7 +273,7 @@ mb_cache_shrink(struct block_device *bdev)
 						   e_lru_list), GFP_KERNEL);
 	}
 }
-
+EXPORT_SYMBOL(mb_cache_shrink);
 
 /*
  * mb_cache_destroy()
@@ -329,6 +316,7 @@ mb_cache_destroy(struct mb_cache *cache)
 	kfree(cache->c_block_hash);
 	kfree(cache);
 }
+EXPORT_SYMBOL(mb_cache_destroy);
 
 /*
  * mb_cache_entry_alloc()
@@ -366,7 +354,7 @@ mb_cache_entry_alloc(struct mb_cache *cache, gfp_t gfp_flags)
 	ce->e_used = 1 + MB_CACHE_WRITER;
 	return ce;
 }
-
+EXPORT_SYMBOL(mb_cache_entry_alloc);
 
 /*
  * mb_cache_entry_insert()
@@ -391,7 +379,7 @@ mb_cache_entry_insert(struct mb_cache_entry *ce, struct block_device *bdev,
 	struct list_head *l;
 	int error = -EBUSY;
 
-	bucket = hash_long((unsigned long)bdev + (block & 0xffffffff), 
+	bucket = hash_long((unsigned long)bdev + (block & 0xffffffff),
 			   cache->c_bucket_bits);
 	spin_lock(&mb_cache_spinlock);
 	list_for_each_prev(l, &cache->c_block_hash[bucket]) {
@@ -412,7 +400,7 @@ out:
 	spin_unlock(&mb_cache_spinlock);
 	return error;
 }
-
+EXPORT_SYMBOL(mb_cache_entry_insert);
 
 /*
  * mb_cache_entry_release()
@@ -427,7 +415,7 @@ mb_cache_entry_release(struct mb_cache_entry *ce)
 	spin_lock(&mb_cache_spinlock);
 	__mb_cache_entry_release_unlock(ce);
 }
-
+EXPORT_SYMBOL(mb_cache_entry_release);
 
 /*
  * mb_cache_entry_free()
@@ -443,7 +431,7 @@ mb_cache_entry_free(struct mb_cache_entry *ce)
 	__mb_cache_entry_unhash(ce);
 	__mb_cache_entry_release_unlock(ce);
 }
-
+EXPORT_SYMBOL(mb_cache_entry_free);
 
 /*
  * mb_cache_entry_get()
@@ -497,6 +485,7 @@ cleanup:
 	spin_unlock(&mb_cache_spinlock);
 	return ce;
 }
+EXPORT_SYMBOL(mb_cache_entry_get);
 
 #if !defined(MB_CACHE_INDEXES_COUNT) || (MB_CACHE_INDEXES_COUNT > 0)
 
@@ -566,7 +555,7 @@ mb_cache_entry_find_first(struct mb_cache *cache, struct block_device *bdev,
 	spin_unlock(&mb_cache_spinlock);
 	return ce;
 }
-
+EXPORT_SYMBOL(mb_cache_entry_find_first);
 
 /*
  * mb_cache_entry_find_next()
@@ -578,7 +567,7 @@ mb_cache_entry_find_first(struct mb_cache *cache, struct block_device *bdev,
  *
  * entry = mb_cache_entry_find_first();
  * while (entry) {
- * 	...
+ *	...
  *	entry = mb_cache_entry_find_next(entry, ...);
  * }
  *
@@ -601,6 +590,7 @@ mb_cache_entry_find_next(struct mb_cache_entry *prev,
 	__mb_cache_entry_release_unlock(prev);
 	return ce;
 }
+EXPORT_SYMBOL(mb_cache_entry_find_next);
 
 #endif  /* !defined(MB_CACHE_INDEXES_COUNT) || (MB_CACHE_INDEXES_COUNT > 0) */
 
-- 
1.7.6.405.gc1be0

[PATCH 28/28] buffer: checkpatch wanking

[Joe Perches]

Just a few ignorable warnings remain.

$ ./scripts/checkpatch.pl -f --terse --nosummary fs/buffer.c | \
  cut -f3- -d":" | sort | uniq -c
      5  ERROR: "foo * bar" should be "foo *bar"
      1  ERROR: space required after that close brace '}'
      1  ERROR: space required after that ',' (ctx:VxO)
      3  ERROR: space required after that ',' (ctx:VxV)
      1  ERROR: space required before that '&' (ctx:OxV)
      3  ERROR: space required before the open parenthesis '('
      1  ERROR: spaces required around that '=' (ctx:OxV)
      3  ERROR: spaces required around that '=' (ctx:VxV)
     13  ERROR: trailing whitespace
      2  WARNING: braces {} are not necessary for any arm of this statement
      2  WARNING: braces {} are not necessary for single statement blocks
      4  WARNING: line over 80 characters
      1  WARNING: Prefer printk_ratelimited or pr_<level>_ratelimited to printk_ratelimit
      1  WARNING: space prohibited between function name and open parenthesis '('

Signed-off-by: Joe Perches <joe@perches.com>
---
 fs/buffer.c |   85 ++++++++++++++++++++++++++++++-----------------------------
 1 files changed, 43 insertions(+), 42 deletions(-)

diff --git a/fs/buffer.c b/fs/buffer.c
index 576a1ba..16a259c 100644
--- a/fs/buffer.c
+++ b/fs/buffer.c
@@ -83,9 +83,10 @@ EXPORT_SYMBOL(unlock_buffer);
  * from becoming locked again - you have to lock it yourself
  * if you want to preserve its state.
  */
-void __wait_on_buffer(struct buffer_head * bh)
+void __wait_on_buffer(struct buffer_head *bh)
 {
-	wait_on_bit(&bh->b_state, BH_Lock, sleep_on_buffer, TASK_UNINTERRUPTIBLE);
+	wait_on_bit(&bh->b_state, BH_Lock, sleep_on_buffer,
+		    TASK_UNINTERRUPTIBLE);
 }
 EXPORT_SYMBOL(__wait_on_buffer);
 
@@ -238,7 +239,7 @@ out:
    Thus invalidate_buffers in general usage is not allwowed to trash
    dirty buffers. For example ioctl(FLSBLKBUF) expects dirty data to
    be preserved.  These buffers are simply skipped.
-  
+
    We also skip buffers which are still in use.  For example this can
    happen if a userspace program is reading the block device.
 
@@ -474,7 +475,7 @@ EXPORT_SYMBOL(mark_buffer_async_write);
  * try_to_free_buffers() will be operating against the *blockdev* mapping
  * at the time, not against the S_ISREG file which depends on those buffers.
  * So the locking for private_list is via the private_lock in the address_space
- * which backs the buffers.  Which is different from the address_space 
+ * which backs the buffers.  Which is different from the address_space
  * against which the buffers are listed.  So for a particular address_space,
  * mapping->private_lock does *not* protect mapping->private_list!  In fact,
  * mapping->private_list will always be protected by the backing blockdev's
@@ -635,11 +636,11 @@ void mark_buffer_dirty_inode(struct buffer_head *bh, struct inode *inode)
 	struct address_space *buffer_mapping = bh->b_page->mapping;
 
 	mark_buffer_dirty(bh);
-	if (!mapping->assoc_mapping) {
+	if (!mapping->assoc_mapping)
 		mapping->assoc_mapping = buffer_mapping;
-	} else {
+	else
 		BUG_ON(mapping->assoc_mapping != buffer_mapping);
-	}
+
 	if (!bh->b_assoc_map) {
 		spin_lock(&buffer_mapping->private_lock);
 		list_move_tail(&bh->b_assoc_buffers,
@@ -734,7 +735,7 @@ EXPORT_SYMBOL(__set_page_dirty_buffers);
  * Do this in two main stages: first we copy dirty buffers to a
  * temporary inode list, queueing the writes as we go.  Then we clean
  * up, waiting for those writes to complete.
- * 
+ *
  * During this second stage, any subsequent updates to the file may end
  * up refiling the buffer on the original inode's dirty list again, so
  * there is a chance we will end up with a buffer queued for write but
@@ -812,7 +813,7 @@ static int fsync_buffers_list(spinlock_t *lock, struct list_head *list)
 		brelse(bh);
 		spin_lock(lock);
 	}
-	
+
 	spin_unlock(lock);
 	err2 = osync_buffers_list(lock, list);
 	if (err)
@@ -927,7 +928,7 @@ no_grow:
 	/*
 	 * Return failure for non-async IO requests.  Async IO requests
 	 * are not allowed to fail, so we have to wait until buffer heads
-	 * become available.  But we don't want tasks sleeping with 
+	 * become available.  But we don't want tasks sleeping with
 	 * partially complete buffers, so all were released above.
 	 */
 	if (!retry)
@@ -936,7 +937,7 @@ no_grow:
 	/* We're _really_ low on memory. Now we just
 	 * wait for old buffer heads to become free due to
 	 * finishing IO.  Since this is an async request and
-	 * the reserve list is empty, we're sure there are 
+	 * the reserve list is empty, we're sure there are
 	 * async buffer heads in use.
 	 */
 	free_more_memory();
@@ -960,7 +961,7 @@ link_dev_buffers(struct page *page, struct buffer_head *head)
 
 /*
  * Initialise the state of a blockdev page's buffers.
- */ 
+ */
 static void
 init_page_buffers(struct page *page, struct block_device *bdev,
 			sector_t block, int size)
@@ -1093,7 +1094,7 @@ __getblk_slow(struct block_device *bdev, sector_t block, int size)
 	}
 
 	for (;;) {
-		struct buffer_head * bh;
+		struct buffer_head *bh;
 		int ret;
 
 		bh = __find_get_block(bdev, block, size);
@@ -1177,7 +1178,7 @@ EXPORT_SYMBOL(mark_buffer_dirty);
  * in preparation for freeing it (sometimes, rarely, buffers are removed from
  * a page but it ends up not being freed, and buffers may later be reattached).
  */
-void __brelse(struct buffer_head * buf)
+void __brelse(struct buffer_head *buf)
 {
 	if (atomic_read(&buf->b_count)) {
 		put_bh(buf);
@@ -1398,7 +1399,7 @@ EXPORT_SYMBOL(__breadahead);
  *  @bdev: the block_device to read from
  *  @block: number of block
  *  @size: size (in bytes) to read
- * 
+ *
  *  Reads a specified block, and returns buffer head that contains it.
  *  It returns NULL if the block was unreadable.
  */
@@ -1429,7 +1430,7 @@ static void invalidate_bh_lru(void *arg)
 	}
 	put_cpu_var(bh_lrus);
 }
-	
+
 void invalidate_bh_lrus(void)
 {
 	on_each_cpu(invalidate_bh_lru, NULL, 1);
@@ -1454,7 +1455,7 @@ EXPORT_SYMBOL(set_bh_page);
 /*
  * Called when truncating a buffer on a page completely.
  */
-static void discard_buffer(struct buffer_head * bh)
+static void discard_buffer(struct buffer_head *bh)
 {
 	lock_buffer(bh);
 	clear_buffer_dirty(bh);
@@ -1700,11 +1701,10 @@ static int __block_write_full_page(struct inode *inode, struct page *page,
 			redirty_page_for_writepage(wbc, page);
 			continue;
 		}
-		if (test_clear_buffer_dirty(bh)) {
+		if (test_clear_buffer_dirty(bh))
 			mark_buffer_async_write_endio(bh, handler);
-		} else {
+		else
 			unlock_buffer(bh);
-		}
 	} while ((bh = bh->b_this_page) != head);
 
 	/*
@@ -1832,7 +1832,7 @@ int __block_write_begin(struct page *page, loff_t pos, unsigned len,
 	sector_t block;
 	int err = 0;
 	unsigned blocksize, bbits;
-	struct buffer_head *bh, *head, *wait[2], **wait_bh=wait;
+	struct buffer_head *bh, *head, *wait[2], **wait_bh = wait;
 
 	BUG_ON(!PageLocked(page));
 	BUG_ON(from > PAGE_CACHE_SIZE);
@@ -1847,8 +1847,8 @@ int __block_write_begin(struct page *page, loff_t pos, unsigned len,
 	bbits = inode->i_blkbits;
 	block = (sector_t)page->index << (PAGE_CACHE_SHIFT - bbits);
 
-	for(bh = head, block_start = 0; bh != head || !block_start;
-	    block++, block_start=block_end, bh = bh->b_this_page) {
+	for (bh = head, block_start = 0; bh != head || !block_start;
+	     block++, block_start = block_end, bh = bh->b_this_page) {
 		block_end = block_start + blocksize;
 		if (block_end <= from || block_start >= to) {
 			if (PageUptodate(page)) {
@@ -1883,19 +1883,19 @@ int __block_write_begin(struct page *page, loff_t pos, unsigned len,
 		if (PageUptodate(page)) {
 			if (!buffer_uptodate(bh))
 				set_buffer_uptodate(bh);
-			continue; 
+			continue;
 		}
 		if (!buffer_uptodate(bh) && !buffer_delay(bh) &&
 		    !buffer_unwritten(bh) &&
 		     (block_start < from || block_end > to)) {
 			ll_rw_block(READ, 1, &bh);
-			*wait_bh++=bh;
+			*wait_bh++ = bh;
 		}
 	}
 	/*
 	 * If we issued read requests - let them complete.
 	 */
-	while(wait_bh > wait) {
+	while (wait_bh > wait) {
 		wait_on_buffer(*--wait_bh);
 		if (!buffer_uptodate(*wait_bh))
 			err = -EIO;
@@ -1916,9 +1916,9 @@ static int __block_commit_write(struct inode *inode, struct page *page,
 
 	blocksize = 1 << inode->i_blkbits;
 
-	for(bh = head = page_buffers(page), block_start = 0;
-	    bh != head || !block_start;
-	    block_start=block_end, bh = bh->b_this_page) {
+	for (bh = head = page_buffers(page), block_start = 0;
+	     bh != head || !block_start;
+	     block_start = block_end, bh = bh->b_this_page) {
 		block_end = block_start + blocksize;
 		if (block_end <= from || block_start >= to) {
 			if (!buffer_uptodate(bh))
@@ -2186,7 +2186,7 @@ EXPORT_SYMBOL(block_read_full_page);
 
 /* utility function for filesystems that need to do work on expanding
  * truncates.  Uses filesystem pagecache writes to allow the filesystem to
- * deal with the hole.  
+ * deal with the hole.
  */
 int generic_cont_expand_simple(struct inode *inode, loff_t size)
 {
@@ -2256,9 +2256,9 @@ static int cont_expand_zero(struct file *file, struct address_space *mapping,
 	if (index == curidx) {
 		zerofrom = curpos & ~PAGE_CACHE_MASK;
 		/* if we will expand the thing last block will be filled */
-		if (offset <= zerofrom) {
+		if (offset <= zerofrom)
 			goto out;
-		}
+
 		if (zerofrom & (blocksize-1)) {
 			*bytes |= (blocksize-1);
 			(*bytes)++;
@@ -2313,7 +2313,7 @@ EXPORT_SYMBOL(cont_write_begin);
 int block_commit_write(struct page *page, unsigned from, unsigned to)
 {
 	struct inode *inode = page->mapping->host;
-	__block_commit_write(inode,page,from,to);
+	__block_commit_write(inode, page, from, to);
 	return 0;
 }
 EXPORT_SYMBOL(block_commit_write);
@@ -2503,8 +2503,8 @@ int nobh_write_begin(struct address_space *mapping,
 	 * page is fully mapped-to-disk.
 	 */
 	for (block_start = 0, block_in_page = 0, bh = head;
-		  block_start < PAGE_CACHE_SIZE;
-		  block_in_page++, block_start += blocksize, bh = bh->b_this_page) {
+	     block_start < PAGE_CACHE_SIZE;
+	     block_in_page++, block_start += blocksize, bh = bh->b_this_page) {
 		int create;
 
 		block_end = block_start + blocksize;
@@ -2769,7 +2769,7 @@ int block_truncate_page(struct address_space *mapping,
 
 	length = blocksize - length;
 	iblock = (sector_t)index << (PAGE_CACHE_SHIFT - inode->i_blkbits);
-	
+
 	page = grab_cache_page(mapping, index);
 	err = -ENOMEM;
 	if (!page)
@@ -2802,7 +2802,9 @@ int block_truncate_page(struct address_space *mapping,
 	if (PageUptodate(page))
 		set_buffer_uptodate(bh);
 
-	if (!buffer_uptodate(bh) && !buffer_delay(bh) && !buffer_unwritten(bh)) {
+	if (!buffer_uptodate(bh) &&
+	    !buffer_delay(bh) &&
+	    !buffer_unwritten(bh)) {
 		err = -EIO;
 		ll_rw_block(READ, 1, &bh);
 		wait_on_buffer(bh);
@@ -2893,18 +2895,17 @@ static void end_bio_bh_io_sync(struct bio *bio, int err)
 {
 	struct buffer_head *bh = bio->bi_private;
 
-	if (err == -EOPNOTSUPP) {
+	if (err == -EOPNOTSUPP)
 		set_bit(BIO_EOPNOTSUPP, &bio->bi_flags);
-	}
 
-	if (unlikely (test_bit(BIO_QUIET,&bio->bi_flags)))
+	if (unlikely(test_bit(BIO_QUIET, &bio->bi_flags)))
 		set_bit(BH_Quiet, &bh->b_state);
 
 	bh->b_end_io(bh, test_bit(BIO_UPTODATE, &bio->bi_flags));
 	bio_put(bio);
 }
 
-int submit_bh(int rw, struct buffer_head * bh)
+int submit_bh(int rw, struct buffer_head *bh)
 {
 	struct bio *bio;
 	int ret = 0;
@@ -2971,7 +2972,7 @@ EXPORT_SYMBOL(submit_bh);
  *
  * ll_rw_block sets b_end_io to simple completion handler that marks
  * the buffer up-to-date (if approriate), unlocks the buffer and wakes
- * any waiters. 
+ * any waiters.
  *
  * All of the buffers must be for the same device, and must also be a
  * multiple of the current approved size for the device.
-- 
1.7.6.405.gc1be0