fs: Logging style neatening and checkpatch wanking...

index 929d620..576a1ba 100644
@@ -18,6 +18,8 @@
  * async buffer flushing, 1999 Andrea Arcangeli <[email protected]>
  */
 
+#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)

index 8c32ef3..a3c533c 100644
@@ -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);

index b1fe82c..98acfb1 100644
@@ -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;

index f6d411e..ad1532f 100644
@@ -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)

index b83d1c1..23ff118 100644
@@ -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;

index 3625464..0839da4 100644
@@ -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 {

index 874dc5c..f9a164d 100644
@@ -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();
 }

index 3154fbe..20aa631 100644
@@ -5,6 +5,8 @@
  *  Copyright (C) 2001  Andrea Arcangeli <[email protected]> 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);
 	}

index 3abfec7..6055631 100644
@@ -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));

index 22764c7..5d16b1d 100644
@@ -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);

index 4c6992d..a88b110 100644
@@ -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

index 3b0d05d..10f2bdb 100644
@@ -114,6 +114,8 @@
  *  Stephen Rothwell <[email protected]>, 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;
 	}
 

index 22c41b5..58c8d94 100644
@@ -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;
 	}
 

index 8806b89..ff9be35 100644
@@ -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... */

index 0839da4..1365d02 100644
@@ -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);
 

index f9a164d..30bc685 100644
@@ -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)

index 20aa631..8b9bbf6 100644
@@ -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);
 
 /**

index 6055631..1d62cf7 100644
@@ -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;

index 5d16b1d..cc887fd 100644
@@ -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);
 
 /*

index a88b110..7128878 100644
@@ -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);

index 10f2bdb..268da7c 100644
@@ -11,11 +11,11 @@
  *
  *  Miscellaneous edits, and a total rewrite of posix_lock_file() code.
  *  Kai Petzke ([email protected]), 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 ([email protected]), 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 ([email protected]), 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 ([email protected]), February 09, 1996.
  *
  *  Addressed Dmitry's concerns. Deadlock checking no longer recursive.

@@ -101,7 +101,8 @@
  *  Some adaptations for NFS support.
  *  Olaf Kirch ([email protected]), 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 ([email protected]), 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)

index 58c8d94..bb3e0e5 100644
@@ -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);

index ff9be35..829d9e9 100644
@@ -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);

index 23ff118..b550808 100644
@@ -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
 

index ad1532f..c224d14 100644
@@ -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;