Merge branch 'akpm' (patches from Andrew)

Merge yet more updates from Andrew Morton:

 - Oleg's "wait/ptrace: assume __WALL if the child is traced".  It's a
   kernel-based workaround for existing userspace issues.

 - A few hotfixes

 - befs cleanups

 - nilfs2 updates

 - sys_wait() changes

 - kexec updates

 - kdump

 - scripts/gdb updates

 - the last of the MM queue

 - a few other misc things

* emailed patches from Andrew Morton <akpm@linux-foundation.org>: (84 commits)
  kgdb: depends on VT
  drm/amdgpu: make amdgpu_mn_get wait for mmap_sem killable
  drm/radeon: make radeon_mn_get wait for mmap_sem killable
  drm/i915: make i915_gem_mmap_ioctl wait for mmap_sem killable
  uprobes: wait for mmap_sem for write killable
  prctl: make PR_SET_THP_DISABLE wait for mmap_sem killable
  exec: make exec path waiting for mmap_sem killable
  aio: make aio_setup_ring killable
  coredump: make coredump_wait wait for mmap_sem for write killable
  vdso: make arch_setup_additional_pages wait for mmap_sem for write killable
  ipc, shm: make shmem attach/detach wait for mmap_sem killable
  mm, fork: make dup_mmap wait for mmap_sem for write killable
  mm, proc: make clear_refs killable
  mm: make vm_brk killable
  mm, elf: handle vm_brk error
  mm, aout: handle vm_brk failures
  mm: make vm_munmap killable
  mm: make vm_mmap killable
  mm: make mmap_sem for write waits killable for mm syscalls
  MAINTAINERS: add co-maintainer for scripts/gdb
  ...

129 files changed, 1355 insertions, 786 deletions

diff --git a/Documentation/filesystems/nilfs2.txt b/Documentation/filesystems/nilfs2.txt
index 41c3d332acc9..5b21ef76f751 100644
--- a/Documentation/filesystems/nilfs2.txt
+++ b/Documentation/filesystems/nilfs2.txt
@@ -268,3 +268,8 @@ among NILFS2 files can be depicted as follows:
                                     ( regular file, directory, or symlink )
 
 For detail on the format of each file, please see include/linux/nilfs2_fs.h.
+
+There are no patents or other intellectual property that we protect
+with regard to the design of NILFS2.  It is allowed to replicate the
+design in hopes that other operating systems could share (mount, read,
+write, etc.) data stored in this format.
diff --git a/Documentation/gdb-kernel-debugging.txt b/Documentation/gdb-kernel-debugging.txt
index 7050ce8794b9..4ab7d43d0754 100644
--- a/Documentation/gdb-kernel-debugging.txt
+++ b/Documentation/gdb-kernel-debugging.txt
@@ -139,6 +139,27 @@ Examples of using the Linux-provided gdb helpers
       start_comm = "swapper/2\000\000\000\000\000\000"
     }
 
+ o Dig into a radix tree data structure, such as the IRQ descriptors:
+    (gdb) print (struct irq_desc)$lx_radix_tree_lookup(irq_desc_tree, 18)
+    $6 = {
+      irq_common_data = {
+        state_use_accessors = 67584,
+        handler_data = 0x0 <__vectors_start>,
+        msi_desc = 0x0 <__vectors_start>,
+        affinity = {{
+            bits = {65535}
+          }}
+      },
+      irq_data = {
+        mask = 0,
+        irq = 18,
+        hwirq = 27,
+        common = 0xee803d80,
+        chip = 0xc0eb0854 <gic_data>,
+        domain = 0xee808000,
+        parent_data = 0x0 <__vectors_start>,
+        chip_data = 0xc0eb0854 <gic_data>
+      } <... trimmed ...>
 
 List of commands and functions
 ------------------------------
diff --git a/Documentation/kdump/gdbmacros.txt b/Documentation/kdump/gdbmacros.txt
index 9b9b454b048a..35f6a982a0d5 100644
--- a/Documentation/kdump/gdbmacros.txt
+++ b/Documentation/kdump/gdbmacros.txt
@@ -15,15 +15,16 @@
 
 define bttnobp
         set $tasks_off=((size_t)&((struct task_struct *)0)->tasks)
-        set $pid_off=((size_t)&((struct task_struct *)0)->pids[1].pid_list.next)
+        set $pid_off=((size_t)&((struct task_struct *)0)->thread_group.next)
         set $init_t=&init_task
         set $next_t=(((char *)($init_t->tasks).next) - $tasks_off)
+        set var $stacksize = sizeof(union thread_union)
         while ($next_t != $init_t)
                 set $next_t=(struct task_struct *)$next_t
                 printf "\npid %d; comm %s:\n", $next_t.pid, $next_t.comm
                 printf "===================\n"
-                set var $stackp = $next_t.thread.esp
-                set var $stack_top = ($stackp & ~4095) + 4096
+                set var $stackp = $next_t.thread.sp
+                set var $stack_top = ($stackp & ~($stacksize - 1)) + $stacksize
 
                 while ($stackp < $stack_top)
                         if (*($stackp) > _stext && *($stackp) < _sinittext)
@@ -31,13 +32,13 @@ define bttnobp
                         end
                         set $stackp += 4
                 end
-                set $next_th=(((char *)$next_t->pids[1].pid_list.next) - $pid_off)
+                set $next_th=(((char *)$next_t->thread_group.next) - $pid_off)
                 while ($next_th != $next_t)
                         set $next_th=(struct task_struct *)$next_th
                         printf "\npid %d; comm %s:\n", $next_t.pid, $next_t.comm
                         printf "===================\n"
-                        set var $stackp = $next_t.thread.esp
-                        set var $stack_top = ($stackp & ~4095) + 4096
+                        set var $stackp = $next_t.thread.sp
+                        set var $stack_top = ($stackp & ~($stacksize - 1)) + stacksize
 
                         while ($stackp < $stack_top)
                                 if (*($stackp) > _stext && *($stackp) < _sinittext)
@@ -45,7 +46,7 @@ define bttnobp
                                 end
                                 set $stackp += 4
                         end
-                        set $next_th=(((char *)$next_th->pids[1].pid_list.next) - $pid_off)
+                        set $next_th=(((char *)$next_th->thread_group.next) - $pid_off)
                 end
                 set $next_t=(char *)($next_t->tasks.next) - $tasks_off
         end
@@ -54,42 +55,44 @@ document bttnobp
         dump all thread stack traces on a kernel compiled with !CONFIG_FRAME_POINTER
 end
 
+define btthreadstack
+        set var $pid_task = $arg0
+
+        printf "\npid %d; comm %s:\n", $pid_task.pid, $pid_task.comm
+        printf "task struct: "
+        print $pid_task
+        printf "===================\n"
+        set var $stackp = $pid_task.thread.sp
+        set var $stacksize = sizeof(union thread_union)
+        set var $stack_top = ($stackp & ~($stacksize - 1)) + $stacksize
+        set var $stack_bot = ($stackp & ~($stacksize - 1))
+
+        set $stackp = *((unsigned long *) $stackp)
+        while (($stackp < $stack_top) && ($stackp > $stack_bot))
+                set var $addr = *(((unsigned long *) $stackp) + 1)
+                info symbol $addr
+                set $stackp = *((unsigned long *) $stackp)
+        end
+end
+document btthreadstack
+         dump a thread stack using the given task structure pointer
+end
+
+
 define btt
         set $tasks_off=((size_t)&((struct task_struct *)0)->tasks)
-        set $pid_off=((size_t)&((struct task_struct *)0)->pids[1].pid_list.next)
+        set $pid_off=((size_t)&((struct task_struct *)0)->thread_group.next)
         set $init_t=&init_task
         set $next_t=(((char *)($init_t->tasks).next) - $tasks_off)
         while ($next_t != $init_t)
                 set $next_t=(struct task_struct *)$next_t
-                printf "\npid %d; comm %s:\n", $next_t.pid, $next_t.comm
-                printf "===================\n"
-                set var $stackp = $next_t.thread.esp
-                set var $stack_top = ($stackp & ~4095) + 4096
-                set var $stack_bot = ($stackp & ~4095)
-
-                set $stackp = *($stackp)
-                while (($stackp < $stack_top) && ($stackp > $stack_bot))
-                        set var $addr = *($stackp + 4)
-                        info symbol $addr
-                        set $stackp = *($stackp)
-                end
+                btthreadstack $next_t
 
-                set $next_th=(((char *)$next_t->pids[1].pid_list.next) - $pid_off)
+                set $next_th=(((char *)$next_t->thread_group.next) - $pid_off)
                 while ($next_th != $next_t)
                         set $next_th=(struct task_struct *)$next_th
-                        printf "\npid %d; comm %s:\n", $next_t.pid, $next_t.comm
-                        printf "===================\n"
-                        set var $stackp = $next_t.thread.esp
-                        set var $stack_top = ($stackp & ~4095) + 4096
-                        set var $stack_bot = ($stackp & ~4095)
-
-                        set $stackp = *($stackp)
-                        while (($stackp < $stack_top) && ($stackp > $stack_bot))
-                                set var $addr = *($stackp + 4)
-                                info symbol $addr
-                                set $stackp = *($stackp)
-                        end
-                        set $next_th=(((char *)$next_th->pids[1].pid_list.next) - $pid_off)
+                        btthreadstack $next_th
+                        set $next_th=(((char *)$next_th->thread_group.next) - $pid_off)
                 end
                 set $next_t=(char *)($next_t->tasks.next) - $tasks_off
         end
@@ -101,7 +104,7 @@ end
 define btpid
         set var $pid = $arg0
         set $tasks_off=((size_t)&((struct task_struct *)0)->tasks)
-        set $pid_off=((size_t)&((struct task_struct *)0)->pids[1].pid_list.next)
+        set $pid_off=((size_t)&((struct task_struct *)0)->thread_group.next)
         set $init_t=&init_task
         set $next_t=(((char *)($init_t->tasks).next) - $tasks_off)
         set var $pid_task = 0
@@ -113,29 +116,18 @@ define btpid
                         set $pid_task = $next_t
                 end
 
-                set $next_th=(((char *)$next_t->pids[1].pid_list.next) - $pid_off)
+                set $next_th=(((char *)$next_t->thread_group.next) - $pid_off)
                 while ($next_th != $next_t)
                         set $next_th=(struct task_struct *)$next_th
                         if ($next_th.pid == $pid)
                                 set $pid_task = $next_th
                         end
-                        set $next_th=(((char *)$next_th->pids[1].pid_list.next) - $pid_off)
+                        set $next_th=(((char *)$next_th->thread_group.next) - $pid_off)
                 end
                 set $next_t=(char *)($next_t->tasks.next) - $tasks_off
         end
 
-        printf "\npid %d; comm %s:\n", $pid_task.pid, $pid_task.comm
-        printf "===================\n"
-        set var $stackp = $pid_task.thread.esp
-        set var $stack_top = ($stackp & ~4095) + 4096
-        set var $stack_bot = ($stackp & ~4095)
-
-        set $stackp = *($stackp)
-        while (($stackp < $stack_top) && ($stackp > $stack_bot))
-                set var $addr = *($stackp + 4)
-                info symbol $addr
-                set $stackp = *($stackp)
-        end
+        btthreadstack $pid_task
 end
 document btpid
         backtrace of pid
@@ -145,7 +137,7 @@ end
 define trapinfo
         set var $pid = $arg0
         set $tasks_off=((size_t)&((struct task_struct *)0)->tasks)
-        set $pid_off=((size_t)&((struct task_struct *)0)->pids[1].pid_list.next)
+        set $pid_off=((size_t)&((struct task_struct *)0)->thread_group.next)
         set $init_t=&init_task
         set $next_t=(((char *)($init_t->tasks).next) - $tasks_off)
         set var $pid_task = 0
@@ -157,13 +149,13 @@ define trapinfo
                         set $pid_task = $next_t
                 end
 
-                set $next_th=(((char *)$next_t->pids[1].pid_list.next) - $pid_off)
+                set $next_th=(((char *)$next_t->thread_group.next) - $pid_off)
                 while ($next_th != $next_t)
                         set $next_th=(struct task_struct *)$next_th
                         if ($next_th.pid == $pid)
                                 set $pid_task = $next_th
                         end
-                        set $next_th=(((char *)$next_th->pids[1].pid_list.next) - $pid_off)
+                        set $next_th=(((char *)$next_th->thread_group.next) - $pid_off)
                 end
                 set $next_t=(char *)($next_t->tasks.next) - $tasks_off
         end
diff --git a/Kbuild b/Kbuild
index f55cefd9bf29..3d0ae152af7c 100644
--- a/Kbuild
+++ b/Kbuild
@@ -5,6 +5,7 @@
 # 2) Generate timeconst.h
 # 3) Generate asm-offsets.h (may need bounds.h and timeconst.h)
 # 4) Check for missing system calls
+# 5) Generate constants.py (may need bounds.h)
 
 # Default sed regexp - multiline due to syntax constraints
 define sed-y
@@ -96,5 +97,14 @@ quiet_cmd_syscalls = CALL    $<
 missing-syscalls: scripts/checksyscalls.sh $(offsets-file) FORCE
         $(call cmd,syscalls)
 
+#####
+# 5) Generate constants for Python GDB integration
+#
+
+extra-$(CONFIG_GDB_SCRIPTS) += build_constants_py
+
+build_constants_py: $(obj)/$(timeconst-file) $(obj)/$(bounds-file)
+        @$(MAKE) $(build)=scripts/gdb/linux $@
+
 # Keep these three files during make clean
 no-clean-files := $(bounds-file) $(offsets-file) $(timeconst-file)
diff --git a/MAINTAINERS b/MAINTAINERS
index f27ff1b32757..330200688228 100644
--- a/MAINTAINERS
+++ b/MAINTAINERS
@@ -4993,6 +4993,7 @@ F:	drivers/scsi/gdt*
 
 GDB KERNEL DEBUGGING HELPER SCRIPTS
 M:      Jan Kiszka <jan.kiszka@siemens.com>
+M:      Kieran Bingham <kieran@bingham.xyz>
 S:      Supported
 F:      scripts/gdb/
 
@@ -8038,6 +8039,7 @@ NILFS2 FILESYSTEM
 M:      Ryusuke Konishi <konishi.ryusuke@lab.ntt.co.jp>
 L:      linux-nilfs@vger.kernel.org
 W:      http://nilfs.sourceforge.net/
+W:      http://nilfs.osdn.jp/
 T:      git git://github.com/konis/nilfs2.git
 S:      Supported
 F:      Documentation/filesystems/nilfs2.txt
diff --git a/arch/arm/configs/bcm_defconfig b/arch/arm/configs/bcm_defconfig
index 7117662bab2e..909049a280ec 100644
--- a/arch/arm/configs/bcm_defconfig
+++ b/arch/arm/configs/bcm_defconfig
@@ -12,7 +12,6 @@ CONFIG_CGROUPS=y
 CONFIG_CGROUP_FREEZER=y
 CONFIG_CGROUP_DEVICE=y
 CONFIG_CGROUP_CPUACCT=y
-CONFIG_RESOURCE_COUNTERS=y
 CONFIG_CGROUP_SCHED=y
 CONFIG_BLK_CGROUP=y
 CONFIG_NAMESPACES=y
diff --git a/arch/arm/configs/zx_defconfig b/arch/arm/configs/zx_defconfig
index ab683fbbb954..d6253a48a9fa 100644
--- a/arch/arm/configs/zx_defconfig
+++ b/arch/arm/configs/zx_defconfig
@@ -7,7 +7,6 @@ CONFIG_CGROUPS=y
 CONFIG_CGROUP_DEBUG=y
 CONFIG_CGROUP_FREEZER=y
 CONFIG_CGROUP_CPUACCT=y
-CONFIG_RESOURCE_COUNTERS=y
 CONFIG_CGROUP_SCHED=y
 CONFIG_RT_GROUP_SCHED=y
 CONFIG_NAMESPACES=y
diff --git a/arch/arm/kernel/process.c b/arch/arm/kernel/process.c
index a647d6642f3e..4a803c5a1ff7 100644
--- a/arch/arm/kernel/process.c
+++ b/arch/arm/kernel/process.c
@@ -420,7 +420,8 @@ int arch_setup_additional_pages(struct linux_binprm *bprm, int uses_interp)
         npages = 1; /* for sigpage */
         npages += vdso_total_pages;
 
-        down_write(&mm->mmap_sem);
+        if (down_write_killable(&mm->mmap_sem))
+                return -EINTR;
         hint = sigpage_addr(mm, npages);
         addr = get_unmapped_area(NULL, hint, npages << PAGE_SHIFT, 0, 0);
         if (IS_ERR_VALUE(addr)) {
diff --git a/arch/arm64/kernel/vdso.c b/arch/arm64/kernel/vdso.c
index 64fc030be0f2..9fefb005812a 100644
--- a/arch/arm64/kernel/vdso.c
+++ b/arch/arm64/kernel/vdso.c
@@ -95,7 +95,8 @@ int aarch32_setup_vectors_page(struct linux_binprm *bprm, int uses_interp)
         };
         void *ret;
 
-        down_write(&mm->mmap_sem);
+        if (down_write_killable(&mm->mmap_sem))
+                return -EINTR;
         current->mm->context.vdso = (void *)addr;
 
         /* Map vectors page at the high address. */
@@ -163,7 +164,8 @@ int arch_setup_additional_pages(struct linux_binprm *bprm,
         /* Be sure to map the data page */
         vdso_mapping_len = vdso_text_len + PAGE_SIZE;
 
-        down_write(&mm->mmap_sem);
+        if (down_write_killable(&mm->mmap_sem))
+                return -EINTR;
         vdso_base = get_unmapped_area(NULL, 0, vdso_mapping_len, 0, 0);
         if (IS_ERR_VALUE(vdso_base)) {
                 ret = ERR_PTR(vdso_base);
diff --git a/arch/hexagon/kernel/vdso.c b/arch/hexagon/kernel/vdso.c
index 0bf5a87e4d0a..3ea968415539 100644
--- a/arch/hexagon/kernel/vdso.c
+++ b/arch/hexagon/kernel/vdso.c
@@ -65,7 +65,8 @@ int arch_setup_additional_pages(struct linux_binprm *bprm, int uses_interp)
         unsigned long vdso_base;
         struct mm_struct *mm = current->mm;
 
-        down_write(&mm->mmap_sem);
+        if (down_write_killable(&mm->mmap_sem))
+                return -EINTR;
 
         /* Try to get it loaded right near ld.so/glibc. */
         vdso_base = STACK_TOP;
diff --git a/arch/m32r/kernel/smp.c b/arch/m32r/kernel/smp.c
index 62d6961e7f2b..564052e3d3a0 100644
--- a/arch/m32r/kernel/smp.c
+++ b/arch/m32r/kernel/smp.c
@@ -164,6 +164,7 @@ void smp_flush_cache_all(void)
         spin_unlock(&flushcache_lock);
         preempt_enable();
 }
+EXPORT_SYMBOL(smp_flush_cache_all);
 
 void smp_flush_cache_all_interrupt(void)
 {
diff --git a/arch/mips/Kconfig b/arch/mips/Kconfig
index 8040fb1845b4..46938847e794 100644
--- a/arch/mips/Kconfig
+++ b/arch/mips/Kconfig
@@ -3117,6 +3117,7 @@ config MIPS32_N32
 config BINFMT_ELF32
         bool
         default y if MIPS32_O32 || MIPS32_N32
+        select ELFCORE
 
 endmenu
 
diff --git a/arch/mips/configs/db1xxx_defconfig b/arch/mips/configs/db1xxx_defconfig
index 3bdb72a70364..f0c8971030c4 100644
--- a/arch/mips/configs/db1xxx_defconfig
+++ b/arch/mips/configs/db1xxx_defconfig
@@ -18,7 +18,6 @@ CONFIG_CGROUP_FREEZER=y
 CONFIG_CGROUP_DEVICE=y
 CONFIG_CPUSETS=y
 CONFIG_CGROUP_CPUACCT=y
-CONFIG_RESOURCE_COUNTERS=y
 CONFIG_MEMCG=y
 CONFIG_MEMCG_SWAP=y
 CONFIG_MEMCG_KMEM=y
diff --git a/arch/mips/configs/loongson3_defconfig b/arch/mips/configs/loongson3_defconfig
index f8bf915c6d6b..7f95c4b3ab2c 100644
--- a/arch/mips/configs/loongson3_defconfig
+++ b/arch/mips/configs/loongson3_defconfig
@@ -25,7 +25,6 @@ CONFIG_TASK_XACCT=y
 CONFIG_TASK_IO_ACCOUNTING=y
 CONFIG_LOG_BUF_SHIFT=14
 CONFIG_CPUSETS=y
-CONFIG_RESOURCE_COUNTERS=y
 CONFIG_MEMCG=y
 CONFIG_MEMCG_SWAP=y
 CONFIG_BLK_CGROUP=y
diff --git a/arch/mips/kernel/vdso.c b/arch/mips/kernel/vdso.c
index 975e99759bab..54e1663ce639 100644
--- a/arch/mips/kernel/vdso.c
+++ b/arch/mips/kernel/vdso.c
@@ -104,7 +104,8 @@ int arch_setup_additional_pages(struct linux_binprm *bprm, int uses_interp)
         struct resource gic_res;
         int ret;
 
-        down_write(&mm->mmap_sem);
+        if (down_write_killable(&mm->mmap_sem))
+                return -EINTR;
 
         /*
          * Determine total area size. This includes the VDSO data itself, the
diff --git a/arch/mn10300/configs/asb2364_defconfig b/arch/mn10300/configs/asb2364_defconfig
index fbb96ae3122a..cd0a6cb17dee 100644
--- a/arch/mn10300/configs/asb2364_defconfig
+++ b/arch/mn10300/configs/asb2364_defconfig
@@ -11,7 +11,6 @@ CONFIG_CGROUPS=y
 CONFIG_CGROUP_FREEZER=y
 CONFIG_CGROUP_DEVICE=y
 CONFIG_CGROUP_CPUACCT=y
-CONFIG_RESOURCE_COUNTERS=y
 CONFIG_RELAY=y
 # CONFIG_CC_OPTIMIZE_FOR_SIZE is not set
 CONFIG_EXPERT=y
diff --git a/arch/powerpc/kernel/vdso.c b/arch/powerpc/kernel/vdso.c
index def1b8b5e6c1..6767605ea8da 100644
--- a/arch/powerpc/kernel/vdso.c
+++ b/arch/powerpc/kernel/vdso.c
@@ -195,7 +195,8 @@ int arch_setup_additional_pages(struct linux_binprm *bprm, int uses_interp)
          * and end up putting it elsewhere.
          * Add enough to the size so that the result can be aligned.
          */
-        down_write(&mm->mmap_sem);
+        if (down_write_killable(&mm->mmap_sem))
+                return -EINTR;
         vdso_base = get_unmapped_area(NULL, vdso_base,
                                       (vdso_pages << PAGE_SHIFT) +
                                       ((VDSO_ALIGNMENT - 1) & PAGE_MASK),
diff --git a/arch/s390/kernel/machine_kexec.c b/arch/s390/kernel/machine_kexec.c
index 2f1b7217c25c..0e64f08d3d69 100644
--- a/arch/s390/kernel/machine_kexec.c
+++ b/arch/s390/kernel/machine_kexec.c
@@ -43,13 +43,13 @@ static int machine_kdump_pm_cb(struct notifier_block *nb, unsigned long action,
         switch (action) {
         case PM_SUSPEND_PREPARE:
         case PM_HIBERNATION_PREPARE:
-                if (crashk_res.start)
-                        crash_map_reserved_pages();
+                if (kexec_crash_image)
+                        arch_kexec_unprotect_crashkres();
                 break;
         case PM_POST_SUSPEND:
         case PM_POST_HIBERNATION:
-                if (crashk_res.start)
-                        crash_unmap_reserved_pages();
+                if (kexec_crash_image)
+                        arch_kexec_protect_crashkres();
                 break;
         default:
                 return NOTIFY_DONE;
@@ -60,6 +60,8 @@ static int machine_kdump_pm_cb(struct notifier_block *nb, unsigned long action,
 static int __init machine_kdump_pm_init(void)
 {
         pm_notifier(machine_kdump_pm_cb, 0);
+        /* Create initial mapping for crashkernel memory */
+        arch_kexec_unprotect_crashkres();
         return 0;
 }
 arch_initcall(machine_kdump_pm_init);
@@ -146,6 +148,8 @@ static int kdump_csum_valid(struct kimage *image)
 #endif
 }
 
+#ifdef CONFIG_CRASH_DUMP
+
 /*
  * Map or unmap crashkernel memory
  */
@@ -167,21 +171,25 @@ static void crash_map_pages(int enable)
 }
 
 /*
- * Map crashkernel memory
+ * Unmap crashkernel memory
  */
-void crash_map_reserved_pages(void)
+void arch_kexec_protect_crashkres(void)
 {
-        crash_map_pages(1);
+        if (crashk_res.end)
+                crash_map_pages(0);
 }
 
 /*
- * Unmap crashkernel memory
+ * Map crashkernel memory
  */
-void crash_unmap_reserved_pages(void)
+void arch_kexec_unprotect_crashkres(void)
 {
-        crash_map_pages(0);
+        if (crashk_res.end)
+                crash_map_pages(1);
 }
 
+#endif
+
 /*
  * Give back memory to hypervisor before new kdump is loaded
  */
diff --git a/arch/s390/kernel/vdso.c b/arch/s390/kernel/vdso.c
index 94495cac8be3..5904abf6b1ae 100644
--- a/arch/s390/kernel/vdso.c
+++ b/arch/s390/kernel/vdso.c
@@ -216,7 +216,8 @@ int arch_setup_additional_pages(struct linux_binprm *bprm, int uses_interp)
          * it at vdso_base which is the "natural" base for it, but we might
          * fail and end up putting it elsewhere.
          */
-        down_write(&mm->mmap_sem);
+        if (down_write_killable(&mm->mmap_sem))
+                return -EINTR;
         vdso_base = get_unmapped_area(NULL, 0, vdso_pages << PAGE_SHIFT, 0, 0);
         if (IS_ERR_VALUE(vdso_base)) {
                 rc = vdso_base;
diff --git a/arch/sh/configs/apsh4ad0a_defconfig b/arch/sh/configs/apsh4ad0a_defconfig
index a8d975793b6d..fe45d2c9b151 100644
--- a/arch/sh/configs/apsh4ad0a_defconfig
+++ b/arch/sh/configs/apsh4ad0a_defconfig
@@ -10,7 +10,6 @@ CONFIG_CGROUPS=y
 CONFIG_CGROUP_FREEZER=y
 CONFIG_CGROUP_DEVICE=y
 CONFIG_CGROUP_CPUACCT=y
-CONFIG_RESOURCE_COUNTERS=y
 CONFIG_CGROUP_MEMCG=y
 CONFIG_BLK_CGROUP=y
 CONFIG_NAMESPACES=y
diff --git a/arch/sh/configs/sdk7786_defconfig b/arch/sh/configs/sdk7786_defconfig
index e7e56a4131b4..36642ec2cb97 100644
--- a/arch/sh/configs/sdk7786_defconfig
+++ b/arch/sh/configs/sdk7786_defconfig
@@ -17,7 +17,6 @@ CONFIG_CGROUP_DEVICE=y
 CONFIG_CPUSETS=y
 # CONFIG_PROC_PID_CPUSET is not set
 CONFIG_CGROUP_CPUACCT=y
-CONFIG_RESOURCE_COUNTERS=y
 CONFIG_CGROUP_MEMCG=y
 CONFIG_CGROUP_MEMCG_SWAP=y
 CONFIG_CGROUP_SCHED=y
diff --git a/arch/sh/configs/se7206_defconfig b/arch/sh/configs/se7206_defconfig
index 6bc30ab9fd18..91853a67ec34 100644
--- a/arch/sh/configs/se7206_defconfig
+++ b/arch/sh/configs/se7206_defconfig
@@ -10,7 +10,6 @@ CONFIG_CGROUPS=y
 CONFIG_CGROUP_DEBUG=y
 CONFIG_CGROUP_DEVICE=y
 CONFIG_CGROUP_CPUACCT=y
-CONFIG_RESOURCE_COUNTERS=y
 CONFIG_CGROUP_MEMCG=y
 CONFIG_RELAY=y
 CONFIG_NAMESPACES=y
diff --git a/arch/sh/configs/shx3_defconfig b/arch/sh/configs/shx3_defconfig
index cd6c519f8fad..4a4269ad5b04 100644
--- a/arch/sh/configs/shx3_defconfig
+++ b/arch/sh/configs/shx3_defconfig
@@ -12,7 +12,6 @@ CONFIG_CGROUPS=y
 CONFIG_CGROUP_FREEZER=y
 CONFIG_CGROUP_DEVICE=y
 CONFIG_CGROUP_CPUACCT=y
-CONFIG_RESOURCE_COUNTERS=y
 CONFIG_CGROUP_MEMCG=y
 CONFIG_RELAY=y
 CONFIG_NAMESPACES=y
diff --git a/arch/sh/configs/urquell_defconfig b/arch/sh/configs/urquell_defconfig
index 1e843dbed5f0..01c9a91ee896 100644
--- a/arch/sh/configs/urquell_defconfig
+++ b/arch/sh/configs/urquell_defconfig
@@ -14,7 +14,6 @@ CONFIG_CGROUP_DEVICE=y
 CONFIG_CPUSETS=y
 # CONFIG_PROC_PID_CPUSET is not set
 CONFIG_CGROUP_CPUACCT=y
-CONFIG_RESOURCE_COUNTERS=y
 CONFIG_CGROUP_MEMCG=y
 CONFIG_CGROUP_MEMCG_SWAP=y
 CONFIG_CGROUP_SCHED=y
diff --git a/arch/sh/kernel/vsyscall/vsyscall.c b/arch/sh/kernel/vsyscall/vsyscall.c
index ea2aa1393b87..cc0cc5b4ff18 100644
--- a/arch/sh/kernel/vsyscall/vsyscall.c
+++ b/arch/sh/kernel/vsyscall/vsyscall.c
@@ -64,7 +64,9 @@ int arch_setup_additional_pages(struct linux_binprm *bprm, int uses_interp)
         unsigned long addr;
         int ret;
 
-        down_write(&mm->mmap_sem);
+        if (down_write_killable(&mm->mmap_sem))
+                return -EINTR;
+
         addr = get_unmapped_area(NULL, 0, PAGE_SIZE, 0, 0);
         if (IS_ERR_VALUE(addr)) {
                 ret = addr;
diff --git a/arch/tile/configs/tilegx_defconfig b/arch/tile/configs/tilegx_defconfig
index dea47c31ab16..fd122ef45b00 100644
--- a/arch/tile/configs/tilegx_defconfig
+++ b/arch/tile/configs/tilegx_defconfig
@@ -16,7 +16,6 @@ CONFIG_CGROUP_DEBUG=y
 CONFIG_CGROUP_DEVICE=y
 CONFIG_CPUSETS=y
 CONFIG_CGROUP_CPUACCT=y
-CONFIG_RESOURCE_COUNTERS=y
 CONFIG_CGROUP_SCHED=y
 CONFIG_RT_GROUP_SCHED=y
 CONFIG_BLK_CGROUP=y
diff --git a/arch/tile/configs/tilepro_defconfig b/arch/tile/configs/tilepro_defconfig
index 95743eedf747..eb6a55944191 100644
--- a/arch/tile/configs/tilepro_defconfig
+++ b/arch/tile/configs/tilepro_defconfig
@@ -15,7 +15,6 @@ CONFIG_CGROUP_DEBUG=y
 CONFIG_CGROUP_DEVICE=y
 CONFIG_CPUSETS=y
 CONFIG_CGROUP_CPUACCT=y
-CONFIG_RESOURCE_COUNTERS=y
 CONFIG_CGROUP_SCHED=y
 CONFIG_RT_GROUP_SCHED=y
 CONFIG_BLK_CGROUP=y
diff --git a/arch/um/configs/i386_defconfig b/arch/um/configs/i386_defconfig
index a12bf68c9f3a..5636221b8785 100644
--- a/arch/um/configs/i386_defconfig
+++ b/arch/um/configs/i386_defconfig
@@ -17,7 +17,6 @@ CONFIG_CGROUP_FREEZER=y
 CONFIG_CGROUP_DEVICE=y
 CONFIG_CPUSETS=y
 CONFIG_CGROUP_CPUACCT=y
-CONFIG_RESOURCE_COUNTERS=y
 CONFIG_CGROUP_SCHED=y
 CONFIG_BLK_CGROUP=y
 # CONFIG_PID_NS is not set
diff --git a/arch/um/configs/x86_64_defconfig b/arch/um/configs/x86_64_defconfig
index 3aab117bd553..7a67b7ac1a7e 100644
--- a/arch/um/configs/x86_64_defconfig
+++ b/arch/um/configs/x86_64_defconfig
@@ -15,7 +15,6 @@ CONFIG_CGROUP_FREEZER=y
 CONFIG_CGROUP_DEVICE=y
 CONFIG_CPUSETS=y
 CONFIG_CGROUP_CPUACCT=y
-CONFIG_RESOURCE_COUNTERS=y
 CONFIG_CGROUP_SCHED=y
 CONFIG_BLK_CGROUP=y
 # CONFIG_PID_NS is not set
diff --git a/arch/x86/configs/i386_defconfig b/arch/x86/configs/i386_defconfig
index 265901a84f3f..5fa6ee2c2dde 100644
--- a/arch/x86/configs/i386_defconfig
+++ b/arch/x86/configs/i386_defconfig
@@ -17,7 +17,6 @@ CONFIG_CGROUPS=y
 CONFIG_CGROUP_FREEZER=y
 CONFIG_CPUSETS=y
 CONFIG_CGROUP_CPUACCT=y
-CONFIG_RESOURCE_COUNTERS=y
 CONFIG_CGROUP_SCHED=y
 CONFIG_BLK_DEV_INITRD=y
 # CONFIG_COMPAT_BRK is not set
diff --git a/arch/x86/configs/x86_64_defconfig b/arch/x86/configs/x86_64_defconfig
index 0c8d7963483c..d28bdabcc87e 100644
--- a/arch/x86/configs/x86_64_defconfig
+++ b/arch/x86/configs/x86_64_defconfig
@@ -16,7 +16,6 @@ CONFIG_CGROUPS=y
 CONFIG_CGROUP_FREEZER=y
 CONFIG_CPUSETS=y
 CONFIG_CGROUP_CPUACCT=y
-CONFIG_RESOURCE_COUNTERS=y
 CONFIG_CGROUP_SCHED=y
 CONFIG_BLK_DEV_INITRD=y
 # CONFIG_COMPAT_BRK is not set
diff --git a/arch/x86/entry/vdso/vma.c b/arch/x86/entry/vdso/vma.c
index b3cf81333a54..ab220ac9b3b9 100644
--- a/arch/x86/entry/vdso/vma.c
+++ b/arch/x86/entry/vdso/vma.c
@@ -163,7 +163,8 @@ static int map_vdso(const struct vdso_image *image, bool calculate_addr)
                 addr = 0;
         }
 
-        down_write(&mm->mmap_sem);
+        if (down_write_killable(&mm->mmap_sem))
+                return -EINTR;
 
         addr = get_unmapped_area(NULL, addr,
                                  image->size - image->sym_vvar_start, 0, 0);
diff --git a/arch/x86/ia32/ia32_aout.c b/arch/x86/ia32/ia32_aout.c
index ae6aad1d24f7..f5e737ff0022 100644
--- a/arch/x86/ia32/ia32_aout.c
+++ b/arch/x86/ia32/ia32_aout.c
@@ -116,13 +116,13 @@ static struct linux_binfmt aout_format = {
         .min_coredump   = PAGE_SIZE
 };
 
-static void set_brk(unsigned long start, unsigned long end)
+static unsigned long set_brk(unsigned long start, unsigned long end)
 {
         start = PAGE_ALIGN(start);
         end = PAGE_ALIGN(end);
         if (end <= start)
-                return;
-        vm_brk(start, end - start);
+                return start;
+        return vm_brk(start, end - start);
 }
 
 #ifdef CONFIG_COREDUMP
@@ -349,7 +349,10 @@ static int load_aout_binary(struct linux_binprm *bprm)
 #endif
 
                 if (!bprm->file->f_op->mmap || (fd_offset & ~PAGE_MASK) != 0) {
-                        vm_brk(N_TXTADDR(ex), ex.a_text+ex.a_data);
+                        error = vm_brk(N_TXTADDR(ex), ex.a_text+ex.a_data);
+                        if (IS_ERR_VALUE(error))
+                                return error;
+
                         read_code(bprm->file, N_TXTADDR(ex), fd_offset,
                                         ex.a_text+ex.a_data);
                         goto beyond_if;
@@ -372,10 +375,13 @@ static int load_aout_binary(struct linux_binprm *bprm)
                 if (error != N_DATADDR(ex))
                         return error;
         }
+
 beyond_if:
-        set_binfmt(&aout_format);
+        error = set_brk(current->mm->start_brk, current->mm->brk);
+        if (IS_ERR_VALUE(error))
+                return error;
 
-        set_brk(current->mm->start_brk, current->mm->brk);
+        set_binfmt(&aout_format);
 
         current->mm->start_stack =
                 (unsigned long)create_aout_tables((char __user *)bprm->p, bprm);
@@ -434,7 +440,9 @@ static int load_aout_library(struct file *file)
                         error_time = jiffies;
                 }
 #endif
-                vm_brk(start_addr, ex.a_text + ex.a_data + ex.a_bss);
+                retval = vm_brk(start_addr, ex.a_text + ex.a_data + ex.a_bss);
+                if (IS_ERR_VALUE(retval))
+                        goto out;
 
                 read_code(file, start_addr, N_TXTOFF(ex),
                           ex.a_text + ex.a_data);
diff --git a/arch/x86/kernel/machine_kexec_64.c b/arch/x86/kernel/machine_kexec_64.c
index ba7fbba9831b..5a294e48b185 100644
--- a/arch/x86/kernel/machine_kexec_64.c
+++ b/arch/x86/kernel/machine_kexec_64.c
@@ -538,3 +538,48 @@ overflow:
         return -ENOEXEC;
 }
 #endif /* CONFIG_KEXEC_FILE */
+
+static int
+kexec_mark_range(unsigned long start, unsigned long end, bool protect)
+{
+        struct page *page;
+        unsigned int nr_pages;
+
+        /*
+         * For physical range: [start, end]. We must skip the unassigned
+         * crashk resource with zero-valued "end" member.
+         */
+        if (!end || start > end)
+                return 0;
+
+        page = pfn_to_page(start >> PAGE_SHIFT);
+        nr_pages = (end >> PAGE_SHIFT) - (start >> PAGE_SHIFT) + 1;
+        if (protect)
+                return set_pages_ro(page, nr_pages);
+        else
+                return set_pages_rw(page, nr_pages);
+}
+
+static void kexec_mark_crashkres(bool protect)
+{
+        unsigned long control;
+
+        kexec_mark_range(crashk_low_res.start, crashk_low_res.end, protect);
+
+        /* Don't touch the control code page used in crash_kexec().*/
+        control = PFN_PHYS(page_to_pfn(kexec_crash_image->control_code_page));
+        /* Control code page is located in the 2nd page. */
+        kexec_mark_range(crashk_res.start, control + PAGE_SIZE - 1, protect);
+        control += KEXEC_CONTROL_PAGE_SIZE;
+        kexec_mark_range(control, crashk_res.end, protect);
+}
+
+void arch_kexec_protect_crashkres(void)
+{
+        kexec_mark_crashkres(true);
+}
+
+void arch_kexec_unprotect_crashkres(void)
+{
+        kexec_mark_crashkres(false);
+}
diff --git a/arch/x86/um/vdso/vma.c b/arch/x86/um/vdso/vma.c
index 237c6831e095..6be22f991b59 100644
--- a/arch/x86/um/vdso/vma.c
+++ b/arch/x86/um/vdso/vma.c
@@ -61,7 +61,8 @@ int arch_setup_additional_pages(struct linux_binprm *bprm, int uses_interp)
         if (!vdso_enabled)
                 return 0;
 
-        down_write(&mm->mmap_sem);
+        if (down_write_killable(&mm->mmap_sem))
+                return -EINTR;
 
         err = install_special_mapping(mm, um_vdso_addr, PAGE_SIZE,
                 VM_READ|VM_EXEC|
diff --git a/arch/xtensa/configs/generic_kc705_defconfig b/arch/xtensa/configs/generic_kc705_defconfig
index f4b7b3888da8..d9444f01f4da 100644
--- a/arch/xtensa/configs/generic_kc705_defconfig
+++ b/arch/xtensa/configs/generic_kc705_defconfig
@@ -11,7 +11,6 @@ CONFIG_CGROUP_FREEZER=y
 CONFIG_CGROUP_DEVICE=y
 CONFIG_CPUSETS=y
 CONFIG_CGROUP_CPUACCT=y
-CONFIG_RESOURCE_COUNTERS=y
 CONFIG_MEMCG=y
 CONFIG_NAMESPACES=y
 CONFIG_SCHED_AUTOGROUP=y
diff --git a/arch/xtensa/configs/smp_lx200_defconfig b/arch/xtensa/configs/smp_lx200_defconfig
index 22eeacba37cc..61f943c95619 100644
--- a/arch/xtensa/configs/smp_lx200_defconfig
+++ b/arch/xtensa/configs/smp_lx200_defconfig
@@ -11,7 +11,6 @@ CONFIG_CGROUP_FREEZER=y
 CONFIG_CGROUP_DEVICE=y
 CONFIG_CPUSETS=y
 CONFIG_CGROUP_CPUACCT=y
-CONFIG_RESOURCE_COUNTERS=y
 CONFIG_MEMCG=y
 CONFIG_NAMESPACES=y
 CONFIG_SCHED_AUTOGROUP=y
diff --git a/drivers/gpu/drm/amd/amdgpu/amdgpu_mn.c b/drivers/gpu/drm/amd/amdgpu/amdgpu_mn.c
index 9f4a45cd2aab..32fa7b7913f7 100644
--- a/drivers/gpu/drm/amd/amdgpu/amdgpu_mn.c
+++ b/drivers/gpu/drm/amd/amdgpu/amdgpu_mn.c
@@ -232,7 +232,10 @@ static struct amdgpu_mn *amdgpu_mn_get(struct amdgpu_device *adev)
         int r;
 
         mutex_lock(&adev->mn_lock);
-        down_write(&mm->mmap_sem);
+        if (down_write_killable(&mm->mmap_sem)) {
+                mutex_unlock(&adev->mn_lock);
+                return ERR_PTR(-EINTR);
+        }
 
         hash_for_each_possible(adev->mn_hash, rmn, node, (unsigned long)mm)
                 if (rmn->mm == mm)
diff --git a/drivers/gpu/drm/i915/i915_gem.c b/drivers/gpu/drm/i915/i915_gem.c
index 94bbc4314ac5..9b99490e8367 100644
--- a/drivers/gpu/drm/i915/i915_gem.c
+++ b/drivers/gpu/drm/i915/i915_gem.c
@@ -1721,7 +1721,10 @@ i915_gem_mmap_ioctl(struct drm_device *dev, void *data,
                 struct mm_struct *mm = current->mm;
                 struct vm_area_struct *vma;
 
-                down_write(&mm->mmap_sem);
+                if (down_write_killable(&mm->mmap_sem)) {
+                        drm_gem_object_unreference_unlocked(obj);
+                        return -EINTR;
+                }
                 vma = find_vma(mm, addr);
                 if (vma)
                         vma->vm_page_prot =
diff --git a/drivers/gpu/drm/radeon/radeon_mn.c b/drivers/gpu/drm/radeon/radeon_mn.c
index eef006c48584..896f2cf51e4e 100644
--- a/drivers/gpu/drm/radeon/radeon_mn.c
+++ b/drivers/gpu/drm/radeon/radeon_mn.c
@@ -186,7 +186,9 @@ static struct radeon_mn *radeon_mn_get(struct radeon_device *rdev)
         struct radeon_mn *rmn;
         int r;
 
-        down_write(&mm->mmap_sem);
+        if (down_write_killable(&mm->mmap_sem))
+                return ERR_PTR(-EINTR);
+
         mutex_lock(&rdev->mn_lock);
 
         hash_for_each_possible(rdev->mn_hash, rmn, node, (unsigned long)mm)
diff --git a/drivers/memstick/core/mspro_block.c b/drivers/memstick/core/mspro_block.c
index 922a750640e8..0fb27d338811 100644
--- a/drivers/memstick/core/mspro_block.c
+++ b/drivers/memstick/core/mspro_block.c
@@ -1033,12 +1033,11 @@ static int mspro_block_read_attributes(struct memstick_dev *card)
         }
         msb->attr_group.name = "media_attributes";
 
-        buffer = kmalloc(attr_len, GFP_KERNEL);
+        buffer = kmemdup(attr, attr_len, GFP_KERNEL);
         if (!buffer) {
                 rc = -ENOMEM;
                 goto out_free_attr;
         }
-        memcpy(buffer, (char *)attr, attr_len);
 
         for (cnt = 0; cnt < attr_count; ++cnt) {
                 s_attr = kzalloc(sizeof(struct mspro_sys_attr), GFP_KERNEL);
diff --git a/drivers/memstick/host/rtsx_usb_ms.c b/drivers/memstick/host/rtsx_usb_ms.c
index 1105db2355d2..d34bc3530385 100644
--- a/drivers/memstick/host/rtsx_usb_ms.c
+++ b/drivers/memstick/host/rtsx_usb_ms.c
@@ -706,7 +706,7 @@ poll_again:
                 if (host->eject)
                         break;
 
-                msleep(1000);
+                schedule_timeout_idle(HZ);
         }
 
         complete(&host->detect_ms_exit);
diff --git a/fs/Kconfig.binfmt b/fs/Kconfig.binfmt
index 2d0cbbd14cfc..72c03354c14b 100644
--- a/fs/Kconfig.binfmt
+++ b/fs/Kconfig.binfmt
@@ -1,6 +1,7 @@
 config BINFMT_ELF
         bool "Kernel support for ELF binaries"
         depends on MMU && (BROKEN || !FRV)
+        select ELFCORE
         default y
         ---help---
           ELF (Executable and Linkable Format) is a format for libraries and
@@ -26,6 +27,7 @@ config BINFMT_ELF
 config COMPAT_BINFMT_ELF
         bool
         depends on COMPAT && BINFMT_ELF
+        select ELFCORE
 
 config ARCH_BINFMT_ELF_STATE
         bool
@@ -34,6 +36,7 @@ config BINFMT_ELF_FDPIC
         bool "Kernel support for FDPIC ELF binaries"
         default y
         depends on (FRV || BLACKFIN || (SUPERH32 && !MMU) || C6X)
+        select ELFCORE
         help
           ELF FDPIC binaries are based on ELF, but allow the individual load
           segments of a binary to be located in memory independently of each
@@ -43,6 +46,11 @@ config BINFMT_ELF_FDPIC
 
           It is also possible to run FDPIC ELF binaries on MMU linux also.
 
+config ELFCORE
+        bool
+        help
+          This option enables kernel/elfcore.o.
+
 config CORE_DUMP_DEFAULT_ELF_HEADERS
         bool "Write ELF core dumps with partial segments"
         default y
diff --git a/fs/aio.c b/fs/aio.c
index a6deaa78326d..fb8e45b88cd4 100644
--- a/fs/aio.c
+++ b/fs/aio.c
@@ -496,7 +496,12 @@ static int aio_setup_ring(struct kioctx *ctx)
         ctx->mmap_size = nr_pages * PAGE_SIZE;
         pr_debug("attempting mmap of %lu bytes\n", ctx->mmap_size);
 
-        down_write(&mm->mmap_sem);
+        if (down_write_killable(&mm->mmap_sem)) {
+                ctx->mmap_size = 0;
+                aio_free_ring(ctx);
+                return -EINTR;
+        }
+
         ctx->mmap_base = do_mmap_pgoff(ctx->aio_ring_file, 0, ctx->mmap_size,
                                        PROT_READ | PROT_WRITE,
                                        MAP_SHARED, 0, &unused);
diff --git a/fs/befs/datastream.c b/fs/befs/datastream.c
index dde0b79f3948..af1bc19b7c85 100644
--- a/fs/befs/datastream.c
+++ b/fs/befs/datastream.c
@@ -48,7 +48,7 @@ struct buffer_head *
 befs_read_datastream(struct super_block *sb, const befs_data_stream *ds,
                      befs_off_t pos, uint * off)
 {
-        struct buffer_head *bh = NULL;
+        struct buffer_head *bh;
         befs_block_run run;
         befs_blocknr_t block;   /* block coresponding to pos */
 
@@ -127,7 +127,7 @@ befs_read_lsymlink(struct super_block *sb, const befs_data_stream *ds,
 {
         befs_off_t bytes_read = 0;      /* bytes readed */
         u16 plen;
-        struct buffer_head *bh = NULL;
+        struct buffer_head *bh;
         befs_debug(sb, "---> %s length: %llu", __func__, len);
 
         while (bytes_read < len) {
@@ -429,7 +429,7 @@ befs_find_brun_dblindirect(struct super_block *sb,
         struct buffer_head *dbl_indir_block;
         struct buffer_head *indir_block;
         befs_block_run indir_run;
-        befs_disk_inode_addr *iaddr_array = NULL;
+        befs_disk_inode_addr *iaddr_array;
         struct befs_sb_info *befs_sb = BEFS_SB(sb);
 
         befs_blocknr_t indir_start_blk =
@@ -488,7 +488,6 @@ befs_find_brun_dblindirect(struct super_block *sb,
         iaddr_array = (befs_disk_inode_addr *) dbl_indir_block->b_data;
         indir_run = fsrun_to_cpu(sb, iaddr_array[dbl_block_indx]);
         brelse(dbl_indir_block);
-        iaddr_array = NULL;
 
         /* Read indirect block */
         which_block = indir_indx / befs_iaddrs_per_block(sb);
@@ -513,7 +512,6 @@ befs_find_brun_dblindirect(struct super_block *sb,
         iaddr_array = (befs_disk_inode_addr *) indir_block->b_data;
         *run = fsrun_to_cpu(sb, iaddr_array[block_indx]);
         brelse(indir_block);
-        iaddr_array = NULL;
 
         blockno_at_run_start = indir_start_blk;
         blockno_at_run_start += diblklen * dblindir_indx;
diff --git a/fs/befs/io.c b/fs/befs/io.c
index 7a5b4ec21c56..523c8af2d770 100644
--- a/fs/befs/io.c
+++ b/fs/befs/io.c
@@ -26,7 +26,7 @@
 struct buffer_head *
 befs_bread_iaddr(struct super_block *sb, befs_inode_addr iaddr)
 {
-        struct buffer_head *bh = NULL;
+        struct buffer_head *bh;
         befs_blocknr_t block = 0;
         struct befs_sb_info *befs_sb = BEFS_SB(sb);
 
@@ -63,7 +63,7 @@ befs_bread_iaddr(struct super_block *sb, befs_inode_addr iaddr)
 struct buffer_head *
 befs_bread(struct super_block *sb, befs_blocknr_t block)
 {
-        struct buffer_head *bh = NULL;
+        struct buffer_head *bh;
 
         befs_debug(sb, "---> Enter %s %lu", __func__, (unsigned long)block);
 
diff --git a/fs/befs/linuxvfs.c b/fs/befs/linuxvfs.c
index 71112aa07d84..7da05b159ade 100644
--- a/fs/befs/linuxvfs.c
+++ b/fs/befs/linuxvfs.c
@@ -155,7 +155,7 @@ befs_get_block(struct inode *inode, sector_t block,
 static struct dentry *
 befs_lookup(struct inode *dir, struct dentry *dentry, unsigned int flags)
 {
-        struct inode *inode = NULL;
+        struct inode *inode;
         struct super_block *sb = dir->i_sb;
         const befs_data_stream *ds = &BEFS_I(dir)->i_data.ds;
         befs_off_t offset;
@@ -294,10 +294,10 @@ static void init_once(void *foo)
 
 static struct inode *befs_iget(struct super_block *sb, unsigned long ino)
 {
-        struct buffer_head *bh = NULL;
-        befs_inode *raw_inode = NULL;
+        struct buffer_head *bh;
+        befs_inode *raw_inode;
         struct befs_sb_info *befs_sb = BEFS_SB(sb);
-        struct befs_inode_info *befs_ino = NULL;
+        struct befs_inode_info *befs_ino;
         struct inode *inode;
         long ret = -EIO;
 
diff --git a/fs/binfmt_aout.c b/fs/binfmt_aout.c
index 4c556680fa74..2fab9f130e51 100644
--- a/fs/binfmt_aout.c
+++ b/fs/binfmt_aout.c
@@ -297,7 +297,10 @@ static int load_aout_binary(struct linux_binprm * bprm)
                 }
 
                 if (!bprm->file->f_op->mmap||((fd_offset & ~PAGE_MASK) != 0)) {
-                        vm_brk(N_TXTADDR(ex), ex.a_text+ex.a_data);
+                        error = vm_brk(N_TXTADDR(ex), ex.a_text+ex.a_data);
+                        if (IS_ERR_VALUE(error))
+                                return error;
+
                         read_code(bprm->file, N_TXTADDR(ex), fd_offset,
                                   ex.a_text + ex.a_data);
                         goto beyond_if;
@@ -378,8 +381,10 @@ static int load_aout_library(struct file *file)
                                "N_TXTOFF is not page aligned. Please convert library: %pD\n",
                                file);
                 }
-                vm_brk(start_addr, ex.a_text + ex.a_data + ex.a_bss);
-                
+                retval = vm_brk(start_addr, ex.a_text + ex.a_data + ex.a_bss);
+                if (IS_ERR_VALUE(retval))
+                        goto out;
+
                 read_code(file, start_addr, N_TXTOFF(ex),
                           ex.a_text + ex.a_data);
                 retval = 0;
diff --git a/fs/binfmt_elf.c b/fs/binfmt_elf.c
index 56224ffa94d2..938fc4ede764 100644
--- a/fs/binfmt_elf.c
+++ b/fs/binfmt_elf.c
@@ -1176,8 +1176,11 @@ static int load_elf_library(struct file *file)
         len = ELF_PAGESTART(eppnt->p_filesz + eppnt->p_vaddr +
                             ELF_MIN_ALIGN - 1);
         bss = eppnt->p_memsz + eppnt->p_vaddr;
-        if (bss > len)
-                vm_brk(len, bss - len);
+        if (bss > len) {
+                error = vm_brk(len, bss - len);
+                if (BAD_ADDR(error))
+                        goto out_free_ph;
+        }
         error = 0;
 
 out_free_ph:
diff --git a/fs/coredump.c b/fs/coredump.c
index 492c2db25dc9..38a7ab87e10a 100644
--- a/fs/coredump.c
+++ b/fs/coredump.c
@@ -413,7 +413,9 @@ static int coredump_wait(int exit_code, struct core_state *core_state)
         core_state->dumper.task = tsk;
         core_state->dumper.next = NULL;
 
-        down_write(&mm->mmap_sem);
+        if (down_write_killable(&mm->mmap_sem))
+                return -EINTR;
+
         if (!mm->core_state)
                 core_waiters = zap_threads(tsk, mm, core_state, exit_code);
         up_write(&mm->mmap_sem);
diff --git a/fs/exec.c b/fs/exec.c
index e92419fd78b3..887c1c955df8 100644
--- a/fs/exec.c
+++ b/fs/exec.c
@@ -243,10 +243,6 @@ static void put_arg_page(struct page *page)
         put_page(page);
 }
 
-static void free_arg_page(struct linux_binprm *bprm, int i)
-{
-}
-
 static void free_arg_pages(struct linux_binprm *bprm)
 {
 }
@@ -267,7 +263,10 @@ static int __bprm_mm_init(struct linux_binprm *bprm)
         if (!vma)
                 return -ENOMEM;
 
-        down_write(&mm->mmap_sem);
+        if (down_write_killable(&mm->mmap_sem)) {
+                err = -EINTR;
+                goto err_free;
+        }
         vma->vm_mm = mm;
 
         /*
@@ -294,6 +293,7 @@ static int __bprm_mm_init(struct linux_binprm *bprm)
         return 0;
 err:
         up_write(&mm->mmap_sem);
+err_free:
         bprm->vma = NULL;
         kmem_cache_free(vm_area_cachep, vma);
         return err;
@@ -700,7 +700,9 @@ int setup_arg_pages(struct linux_binprm *bprm,
                 bprm->loader -= stack_shift;
         bprm->exec -= stack_shift;
 
-        down_write(&mm->mmap_sem);
+        if (down_write_killable(&mm->mmap_sem))
+                return -EINTR;
+
         vm_flags = VM_STACK_FLAGS;
 
         /*
@@ -1499,9 +1501,6 @@ int remove_arg_zero(struct linux_binprm *bprm)
 
                 kunmap_atomic(kaddr);
                 put_arg_page(page);
-
-                if (offset == PAGE_SIZE)
-                        free_arg_page(bprm, (bprm->p >> PAGE_SHIFT) - 1);
         } while (offset == PAGE_SIZE);
 
         bprm->p++;
diff --git a/fs/nilfs2/alloc.c b/fs/nilfs2/alloc.c
index 2ccbf5531554..1a85d94f5b25 100644
--- a/fs/nilfs2/alloc.c
+++ b/fs/nilfs2/alloc.c
@@ -13,13 +13,8 @@
  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  * GNU General Public License for more details.
  *
- * You should have received a copy of the GNU General Public License
- * along with this program; if not, write to the Free Software
- * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
- *
- * Original code was written by Koji Sato <koji@osrg.net>.
- * Two allocators were unified by Ryusuke Konishi <ryusuke@osrg.net>,
- *                                Amagai Yoshiji <amagai@osrg.net>.
+ * Originally written by Koji Sato.
+ * Two allocators were unified by Ryusuke Konishi and Amagai Yoshiji.
  */
 
 #include <linux/types.h>
@@ -58,7 +53,7 @@ nilfs_palloc_groups_count(const struct inode *inode)
  * @inode: inode of metadata file using this allocator
  * @entry_size: size of the persistent object
  */
-int nilfs_palloc_init_blockgroup(struct inode *inode, unsigned entry_size)
+int nilfs_palloc_init_blockgroup(struct inode *inode, unsigned int entry_size)
 {
         struct nilfs_mdt_info *mi = NILFS_MDT(inode);
 
@@ -73,13 +68,17 @@ int nilfs_palloc_init_blockgroup(struct inode *inode, unsigned entry_size)
         mi->mi_blocks_per_group =
                 DIV_ROUND_UP(nilfs_palloc_entries_per_group(inode),
                              mi->mi_entries_per_block) + 1;
-                /* Number of blocks in a group including entry blocks and
-                   a bitmap block */
+                /*
+                 * Number of blocks in a group including entry blocks
+                 * and a bitmap block
+                 */
         mi->mi_blocks_per_desc_block =
                 nilfs_palloc_groups_per_desc_block(inode) *
                 mi->mi_blocks_per_group + 1;
-                /* Number of blocks per descriptor including the
-                   descriptor block */
+                /*
+                 * Number of blocks per descriptor including the
+                 * descriptor block
+                 */
         return 0;
 }
 
@@ -389,7 +388,7 @@ void *nilfs_palloc_block_get_entry(const struct inode *inode, __u64 nr,
  */
 static int nilfs_palloc_find_available_slot(unsigned char *bitmap,
                                             unsigned long target,
-                                            unsigned bsize,
+                                            unsigned int bsize,
                                             spinlock_t *lock)
 {
         int pos, end = bsize;
@@ -624,7 +623,7 @@ void nilfs_palloc_commit_free_entry(struct inode *inode,
 
         if (!nilfs_clear_bit_atomic(lock, group_offset, bitmap))
                 nilfs_warning(inode->i_sb, __func__,
-                              "entry number %llu already freed: ino=%lu\n",
+                              "entry number %llu already freed: ino=%lu",
                               (unsigned long long)req->pr_entry_nr,
                               (unsigned long)inode->i_ino);
         else
@@ -665,7 +664,7 @@ void nilfs_palloc_abort_alloc_entry(struct inode *inode,
 
         if (!nilfs_clear_bit_atomic(lock, group_offset, bitmap))
                 nilfs_warning(inode->i_sb, __func__,
-                              "entry number %llu already freed: ino=%lu\n",
+                              "entry number %llu already freed: ino=%lu",
                               (unsigned long long)req->pr_entry_nr,
                               (unsigned long)inode->i_ino);
         else
@@ -740,8 +739,8 @@ int nilfs_palloc_freev(struct inode *inode, __u64 *entry_nrs, size_t nitems)
         unsigned long group, group_offset;
         __u64 group_min_nr, last_nrs[8];
         const unsigned long epg = nilfs_palloc_entries_per_group(inode);
-        const unsigned epb = NILFS_MDT(inode)->mi_entries_per_block;
-        unsigned entry_start, end, pos;
+        const unsigned int epb = NILFS_MDT(inode)->mi_entries_per_block;
+        unsigned int entry_start, end, pos;
         spinlock_t *lock;
         int i, j, k, ret;
         u32 nfree;
@@ -774,7 +773,7 @@ int nilfs_palloc_freev(struct inode *inode, __u64 *entry_nrs, size_t nitems)
                         if (!nilfs_clear_bit_atomic(lock, group_offset,
                                                     bitmap)) {
                                 nilfs_warning(inode->i_sb, __func__,
-                                              "entry number %llu already freed: ino=%lu\n",
+                                              "entry number %llu already freed: ino=%lu",
                                               (unsigned long long)entry_nrs[j],
                                               (unsigned long)inode->i_ino);
                         } else {
@@ -819,7 +818,7 @@ int nilfs_palloc_freev(struct inode *inode, __u64 *entry_nrs, size_t nitems)
                                                               last_nrs[k]);
                         if (ret && ret != -ENOENT) {
                                 nilfs_warning(inode->i_sb, __func__,
-                                              "failed to delete block of entry %llu: ino=%lu, err=%d\n",
+                                              "failed to delete block of entry %llu: ino=%lu, err=%d",
                                               (unsigned long long)last_nrs[k],
                                               (unsigned long)inode->i_ino, ret);
                         }
@@ -838,7 +837,7 @@ int nilfs_palloc_freev(struct inode *inode, __u64 *entry_nrs, size_t nitems)
                         ret = nilfs_palloc_delete_bitmap_block(inode, group);
                         if (ret && ret != -ENOENT) {
                                 nilfs_warning(inode->i_sb, __func__,
-                                              "failed to delete bitmap block of group %lu: ino=%lu, err=%d\n",
+                                              "failed to delete bitmap block of group %lu: ino=%lu, err=%d",
                                               group,
                                               (unsigned long)inode->i_ino, ret);
                         }
diff --git a/fs/nilfs2/alloc.h b/fs/nilfs2/alloc.h
index 6e6f49aa53df..05149e606a78 100644
--- a/fs/nilfs2/alloc.h
+++ b/fs/nilfs2/alloc.h
@@ -13,13 +13,8 @@
  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  * GNU General Public License for more details.
  *
- * You should have received a copy of the GNU General Public License
- * along with this program; if not, write to the Free Software
- * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
- *
- * Original code was written by Koji Sato <koji@osrg.net>.
- * Two allocators were unified by Ryusuke Konishi <ryusuke@osrg.net>,
- *                                Amagai Yoshiji <amagai@osrg.net>.
+ * Originally written by Koji Sato.
+ * Two allocators were unified by Ryusuke Konishi and Amagai Yoshiji.
  */
 
 #ifndef _NILFS_ALLOC_H
@@ -42,7 +37,7 @@ nilfs_palloc_entries_per_group(const struct inode *inode)
         return 1UL << (inode->i_blkbits + 3 /* log2(8 = CHAR_BITS) */);
 }
 
-int nilfs_palloc_init_blockgroup(struct inode *, unsigned);
+int nilfs_palloc_init_blockgroup(struct inode *, unsigned int);
 int nilfs_palloc_get_entry_block(struct inode *, __u64, int,
                                  struct buffer_head **);
 void *nilfs_palloc_block_get_entry(const struct inode *, __u64,
diff --git a/fs/nilfs2/bmap.c b/fs/nilfs2/bmap.c
index a9fb3636c142..f2a7877e0c8c 100644
--- a/fs/nilfs2/bmap.c
+++ b/fs/nilfs2/bmap.c
@@ -13,11 +13,7 @@
  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  * GNU General Public License for more details.
  *
- * You should have received a copy of the GNU General Public License
- * along with this program; if not, write to the Free Software
- * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
- *
- * Written by Koji Sato <koji@osrg.net>.
+ * Written by Koji Sato.
  */
 
 #include <linux/fs.h>
@@ -46,7 +42,7 @@ static int nilfs_bmap_convert_error(struct nilfs_bmap *bmap,
 
         if (err == -EINVAL) {
                 nilfs_error(inode->i_sb, fname,
-                            "broken bmap (inode number=%lu)\n", inode->i_ino);
+                            "broken bmap (inode number=%lu)", inode->i_ino);
                 err = -EIO;
         }
         return err;
@@ -97,7 +93,7 @@ int nilfs_bmap_lookup_at_level(struct nilfs_bmap *bmap, __u64 key, int level,
 }
 
 int nilfs_bmap_lookup_contig(struct nilfs_bmap *bmap, __u64 key, __u64 *ptrp,
-                             unsigned maxblocks)
+                             unsigned int maxblocks)
 {
         int ret;
 
diff --git a/fs/nilfs2/bmap.h b/fs/nilfs2/bmap.h
index bfa817ce40b3..b6a4c8f93ac8 100644
--- a/fs/nilfs2/bmap.h
+++ b/fs/nilfs2/bmap.h
@@ -13,11 +13,7 @@
  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  * GNU General Public License for more details.
  *
- * You should have received a copy of the GNU General Public License
- * along with this program; if not, write to the Free Software
- * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
- *
- * Written by Koji Sato <koji@osrg.net>.
+ * Written by Koji Sato.
  */
 
 #ifndef _NILFS_BMAP_H
@@ -61,7 +57,7 @@ struct nilfs_bmap_stats {
 struct nilfs_bmap_operations {
         int (*bop_lookup)(const struct nilfs_bmap *, __u64, int, __u64 *);
         int (*bop_lookup_contig)(const struct nilfs_bmap *, __u64, __u64 *,
-                                 unsigned);
+                                 unsigned int);
         int (*bop_insert)(struct nilfs_bmap *, __u64, __u64);
         int (*bop_delete)(struct nilfs_bmap *, __u64);
         void (*bop_clear)(struct nilfs_bmap *);
@@ -126,10 +122,14 @@ struct nilfs_bmap {
 
 /* pointer type */
 #define NILFS_BMAP_PTR_P        0       /* physical block number (i.e. LBN) */
-#define NILFS_BMAP_PTR_VS       1       /* virtual block number (single
-                                           version) */
-#define NILFS_BMAP_PTR_VM       2       /* virtual block number (has multiple
-                                           versions) */
+#define NILFS_BMAP_PTR_VS       1       /*
+                                         * virtual block number (single
+                                         * version)
+                                         */
+#define NILFS_BMAP_PTR_VM       2       /*
+                                         * virtual block number (has multiple
+                                         * versions)
+                                         */
 #define NILFS_BMAP_PTR_U        (-1)    /* never perform pointer operations */
 
 #define NILFS_BMAP_USE_VBN(bmap)        ((bmap)->b_ptr_type > 0)
@@ -154,7 +154,7 @@ struct nilfs_bmap_store {
 int nilfs_bmap_test_and_clear_dirty(struct nilfs_bmap *);
 int nilfs_bmap_read(struct nilfs_bmap *, struct nilfs_inode *);
 void nilfs_bmap_write(struct nilfs_bmap *, struct nilfs_inode *);
-int nilfs_bmap_lookup_contig(struct nilfs_bmap *, __u64, __u64 *, unsigned);
+int nilfs_bmap_lookup_contig(struct nilfs_bmap *, __u64, __u64 *, unsigned int);
 int nilfs_bmap_insert(struct nilfs_bmap *bmap, __u64 key, unsigned long rec);
 int nilfs_bmap_delete(struct nilfs_bmap *bmap, __u64 key);
 int nilfs_bmap_seek_key(struct nilfs_bmap *bmap, __u64 start, __u64 *keyp);
diff --git a/fs/nilfs2/btnode.c b/fs/nilfs2/btnode.c
index e0c9daf9aa22..0576033699bc 100644
--- a/fs/nilfs2/btnode.c
+++ b/fs/nilfs2/btnode.c
@@ -13,13 +13,8 @@
  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  * GNU General Public License for more details.
  *
- * You should have received a copy of the GNU General Public License
- * along with this program; if not, write to the Free Software
- * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
- *
- * This file was originally written by Seiji Kihara <kihara@osrg.net>
- * and fully revised by Ryusuke Konishi <ryusuke@osrg.net> for
- * stabilization and simplification.
+ * Originally written by Seiji Kihara.
+ * Fully revised by Ryusuke Konishi for stabilization and simplification.
  *
  */
 
diff --git a/fs/nilfs2/btnode.h b/fs/nilfs2/btnode.h
index d876b565ce64..2cc1b80e18f7 100644
--- a/fs/nilfs2/btnode.h
+++ b/fs/nilfs2/btnode.h
@@ -13,12 +13,8 @@
  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  * GNU General Public License for more details.
  *
- * You should have received a copy of the GNU General Public License
- * along with this program; if not, write to the Free Software
- * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
- *
- * Written by Seiji Kihara <kihara@osrg.net>
- * Revised by Ryusuke Konishi <ryusuke@osrg.net>
+ * Written by Seiji Kihara.
+ * Revised by Ryusuke Konishi.
  */
 
 #ifndef _NILFS_BTNODE_H
diff --git a/fs/nilfs2/btree.c b/fs/nilfs2/btree.c
index 3a3821b00486..eccb1c89ccbb 100644
--- a/fs/nilfs2/btree.c
+++ b/fs/nilfs2/btree.c
@@ -13,11 +13,7 @@
  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  * GNU General Public License for more details.
  *
- * You should have received a copy of the GNU General Public License
- * along with this program; if not, write to the Free Software
- * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
- *
- * Written by Koji Sato <koji@osrg.net>.
+ * Written by Koji Sato.
  */
 
 #include <linux/slab.h>
@@ -689,7 +685,8 @@ static int nilfs_btree_lookup(const struct nilfs_bmap *btree,
 }
 
 static int nilfs_btree_lookup_contig(const struct nilfs_bmap *btree,
-                                     __u64 key, __u64 *ptrp, unsigned maxblocks)
+                                     __u64 key, __u64 *ptrp,
+                                     unsigned int maxblocks)
 {
         struct nilfs_btree_path *path;
         struct nilfs_btree_node *node;
@@ -1032,12 +1029,12 @@ static __u64 nilfs_btree_find_target_v(const struct nilfs_bmap *btree,
         if (ptr != NILFS_BMAP_INVALID_PTR)
                 /* sequential access */
                 return ptr;
-        else {
-                ptr = nilfs_btree_find_near(btree, path);
-                if (ptr != NILFS_BMAP_INVALID_PTR)
-                        /* near */
-                        return ptr;
-        }
+
+        ptr = nilfs_btree_find_near(btree, path);
+        if (ptr != NILFS_BMAP_INVALID_PTR)
+                /* near */
+                return ptr;
+
         /* block group */
         return nilfs_bmap_find_target_in_group(btree);
 }
diff --git a/fs/nilfs2/btree.h b/fs/nilfs2/btree.h
index 22c02e35b6ef..df1a25faa83b 100644
--- a/fs/nilfs2/btree.h
+++ b/fs/nilfs2/btree.h
@@ -13,11 +13,7 @@
  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  * GNU General Public License for more details.
  *
- * You should have received a copy of the GNU General Public License
- * along with this program; if not, write to the Free Software
- * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
- *
- * Written by Koji Sato <koji@osrg.net>.
+ * Written by Koji Sato.
  */
 
 #ifndef _NILFS_BTREE_H
diff --git a/fs/nilfs2/cpfile.c b/fs/nilfs2/cpfile.c
index b6596cab9e99..8a3d3b65af3f 100644
--- a/fs/nilfs2/cpfile.c
+++ b/fs/nilfs2/cpfile.c
@@ -13,11 +13,7 @@
  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  * GNU General Public License for more details.
  *
- * You should have received a copy of the GNU General Public License
- * along with this program; if not, write to the Free Software
- * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
- *
- * Written by Koji Sato <koji@osrg.net>.
+ * Written by Koji Sato.
  */
 
 #include <linux/kernel.h>
@@ -41,6 +37,7 @@ static unsigned long
 nilfs_cpfile_get_blkoff(const struct inode *cpfile, __u64 cno)
 {
         __u64 tcno = cno + NILFS_MDT(cpfile)->mi_first_entry_offset - 1;
+
         do_div(tcno, nilfs_cpfile_checkpoints_per_block(cpfile));
         return (unsigned long)tcno;
 }
@@ -50,6 +47,7 @@ static unsigned long
 nilfs_cpfile_get_offset(const struct inode *cpfile, __u64 cno)
 {
         __u64 tcno = cno + NILFS_MDT(cpfile)->mi_first_entry_offset - 1;
+
         return do_div(tcno, nilfs_cpfile_checkpoints_per_block(cpfile));
 }
 
@@ -433,7 +431,8 @@ static void nilfs_cpfile_checkpoint_to_cpinfo(struct inode *cpfile,
 }
 
 static ssize_t nilfs_cpfile_do_get_cpinfo(struct inode *cpfile, __u64 *cnop,
-                                          void *buf, unsigned cisz, size_t nci)
+                                          void *buf, unsigned int cisz,
+                                          size_t nci)
 {
         struct nilfs_checkpoint *cp;
         struct nilfs_cpinfo *ci = buf;
@@ -484,7 +483,8 @@ static ssize_t nilfs_cpfile_do_get_cpinfo(struct inode *cpfile, __u64 *cnop,
 }
 
 static ssize_t nilfs_cpfile_do_get_ssinfo(struct inode *cpfile, __u64 *cnop,
-                                          void *buf, unsigned cisz, size_t nci)
+                                          void *buf, unsigned int cisz,
+                                          size_t nci)
 {
         struct buffer_head *bh;
         struct nilfs_cpfile_header *header;
@@ -570,7 +570,7 @@ static ssize_t nilfs_cpfile_do_get_ssinfo(struct inode *cpfile, __u64 *cnop,
  */
 
 ssize_t nilfs_cpfile_get_cpinfo(struct inode *cpfile, __u64 *cnop, int mode,
-                                void *buf, unsigned cisz, size_t nci)
+                                void *buf, unsigned int cisz, size_t nci)
 {
         switch (mode) {
         case NILFS_CHECKPOINT:
@@ -870,8 +870,10 @@ int nilfs_cpfile_is_snapshot(struct inode *cpfile, __u64 cno)
         void *kaddr;
         int ret;
 
-        /* CP number is invalid if it's zero or larger than the
-        largest exist one.*/
+        /*
+         * CP number is invalid if it's zero or larger than the
+         * largest existing one.
+         */
         if (cno == 0 || cno >= nilfs_mdt_cno(cpfile))
                 return -ENOENT;
         down_read(&NILFS_MDT(cpfile)->mi_sem);
diff --git a/fs/nilfs2/cpfile.h b/fs/nilfs2/cpfile.h
index a242b9a314f9..0249744ae234 100644
--- a/fs/nilfs2/cpfile.h
+++ b/fs/nilfs2/cpfile.h
@@ -13,11 +13,7 @@
  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  * GNU General Public License for more details.
  *
- * You should have received a copy of the GNU General Public License
- * along with this program; if not, write to the Free Software
- * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
- *
- * Written by Koji Sato <koji@osrg.net>.
+ * Written by Koji Sato.
  */
 
 #ifndef _NILFS_CPFILE_H
@@ -37,8 +33,8 @@ int nilfs_cpfile_delete_checkpoint(struct inode *, __u64);
 int nilfs_cpfile_change_cpmode(struct inode *, __u64, int);
 int nilfs_cpfile_is_snapshot(struct inode *, __u64);
 int nilfs_cpfile_get_stat(struct inode *, struct nilfs_cpstat *);
-ssize_t nilfs_cpfile_get_cpinfo(struct inode *, __u64 *, int, void *, unsigned,
-                                size_t);
+ssize_t nilfs_cpfile_get_cpinfo(struct inode *, __u64 *, int, void *,
+                                unsigned int, size_t);
 
 int nilfs_cpfile_read(struct super_block *sb, size_t cpsize,
                       struct nilfs_inode *raw_inode, struct inode **inodep);
diff --git a/fs/nilfs2/dat.c b/fs/nilfs2/dat.c
index 7dc23f100e57..7367610ea807 100644
--- a/fs/nilfs2/dat.c
+++ b/fs/nilfs2/dat.c
@@ -13,11 +13,7 @@
  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  * GNU General Public License for more details.
  *
- * You should have received a copy of the GNU General Public License
- * along with this program; if not, write to the Free Software
- * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
- *
- * Written by Koji Sato <koji@osrg.net>.
+ * Written by Koji Sato.
  */
 
 #include <linux/types.h>
@@ -428,7 +424,7 @@ int nilfs_dat_translate(struct inode *dat, __u64 vblocknr, sector_t *blocknrp)
         return ret;
 }
 
-ssize_t nilfs_dat_get_vinfo(struct inode *dat, void *buf, unsigned visz,
+ssize_t nilfs_dat_get_vinfo(struct inode *dat, void *buf, unsigned int visz,
                             size_t nvi)
 {
         struct buffer_head *entry_bh;
diff --git a/fs/nilfs2/dat.h b/fs/nilfs2/dat.h
index cbd8e9732503..abbfdabcabea 100644
--- a/fs/nilfs2/dat.h
+++ b/fs/nilfs2/dat.h
@@ -13,11 +13,7 @@
  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  * GNU General Public License for more details.
  *
- * You should have received a copy of the GNU General Public License
- * along with this program; if not, write to the Free Software
- * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
- *
- * Written by Koji Sato <koji@osrg.net>.
+ * Written by Koji Sato.
  */
 
 #ifndef _NILFS_DAT_H
@@ -51,7 +47,7 @@ void nilfs_dat_abort_update(struct inode *, struct nilfs_palloc_req *,
 int nilfs_dat_mark_dirty(struct inode *, __u64);
 int nilfs_dat_freev(struct inode *, __u64 *, size_t);
 int nilfs_dat_move(struct inode *, __u64, sector_t);
-ssize_t nilfs_dat_get_vinfo(struct inode *, void *, unsigned, size_t);
+ssize_t nilfs_dat_get_vinfo(struct inode *, void *, unsigned int, size_t);
 
 int nilfs_dat_read(struct super_block *sb, size_t entry_size,
                    struct nilfs_inode *raw_inode, struct inode **inodep);
diff --git a/fs/nilfs2/dir.c b/fs/nilfs2/dir.c
index 6723d45a631a..e506f4f7120a 100644
--- a/fs/nilfs2/dir.c
+++ b/fs/nilfs2/dir.c
@@ -13,11 +13,7 @@
  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  * GNU General Public License for more details.
  *
- * You should have received a copy of the GNU General Public License
- * along with this program; if not, write to the Free Software
- * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
- *
- * Modified for NILFS by Amagai Yoshiji <amagai@osrg.net>
+ * Modified for NILFS by Amagai Yoshiji.
  */
 /*
  *  linux/fs/ext2/dir.c
@@ -50,7 +46,7 @@
  * nilfs uses block-sized chunks. Arguably, sector-sized ones would be
  * more robust, but we have what we have
  */
-static inline unsigned nilfs_chunk_size(struct inode *inode)
+static inline unsigned int nilfs_chunk_size(struct inode *inode)
 {
         return inode->i_sb->s_blocksize;
 }
@@ -65,9 +61,9 @@ static inline void nilfs_put_page(struct page *page)
  * Return the offset into page `page_nr' of the last valid
  * byte in that page, plus one.
  */
-static unsigned nilfs_last_byte(struct inode *inode, unsigned long page_nr)
+static unsigned int nilfs_last_byte(struct inode *inode, unsigned long page_nr)
 {
-        unsigned last_byte = inode->i_size;
+        unsigned int last_byte = inode->i_size;
 
         last_byte -= page_nr << PAGE_SHIFT;
         if (last_byte > PAGE_SIZE)
@@ -75,20 +71,22 @@ static unsigned nilfs_last_byte(struct inode *inode, unsigned long page_nr)
         return last_byte;
 }
 
-static int nilfs_prepare_chunk(struct page *page, unsigned from, unsigned to)
+static int nilfs_prepare_chunk(struct page *page, unsigned int from,
+                               unsigned int to)
 {
         loff_t pos = page_offset(page) + from;
+
         return __block_write_begin(page, pos, to - from, nilfs_get_block);
 }
 
 static void nilfs_commit_chunk(struct page *page,
                                struct address_space *mapping,
-                               unsigned from, unsigned to)
+                               unsigned int from, unsigned int to)
 {
         struct inode *dir = mapping->host;
         loff_t pos = page_offset(page) + from;
-        unsigned len = to - from;
-        unsigned nr_dirty, copied;
+        unsigned int len = to - from;
+        unsigned int nr_dirty, copied;
         int err;
 
         nr_dirty = nilfs_page_count_clean_buffers(page, from, to);
@@ -106,10 +104,10 @@ static bool nilfs_check_page(struct page *page)
 {
         struct inode *dir = page->mapping->host;
         struct super_block *sb = dir->i_sb;
-        unsigned chunk_size = nilfs_chunk_size(dir);
+        unsigned int chunk_size = nilfs_chunk_size(dir);
         char *kaddr = page_address(page);
-        unsigned offs, rec_len;
-        unsigned limit = PAGE_SIZE;
+        unsigned int offs, rec_len;
+        unsigned int limit = PAGE_SIZE;
         struct nilfs_dir_entry *p;
         char *error;
 
@@ -259,7 +257,6 @@ static int nilfs_readdir(struct file *file, struct dir_context *ctx)
         unsigned int offset = pos & ~PAGE_MASK;
         unsigned long n = pos >> PAGE_SHIFT;
         unsigned long npages = dir_pages(inode);
-/*      unsigned chunk_mask = ~(nilfs_chunk_size(inode)-1); */
 
         if (pos > inode->i_size - NILFS_DIR_REC_LEN(1))
                 return 0;
@@ -321,7 +318,7 @@ nilfs_find_entry(struct inode *dir, const struct qstr *qstr,
 {
         const unsigned char *name = qstr->name;
         int namelen = qstr->len;
-        unsigned reclen = NILFS_DIR_REC_LEN(namelen);
+        unsigned int reclen = NILFS_DIR_REC_LEN(namelen);
         unsigned long start, n;
         unsigned long npages = dir_pages(dir);
         struct page *page = NULL;
@@ -340,6 +337,7 @@ nilfs_find_entry(struct inode *dir, const struct qstr *qstr,
         n = start;
         do {
                 char *kaddr;
+
                 page = nilfs_get_page(dir, n);
                 if (!IS_ERR(page)) {
                         kaddr = page_address(page);
@@ -410,8 +408,8 @@ ino_t nilfs_inode_by_name(struct inode *dir, const struct qstr *qstr)
 void nilfs_set_link(struct inode *dir, struct nilfs_dir_entry *de,
                     struct page *page, struct inode *inode)
 {
-        unsigned from = (char *) de - (char *) page_address(page);
-        unsigned to = from + nilfs_rec_len_from_disk(de->rec_len);
+        unsigned int from = (char *)de - (char *)page_address(page);
+        unsigned int to = from + nilfs_rec_len_from_disk(de->rec_len);
         struct address_space *mapping = page->mapping;
         int err;
 
@@ -433,15 +431,15 @@ int nilfs_add_link(struct dentry *dentry, struct inode *inode)
         struct inode *dir = d_inode(dentry->d_parent);
         const unsigned char *name = dentry->d_name.name;
         int namelen = dentry->d_name.len;
-        unsigned chunk_size = nilfs_chunk_size(dir);
-        unsigned reclen = NILFS_DIR_REC_LEN(namelen);
+        unsigned int chunk_size = nilfs_chunk_size(dir);
+        unsigned int reclen = NILFS_DIR_REC_LEN(namelen);
         unsigned short rec_len, name_len;
         struct page *page = NULL;
         struct nilfs_dir_entry *de;
         unsigned long npages = dir_pages(dir);
         unsigned long n;
         char *kaddr;
-        unsigned from, to;
+        unsigned int from, to;
         int err;
 
         /*
@@ -533,13 +531,14 @@ int nilfs_delete_entry(struct nilfs_dir_entry *dir, struct page *page)
         struct address_space *mapping = page->mapping;
         struct inode *inode = mapping->host;
         char *kaddr = page_address(page);
-        unsigned from = ((char *)dir - kaddr) & ~(nilfs_chunk_size(inode) - 1);
-        unsigned to = ((char *)dir - kaddr) +
-                nilfs_rec_len_from_disk(dir->rec_len);
-        struct nilfs_dir_entry *pde = NULL;
-        struct nilfs_dir_entry *de = (struct nilfs_dir_entry *)(kaddr + from);
+        unsigned int from, to;
+        struct nilfs_dir_entry *de, *pde = NULL;
         int err;
 
+        from = ((char *)dir - kaddr) & ~(nilfs_chunk_size(inode) - 1);
+        to = ((char *)dir - kaddr) + nilfs_rec_len_from_disk(dir->rec_len);
+        de = (struct nilfs_dir_entry *)(kaddr + from);
+
         while ((char *)de < (char *)dir) {
                 if (de->rec_len == 0) {
                         nilfs_error(inode->i_sb, __func__,
@@ -572,7 +571,7 @@ int nilfs_make_empty(struct inode *inode, struct inode *parent)
 {
         struct address_space *mapping = inode->i_mapping;
         struct page *page = grab_cache_page(mapping, 0);
-        unsigned chunk_size = nilfs_chunk_size(inode);
+        unsigned int chunk_size = nilfs_chunk_size(inode);
         struct nilfs_dir_entry *de;
         int err;
         void *kaddr;
@@ -630,8 +629,8 @@ int nilfs_empty_dir(struct inode *inode)
                 while ((char *)de <= kaddr) {
                         if (de->rec_len == 0) {
                                 nilfs_error(inode->i_sb, __func__,
-                                            "zero-length directory entry "
-                                            "(kaddr=%p, de=%p)\n", kaddr, de);
+                                            "zero-length directory entry (kaddr=%p, de=%p)",
+                                            kaddr, de);
                                 goto not_empty;
                         }
                         if (de->inode != 0) {
diff --git a/fs/nilfs2/direct.c b/fs/nilfs2/direct.c
index ebf89fd8ac1a..251a44928405 100644
--- a/fs/nilfs2/direct.c
+++ b/fs/nilfs2/direct.c
@@ -13,11 +13,7 @@
  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  * GNU General Public License for more details.
  *
- * You should have received a copy of the GNU General Public License
- * along with this program; if not, write to the Free Software
- * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
- *
- * Written by Koji Sato <koji@osrg.net>.
+ * Written by Koji Sato.
  */
 
 #include <linux/errno.h>
@@ -62,7 +58,7 @@ static int nilfs_direct_lookup(const struct nilfs_bmap *direct,
 
 static int nilfs_direct_lookup_contig(const struct nilfs_bmap *direct,
                                       __u64 key, __u64 *ptrp,
-                                      unsigned maxblocks)
+                                      unsigned int maxblocks)
 {
         struct inode *dat = NULL;
         __u64 ptr, ptr2;
@@ -83,7 +79,8 @@ static int nilfs_direct_lookup_contig(const struct nilfs_bmap *direct,
                 ptr = blocknr;
         }
 
-        maxblocks = min_t(unsigned, maxblocks, NILFS_DIRECT_KEY_MAX - key + 1);
+        maxblocks = min_t(unsigned int, maxblocks,
+                          NILFS_DIRECT_KEY_MAX - key + 1);
         for (cnt = 1; cnt < maxblocks &&
                      (ptr2 = nilfs_direct_get_ptr(direct, key + cnt)) !=
                      NILFS_BMAP_INVALID_PTR;
@@ -110,9 +107,9 @@ nilfs_direct_find_target_v(const struct nilfs_bmap *direct, __u64 key)
         if (ptr != NILFS_BMAP_INVALID_PTR)
                 /* sequential access */
                 return ptr;
-        else
-                /* block group */
-                return nilfs_bmap_find_target_in_group(direct);
+
+        /* block group */
+        return nilfs_bmap_find_target_in_group(direct);
 }
 
 static int nilfs_direct_insert(struct nilfs_bmap *bmap, __u64 key, __u64 ptr)
diff --git a/fs/nilfs2/direct.h b/fs/nilfs2/direct.h
index dc643de20a25..3015a6e78724 100644
--- a/fs/nilfs2/direct.h
+++ b/fs/nilfs2/direct.h
@@ -13,11 +13,7 @@
  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  * GNU General Public License for more details.
  *
- * You should have received a copy of the GNU General Public License
- * along with this program; if not, write to the Free Software
- * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
- *
- * Written by Koji Sato <koji@osrg.net>.
+ * Written by Koji Sato.
  */
 
 #ifndef _NILFS_DIRECT_H
diff --git a/fs/nilfs2/export.h b/fs/nilfs2/export.h
index 19ccbf9522ab..00107fdb9343 100644
--- a/fs/nilfs2/export.h
+++ b/fs/nilfs2/export.h
@@ -20,6 +20,6 @@ struct nilfs_fid {
 
         u32 parent_gen;
         u64 parent_ino;
-} __attribute__ ((packed));
+} __packed;
 
 #endif
diff --git a/fs/nilfs2/file.c b/fs/nilfs2/file.c
index 088ba001c6ef..547381f3ce13 100644
--- a/fs/nilfs2/file.c
+++ b/fs/nilfs2/file.c
@@ -13,12 +13,7 @@
  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  * GNU General Public License for more details.
  *
- * You should have received a copy of the GNU General Public License
- * along with this program; if not, write to the Free Software
- * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
- *
- * Written by Amagai Yoshiji <amagai@osrg.net>,
- *            Ryusuke Konishi <ryusuke@osrg.net>
+ * Written by Amagai Yoshiji and Ryusuke Konishi.
  */
 
 #include <linux/fs.h>
diff --git a/fs/nilfs2/gcinode.c b/fs/nilfs2/gcinode.c
index 0224b7826ace..693aded72498 100644
--- a/fs/nilfs2/gcinode.c
+++ b/fs/nilfs2/gcinode.c
@@ -13,13 +13,8 @@
  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  * GNU General Public License for more details.
  *
- * You should have received a copy of the GNU General Public License
- * along with this program; if not, write to the Free Software
- * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
- *
- * Written by Seiji Kihara <kihara@osrg.net>, Amagai Yoshiji <amagai@osrg.net>,
- *            and Ryusuke Konishi <ryusuke@osrg.net>.
- * Revised by Ryusuke Konishi <ryusuke@osrg.net>.
+ * Written by Seiji Kihara, Amagai Yoshiji, and Ryusuke Konishi.
+ * Revised by Ryusuke Konishi.
  *
  */
 /*
diff --git a/fs/nilfs2/ifile.c b/fs/nilfs2/ifile.c
index 6548c7851b48..1d2b1805327a 100644
--- a/fs/nilfs2/ifile.c
+++ b/fs/nilfs2/ifile.c
@@ -13,12 +13,8 @@
  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  * GNU General Public License for more details.
  *
- * You should have received a copy of the GNU General Public License
- * along with this program; if not, write to the Free Software
- * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
- *
- * Written by Amagai Yoshiji <amagai@osrg.net>.
- * Revised by Ryusuke Konishi <ryusuke@osrg.net>.
+ * Written by Amagai Yoshiji.
+ * Revised by Ryusuke Konishi.
  *
  */
 
@@ -68,8 +64,10 @@ int nilfs_ifile_create_inode(struct inode *ifile, ino_t *out_ino,
         struct nilfs_palloc_req req;
         int ret;
 
-        req.pr_entry_nr = 0;  /* 0 says find free inode from beginning of
-                                 a group. dull code!! */
+        req.pr_entry_nr = 0;  /*
+                               * 0 says find free inode from beginning
+                               * of a group. dull code!!
+                               */
         req.pr_entry_bh = NULL;
 
         ret = nilfs_palloc_prepare_alloc_entry(ifile, &req);
diff --git a/fs/nilfs2/ifile.h b/fs/nilfs2/ifile.h
index 679674d13372..23ad2f091e76 100644
--- a/fs/nilfs2/ifile.h
+++ b/fs/nilfs2/ifile.h
@@ -13,12 +13,8 @@
  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  * GNU General Public License for more details.
  *
- * You should have received a copy of the GNU General Public License
- * along with this program; if not, write to the Free Software
- * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
- *
- * Written by Amagai Yoshiji <amagai@osrg.net>
- * Revised by Ryusuke Konishi <ryusuke@osrg.net>
+ * Written by Amagai Yoshiji.
+ * Revised by Ryusuke Konishi.
  *
  */
 
@@ -36,6 +32,7 @@ static inline struct nilfs_inode *
 nilfs_ifile_map_inode(struct inode *ifile, ino_t ino, struct buffer_head *ibh)
 {
         void *kaddr = kmap(ibh->b_page);
+
         return nilfs_palloc_block_get_entry(ifile, ino, ibh, kaddr);
 }
 
diff --git a/fs/nilfs2/inode.c b/fs/nilfs2/inode.c
index cfebcd2fc7f3..a0ebdb17e912 100644
--- a/fs/nilfs2/inode.c
+++ b/fs/nilfs2/inode.c
@@ -13,11 +13,7 @@
  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  * GNU General Public License for more details.
  *
- * You should have received a copy of the GNU General Public License
- * along with this program; if not, write to the Free Software
- * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
- *
- * Written by Ryusuke Konishi <ryusuke@osrg.net>
+ * Written by Ryusuke Konishi.
  *
  */
 
@@ -87,7 +83,7 @@ int nilfs_get_block(struct inode *inode, sector_t blkoff,
         struct the_nilfs *nilfs = inode->i_sb->s_fs_info;
         __u64 blknum = 0;
         int err = 0, ret;
-        unsigned maxblocks = bh_result->b_size >> inode->i_blkbits;
+        unsigned int maxblocks = bh_result->b_size >> inode->i_blkbits;
 
         down_read(&NILFS_MDT(nilfs->ns_dat)->mi_sem);
         ret = nilfs_bmap_lookup_contig(ii->i_bmap, blkoff, &blknum, maxblocks);
@@ -133,11 +129,14 @@ int nilfs_get_block(struct inode *inode, sector_t blkoff,
                 /* Error handling should be detailed */
                 set_buffer_new(bh_result);
                 set_buffer_delay(bh_result);
-                map_bh(bh_result, inode->i_sb, 0); /* dbn must be changed
-                                                      to proper value */
+                map_bh(bh_result, inode->i_sb, 0);
+                /* Disk block number must be changed to proper value */
+
         } else if (ret == -ENOENT) {
-                /* not found is not error (e.g. hole); must return without
-                   the mapped state flag. */
+                /*
+                 * not found is not error (e.g. hole); must return without
+                 * the mapped state flag.
+                 */
                 ;
         } else {
                 err = ret;
@@ -167,7 +166,7 @@ static int nilfs_readpage(struct file *file, struct page *page)
  * @nr_pages - number of pages to be read
  */
 static int nilfs_readpages(struct file *file, struct address_space *mapping,
-                           struct list_head *pages, unsigned nr_pages)
+                           struct list_head *pages, unsigned int nr_pages)
 {
         return mpage_readpages(mapping, pages, nr_pages, nilfs_get_block);
 }
@@ -226,7 +225,7 @@ static int nilfs_set_page_dirty(struct page *page)
         int ret = __set_page_dirty_nobuffers(page);
 
         if (page_has_buffers(page)) {
-                unsigned nr_dirty = 0;
+                unsigned int nr_dirty = 0;
                 struct buffer_head *bh, *head;
 
                 /*
@@ -249,7 +248,7 @@ static int nilfs_set_page_dirty(struct page *page)
                 if (nr_dirty)
                         nilfs_set_file_dirty(inode, nr_dirty);
         } else if (ret) {
-                unsigned nr_dirty = 1 << (PAGE_SHIFT - inode->i_blkbits);
+                unsigned int nr_dirty = 1 << (PAGE_SHIFT - inode->i_blkbits);
 
                 nilfs_set_file_dirty(inode, nr_dirty);
         }
@@ -291,8 +290,8 @@ static int nilfs_write_end(struct file *file, struct address_space *mapping,
                            struct page *page, void *fsdata)
 {
         struct inode *inode = mapping->host;
-        unsigned start = pos & (PAGE_SIZE - 1);
-        unsigned nr_dirty;
+        unsigned int start = pos & (PAGE_SIZE - 1);
+        unsigned int nr_dirty;
         int err;
 
         nr_dirty = nilfs_page_count_clean_buffers(page, start,
@@ -399,23 +398,26 @@ struct inode *nilfs_new_inode(struct inode *dir, umode_t mode)
 
         err = nilfs_init_acl(inode, dir);
         if (unlikely(err))
-                goto failed_after_creation; /* never occur. When supporting
-                                    nilfs_init_acl(), proper cancellation of
-                                    above jobs should be considered */
+                /*
+                 * Never occur.  When supporting nilfs_init_acl(),
+                 * proper cancellation of above jobs should be considered.
+                 */
+                goto failed_after_creation;
 
         return inode;
 
  failed_after_creation:
         clear_nlink(inode);
         unlock_new_inode(inode);
-        iput(inode);  /* raw_inode will be deleted through
-                         nilfs_evict_inode() */
+        iput(inode);  /*
+                       * raw_inode will be deleted through
+                       * nilfs_evict_inode().
+                       */
         goto failed;
 
  failed_ifile_create_inode:
         make_bad_inode(inode);
-        iput(inode);  /* if i_nlink == 1, generic_forget_inode() will be
-                         called */
+        iput(inode);
  failed:
         return ERR_PTR(err);
 }
@@ -666,8 +668,10 @@ void nilfs_write_inode_common(struct inode *inode,
         else if (S_ISCHR(inode->i_mode) || S_ISBLK(inode->i_mode))
                 raw_inode->i_device_code =
                         cpu_to_le64(huge_encode_dev(inode->i_rdev));
-        /* When extending inode, nilfs->ns_inode_size should be checked
-           for substitutions of appended fields */
+        /*
+         * When extending inode, nilfs->ns_inode_size should be checked
+         * for substitutions of appended fields.
+         */
 }
 
 void nilfs_update_inode(struct inode *inode, struct buffer_head *ibh, int flags)
@@ -685,9 +689,12 @@ void nilfs_update_inode(struct inode *inode, struct buffer_head *ibh, int flags)
                 set_bit(NILFS_I_INODE_SYNC, &ii->i_state);
 
         nilfs_write_inode_common(inode, raw_inode, 0);
-                /* XXX: call with has_bmap = 0 is a workaround to avoid
-                   deadlock of bmap. This delays update of i_bmap to just
-                   before writing */
+                /*
+                 * XXX: call with has_bmap = 0 is a workaround to avoid
+                 * deadlock of bmap.  This delays update of i_bmap to just
+                 * before writing.
+                 */
+
         nilfs_ifile_unmap_inode(ifile, ino, ibh);
 }
 
@@ -752,14 +759,15 @@ void nilfs_truncate(struct inode *inode)
         nilfs_mark_inode_dirty(inode);
         nilfs_set_file_dirty(inode, 0);
         nilfs_transaction_commit(sb);
-        /* May construct a logical segment and may fail in sync mode.
-           But truncate has no return value. */
+        /*
+         * May construct a logical segment and may fail in sync mode.
+         * But truncate has no return value.
+         */
 }
 
 static void nilfs_clear_inode(struct inode *inode)
 {
         struct nilfs_inode_info *ii = NILFS_I(inode);
-        struct nilfs_mdt_info *mdi = NILFS_MDT(inode);
 
         /*
          * Free resources allocated in nilfs_read_inode(), here.
@@ -768,8 +776,8 @@ static void nilfs_clear_inode(struct inode *inode)
         brelse(ii->i_bh);
         ii->i_bh = NULL;
 
-        if (mdi && mdi->mi_palloc_cache)
-                nilfs_palloc_destroy_cache(inode);
+        if (nilfs_is_metadata_file_inode(inode))
+                nilfs_mdt_clear(inode);
 
         if (test_bit(NILFS_I_BMAP, &ii->i_state))
                 nilfs_bmap_clear(ii->i_bmap);
@@ -811,8 +819,10 @@ void nilfs_evict_inode(struct inode *inode)
         if (IS_SYNC(inode))
                 nilfs_set_transaction_flag(NILFS_TI_SYNC);
         nilfs_transaction_commit(sb);
-        /* May construct a logical segment and may fail in sync mode.
-           But delete_inode has no return value. */
+        /*
+         * May construct a logical segment and may fail in sync mode.
+         * But delete_inode has no return value.
+         */
 }
 
 int nilfs_setattr(struct dentry *dentry, struct iattr *iattr)
@@ -856,6 +866,7 @@ out_err:
 int nilfs_permission(struct inode *inode, int mask)
 {
         struct nilfs_root *root = NILFS_I(inode)->i_root;
+
         if ((mask & MAY_WRITE) && root &&
             root->cno != NILFS_CPTREE_CURRENT_CNO)
                 return -EROFS; /* snapshot is not writable */
@@ -906,7 +917,7 @@ int nilfs_inode_dirty(struct inode *inode)
         return ret;
 }
 
-int nilfs_set_file_dirty(struct inode *inode, unsigned nr_dirty)
+int nilfs_set_file_dirty(struct inode *inode, unsigned int nr_dirty)
 {
         struct nilfs_inode_info *ii = NILFS_I(inode);
         struct the_nilfs *nilfs = inode->i_sb->s_fs_info;
@@ -919,17 +930,23 @@ int nilfs_set_file_dirty(struct inode *inode, unsigned nr_dirty)
         spin_lock(&nilfs->ns_inode_lock);
         if (!test_bit(NILFS_I_QUEUED, &ii->i_state) &&
             !test_bit(NILFS_I_BUSY, &ii->i_state)) {
-                /* Because this routine may race with nilfs_dispose_list(),
-                   we have to check NILFS_I_QUEUED here, too. */
+                /*
+                 * Because this routine may race with nilfs_dispose_list(),
+                 * we have to check NILFS_I_QUEUED here, too.
+                 */
                 if (list_empty(&ii->i_dirty) && igrab(inode) == NULL) {
-                        /* This will happen when somebody is freeing
-                           this inode. */
+                        /*
+                         * This will happen when somebody is freeing
+                         * this inode.
+                         */
                         nilfs_warning(inode->i_sb, __func__,
-                                      "cannot get inode (ino=%lu)\n",
+                                      "cannot get inode (ino=%lu)",
                                       inode->i_ino);
                         spin_unlock(&nilfs->ns_inode_lock);
-                        return -EINVAL; /* NILFS_I_DIRTY may remain for
-                                           freeing inode */
+                        return -EINVAL; /*
+                                         * NILFS_I_DIRTY may remain for
+                                         * freeing inode.
+                                         */
                 }
                 list_move_tail(&ii->i_dirty, &nilfs->ns_dirty_files);
                 set_bit(NILFS_I_QUEUED, &ii->i_state);
@@ -946,7 +963,7 @@ int __nilfs_mark_inode_dirty(struct inode *inode, int flags)
         err = nilfs_load_inode_block(inode, &ibh);
         if (unlikely(err)) {
                 nilfs_warning(inode->i_sb, __func__,
-                              "failed to reget inode block.\n");
+                              "failed to reget inode block.");
                 return err;
         }
         nilfs_update_inode(inode, ibh, flags);
@@ -973,7 +990,7 @@ void nilfs_dirty_inode(struct inode *inode, int flags)
 
         if (is_bad_inode(inode)) {
                 nilfs_warning(inode->i_sb, __func__,
-                              "tried to mark bad_inode dirty. ignored.\n");
+                              "tried to mark bad_inode dirty. ignored.");
                 dump_stack();
                 return;
         }
diff --git a/fs/nilfs2/ioctl.c b/fs/nilfs2/ioctl.c
index e8fe24882b5b..358b57e2cdf9 100644
--- a/fs/nilfs2/ioctl.c
+++ b/fs/nilfs2/ioctl.c
@@ -13,11 +13,7 @@
  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  * GNU General Public License for more details.
  *
- * You should have received a copy of the GNU General Public License
- * along with this program; if not, write to the Free Software
- * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
- *
- * Written by Koji Sato <koji@osrg.net>.
+ * Written by Koji Sato.
  */
 
 #include <linux/fs.h>
@@ -783,6 +779,7 @@ static int nilfs_ioctl_mark_blocks_dirty(struct the_nilfs *nilfs,
         size_t nmembs = argv->v_nmembs;
         struct nilfs_bmap *bmap = NILFS_I(nilfs->ns_dat)->i_bmap;
         struct nilfs_bdesc *bdescs = buf;
+        struct buffer_head *bh;
         int ret, i;
 
         for (i = 0; i < nmembs; i++) {
@@ -800,12 +797,16 @@ static int nilfs_ioctl_mark_blocks_dirty(struct the_nilfs *nilfs,
                         /* skip dead block */
                         continue;
                 if (bdescs[i].bd_level == 0) {
-                        ret = nilfs_mdt_mark_block_dirty(nilfs->ns_dat,
-                                                         bdescs[i].bd_offset);
-                        if (ret < 0) {
+                        ret = nilfs_mdt_get_block(nilfs->ns_dat,
+                                                  bdescs[i].bd_offset,
+                                                  false, NULL, &bh);
+                        if (unlikely(ret)) {
                                 WARN_ON(ret == -ENOENT);
                                 return ret;
                         }
+                        mark_buffer_dirty(bh);
+                        nilfs_mdt_mark_dirty(nilfs->ns_dat);
+                        put_bh(bh);
                 } else {
                         ret = nilfs_bmap_mark(bmap, bdescs[i].bd_offset,
                                               bdescs[i].bd_level);
diff --git a/fs/nilfs2/mdt.c b/fs/nilfs2/mdt.c
index f6982b9153d5..3417d859a03c 100644
--- a/fs/nilfs2/mdt.c
+++ b/fs/nilfs2/mdt.c
@@ -13,11 +13,7 @@
  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  * GNU General Public License for more details.
  *
- * You should have received a copy of the GNU General Public License
- * along with this program; if not, write to the Free Software
- * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
- *
- * Written by Ryusuke Konishi <ryusuke@osrg.net>
+ * Written by Ryusuke Konishi.
  */
 
 #include <linux/buffer_head.h>
@@ -32,6 +28,7 @@
 #include "segment.h"
 #include "page.h"
 #include "mdt.h"
+#include "alloc.h"              /* nilfs_palloc_destroy_cache() */
 
 #include <trace/events/nilfs2.h>
 
@@ -393,34 +390,6 @@ int nilfs_mdt_forget_block(struct inode *inode, unsigned long block)
         return ret;
 }
 
-/**
- * nilfs_mdt_mark_block_dirty - mark a block on the meta data file dirty.
- * @inode: inode of the meta data file
- * @block: block offset
- *
- * Return Value: On success, it returns 0. On error, the following negative
- * error code is returned.
- *
- * %-ENOMEM - Insufficient memory available.
- *
- * %-EIO - I/O error
- *
- * %-ENOENT - the specified block does not exist (hole block)
- */
-int nilfs_mdt_mark_block_dirty(struct inode *inode, unsigned long block)
-{
-        struct buffer_head *bh;
-        int err;
-
-        err = nilfs_mdt_read_block(inode, block, 0, &bh);
-        if (unlikely(err))
-                return err;
-        mark_buffer_dirty(bh);
-        nilfs_mdt_mark_dirty(inode);
-        brelse(bh);
-        return 0;
-}
-
 int nilfs_mdt_fetch_dirty(struct inode *inode)
 {
         struct nilfs_inode_info *ii = NILFS_I(inode);
@@ -497,8 +466,32 @@ int nilfs_mdt_init(struct inode *inode, gfp_t gfp_mask, size_t objsz)
         return 0;
 }
 
-void nilfs_mdt_set_entry_size(struct inode *inode, unsigned entry_size,
-                              unsigned header_size)
+/**
+ * nilfs_mdt_clear - do cleanup for the metadata file
+ * @inode: inode of the metadata file
+ */
+void nilfs_mdt_clear(struct inode *inode)
+{
+        struct nilfs_mdt_info *mdi = NILFS_MDT(inode);
+
+        if (mdi->mi_palloc_cache)
+                nilfs_palloc_destroy_cache(inode);
+}
+
+/**
+ * nilfs_mdt_destroy - release resources used by the metadata file
+ * @inode: inode of the metadata file
+ */
+void nilfs_mdt_destroy(struct inode *inode)
+{
+        struct nilfs_mdt_info *mdi = NILFS_MDT(inode);
+
+        kfree(mdi->mi_bgl); /* kfree(NULL) is safe */
+        kfree(mdi);
+}
+
+void nilfs_mdt_set_entry_size(struct inode *inode, unsigned int entry_size,
+                              unsigned int header_size)
 {
         struct nilfs_mdt_info *mi = NILFS_MDT(inode);
 
diff --git a/fs/nilfs2/mdt.h b/fs/nilfs2/mdt.h
index 03246cac3338..3f67f3932097 100644
--- a/fs/nilfs2/mdt.h
+++ b/fs/nilfs2/mdt.h
@@ -13,11 +13,7 @@
  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  * GNU General Public License for more details.
  *
- * You should have received a copy of the GNU General Public License
- * along with this program; if not, write to the Free Software
- * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
- *
- * Written by Ryusuke Konishi <ryusuke@osrg.net>
+ * Written by Ryusuke Konishi.
  */
 
 #ifndef _NILFS_MDT_H
@@ -57,8 +53,8 @@ struct nilfs_shadow_map {
 struct nilfs_mdt_info {
         struct rw_semaphore     mi_sem;
         struct blockgroup_lock *mi_bgl;
-        unsigned                mi_entry_size;
-        unsigned                mi_first_entry_offset;
+        unsigned int            mi_entry_size;
+        unsigned int            mi_first_entry_offset;
         unsigned long           mi_entries_per_block;
         struct nilfs_palloc_cache *mi_palloc_cache;
         struct nilfs_shadow_map *mi_shadow;
@@ -71,6 +67,11 @@ static inline struct nilfs_mdt_info *NILFS_MDT(const struct inode *inode)
         return inode->i_private;
 }
 
+static inline int nilfs_is_metadata_file_inode(const struct inode *inode)
+{
+        return inode->i_private != NULL;
+}
+
 /* Default GFP flags using highmem */
 #define NILFS_MDT_GFP      (__GFP_RECLAIM | __GFP_IO | __GFP_HIGHMEM)
 
@@ -83,11 +84,13 @@ int nilfs_mdt_find_block(struct inode *inode, unsigned long start,
                          struct buffer_head **out_bh);
 int nilfs_mdt_delete_block(struct inode *, unsigned long);
 int nilfs_mdt_forget_block(struct inode *, unsigned long);
-int nilfs_mdt_mark_block_dirty(struct inode *, unsigned long);
 int nilfs_mdt_fetch_dirty(struct inode *);
 
 int nilfs_mdt_init(struct inode *inode, gfp_t gfp_mask, size_t objsz);
-void nilfs_mdt_set_entry_size(struct inode *, unsigned, unsigned);
+void nilfs_mdt_clear(struct inode *inode);
+void nilfs_mdt_destroy(struct inode *inode);
+
+void nilfs_mdt_set_entry_size(struct inode *, unsigned int, unsigned int);
 
 int nilfs_mdt_setup_shadow_map(struct inode *inode,
                                struct nilfs_shadow_map *shadow);
diff --git a/fs/nilfs2/namei.c b/fs/nilfs2/namei.c
index 3b2af05f9fb4..1ec8ae5995a5 100644
--- a/fs/nilfs2/namei.c
+++ b/fs/nilfs2/namei.c
@@ -13,12 +13,7 @@
  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  * GNU General Public License for more details.
  *
- * You should have received a copy of the GNU General Public License
- * along with this program; if not, write to the Free Software
- * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
- *
- * Modified for NILFS by Amagai Yoshiji <amagai@osrg.net>,
- *                       Ryusuke Konishi <ryusuke@osrg.net>
+ * Modified for NILFS by Amagai Yoshiji and Ryusuke Konishi.
  */
 /*
  *  linux/fs/ext2/namei.c
@@ -49,6 +44,7 @@
 static inline int nilfs_add_nondir(struct dentry *dentry, struct inode *inode)
 {
         int err = nilfs_add_link(dentry, inode);
+
         if (!err) {
                 d_instantiate(dentry, inode);
                 unlock_new_inode(inode);
@@ -143,7 +139,7 @@ static int nilfs_symlink(struct inode *dir, struct dentry *dentry,
 {
         struct nilfs_transaction_info ti;
         struct super_block *sb = dir->i_sb;
-        unsigned l = strlen(symname)+1;
+        unsigned int l = strlen(symname) + 1;
         struct inode *inode;
         int err;
 
@@ -288,7 +284,7 @@ static int nilfs_do_unlink(struct inode *dir, struct dentry *dentry)
 
         if (!inode->i_nlink) {
                 nilfs_warning(inode->i_sb, __func__,
-                              "deleting nonexistent file (%lu), %d\n",
+                              "deleting nonexistent file (%lu), %d",
                               inode->i_ino, inode->i_nlink);
                 set_nlink(inode, 1);
         }
diff --git a/fs/nilfs2/nilfs.h b/fs/nilfs2/nilfs.h
index 385704027575..b1d48bc0532d 100644
--- a/fs/nilfs2/nilfs.h
+++ b/fs/nilfs2/nilfs.h
@@ -13,12 +13,7 @@
  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  * GNU General Public License for more details.
  *
- * You should have received a copy of the GNU General Public License
- * along with this program; if not, write to the Free Software
- * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
- *
- * Written by Koji Sato <koji@osrg.net>
- *            Ryusuke Konishi <ryusuke@osrg.net>
+ * Written by Koji Sato and Ryusuke Konishi.
  */
 
 #ifndef _NILFS_H
@@ -69,8 +64,10 @@ struct nilfs_inode_info {
          */
         struct rw_semaphore xattr_sem;
 #endif
-        struct buffer_head *i_bh;       /* i_bh contains a new or dirty
-                                           disk inode */
+        struct buffer_head *i_bh;       /*
+                                         * i_bh contains a new or dirty
+                                         * disk inode.
+                                         */
         struct nilfs_root *i_root;
         struct inode vfs_inode;
 };
@@ -100,8 +97,10 @@ enum {
         NILFS_I_NEW = 0,                /* Inode is newly created */
         NILFS_I_DIRTY,                  /* The file is dirty */
         NILFS_I_QUEUED,                 /* inode is in dirty_files list */
-        NILFS_I_BUSY,                   /* inode is grabbed by a segment
-                                           constructor */
+        NILFS_I_BUSY,                   /*
+                                         * Inode is grabbed by a segment
+                                         * constructor
+                                         */
         NILFS_I_COLLECTED,              /* All dirty blocks are collected */
         NILFS_I_UPDATED,                /* The file has been written back */
         NILFS_I_INODE_SYNC,             /* dsync is not allowed for inode */
@@ -145,8 +144,10 @@ enum {
 struct nilfs_transaction_info {
         u32                     ti_magic;
         void                   *ti_save;
-                                /* This should never used. If this happens,
-                                   one of other filesystems has a bug. */
+                                /*
+                                 * This should never be used.  If it happens,
+                                 * one of other filesystems has a bug.
+                                 */
         unsigned short          ti_flags;
         unsigned short          ti_count;
 };
@@ -156,8 +157,10 @@ struct nilfs_transaction_info {
 
 /* ti_flags */
 #define NILFS_TI_DYNAMIC_ALLOC  0x0001  /* Allocated from slab */
-#define NILFS_TI_SYNC           0x0002  /* Force to construct segment at the
-                                           end of transaction. */
+#define NILFS_TI_SYNC           0x0002  /*
+                                         * Force to construct segment at the
+                                         * end of transaction.
+                                         */
 #define NILFS_TI_GC             0x0004  /* GC context */
 #define NILFS_TI_COMMIT         0x0008  /* Change happened or not */
 #define NILFS_TI_WRITER         0x0010  /* Constructor context */
@@ -279,7 +282,7 @@ extern void nilfs_write_failed(struct address_space *mapping, loff_t to);
 int nilfs_permission(struct inode *inode, int mask);
 int nilfs_load_inode_block(struct inode *inode, struct buffer_head **pbh);
 extern int nilfs_inode_dirty(struct inode *);
-int nilfs_set_file_dirty(struct inode *inode, unsigned nr_dirty);
+int nilfs_set_file_dirty(struct inode *inode, unsigned int nr_dirty);
 extern int __nilfs_mark_inode_dirty(struct inode *, int);
 extern void nilfs_dirty_inode(struct inode *, int flags);
 int nilfs_fiemap(struct inode *inode, struct fiemap_extent_info *fieinfo,
diff --git a/fs/nilfs2/page.c b/fs/nilfs2/page.c
index 489391561cda..d97ba5f11b77 100644
--- a/fs/nilfs2/page.c
+++ b/fs/nilfs2/page.c
@@ -13,12 +13,7 @@
  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  * GNU General Public License for more details.
  *
- * You should have received a copy of the GNU General Public License
- * along with this program; if not, write to the Free Software
- * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
- *
- * Written by Ryusuke Konishi <ryusuke@osrg.net>,
- *            Seiji Kihara <kihara@osrg.net>.
+ * Written by Ryusuke Konishi and Seiji Kihara.
  */
 
 #include <linux/pagemap.h>
@@ -440,12 +435,12 @@ void nilfs_clear_dirty_page(struct page *page, bool silent)
         __nilfs_clear_page_dirty(page);
 }
 
-unsigned nilfs_page_count_clean_buffers(struct page *page,
-                                        unsigned from, unsigned to)
+unsigned int nilfs_page_count_clean_buffers(struct page *page,
+                                            unsigned int from, unsigned int to)
 {
-        unsigned block_start, block_end;
+        unsigned int block_start, block_end;
         struct buffer_head *bh, *head;
-        unsigned nc = 0;
+        unsigned int nc = 0;
 
         for (bh = head = page_buffers(page), block_start = 0;
              bh != head || !block_start;
diff --git a/fs/nilfs2/page.h b/fs/nilfs2/page.h
index a43b8287d012..f3687c958fa8 100644
--- a/fs/nilfs2/page.h
+++ b/fs/nilfs2/page.h
@@ -13,12 +13,7 @@
  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  * GNU General Public License for more details.
  *
- * You should have received a copy of the GNU General Public License
- * along with this program; if not, write to the Free Software
- * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
- *
- * Written by Ryusuke Konishi <ryusuke@osrg.net>,
- *            Seiji Kihara <kihara@osrg.net>.
+ * Written by Ryusuke Konishi and Seiji Kihara.
  */
 
 #ifndef _NILFS_PAGE_H
@@ -58,7 +53,8 @@ void nilfs_copy_back_pages(struct address_space *, struct address_space *);
 void nilfs_clear_dirty_page(struct page *, bool);
 void nilfs_clear_dirty_pages(struct address_space *, bool);
 void nilfs_mapping_init(struct address_space *mapping, struct inode *inode);
-unsigned nilfs_page_count_clean_buffers(struct page *, unsigned, unsigned);
+unsigned int nilfs_page_count_clean_buffers(struct page *, unsigned int,
+                                            unsigned int);
 unsigned long nilfs_find_uncommitted_extent(struct inode *inode,
                                             sector_t start_blk,
                                             sector_t *blkoff);
diff --git a/fs/nilfs2/recovery.c b/fs/nilfs2/recovery.c
index 5afa77fadc11..d893dc912b62 100644
--- a/fs/nilfs2/recovery.c
+++ b/fs/nilfs2/recovery.c
@@ -13,11 +13,7 @@
  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  * GNU General Public License for more details.
  *
- * You should have received a copy of the GNU General Public License
- * along with this program; if not, write to the Free Software
- * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
- *
- * Written by Ryusuke Konishi <ryusuke@osrg.net>
+ * Written by Ryusuke Konishi.
  */
 
 #include <linux/buffer_head.h>
@@ -47,8 +43,10 @@ enum {
 
 /* work structure for recovery */
 struct nilfs_recovery_block {
-        ino_t ino;              /* Inode number of the file that this block
-                                   belongs to */
+        ino_t ino;              /*
+                                 * Inode number of the file that this block
+                                 * belongs to
+                                 */
         sector_t blocknr;       /* block number */
         __u64 vblocknr;         /* virtual block number */
         unsigned long blkoff;   /* File offset of the data block (per block) */
@@ -156,7 +154,7 @@ int nilfs_read_super_root_block(struct the_nilfs *nilfs, sector_t sr_block,
 
         sr = (struct nilfs_super_root *)bh_sr->b_data;
         if (check) {
-                unsigned bytes = le16_to_cpu(sr->sr_bytes);
+                unsigned int bytes = le16_to_cpu(sr->sr_bytes);
 
                 if (bytes == 0 || bytes > nilfs->ns_blocksize) {
                         ret = NILFS_SEG_FAIL_CHECKSUM_SUPER_ROOT;
@@ -508,7 +506,7 @@ static int nilfs_recover_dsync_blocks(struct the_nilfs *nilfs,
 {
         struct inode *inode;
         struct nilfs_recovery_block *rb, *n;
-        unsigned blocksize = nilfs->ns_blocksize;
+        unsigned int blocksize = nilfs->ns_blocksize;
         struct page *page;
         loff_t pos;
         int err = 0, err2 = 0;
@@ -526,6 +524,7 @@ static int nilfs_recover_dsync_blocks(struct the_nilfs *nilfs,
                                         0, &page, nilfs_get_block);
                 if (unlikely(err)) {
                         loff_t isize = inode->i_size;
+
                         if (pos + blocksize > isize)
                                 nilfs_write_failed(inode->i_mapping,
                                                         pos + blocksize);
@@ -872,9 +871,11 @@ int nilfs_search_super_root(struct the_nilfs *nilfs,
 
                 flags = le16_to_cpu(sum->ss_flags);
                 if (!(flags & NILFS_SS_SR) && !scan_newer) {
-                        /* This will never happen because a superblock
-                           (last_segment) always points to a pseg
-                           having a super root. */
+                        /*
+                         * This will never happen because a superblock
+                         * (last_segment) always points to a pseg with
+                         * a super root.
+                         */
                         ret = NILFS_SEG_FAIL_CONSISTENCY;
                         goto failed;
                 }
diff --git a/fs/nilfs2/segbuf.c b/fs/nilfs2/segbuf.c
index f63620ce3892..bf36df10540b 100644
--- a/fs/nilfs2/segbuf.c
+++ b/fs/nilfs2/segbuf.c
@@ -13,11 +13,7 @@
  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  * GNU General Public License for more details.
  *
- * You should have received a copy of the GNU General Public License
- * along with this program; if not, write to the Free Software
- * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
- *
- * Written by Ryusuke Konishi <ryusuke@osrg.net>
+ * Written by Ryusuke Konishi.
  *
  */
 
@@ -133,7 +129,7 @@ int nilfs_segbuf_extend_payload(struct nilfs_segment_buffer *segbuf,
         return 0;
 }
 
-int nilfs_segbuf_reset(struct nilfs_segment_buffer *segbuf, unsigned flags,
+int nilfs_segbuf_reset(struct nilfs_segment_buffer *segbuf, unsigned int flags,
                        time_t ctime, __u64 cno)
 {
         int err;
@@ -240,7 +236,7 @@ nilfs_segbuf_fill_in_super_root_crc(struct nilfs_segment_buffer *segbuf,
 {
         struct nilfs_super_root *raw_sr;
         struct the_nilfs *nilfs = segbuf->sb_super->s_fs_info;
-        unsigned srsize;
+        unsigned int srsize;
         u32 crc;
 
         raw_sr = (struct nilfs_super_root *)segbuf->sb_super_root->b_data;
diff --git a/fs/nilfs2/segbuf.h b/fs/nilfs2/segbuf.h
index b04f08cc2397..7bbccc099709 100644
--- a/fs/nilfs2/segbuf.h
+++ b/fs/nilfs2/segbuf.h
@@ -13,11 +13,7 @@
  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  * GNU General Public License for more details.
  *
- * You should have received a copy of the GNU General Public License
- * along with this program; if not, write to the Free Software
- * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
- *
- * Written by Ryusuke Konishi <ryusuke@osrg.net>
+ * Written by Ryusuke Konishi.
  *
  */
 #ifndef _NILFS_SEGBUF_H
@@ -82,7 +78,7 @@ struct nilfs_segment_buffer {
         __u64                   sb_nextnum;
         sector_t                sb_fseg_start, sb_fseg_end;
         sector_t                sb_pseg_start;
-        unsigned                sb_rest_blocks;
+        unsigned int            sb_rest_blocks;
 
         /* Buffers */
         struct list_head        sb_segsum_buffers;
@@ -124,7 +120,8 @@ void nilfs_segbuf_map_cont(struct nilfs_segment_buffer *segbuf,
                            struct nilfs_segment_buffer *prev);
 void nilfs_segbuf_set_next_segnum(struct nilfs_segment_buffer *, __u64,
                                   struct the_nilfs *);
-int nilfs_segbuf_reset(struct nilfs_segment_buffer *, unsigned, time_t, __u64);
+int nilfs_segbuf_reset(struct nilfs_segment_buffer *, unsigned int, time_t,
+                       __u64);
 int nilfs_segbuf_extend_segsum(struct nilfs_segment_buffer *);
 int nilfs_segbuf_extend_payload(struct nilfs_segment_buffer *,
                                 struct buffer_head **);
diff --git a/fs/nilfs2/segment.c b/fs/nilfs2/segment.c
index 4317f72568e6..e78b68a81aec 100644
--- a/fs/nilfs2/segment.c
+++ b/fs/nilfs2/segment.c
@@ -13,11 +13,7 @@
  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  * GNU General Public License for more details.
  *
- * You should have received a copy of the GNU General Public License
- * along with this program; if not, write to the Free Software
- * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
- *
- * Written by Ryusuke Konishi <ryusuke@osrg.net>
+ * Written by Ryusuke Konishi.
  *
  */
 
@@ -49,18 +45,26 @@
  */
 #define SC_N_INODEVEC   16   /* Size of locally allocated inode vector */
 
-#define SC_MAX_SEGDELTA 64   /* Upper limit of the number of segments
-                                appended in collection retry loop */
+#define SC_MAX_SEGDELTA 64   /*
+                              * Upper limit of the number of segments
+                              * appended in collection retry loop
+                              */
 
 /* Construction mode */
 enum {
         SC_LSEG_SR = 1, /* Make a logical segment having a super root */
-        SC_LSEG_DSYNC,  /* Flush data blocks of a given file and make
-                           a logical segment without a super root */
-        SC_FLUSH_FILE,  /* Flush data files, leads to segment writes without
-                           creating a checkpoint */
-        SC_FLUSH_DAT,   /* Flush DAT file. This also creates segments without
-                           a checkpoint */
+        SC_LSEG_DSYNC,  /*
+                         * Flush data blocks of a given file and make
+                         * a logical segment without a super root.
+                         */
+        SC_FLUSH_FILE,  /*
+                         * Flush data files, leads to segment writes without
+                         * creating a checkpoint.
+                         */
+        SC_FLUSH_DAT,   /*
+                         * Flush DAT file.  This also creates segments
+                         * without a checkpoint.
+                         */
 };
 
 /* Stage numbers of dirty block collection */
@@ -154,17 +158,15 @@ static int nilfs_prepare_segment_lock(struct nilfs_transaction_info *ti)
         if (cur_ti) {
                 if (cur_ti->ti_magic == NILFS_TI_MAGIC)
                         return ++cur_ti->ti_count;
-                else {
-                        /*
-                         * If journal_info field is occupied by other FS,
-                         * it is saved and will be restored on
-                         * nilfs_transaction_commit().
-                         */
-                        printk(KERN_WARNING
-                               "NILFS warning: journal info from a different "
-                               "FS\n");
-                        save = current->journal_info;
-                }
+
+                /*
+                 * If journal_info field is occupied by other FS,
+                 * it is saved and will be restored on
+                 * nilfs_transaction_commit().
+                 */
+                printk(KERN_WARNING
+                       "NILFS warning: journal info from a different FS\n");
+                save = current->journal_info;
         }
         if (!ti) {
                 ti = kmem_cache_alloc(nilfs_transaction_cachep, GFP_NOFS);
@@ -397,10 +399,10 @@ static void nilfs_transaction_unlock(struct super_block *sb)
 
 static void *nilfs_segctor_map_segsum_entry(struct nilfs_sc_info *sci,
                                             struct nilfs_segsum_pointer *ssp,
-                                            unsigned bytes)
+                                            unsigned int bytes)
 {
         struct nilfs_segment_buffer *segbuf = sci->sc_curseg;
-        unsigned blocksize = sci->sc_super->s_blocksize;
+        unsigned int blocksize = sci->sc_super->s_blocksize;
         void *p;
 
         if (unlikely(ssp->offset + bytes > blocksize)) {
@@ -422,8 +424,8 @@ static int nilfs_segctor_reset_segment_buffer(struct nilfs_sc_info *sci)
 {
         struct nilfs_segment_buffer *segbuf = sci->sc_curseg;
         struct buffer_head *sumbh;
-        unsigned sumbytes;
-        unsigned flags = 0;
+        unsigned int sumbytes;
+        unsigned int flags = 0;
         int err;
 
         if (nilfs_doing_gc())
@@ -444,8 +446,10 @@ static int nilfs_segctor_feed_segment(struct nilfs_sc_info *sci)
 {
         sci->sc_nblk_this_inc += sci->sc_curseg->sb_sum.nblocks;
         if (NILFS_SEGBUF_IS_LAST(sci->sc_curseg, &sci->sc_segbufs))
-                return -E2BIG; /* The current segment is filled up
-                                  (internal code) */
+                return -E2BIG; /*
+                                * The current segment is filled up
+                                * (internal code)
+                                */
         sci->sc_curseg = NILFS_NEXT_SEGBUF(sci->sc_curseg);
         return nilfs_segctor_reset_segment_buffer(sci);
 }
@@ -472,9 +476,9 @@ static int nilfs_segctor_add_super_root(struct nilfs_sc_info *sci)
  */
 static int nilfs_segctor_segsum_block_required(
         struct nilfs_sc_info *sci, const struct nilfs_segsum_pointer *ssp,
-        unsigned binfo_size)
+        unsigned int binfo_size)
 {
-        unsigned blocksize = sci->sc_super->s_blocksize;
+        unsigned int blocksize = sci->sc_super->s_blocksize;
         /* Size of finfo and binfo is enough small against blocksize */
 
         return ssp->offset + binfo_size +
@@ -533,7 +537,7 @@ static void nilfs_segctor_end_finfo(struct nilfs_sc_info *sci,
 static int nilfs_segctor_add_file_block(struct nilfs_sc_info *sci,
                                         struct buffer_head *bh,
                                         struct inode *inode,
-                                        unsigned binfo_size)
+                                        unsigned int binfo_size)
 {
         struct nilfs_segment_buffer *segbuf;
         int required, err = 0;
@@ -617,7 +621,7 @@ static void nilfs_write_file_node_binfo(struct nilfs_sc_info *sci,
         *vblocknr = binfo->bi_v.bi_vblocknr;
 }
 
-static struct nilfs_sc_operations nilfs_sc_file_ops = {
+static const struct nilfs_sc_operations nilfs_sc_file_ops = {
         .collect_data = nilfs_collect_file_data,
         .collect_node = nilfs_collect_file_node,
         .collect_bmap = nilfs_collect_file_bmap,
@@ -666,7 +670,7 @@ static void nilfs_write_dat_node_binfo(struct nilfs_sc_info *sci,
         *binfo_dat = binfo->bi_dat;
 }
 
-static struct nilfs_sc_operations nilfs_sc_dat_ops = {
+static const struct nilfs_sc_operations nilfs_sc_dat_ops = {
         .collect_data = nilfs_collect_dat_data,
         .collect_node = nilfs_collect_file_node,
         .collect_bmap = nilfs_collect_dat_bmap,
@@ -674,7 +678,7 @@ static struct nilfs_sc_operations nilfs_sc_dat_ops = {
         .write_node_binfo = nilfs_write_dat_node_binfo,
 };
 
-static struct nilfs_sc_operations nilfs_sc_dsync_ops = {
+static const struct nilfs_sc_operations nilfs_sc_dsync_ops = {
         .collect_data = nilfs_collect_file_data,
         .collect_node = NULL,
         .collect_bmap = NULL,
@@ -777,7 +781,7 @@ static void nilfs_dispose_list(struct the_nilfs *nilfs,
 {
         struct nilfs_inode_info *ii, *n;
         struct nilfs_inode_info *ivec[SC_N_INODEVEC], **pii;
-        unsigned nv = 0;
+        unsigned int nv = 0;
 
         while (!list_empty(head)) {
                 spin_lock(&nilfs->ns_inode_lock);
@@ -875,9 +879,11 @@ static int nilfs_segctor_create_checkpoint(struct nilfs_sc_info *sci)
         err = nilfs_cpfile_get_checkpoint(nilfs->ns_cpfile, nilfs->ns_cno, 1,
                                           &raw_cp, &bh_cp);
         if (likely(!err)) {
-                /* The following code is duplicated with cpfile.  But, it is
-                   needed to collect the checkpoint even if it was not newly
-                   created */
+                /*
+                 * The following code is duplicated with cpfile.  But, it is
+                 * needed to collect the checkpoint even if it was not newly
+                 * created.
+                 */
                 mark_buffer_dirty(bh_cp);
                 nilfs_mdt_mark_dirty(nilfs->ns_cpfile);
                 nilfs_cpfile_put_checkpoint(
@@ -958,7 +964,7 @@ static void nilfs_segctor_fill_in_super_root(struct nilfs_sc_info *sci,
 {
         struct buffer_head *bh_sr;
         struct nilfs_super_root *raw_sr;
-        unsigned isz, srsz;
+        unsigned int isz, srsz;
 
         bh_sr = NILFS_LAST_SEGBUF(&sci->sc_segbufs)->sb_super_root;
         raw_sr = (struct nilfs_super_root *)bh_sr->b_data;
@@ -1043,7 +1049,7 @@ static size_t nilfs_segctor_buffer_rest(struct nilfs_sc_info *sci)
 
 static int nilfs_segctor_scan_file(struct nilfs_sc_info *sci,
                                    struct inode *inode,
-                                   struct nilfs_sc_operations *sc_ops)
+                                   const struct nilfs_sc_operations *sc_ops)
 {
         LIST_HEAD(data_buffers);
         LIST_HEAD(node_buffers);
@@ -1406,8 +1412,10 @@ static void nilfs_free_incomplete_logs(struct list_head *logs,
         if (atomic_read(&segbuf->sb_err)) {
                 /* Case 1: The first segment failed */
                 if (segbuf->sb_pseg_start != segbuf->sb_fseg_start)
-                        /* Case 1a:  Partial segment appended into an existing
-                           segment */
+                        /*
+                         * Case 1a:  Partial segment appended into an existing
+                         * segment
+                         */
                         nilfs_terminate_segment(nilfs, segbuf->sb_fseg_start,
                                                 segbuf->sb_fseg_end);
                 else /* Case 1b:  New full segment */
@@ -1550,7 +1558,7 @@ nilfs_segctor_update_payload_blocknr(struct nilfs_sc_info *sci,
         sector_t blocknr;
         unsigned long nfinfo = segbuf->sb_sum.nfinfo;
         unsigned long nblocks = 0, ndatablk = 0;
-        struct nilfs_sc_operations *sc_op = NULL;
+        const struct nilfs_sc_operations *sc_op = NULL;
         struct nilfs_segsum_pointer ssp;
         struct nilfs_finfo *finfo = NULL;
         union nilfs_binfo binfo;
@@ -1631,8 +1639,10 @@ static int nilfs_segctor_assign(struct nilfs_sc_info *sci, int mode)
 static void nilfs_begin_page_io(struct page *page)
 {
         if (!page || PageWriteback(page))
-                /* For split b-tree node pages, this function may be called
-                   twice.  We ignore the 2nd or later calls by this check. */
+                /*
+                 * For split b-tree node pages, this function may be called
+                 * twice.  We ignore the 2nd or later calls by this check.
+                 */
                 return;
 
         lock_page(page);
@@ -1942,7 +1952,7 @@ static int nilfs_segctor_collect_dirty_files(struct nilfs_sc_info *sci,
                                 ifile, ii->vfs_inode.i_ino, &ibh);
                         if (unlikely(err)) {
                                 nilfs_warning(sci->sc_super, __func__,
-                                              "failed to get inode block.\n");
+                                              "failed to get inode block.");
                                 return err;
                         }
                         mark_buffer_dirty(ibh);
@@ -2395,6 +2405,7 @@ static int nilfs_segctor_construct(struct nilfs_sc_info *sci, int mode)
 static void nilfs_construction_timeout(unsigned long data)
 {
         struct task_struct *p = (struct task_struct *)data;
+
         wake_up_process(p);
 }
 
@@ -2555,10 +2566,10 @@ static int nilfs_segctor_thread(void *arg)
 
                 if (timeout || sci->sc_seq_request != sci->sc_seq_done)
                         mode = SC_LSEG_SR;
-                else if (!sci->sc_flush_request)
-                        break;
-                else
+                else if (sci->sc_flush_request)
                         mode = nilfs_segctor_flush_mode(sci);
+                else
+                        break;
 
                 spin_unlock(&sci->sc_state_lock);
                 nilfs_segctor_thread_construct(sci, mode);
@@ -2684,8 +2695,10 @@ static void nilfs_segctor_write_out(struct nilfs_sc_info *sci)
 {
         int ret, retrycount = NILFS_SC_CLEANUP_RETRY;
 
-        /* The segctord thread was stopped and its timer was removed.
-           But some tasks remain. */
+        /*
+         * The segctord thread was stopped and its timer was removed.
+         * But some tasks remain.
+         */
         do {
                 struct nilfs_transaction_info ti;
 
@@ -2727,13 +2740,13 @@ static void nilfs_segctor_destroy(struct nilfs_sc_info *sci)
 
         if (!list_empty(&sci->sc_dirty_files)) {
                 nilfs_warning(sci->sc_super, __func__,
-                              "dirty file(s) after the final construction\n");
+                              "dirty file(s) after the final construction");
                 nilfs_dispose_list(nilfs, &sci->sc_dirty_files, 1);
         }
 
         if (!list_empty(&sci->sc_iput_queue)) {
                 nilfs_warning(sci->sc_super, __func__,
-                              "iput queue is not empty\n");
+                              "iput queue is not empty");
                 nilfs_dispose_list(nilfs, &sci->sc_iput_queue, 1);
         }
 
@@ -2810,7 +2823,7 @@ void nilfs_detach_log_writer(struct super_block *sb)
         if (!list_empty(&nilfs->ns_dirty_files)) {
                 list_splice_init(&nilfs->ns_dirty_files, &garbage_list);
                 nilfs_warning(sb, __func__,
-                              "Hit dirty file after stopped log writer\n");
+                              "Hit dirty file after stopped log writer");
         }
         spin_unlock(&nilfs->ns_inode_lock);
         up_write(&nilfs->ns_segctor_sem);
diff --git a/fs/nilfs2/segment.h b/fs/nilfs2/segment.h
index 0408b9b2814b..6565c10b7b76 100644
--- a/fs/nilfs2/segment.h
+++ b/fs/nilfs2/segment.h
@@ -13,11 +13,7 @@
  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  * GNU General Public License for more details.
  *
- * You should have received a copy of the GNU General Public License
- * along with this program; if not, write to the Free Software
- * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
- *
- * Written by Ryusuke Konishi <ryusuke@osrg.net>
+ * Written by Ryusuke Konishi.
  *
  */
 #ifndef _NILFS_SEGMENT_H
@@ -75,7 +71,7 @@ struct nilfs_recovery_info {
  */
 struct nilfs_cstage {
         int                     scnt;
-        unsigned                flags;
+        unsigned int            flags;
         struct nilfs_inode_info *dirty_file_ptr;
         struct nilfs_inode_info *gc_inode_ptr;
 };
@@ -84,7 +80,7 @@ struct nilfs_segment_buffer;
 
 struct nilfs_segsum_pointer {
         struct buffer_head     *bh;
-        unsigned                offset; /* offset in bytes */
+        unsigned int            offset; /* offset in bytes */
 };
 
 /**
@@ -193,11 +189,15 @@ enum {
         NILFS_SC_DIRTY,         /* One or more dirty meta-data blocks exist */
         NILFS_SC_UNCLOSED,      /* Logical segment is not closed */
         NILFS_SC_SUPER_ROOT,    /* The latest segment has a super root */
-        NILFS_SC_PRIOR_FLUSH,   /* Requesting immediate flush without making a
-                                   checkpoint */
-        NILFS_SC_HAVE_DELTA,    /* Next checkpoint will have update of files
-                                   other than DAT, cpfile, sufile, or files
-                                   moved by GC */
+        NILFS_SC_PRIOR_FLUSH,   /*
+                                 * Requesting immediate flush without making a
+                                 * checkpoint
+                                 */
+        NILFS_SC_HAVE_DELTA,    /*
+                                 * Next checkpoint will have update of files
+                                 * other than DAT, cpfile, sufile, or files
+                                 * moved by GC.
+                                 */
 };
 
 /* sc_state */
@@ -207,17 +207,23 @@ enum {
 /*
  * Constant parameters
  */
-#define NILFS_SC_CLEANUP_RETRY      3  /* Retry count of construction when
-                                          destroying segctord */
+#define NILFS_SC_CLEANUP_RETRY      3  /*
+                                        * Retry count of construction when
+                                        * destroying segctord
+                                        */
 
 /*
  * Default values of timeout, in seconds.
  */
-#define NILFS_SC_DEFAULT_TIMEOUT    5   /* Timeout value of dirty blocks.
-                                           It triggers construction of a
-                                           logical segment with a super root */
-#define NILFS_SC_DEFAULT_SR_FREQ    30  /* Maximum frequency of super root
-                                           creation */
+#define NILFS_SC_DEFAULT_TIMEOUT    5   /*
+                                         * Timeout value of dirty blocks.
+                                         * It triggers construction of a
+                                         * logical segment with a super root.
+                                         */
+#define NILFS_SC_DEFAULT_SR_FREQ    30  /*
+                                         * Maximum frequency of super root
+                                         * creation
+                                         */
 
 /*
  * The default threshold amount of data, in block counts.
diff --git a/fs/nilfs2/sufile.c b/fs/nilfs2/sufile.c
index 52821ffc11f4..1963595a1580 100644
--- a/fs/nilfs2/sufile.c
+++ b/fs/nilfs2/sufile.c
@@ -13,12 +13,8 @@
  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  * GNU General Public License for more details.
  *
- * You should have received a copy of the GNU General Public License
- * along with this program; if not, write to the Free Software
- * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
- *
- * Written by Koji Sato <koji@osrg.net>.
- * Revised by Ryusuke Konishi <ryusuke@osrg.net>.
+ * Written by Koji Sato.
+ * Revised by Ryusuke Konishi.
  */
 
 #include <linux/kernel.h>
@@ -61,6 +57,7 @@ static unsigned long
 nilfs_sufile_get_blkoff(const struct inode *sufile, __u64 segnum)
 {
         __u64 t = segnum + NILFS_MDT(sufile)->mi_first_entry_offset;
+
         do_div(t, nilfs_sufile_segment_usages_per_block(sufile));
         return (unsigned long)t;
 }
@@ -69,6 +66,7 @@ static unsigned long
 nilfs_sufile_get_offset(const struct inode *sufile, __u64 segnum)
 {
         __u64 t = segnum + NILFS_MDT(sufile)->mi_first_entry_offset;
+
         return do_div(t, nilfs_sufile_segment_usages_per_block(sufile));
 }
 
@@ -819,7 +817,7 @@ out:
  * %-ENOMEM - Insufficient amount of memory available.
  */
 ssize_t nilfs_sufile_get_suinfo(struct inode *sufile, __u64 segnum, void *buf,
-                                unsigned sisz, size_t nsi)
+                                unsigned int sisz, size_t nsi)
 {
         struct buffer_head *su_bh;
         struct nilfs_segment_usage *su;
@@ -897,7 +895,7 @@ ssize_t nilfs_sufile_get_suinfo(struct inode *sufile, __u64 segnum, void *buf,
  * %-EINVAL - Invalid values in input (segment number, flags or nblocks)
  */
 ssize_t nilfs_sufile_set_suinfo(struct inode *sufile, void *buf,
-                                unsigned supsz, size_t nsup)
+                                unsigned int supsz, size_t nsup)
 {
         struct the_nilfs *nilfs = sufile->i_sb->s_fs_info;
         struct buffer_head *header_bh, *bh;
diff --git a/fs/nilfs2/sufile.h b/fs/nilfs2/sufile.h
index b8afd72f2379..46e89872294c 100644
--- a/fs/nilfs2/sufile.h
+++ b/fs/nilfs2/sufile.h
@@ -13,11 +13,7 @@
  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  * GNU General Public License for more details.
  *
- * You should have received a copy of the GNU General Public License
- * along with this program; if not, write to the Free Software
- * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
- *
- * Written by Koji Sato <koji@osrg.net>.
+ * Written by Koji Sato.
  */
 
 #ifndef _NILFS_SUFILE_H
@@ -42,9 +38,9 @@ int nilfs_sufile_mark_dirty(struct inode *sufile, __u64 segnum);
 int nilfs_sufile_set_segment_usage(struct inode *sufile, __u64 segnum,
                                    unsigned long nblocks, time_t modtime);
 int nilfs_sufile_get_stat(struct inode *, struct nilfs_sustat *);
-ssize_t nilfs_sufile_get_suinfo(struct inode *, __u64, void *, unsigned,
+ssize_t nilfs_sufile_get_suinfo(struct inode *, __u64, void *, unsigned int,
                                 size_t);
-ssize_t nilfs_sufile_set_suinfo(struct inode *, void *, unsigned , size_t);
+ssize_t nilfs_sufile_set_suinfo(struct inode *, void *, unsigned int, size_t);
 
 int nilfs_sufile_updatev(struct inode *, __u64 *, size_t, int, size_t *,
                          void (*dofunc)(struct inode *, __u64,
diff --git a/fs/nilfs2/super.c b/fs/nilfs2/super.c
index 7f5d3d9f1c37..666107a18a22 100644
--- a/fs/nilfs2/super.c
+++ b/fs/nilfs2/super.c
@@ -13,11 +13,7 @@
  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  * GNU General Public License for more details.
  *
- * You should have received a copy of the GNU General Public License
- * along with this program; if not, write to the Free Software
- * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
- *
- * Written by Ryusuke Konishi <ryusuke@osrg.net>
+ * Written by Ryusuke Konishi.
  */
 /*
  *  linux/fs/ext2/super.c
@@ -173,12 +169,10 @@ struct inode *nilfs_alloc_inode(struct super_block *sb)
 static void nilfs_i_callback(struct rcu_head *head)
 {
         struct inode *inode = container_of(head, struct inode, i_rcu);
-        struct nilfs_mdt_info *mdi = NILFS_MDT(inode);
 
-        if (mdi) {
-                kfree(mdi->mi_bgl); /* kfree(NULL) is safe */
-                kfree(mdi);
-        }
+        if (nilfs_is_metadata_file_inode(inode))
+                nilfs_mdt_destroy(inode);
+
         kmem_cache_free(nilfs_inode_cachep, NILFS_I(inode));
 }
 
@@ -279,7 +273,7 @@ struct nilfs_super_block **nilfs_prepare_super(struct super_block *sb,
                 }
         } else if (sbp[1] &&
                    sbp[1]->s_magic != cpu_to_le16(NILFS_SUPER_MAGIC)) {
-                        memcpy(sbp[1], sbp[0], nilfs->ns_sbsize);
+                memcpy(sbp[1], sbp[0], nilfs->ns_sbsize);
         }
 
         if (flip && sbp[1])
@@ -749,6 +743,7 @@ static int parse_options(char *options, struct super_block *sb, int is_remount)
 
         while ((p = strsep(&options, ",")) != NULL) {
                 int token;
+
                 if (!*p)
                         continue;
 
@@ -891,7 +886,7 @@ int nilfs_store_magic_and_option(struct super_block *sb,
         nilfs->ns_interval = le32_to_cpu(sbp->s_c_interval);
         nilfs->ns_watermark = le32_to_cpu(sbp->s_c_block_max);
 
-        return !parse_options(data, sb, 0) ? -EINVAL : 0 ;
+        return !parse_options(data, sb, 0) ? -EINVAL : 0;
 }
 
 int nilfs_check_feature_compatibility(struct super_block *sb,
@@ -1316,7 +1311,7 @@ nilfs_mount(struct file_system_type *fs_type, int flags,
         }
 
         if (!s->s_root) {
-                s_new = true;
+                s_new = true;
 
                 /* New superblock instance created */
                 s->s_mode = mode;
diff --git a/fs/nilfs2/sysfs.c b/fs/nilfs2/sysfs.c
index bbb0dcc35905..8ffa42b704d8 100644
--- a/fs/nilfs2/sysfs.c
+++ b/fs/nilfs2/sysfs.c
@@ -68,7 +68,7 @@ static ssize_t nilfs_##name##_attr_store(struct kobject *kobj, \
 static const struct sysfs_ops nilfs_##name##_attr_ops = { \
         .show   = nilfs_##name##_attr_show, \
         .store  = nilfs_##name##_attr_store, \
-};
+}
 
 #define NILFS_DEV_INT_GROUP_TYPE(name, parent_name) \
 static void nilfs_##name##_attr_release(struct kobject *kobj) \
@@ -84,7 +84,7 @@ static struct kobj_type nilfs_##name##_ktype = { \
         .default_attrs  = nilfs_##name##_attrs, \
         .sysfs_ops      = &nilfs_##name##_attr_ops, \
         .release        = nilfs_##name##_attr_release, \
-};
+}
 
 #define NILFS_DEV_INT_GROUP_FNS(name, parent_name) \
 static int nilfs_sysfs_create_##name##_group(struct the_nilfs *nilfs) \
@@ -756,7 +756,7 @@ nilfs_superblock_sb_write_count_show(struct nilfs_superblock_attr *attr,
                                       struct the_nilfs *nilfs,
                                       char *buf)
 {
-        unsigned sbwcount;
+        unsigned int sbwcount;
 
         down_read(&nilfs->ns_sem);
         sbwcount = nilfs->ns_sbwcount;
@@ -770,7 +770,7 @@ nilfs_superblock_sb_update_frequency_show(struct nilfs_superblock_attr *attr,
                                             struct the_nilfs *nilfs,
                                             char *buf)
 {
-        unsigned sb_update_freq;
+        unsigned int sb_update_freq;
 
         down_read(&nilfs->ns_sem);
         sb_update_freq = nilfs->ns_sb_update_freq;
@@ -784,7 +784,7 @@ nilfs_superblock_sb_update_frequency_store(struct nilfs_superblock_attr *attr,
                                             struct the_nilfs *nilfs,
                                             const char *buf, size_t count)
 {
-        unsigned val;
+        unsigned int val;
         int err;
 
         err = kstrtouint(skip_spaces(buf), 0, &val);
diff --git a/fs/nilfs2/sysfs.h b/fs/nilfs2/sysfs.h
index 677e3a1a8370..648cedf9c06e 100644
--- a/fs/nilfs2/sysfs.h
+++ b/fs/nilfs2/sysfs.h
@@ -66,7 +66,7 @@ struct nilfs_##name##_attr { \
                         char *); \
         ssize_t (*store)(struct kobject *, struct attribute *, \
                          const char *, size_t); \
-};
+}
 
 NILFS_COMMON_ATTR_STRUCT(feature);
 
@@ -77,7 +77,7 @@ struct nilfs_##name##_attr { \
                         char *); \
         ssize_t (*store)(struct nilfs_##name##_attr *, struct the_nilfs *, \
                          const char *, size_t); \
-};
+}
 
 NILFS_DEV_ATTR_STRUCT(dev);
 NILFS_DEV_ATTR_STRUCT(segments);
@@ -93,7 +93,7 @@ struct nilfs_##name##_attr { \
                         char *); \
         ssize_t (*store)(struct nilfs_##name##_attr *, struct nilfs_root *, \
                          const char *, size_t); \
-};
+}
 
 NILFS_CP_ATTR_STRUCT(snapshot);
 
diff --git a/fs/nilfs2/the_nilfs.c b/fs/nilfs2/the_nilfs.c
index 69bd801afb53..809bd2de7ad0 100644
--- a/fs/nilfs2/the_nilfs.c
+++ b/fs/nilfs2/the_nilfs.c
@@ -13,11 +13,7 @@
  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  * GNU General Public License for more details.
  *
- * You should have received a copy of the GNU General Public License
- * along with this program; if not, write to the Free Software
- * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
- *
- * Written by Ryusuke Konishi <ryusuke@osrg.net>
+ * Written by Ryusuke Konishi.
  *
  */
 
@@ -112,8 +108,8 @@ static int nilfs_load_super_root(struct the_nilfs *nilfs,
         struct nilfs_super_root *raw_sr;
         struct nilfs_super_block **sbp = nilfs->ns_sbp;
         struct nilfs_inode *rawi;
-        unsigned dat_entry_size, segment_usage_size, checkpoint_size;
-        unsigned inode_size;
+        unsigned int dat_entry_size, segment_usage_size, checkpoint_size;
+        unsigned int inode_size;
         int err;
 
         err = nilfs_read_super_root_block(nilfs, sr_block, &bh_sr, 1);
@@ -621,8 +617,10 @@ int init_nilfs(struct the_nilfs *nilfs, struct super_block *sb, char *data)
                 err = nilfs_load_super_block(nilfs, sb, blocksize, &sbp);
                 if (err)
                         goto out;
-                        /* not failed_sbh; sbh is released automatically
-                           when reloading fails. */
+                        /*
+                         * Not to failed_sbh; sbh is released automatically
+                         * when reloading fails.
+                         */
         }
         nilfs->ns_blocksize_bits = sb->s_blocksize_bits;
         nilfs->ns_blocksize = blocksize;
diff --git a/fs/nilfs2/the_nilfs.h b/fs/nilfs2/the_nilfs.h
index 23778d385836..79369fd6b13b 100644
--- a/fs/nilfs2/the_nilfs.h
+++ b/fs/nilfs2/the_nilfs.h
@@ -13,11 +13,7 @@
  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  * GNU General Public License for more details.
  *
- * You should have received a copy of the GNU General Public License
- * along with this program; if not, write to the Free Software
- * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
- *
- * Written by Ryusuke Konishi <ryusuke@osrg.net>
+ * Written by Ryusuke Konishi.
  *
  */
 
@@ -118,10 +114,10 @@ struct the_nilfs {
         struct buffer_head     *ns_sbh[2];
         struct nilfs_super_block *ns_sbp[2];
         time_t                  ns_sbwtime;
-        unsigned                ns_sbwcount;
-        unsigned                ns_sbsize;
-        unsigned                ns_mount_state;
-        unsigned                ns_sb_update_freq;
+        unsigned int            ns_sbwcount;
+        unsigned int            ns_sbsize;
+        unsigned int            ns_mount_state;
+        unsigned int            ns_sb_update_freq;
 
         /*
          * Following fields are dedicated to a writable FS-instance.
@@ -226,15 +222,14 @@ THE_NILFS_FNS(SB_DIRTY, sb_dirty)
  * Mount option operations
  */
 #define nilfs_clear_opt(nilfs, opt)  \
-        do { (nilfs)->ns_mount_opt &= ~NILFS_MOUNT_##opt; } while (0)
+        ((nilfs)->ns_mount_opt &= ~NILFS_MOUNT_##opt)
 #define nilfs_set_opt(nilfs, opt)  \
-        do { (nilfs)->ns_mount_opt |= NILFS_MOUNT_##opt; } while (0)
+        ((nilfs)->ns_mount_opt |= NILFS_MOUNT_##opt)
 #define nilfs_test_opt(nilfs, opt) ((nilfs)->ns_mount_opt & NILFS_MOUNT_##opt)
 #define nilfs_write_opt(nilfs, mask, opt)                               \
-        do { (nilfs)->ns_mount_opt =                                    \
+        ((nilfs)->ns_mount_opt =                                        \
                 (((nilfs)->ns_mount_opt & ~NILFS_MOUNT_##mask) |        \
-                 NILFS_MOUNT_##opt);                                    \
-        } while (0)
+                 NILFS_MOUNT_##opt))                                    \
 
 /**
  * struct nilfs_root - nilfs root object
@@ -273,6 +268,7 @@ struct nilfs_root {
 static inline int nilfs_sb_need_update(struct the_nilfs *nilfs)
 {
         u64 t = get_seconds();
+
         return t < nilfs->ns_sbwtime ||
                 t > nilfs->ns_sbwtime + nilfs->ns_sb_update_freq;
 }
@@ -280,6 +276,7 @@ static inline int nilfs_sb_need_update(struct the_nilfs *nilfs)
 static inline int nilfs_sb_will_flip(struct the_nilfs *nilfs)
 {
         int flip_bits = nilfs->ns_sbwcount & 0x0FL;
+
         return (flip_bits != 0x08 && flip_bits != 0x0F);
 }
 
@@ -308,7 +305,7 @@ static inline void nilfs_get_root(struct nilfs_root *root)
 
 static inline int nilfs_valid_fs(struct the_nilfs *nilfs)
 {
-        unsigned valid_fs;
+        unsigned int valid_fs;
 
         down_read(&nilfs->ns_sem);
         valid_fs = (nilfs->ns_mount_state & NILFS_VALID_FS);
diff --git a/fs/proc/task_mmu.c b/fs/proc/task_mmu.c
index 541583510cfb..4648c7f63ae2 100644
--- a/fs/proc/task_mmu.c
+++ b/fs/proc/task_mmu.c
@@ -1027,11 +1027,15 @@ static ssize_t clear_refs_write(struct file *file, const char __user *buf,
                 };
 
                 if (type == CLEAR_REFS_MM_HIWATER_RSS) {
+                        if (down_write_killable(&mm->mmap_sem)) {
+                                count = -EINTR;
+                                goto out_mm;
+                        }
+
                         /*
                          * Writing 5 to /proc/pid/clear_refs resets the peak
                          * resident set size to this mm's current rss value.
                          */
-                        down_write(&mm->mmap_sem);
                         reset_mm_hiwater_rss(mm);
                         up_write(&mm->mmap_sem);
                         goto out_mm;
@@ -1043,7 +1047,10 @@ static ssize_t clear_refs_write(struct file *file, const char __user *buf,
                                 if (!(vma->vm_flags & VM_SOFTDIRTY))
                                         continue;
                                 up_read(&mm->mmap_sem);
-                                down_write(&mm->mmap_sem);
+                                if (down_write_killable(&mm->mmap_sem)) {
+                                        count = -EINTR;
+                                        goto out_mm;
+                                }
                                 for (vma = mm->mmap; vma; vma = vma->vm_next) {
                                         vma->vm_flags &= ~VM_SOFTDIRTY;
                                         vma_set_page_prot(vma);
diff --git a/include/linux/kexec.h b/include/linux/kexec.h
index 2cc643c6e870..e8acb2b43dd9 100644
--- a/include/linux/kexec.h
+++ b/include/linux/kexec.h
@@ -230,8 +230,6 @@ extern void crash_kexec(struct pt_regs *);
 int kexec_should_crash(struct task_struct *);
 void crash_save_cpu(struct pt_regs *regs, int cpu);
 void crash_save_vmcoreinfo(void);
-void crash_map_reserved_pages(void);
-void crash_unmap_reserved_pages(void);
 void arch_crash_save_vmcoreinfo(void);
 __printf(1, 2)
 void vmcoreinfo_append_str(const char *fmt, ...);
@@ -317,6 +315,8 @@ int __weak arch_kexec_apply_relocations_add(const Elf_Ehdr *ehdr,
                                         Elf_Shdr *sechdrs, unsigned int relsec);
 int __weak arch_kexec_apply_relocations(const Elf_Ehdr *ehdr, Elf_Shdr *sechdrs,
                                         unsigned int relsec);
+void arch_kexec_protect_crashkres(void);
+void arch_kexec_unprotect_crashkres(void);
 
 #else /* !CONFIG_KEXEC_CORE */
 struct pt_regs;
diff --git a/include/linux/mm.h b/include/linux/mm.h
index b530c99e8e81..2835d598d258 100644
--- a/include/linux/mm.h
+++ b/include/linux/mm.h
@@ -2011,9 +2011,9 @@ static inline void mm_populate(unsigned long addr, unsigned long len) {}
 #endif
 
 /* These take the mm semaphore themselves */
-extern unsigned long vm_brk(unsigned long, unsigned long);
+extern unsigned long __must_check vm_brk(unsigned long, unsigned long);
 extern int vm_munmap(unsigned long, size_t);
-extern unsigned long vm_mmap(struct file *, unsigned long,
+extern unsigned long __must_check vm_mmap(struct file *, unsigned long,
         unsigned long, unsigned long,
         unsigned long, unsigned long);
 
diff --git a/include/linux/nilfs2_fs.h b/include/linux/nilfs2_fs.h
index e9fcf90b270d..5988dd57ba66 100644
--- a/include/linux/nilfs2_fs.h
+++ b/include/linux/nilfs2_fs.h
@@ -13,12 +13,7 @@
  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  * GNU Lesser General Public License for more details.
  *
- * You should have received a copy of the GNU Lesser General Public License
- * along with this program; if not, write to the Free Software
- * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
- *
- * Written by Koji Sato <koji@osrg.net>
- *            Ryusuke Konishi <ryusuke@osrg.net>
+ * Written by Koji Sato and Ryusuke Konishi.
  */
 /*
  *  linux/include/linux/ext2_fs.h
@@ -132,10 +127,14 @@ struct nilfs_super_root {
 #define NILFS_MOUNT_ERRORS_RO           0x0020  /* Remount fs ro on errors */
 #define NILFS_MOUNT_ERRORS_PANIC        0x0040  /* Panic on errors */
 #define NILFS_MOUNT_BARRIER             0x1000  /* Use block barriers */
-#define NILFS_MOUNT_STRICT_ORDER        0x2000  /* Apply strict in-order
-                                                   semantics also for data */
-#define NILFS_MOUNT_NORECOVERY          0x4000  /* Disable write access during
-                                                   mount-time recovery */
+#define NILFS_MOUNT_STRICT_ORDER        0x2000  /*
+                                                 * Apply strict in-order
+                                                 * semantics also for data
+                                                 */
+#define NILFS_MOUNT_NORECOVERY          0x4000  /*
+                                                 * Disable write access during
+                                                 * mount-time recovery
+                                                 */
 #define NILFS_MOUNT_DISCARD             0x8000  /* Issue DISCARD requests */
 
 
@@ -147,16 +146,20 @@ struct nilfs_super_block {
         __le16  s_minor_rev_level;      /* minor revision level */
         __le16  s_magic;                /* Magic signature */
 
-        __le16  s_bytes;                /* Bytes count of CRC calculation
-                                           for this structure. s_reserved
-                                           is excluded. */
+        __le16  s_bytes;                /*
+                                         * Bytes count of CRC calculation
+                                         * for this structure. s_reserved
+                                         * is excluded.
+                                         */
         __le16  s_flags;                /* flags */
         __le32  s_crc_seed;             /* Seed value of CRC calculation */
 /*10*/  __le32  s_sum;                  /* Check sum of super block */
 
-        __le32  s_log_block_size;       /* Block size represented as follows
-                                           blocksize =
-                                               1 << (s_log_block_size + 10) */
+        __le32  s_log_block_size;       /*
+                                         * Block size represented as follows
+                                         * blocksize =
+                                         *     1 << (s_log_block_size + 10)
+                                         */
         __le64  s_nsegments;            /* Number of segments in filesystem */
 /*20*/  __le64  s_dev_size;             /* block device size in bytes */
         __le64  s_first_data_block;     /* 1st seg disk block number */
@@ -168,8 +171,10 @@ struct nilfs_super_block {
         __le64  s_last_seq;             /* seq. number of seg written last */
 /*50*/  __le64  s_free_blocks_count;    /* Free blocks count */
 
-        __le64  s_ctime;                /* Creation time (execution time of
-                                           newfs) */
+        __le64  s_ctime;                /*
+                                         * Creation time (execution time of
+                                         * newfs)
+                                         */
 /*60*/  __le64  s_mtime;                /* Mount time */
         __le64  s_wtime;                /* Write time */
 /*70*/  __le16  s_mnt_count;            /* Mount count */
@@ -193,8 +198,10 @@ struct nilfs_super_block {
 /*A8*/  char    s_volume_name[80];      /* volume name */
 
 /*F8*/  __le32  s_c_interval;           /* Commit interval of segment */
-        __le32  s_c_block_max;          /* Threshold of data amount for
-                                           the segment construction */
+        __le32  s_c_block_max;          /*
+                                         * Threshold of data amount for
+                                         * the segment construction
+                                         */
 /*100*/ __le64  s_feature_compat;       /* Compatible feature set */
         __le64  s_feature_compat_ro;    /* Read-only compatible feature set */
         __le64  s_feature_incompat;     /* Incompatible feature set */
@@ -247,12 +254,18 @@ struct nilfs_super_block {
 
 #define NILFS_SB_OFFSET_BYTES   1024    /* byte offset of nilfs superblock */
 
-#define NILFS_SEG_MIN_BLOCKS    16      /* Minimum number of blocks in
-                                           a full segment */
-#define NILFS_PSEG_MIN_BLOCKS   2       /* Minimum number of blocks in
-                                           a partial segment */
-#define NILFS_MIN_NRSVSEGS      8       /* Minimum number of reserved
-                                           segments */
+#define NILFS_SEG_MIN_BLOCKS    16      /*
+                                         * Minimum number of blocks in
+                                         * a full segment
+                                         */
+#define NILFS_PSEG_MIN_BLOCKS   2       /*
+                                         * Minimum number of blocks in
+                                         * a partial segment
+                                         */
+#define NILFS_MIN_NRSVSEGS      8       /*
+                                         * Minimum number of reserved
+                                         * segments
+                                         */
 
 /*
  * We call DAT, cpfile, and sufile root metadata files.  Inodes of
@@ -327,9 +340,9 @@ enum {
                                         ~NILFS_DIR_ROUND)
 #define NILFS_MAX_REC_LEN               ((1<<16)-1)
 
-static inline unsigned nilfs_rec_len_from_disk(__le16 dlen)
+static inline unsigned int nilfs_rec_len_from_disk(__le16 dlen)
 {
-        unsigned len = le16_to_cpu(dlen);
+        unsigned int len = le16_to_cpu(dlen);
 
 #if !defined(__KERNEL__) || (PAGE_SIZE >= 65536)
         if (len == NILFS_MAX_REC_LEN)
@@ -338,7 +351,7 @@ static inline unsigned nilfs_rec_len_from_disk(__le16 dlen)
         return len;
 }
 
-static inline __le16 nilfs_rec_len_to_disk(unsigned len)
+static inline __le16 nilfs_rec_len_to_disk(unsigned int len)
 {
 #if !defined(__KERNEL__) || (PAGE_SIZE >= 65536)
         if (len == (1 << 16))
@@ -518,9 +531,11 @@ struct nilfs_checkpoint {
         __le64 cp_inodes_count;
         __le64 cp_blocks_count;
 
-        /* Do not change the byte offset of ifile inode.
-           To keep the compatibility of the disk format,
-           additional fields should be added behind cp_ifile_inode. */
+        /*
+         * Do not change the byte offset of ifile inode.
+         * To keep the compatibility of the disk format,
+         * additional fields should be added behind cp_ifile_inode.
+         */
         struct nilfs_inode cp_ifile_inode;
 };
 
diff --git a/include/linux/oom.h b/include/linux/oom.h
index d3f533f2f481..83469522690a 100644
--- a/include/linux/oom.h
+++ b/include/linux/oom.h
@@ -50,24 +50,21 @@ enum oom_scan_t {
         OOM_SCAN_SELECT,        /* always select this thread first */
 };
 
-/* Thread is the potential origin of an oom condition; kill first on oom */
-#define OOM_FLAG_ORIGIN         ((__force oom_flags_t)0x1)
-
 extern struct mutex oom_lock;
 
 static inline void set_current_oom_origin(void)
 {
-        current->signal->oom_flags |= OOM_FLAG_ORIGIN;
+        current->signal->oom_flag_origin = true;
 }
 
 static inline void clear_current_oom_origin(void)
 {
-        current->signal->oom_flags &= ~OOM_FLAG_ORIGIN;
+        current->signal->oom_flag_origin = false;
 }
 
 static inline bool oom_task_origin(const struct task_struct *p)
 {
-        return !!(p->signal->oom_flags & OOM_FLAG_ORIGIN);
+        return p->signal->oom_flag_origin;
 }
 
 extern void mark_oom_victim(struct task_struct *tsk);
diff --git a/include/linux/sched.h b/include/linux/sched.h
index 2c036de6c1ee..21c26e78aec5 100644
--- a/include/linux/sched.h
+++ b/include/linux/sched.h
@@ -794,7 +794,11 @@ struct signal_struct {
         struct tty_audit_buf *tty_audit_buf;
 #endif
 
-        oom_flags_t oom_flags;
+        /*
+         * Thread is the potential origin of an oom condition; kill first on
+         * oom
+         */
+        bool oom_flag_origin;
         short oom_score_adj;            /* OOM kill score adjustment */
         short oom_score_adj_min;        /* OOM kill score adjustment min value.
                                          * Only settable by CAP_SYS_RESOURCE. */
diff --git a/include/linux/signal.h b/include/linux/signal.h
index 639be264f5f9..b63f63eaa39c 100644
--- a/include/linux/signal.h
+++ b/include/linux/signal.h
@@ -400,7 +400,9 @@ int unhandled_signal(struct task_struct *tsk, int sig);
 #else
 #define rt_sigmask(sig) sigmask(sig)
 #endif
-#define siginmask(sig, mask) (rt_sigmask(sig) & (mask))
+
+#define siginmask(sig, mask) \
+        ((sig) < SIGRTMIN && (rt_sigmask(sig) & (mask)))
 
 #define SIG_KERNEL_ONLY_MASK (\
         rt_sigmask(SIGKILL)   |  rt_sigmask(SIGSTOP))
@@ -421,14 +423,10 @@ int unhandled_signal(struct task_struct *tsk, int sig);
         rt_sigmask(SIGCONT)   |  rt_sigmask(SIGCHLD)   | \
         rt_sigmask(SIGWINCH)  |  rt_sigmask(SIGURG)    )
 
-#define sig_kernel_only(sig) \
-        (((sig) < SIGRTMIN) && siginmask(sig, SIG_KERNEL_ONLY_MASK))
-#define sig_kernel_coredump(sig) \
-        (((sig) < SIGRTMIN) && siginmask(sig, SIG_KERNEL_COREDUMP_MASK))
-#define sig_kernel_ignore(sig) \
-        (((sig) < SIGRTMIN) && siginmask(sig, SIG_KERNEL_IGNORE_MASK))
-#define sig_kernel_stop(sig) \
-        (((sig) < SIGRTMIN) && siginmask(sig, SIG_KERNEL_STOP_MASK))
+#define sig_kernel_only(sig)            siginmask(sig, SIG_KERNEL_ONLY_MASK)
+#define sig_kernel_coredump(sig)        siginmask(sig, SIG_KERNEL_COREDUMP_MASK)
+#define sig_kernel_ignore(sig)          siginmask(sig, SIG_KERNEL_IGNORE_MASK)
+#define sig_kernel_stop(sig)            siginmask(sig, SIG_KERNEL_STOP_MASK)
 
 #define sig_user_defined(t, signr) \
         (((t)->sighand->action[(signr)-1].sa.sa_handler != SIG_DFL) &&  \
diff --git a/include/linux/types.h b/include/linux/types.h
index 70dd3dfde631..baf718324f4a 100644
--- a/include/linux/types.h
+++ b/include/linux/types.h
@@ -156,7 +156,6 @@ typedef u32 dma_addr_t;
 
 typedef unsigned __bitwise__ gfp_t;
 typedef unsigned __bitwise__ fmode_t;
-typedef unsigned __bitwise__ oom_flags_t;
 
 #ifdef CONFIG_PHYS_ADDR_T_64BIT
 typedef u64 phys_addr_t;
diff --git a/ipc/shm.c b/ipc/shm.c
index 331fc1b0b3c7..13282510bc0d 100644
--- a/ipc/shm.c
+++ b/ipc/shm.c
@@ -1200,7 +1200,11 @@ long do_shmat(int shmid, char __user *shmaddr, int shmflg, ulong *raddr,
         if (err)
                 goto out_fput;
 
-        down_write(&current->mm->mmap_sem);
+        if (down_write_killable(&current->mm->mmap_sem)) {
+                err = -EINTR;
+                goto out_fput;
+        }
+
         if (addr && !(shmflg & SHM_REMAP)) {
                 err = -EINVAL;
                 if (addr + size < addr)
@@ -1271,7 +1275,8 @@ SYSCALL_DEFINE1(shmdt, char __user *, shmaddr)
         if (addr & ~PAGE_MASK)
                 return retval;
 
-        down_write(&mm->mmap_sem);
+        if (down_write_killable(&mm->mmap_sem))
+                return -EINTR;
 
         /*
          * This function tries to be smart and unmap shm segments that
diff --git a/kernel/Makefile b/kernel/Makefile
index f0c40bf49d9f..e2ec54e2b952 100644
--- a/kernel/Makefile
+++ b/kernel/Makefile
@@ -91,9 +91,7 @@ obj-$(CONFIG_TASK_DELAY_ACCT) += delayacct.o
 obj-$(CONFIG_TASKSTATS) += taskstats.o tsacct.o
 obj-$(CONFIG_TRACEPOINTS) += tracepoint.o
 obj-$(CONFIG_LATENCYTOP) += latencytop.o
-obj-$(CONFIG_BINFMT_ELF) += elfcore.o
-obj-$(CONFIG_COMPAT_BINFMT_ELF) += elfcore.o
-obj-$(CONFIG_BINFMT_ELF_FDPIC) += elfcore.o
+obj-$(CONFIG_ELFCORE) += elfcore.o
 obj-$(CONFIG_FUNCTION_TRACER) += trace/
 obj-$(CONFIG_TRACING) += trace/
 obj-$(CONFIG_TRACE_CLOCK) += trace/
diff --git a/kernel/events/uprobes.c b/kernel/events/uprobes.c
index c01f733ff2e1..b7a525ab2083 100644
--- a/kernel/events/uprobes.c
+++ b/kernel/events/uprobes.c
@@ -1130,7 +1130,9 @@ static int xol_add_vma(struct mm_struct *mm, struct xol_area *area)
         struct vm_area_struct *vma;
         int ret;
 
-        down_write(&mm->mmap_sem);
+        if (down_write_killable(&mm->mmap_sem))
+                return -EINTR;
+
         if (mm->uprobes_state.xol_area) {
                 ret = -EALREADY;
                 goto fail;
@@ -1469,7 +1471,8 @@ static void dup_xol_work(struct callback_head *work)
         if (current->flags & PF_EXITING)
                 return;
 
-        if (!__create_xol_area(current->utask->dup_xol_addr))
+        if (!__create_xol_area(current->utask->dup_xol_addr) &&
+                        !fatal_signal_pending(current))
                 uprobe_warn(current, "dup xol area");
 }
 
diff --git a/kernel/exit.c b/kernel/exit.c
index 75b34fe835b2..9e6e1356e6bb 100644
--- a/kernel/exit.c
+++ b/kernel/exit.c
@@ -918,17 +918,28 @@ static int eligible_pid(struct wait_opts *wo, struct task_struct *p)
                 task_pid_type(p, wo->wo_type) == wo->wo_pid;
 }
 
-static int eligible_child(struct wait_opts *wo, struct task_struct *p)
+static int
+eligible_child(struct wait_opts *wo, bool ptrace, struct task_struct *p)
 {
         if (!eligible_pid(wo, p))
                 return 0;
-        /* Wait for all children (clone and not) if __WALL is set;
-         * otherwise, wait for clone children *only* if __WCLONE is
-         * set; otherwise, wait for non-clone children *only*.  (Note:
-         * A "clone" child here is one that reports to its parent
-         * using a signal other than SIGCHLD.) */
-        if (((p->exit_signal != SIGCHLD) ^ !!(wo->wo_flags & __WCLONE))
-            && !(wo->wo_flags & __WALL))
+
+        /*
+         * Wait for all children (clone and not) if __WALL is set or
+         * if it is traced by us.
+         */
+        if (ptrace || (wo->wo_flags & __WALL))
+                return 1;
+
+        /*
+         * Otherwise, wait for clone children *only* if __WCLONE is set;
+         * otherwise, wait for non-clone children *only*.
+         *
+         * Note: a "clone" child here is one that reports to its parent
+         * using a signal other than SIGCHLD, or a non-leader thread which
+         * we can only see if it is traced by us.
+         */
+        if ((p->exit_signal != SIGCHLD) ^ !!(wo->wo_flags & __WCLONE))
                 return 0;
 
         return 1;
@@ -1300,7 +1311,7 @@ static int wait_consider_task(struct wait_opts *wo, int ptrace,
         if (unlikely(exit_state == EXIT_DEAD))
                 return 0;
 
-        ret = eligible_child(wo, p);
+        ret = eligible_child(wo, ptrace, p);
         if (!ret)
                 return ret;
 
@@ -1524,7 +1535,8 @@ SYSCALL_DEFINE5(waitid, int, which, pid_t, upid, struct siginfo __user *,
         enum pid_type type;
         long ret;
 
-        if (options & ~(WNOHANG|WNOWAIT|WEXITED|WSTOPPED|WCONTINUED))
+        if (options & ~(WNOHANG|WNOWAIT|WEXITED|WSTOPPED|WCONTINUED|
+                        __WNOTHREAD|__WCLONE|__WALL))
                 return -EINVAL;
         if (!(options & (WEXITED|WSTOPPED|WCONTINUED)))
                 return -EINVAL;
diff --git a/kernel/fork.c b/kernel/fork.c
index 103d78fd8f75..47887bba944f 100644
--- a/kernel/fork.c
+++ b/kernel/fork.c
@@ -340,13 +340,14 @@ void set_task_stack_end_magic(struct task_struct *tsk)
         *stackend = STACK_END_MAGIC;    /* for overflow detection */
 }
 
-static struct task_struct *dup_task_struct(struct task_struct *orig)
+static struct task_struct *dup_task_struct(struct task_struct *orig, int node)
 {
         struct task_struct *tsk;
         struct thread_info *ti;
-        int node = tsk_fork_get_node(orig);
         int err;
 
+        if (node == NUMA_NO_NODE)
+                node = tsk_fork_get_node(orig);
         tsk = alloc_task_struct_node(node);
         if (!tsk)
                 return NULL;
@@ -413,7 +414,10 @@ static int dup_mmap(struct mm_struct *mm, struct mm_struct *oldmm)
         unsigned long charge;
 
         uprobe_start_dup_mmap();
-        down_write(&oldmm->mmap_sem);
+        if (down_write_killable(&oldmm->mmap_sem)) {
+                retval = -EINTR;
+                goto fail_uprobe_end;
+        }
         flush_cache_dup_mm(oldmm);
         uprobe_dup_mmap(oldmm, mm);
         /*
@@ -525,6 +529,7 @@ out:
         up_write(&mm->mmap_sem);
         flush_tlb_mm(oldmm);
         up_write(&oldmm->mmap_sem);
+fail_uprobe_end:
         uprobe_end_dup_mmap();
         return retval;
 fail_nomem_anon_vma_fork:
@@ -1276,7 +1281,8 @@ static struct task_struct *copy_process(unsigned long clone_flags,
                                         int __user *child_tidptr,
                                         struct pid *pid,
                                         int trace,
-                                        unsigned long tls)
+                                        unsigned long tls,
+                                        int node)
 {
         int retval;
         struct task_struct *p;
@@ -1328,7 +1334,7 @@ static struct task_struct *copy_process(unsigned long clone_flags,
                 goto fork_out;
 
         retval = -ENOMEM;
-        p = dup_task_struct(current);
+        p = dup_task_struct(current, node);
         if (!p)
                 goto fork_out;
 
@@ -1706,7 +1712,8 @@ static inline void init_idle_pids(struct pid_link *links)
 struct task_struct *fork_idle(int cpu)
 {
         struct task_struct *task;
-        task = copy_process(CLONE_VM, 0, 0, NULL, &init_struct_pid, 0, 0);
+        task = copy_process(CLONE_VM, 0, 0, NULL, &init_struct_pid, 0, 0,
+                            cpu_to_node(cpu));
         if (!IS_ERR(task)) {
                 init_idle_pids(task->pids);
                 init_idle(task, cpu);
@@ -1751,7 +1758,7 @@ long _do_fork(unsigned long clone_flags,
         }
 
         p = copy_process(clone_flags, stack_start, stack_size,
-                         child_tidptr, NULL, trace, tls);
+                         child_tidptr, NULL, trace, tls, NUMA_NO_NODE);
         /*
          * Do this prior waking up the new thread - the thread pointer
          * might get invalid after that point, if the thread exits quickly.
diff --git a/kernel/kexec.c b/kernel/kexec.c
index ee70aef5cd81..4384672d3245 100644
--- a/kernel/kexec.c
+++ b/kernel/kexec.c
@@ -103,6 +103,65 @@ out_free_image:
         return ret;
 }
 
+static int do_kexec_load(unsigned long entry, unsigned long nr_segments,
+                struct kexec_segment __user *segments, unsigned long flags)
+{
+        struct kimage **dest_image, *image;
+        unsigned long i;
+        int ret;
+
+        if (flags & KEXEC_ON_CRASH) {
+                dest_image = &kexec_crash_image;
+                if (kexec_crash_image)
+                        arch_kexec_unprotect_crashkres();
+        } else {
+                dest_image = &kexec_image;
+        }
+
+        if (nr_segments == 0) {
+                /* Uninstall image */
+                kimage_free(xchg(dest_image, NULL));
+                return 0;
+        }
+        if (flags & KEXEC_ON_CRASH) {
+                /*
+                 * Loading another kernel to switch to if this one
+                 * crashes.  Free any current crash dump kernel before
+                 * we corrupt it.
+                 */
+                kimage_free(xchg(&kexec_crash_image, NULL));
+        }
+
+        ret = kimage_alloc_init(&image, entry, nr_segments, segments, flags);
+        if (ret)
+                return ret;
+
+        if (flags & KEXEC_PRESERVE_CONTEXT)
+                image->preserve_context = 1;
+
+        ret = machine_kexec_prepare(image);
+        if (ret)
+                goto out;
+
+        for (i = 0; i < nr_segments; i++) {
+                ret = kimage_load_segment(image, &image->segment[i]);
+                if (ret)
+                        goto out;
+        }
+
+        kimage_terminate(image);
+
+        /* Install the new kernel and uninstall the old */
+        image = xchg(dest_image, image);
+
+out:
+        if ((flags & KEXEC_ON_CRASH) && kexec_crash_image)
+                arch_kexec_protect_crashkres();
+
+        kimage_free(image);
+        return ret;
+}
+
 /*
  * Exec Kernel system call: for obvious reasons only root may call it.
  *
@@ -127,7 +186,6 @@ out_free_image:
 SYSCALL_DEFINE4(kexec_load, unsigned long, entry, unsigned long, nr_segments,
                 struct kexec_segment __user *, segments, unsigned long, flags)
 {
-        struct kimage **dest_image, *image;
         int result;
 
         /* We only trust the superuser with rebooting the system. */
@@ -152,9 +210,6 @@ SYSCALL_DEFINE4(kexec_load, unsigned long, entry, unsigned long, nr_segments,
         if (nr_segments > KEXEC_SEGMENT_MAX)
                 return -EINVAL;
 
-        image = NULL;
-        result = 0;
-
         /* Because we write directly to the reserved memory
          * region when loading crash kernels we need a mutex here to
          * prevent multiple crash  kernels from attempting to load
@@ -166,53 +221,9 @@ SYSCALL_DEFINE4(kexec_load, unsigned long, entry, unsigned long, nr_segments,
         if (!mutex_trylock(&kexec_mutex))
                 return -EBUSY;
 
-        dest_image = &kexec_image;
-        if (flags & KEXEC_ON_CRASH)
-                dest_image = &kexec_crash_image;
-        if (nr_segments > 0) {
-                unsigned long i;
-
-                if (flags & KEXEC_ON_CRASH) {
-                        /*
-                         * Loading another kernel to switch to if this one
-                         * crashes.  Free any current crash dump kernel before
-                         * we corrupt it.
-                         */
-
-                        kimage_free(xchg(&kexec_crash_image, NULL));
-                        result = kimage_alloc_init(&image, entry, nr_segments,
-                                                   segments, flags);
-                        crash_map_reserved_pages();
-                } else {
-                        /* Loading another kernel to reboot into. */
-
-                        result = kimage_alloc_init(&image, entry, nr_segments,
-                                                   segments, flags);
-                }
-                if (result)
-                        goto out;
-
-                if (flags & KEXEC_PRESERVE_CONTEXT)
-                        image->preserve_context = 1;
-                result = machine_kexec_prepare(image);
-                if (result)
-                        goto out;
-
-                for (i = 0; i < nr_segments; i++) {
-                        result = kimage_load_segment(image, &image->segment[i]);
-                        if (result)
-                                goto out;
-                }
-                kimage_terminate(image);
-                if (flags & KEXEC_ON_CRASH)
-                        crash_unmap_reserved_pages();
-        }
-        /* Install the new kernel, and  Uninstall the old */
-        image = xchg(dest_image, image);
+        result = do_kexec_load(entry, nr_segments, segments, flags);
 
-out:
         mutex_unlock(&kexec_mutex);
-        kimage_free(image);
 
         return result;
 }
diff --git a/kernel/kexec_core.c b/kernel/kexec_core.c
index d5d408252992..56b3ed0927b0 100644
--- a/kernel/kexec_core.c
+++ b/kernel/kexec_core.c
@@ -954,7 +954,6 @@ int crash_shrink_memory(unsigned long new_size)
         start = roundup(start, KEXEC_CRASH_MEM_ALIGN);
         end = roundup(start + new_size, KEXEC_CRASH_MEM_ALIGN);
 
-        crash_map_reserved_pages();
         crash_free_reserved_phys_range(end, crashk_res.end);
 
         if ((start == end) && (crashk_res.parent != NULL))
@@ -968,7 +967,6 @@ int crash_shrink_memory(unsigned long new_size)
         crashk_res.end = end - 1;
 
         insert_resource(&iomem_resource, ram_res);
-        crash_unmap_reserved_pages();
 
 unlock:
         mutex_unlock(&kexec_mutex);
@@ -1553,13 +1551,14 @@ int kernel_kexec(void)
 }
 
 /*
- * Add and remove page tables for crashkernel memory
+ * Protection mechanism for crashkernel reserved memory after
+ * the kdump kernel is loaded.
  *
  * Provide an empty default implementation here -- architecture
  * code may override this
  */
-void __weak crash_map_reserved_pages(void)
+void __weak arch_kexec_protect_crashkres(void)
 {}
 
-void __weak crash_unmap_reserved_pages(void)
+void __weak arch_kexec_unprotect_crashkres(void)
 {}
diff --git a/kernel/kexec_file.c b/kernel/kexec_file.c
index c72d2ff5896e..503bc2d348e5 100644
--- a/kernel/kexec_file.c
+++ b/kernel/kexec_file.c
@@ -274,8 +274,11 @@ SYSCALL_DEFINE5(kexec_file_load, int, kernel_fd, int, initrd_fd,
                 return -EBUSY;
 
         dest_image = &kexec_image;
-        if (flags & KEXEC_FILE_ON_CRASH)
+        if (flags & KEXEC_FILE_ON_CRASH) {
                 dest_image = &kexec_crash_image;
+                if (kexec_crash_image)
+                        arch_kexec_unprotect_crashkres();
+        }
 
         if (flags & KEXEC_FILE_UNLOAD)
                 goto exchange;
@@ -324,6 +327,9 @@ SYSCALL_DEFINE5(kexec_file_load, int, kernel_fd, int, initrd_fd,
 exchange:
         image = xchg(dest_image, image);
 out:
+        if ((flags & KEXEC_FILE_ON_CRASH) && kexec_crash_image)
+                arch_kexec_protect_crashkres();
+
         mutex_unlock(&kexec_mutex);
         kimage_free(image);
         return ret;
diff --git a/kernel/signal.c b/kernel/signal.c
index ab122a2cee41..96e9bc40667f 100644
--- a/kernel/signal.c
+++ b/kernel/signal.c
@@ -224,7 +224,7 @@ static inline void print_dropped_signal(int sig)
         if (!__ratelimit(&ratelimit_state))
                 return;
 
-        printk(KERN_INFO "%s/%d: reached RLIMIT_SIGPENDING, dropped signal %d\n",
+        pr_info("%s/%d: reached RLIMIT_SIGPENDING, dropped signal %d\n",
                                 current->comm, current->pid, sig);
 }
 
@@ -1089,10 +1089,10 @@ static int send_signal(int sig, struct siginfo *info, struct task_struct *t,
 static void print_fatal_signal(int signr)
 {
         struct pt_regs *regs = signal_pt_regs();
-        printk(KERN_INFO "potentially unexpected fatal signal %d.\n", signr);
+        pr_info("potentially unexpected fatal signal %d.\n", signr);
 
 #if defined(__i386__) && !defined(__arch_um__)
-        printk(KERN_INFO "code at %08lx: ", regs->ip);
+        pr_info("code at %08lx: ", regs->ip);
         {
                 int i;
                 for (i = 0; i < 16; i++) {
@@ -1100,10 +1100,10 @@ static void print_fatal_signal(int signr)
 
                         if (get_user(insn, (unsigned char *)(regs->ip + i)))
                                 break;
-                        printk(KERN_CONT "%02x ", insn);
+                        pr_cont("%02x ", insn);
                 }
         }
-        printk(KERN_CONT "\n");
+        pr_cont("\n");
 #endif
         preempt_disable();
         show_regs(regs);
diff --git a/kernel/sys.c b/kernel/sys.c
index cf8ba545c7d3..89d5be418157 100644
--- a/kernel/sys.c
+++ b/kernel/sys.c
@@ -2246,7 +2246,8 @@ SYSCALL_DEFINE5(prctl, int, option, unsigned long, arg2, unsigned long, arg3,
         case PR_SET_THP_DISABLE:
                 if (arg3 || arg4 || arg5)
                         return -EINVAL;
-                down_write(&me->mm->mmap_sem);
+                if (down_write_killable(&me->mm->mmap_sem))
+                        return -EINTR;
                 if (arg2)
                         me->mm->def_flags |= VM_NOHUGEPAGE;
                 else
diff --git a/lib/Kconfig.kgdb b/lib/Kconfig.kgdb
index c635a107a7de..533f912638ed 100644
--- a/lib/Kconfig.kgdb
+++ b/lib/Kconfig.kgdb
@@ -22,7 +22,7 @@ config KGDB_SERIAL_CONSOLE
         tristate "KGDB: use kgdb over the serial console"
         select CONSOLE_POLL
         select MAGIC_SYSRQ
-        depends on TTY
+        depends on TTY && HW_CONSOLE
         default y
         help
           Share a serial console with kgdb. Sysrq-g must be used
diff --git a/mm/internal.h b/mm/internal.h
index f6f3353b0868..a37e5b6f9d25 100644
--- a/mm/internal.h
+++ b/mm/internal.h
@@ -442,7 +442,7 @@ extern u64 hwpoison_filter_flags_value;
 extern u64 hwpoison_filter_memcg;
 extern u32 hwpoison_filter_enable;
 
-extern unsigned long vm_mmap_pgoff(struct file *, unsigned long,
+extern unsigned long  __must_check vm_mmap_pgoff(struct file *, unsigned long,
         unsigned long, unsigned long,
         unsigned long, unsigned long);
 
diff --git a/mm/madvise.c b/mm/madvise.c
index 07427d3fcead..93fb63e88b5e 100644
--- a/mm/madvise.c
+++ b/mm/madvise.c
@@ -707,10 +707,12 @@ SYSCALL_DEFINE3(madvise, unsigned long, start, size_t, len_in, int, behavior)
                 return error;
 
         write = madvise_need_mmap_write(behavior);
-        if (write)
-                down_write(&current->mm->mmap_sem);
-        else
+        if (write) {
+                if (down_write_killable(&current->mm->mmap_sem))
+                        return -EINTR;
+        } else {
                 down_read(&current->mm->mmap_sem);
+        }
 
         /*
          * If the interval [start,end) covers some unmapped address
diff --git a/mm/memcontrol.c b/mm/memcontrol.c
index b3f16ab4b431..cf428d7b9a03 100644
--- a/mm/memcontrol.c
+++ b/mm/memcontrol.c
@@ -1604,7 +1604,7 @@ static void memcg_oom_recover(struct mem_cgroup *memcg)
 
 static void mem_cgroup_oom(struct mem_cgroup *memcg, gfp_t mask, int order)
 {
-        if (!current->memcg_may_oom)
+        if (!current->memcg_may_oom || current->memcg_in_oom)
                 return;
         /*
          * We are in the middle of the charge context here, so we
diff --git a/mm/mlock.c b/mm/mlock.c
index 96f001041928..ef8dc9f395c4 100644
--- a/mm/mlock.c
+++ b/mm/mlock.c
@@ -617,7 +617,7 @@ static int apply_vma_lock_flags(unsigned long start, size_t len,
         return error;
 }
 
-static int do_mlock(unsigned long start, size_t len, vm_flags_t flags)
+static __must_check int do_mlock(unsigned long start, size_t len, vm_flags_t flags)
 {
         unsigned long locked;
         unsigned long lock_limit;
@@ -635,7 +635,8 @@ static int do_mlock(unsigned long start, size_t len, vm_flags_t flags)
         lock_limit >>= PAGE_SHIFT;
         locked = len >> PAGE_SHIFT;
 
-        down_write(&current->mm->mmap_sem);
+        if (down_write_killable(&current->mm->mmap_sem))
+                return -EINTR;
 
         locked += current->mm->locked_vm;
 
@@ -678,7 +679,8 @@ SYSCALL_DEFINE2(munlock, unsigned long, start, size_t, len)
         len = PAGE_ALIGN(len + (offset_in_page(start)));
         start &= PAGE_MASK;
 
-        down_write(&current->mm->mmap_sem);
+        if (down_write_killable(&current->mm->mmap_sem))
+                return -EINTR;
         ret = apply_vma_lock_flags(start, len, 0);
         up_write(&current->mm->mmap_sem);
 
@@ -748,9 +750,10 @@ SYSCALL_DEFINE1(mlockall, int, flags)
         lock_limit = rlimit(RLIMIT_MEMLOCK);
         lock_limit >>= PAGE_SHIFT;
 
-        ret = -ENOMEM;
-        down_write(&current->mm->mmap_sem);
+        if (down_write_killable(&current->mm->mmap_sem))
+                return -EINTR;
 
+        ret = -ENOMEM;
         if (!(flags & MCL_CURRENT) || (current->mm->total_vm <= lock_limit) ||
             capable(CAP_IPC_LOCK))
                 ret = apply_mlockall_flags(flags);
@@ -765,7 +768,8 @@ SYSCALL_DEFINE0(munlockall)
 {
         int ret;
 
-        down_write(&current->mm->mmap_sem);
+        if (down_write_killable(&current->mm->mmap_sem))
+                return -EINTR;
         ret = apply_mlockall_flags(0);
         up_write(&current->mm->mmap_sem);
         return ret;
diff --git a/mm/mmap.c b/mm/mmap.c
index b9274a0c82c9..d3d9a94ca031 100644
--- a/mm/mmap.c
+++ b/mm/mmap.c
@@ -178,7 +178,8 @@ SYSCALL_DEFINE1(brk, unsigned long, brk)
         unsigned long min_brk;
         bool populate;
 
-        down_write(&mm->mmap_sem);
+        if (down_write_killable(&mm->mmap_sem))
+                return -EINTR;
 
 #ifdef CONFIG_COMPAT_BRK
         /*
@@ -2493,7 +2494,9 @@ int vm_munmap(unsigned long start, size_t len)
         int ret;
         struct mm_struct *mm = current->mm;
 
-        down_write(&mm->mmap_sem);
+        if (down_write_killable(&mm->mmap_sem))
+                return -EINTR;
+
         ret = do_munmap(mm, start, len);
         up_write(&mm->mmap_sem);
         return ret;
@@ -2502,8 +2505,15 @@ EXPORT_SYMBOL(vm_munmap);
 
 SYSCALL_DEFINE2(munmap, unsigned long, addr, size_t, len)
 {
+        int ret;
+        struct mm_struct *mm = current->mm;
+
         profile_munmap(addr);
-        return vm_munmap(addr, len);
+        if (down_write_killable(&mm->mmap_sem))
+                return -EINTR;
+        ret = do_munmap(mm, addr, len);
+        up_write(&mm->mmap_sem);
+        return ret;
 }
 
 
@@ -2535,7 +2545,9 @@ SYSCALL_DEFINE5(remap_file_pages, unsigned long, start, unsigned long, size,
         if (pgoff + (size >> PAGE_SHIFT) < pgoff)
                 return ret;
 
-        down_write(&mm->mmap_sem);
+        if (down_write_killable(&mm->mmap_sem))
+                return -EINTR;
+
         vma = find_vma(mm, start);
 
         if (!vma || !(vma->vm_flags & VM_SHARED))
@@ -2700,7 +2712,9 @@ unsigned long vm_brk(unsigned long addr, unsigned long len)
         unsigned long ret;
         bool populate;
 
-        down_write(&mm->mmap_sem);
+        if (down_write_killable(&mm->mmap_sem))
+                return -EINTR;
+
         ret = do_brk(addr, len);
         populate = ((mm->def_flags & VM_LOCKED) != 0);
         up_write(&mm->mmap_sem);
diff --git a/mm/mprotect.c b/mm/mprotect.c
index b650c5412f58..5019a1ef2848 100644
--- a/mm/mprotect.c
+++ b/mm/mprotect.c
@@ -379,7 +379,8 @@ SYSCALL_DEFINE3(mprotect, unsigned long, start, size_t, len,
 
         reqprot = prot;
 
-        down_write(&current->mm->mmap_sem);
+        if (down_write_killable(&current->mm->mmap_sem))
+                return -EINTR;
 
         vma = find_vma(current->mm, start);
         error = -ENOMEM;
diff --git a/mm/mremap.c b/mm/mremap.c
index 9dc499977924..1f157adfdaf9 100644
--- a/mm/mremap.c
+++ b/mm/mremap.c
@@ -503,7 +503,8 @@ SYSCALL_DEFINE5(mremap, unsigned long, addr, unsigned long, old_len,
         if (!new_len)
                 return ret;
 
-        down_write(&current->mm->mmap_sem);
+        if (down_write_killable(&current->mm->mmap_sem))
+                return -EINTR;
 
         if (flags & MREMAP_FIXED) {
                 ret = mremap_to(addr, old_len, new_addr, new_len,
diff --git a/mm/util.c b/mm/util.c
index 8a1b3a1fb595..917e0e3d0f8e 100644
--- a/mm/util.c
+++ b/mm/util.c
@@ -297,7 +297,8 @@ unsigned long vm_mmap_pgoff(struct file *file, unsigned long addr,
 
         ret = security_mmap_file(file, prot, flag);
         if (!ret) {
-                down_write(&mm->mmap_sem);
+                if (down_write_killable(&mm->mmap_sem))
+                        return -EINTR;
                 ret = do_mmap_pgoff(file, addr, len, prot, flag, pgoff,
                                     &populate);
                 up_write(&mm->mmap_sem);
diff --git a/scripts/gdb/linux/Makefile b/scripts/gdb/linux/Makefile
index 6cf1ecf61057..cd129e65d1ff 100644
--- a/scripts/gdb/linux/Makefile
+++ b/scripts/gdb/linux/Makefile
@@ -8,4 +8,14 @@ ifneq ($(KBUILD_SRC),)
 endif
         @:
 
-clean-files := *.pyc *.pyo $(if $(KBUILD_SRC),*.py)
+quiet_cmd_gen_constants_py = GEN     $@
+      cmd_gen_constants_py = \
+        $(CPP) -E -x c -P $(c_flags) $< > $@ ;\
+        sed -i '1,/<!-- end-c-headers -->/d;' $@
+
+$(obj)/constants.py: $(SRCTREE)/$(obj)/constants.py.in
+        $(call if_changed,gen_constants_py)
+
+build_constants_py: $(obj)/constants.py
+
+clean-files := *.pyc *.pyo $(if $(KBUILD_SRC),*.py) $(obj)/constants.py
diff --git a/scripts/gdb/linux/constants.py.in b/scripts/gdb/linux/constants.py.in
new file mode 100644
index 000000000000..07e6c2befe36
--- /dev/null
+++ b/scripts/gdb/linux/constants.py.in
@@ -0,0 +1,59 @@
+/*
+ * gdb helper commands and functions for Linux kernel debugging
+ *
+ *  Kernel constants derived from include files.
+ *
+ * Copyright (c) 2016 Linaro Ltd
+ *
+ * Authors:
+ *  Kieran Bingham <kieran.bingham@linaro.org>
+ *
+ * This work is licensed under the terms of the GNU GPL version 2.
+ *
+ */
+
+#include <linux/fs.h>
+#include <linux/mount.h>
+#include <linux/radix-tree.h>
+
+/* We need to stringify expanded macros so that they can be parsed */
+
+#define STRING(x) #x
+#define XSTRING(x) STRING(x)
+
+#define LX_VALUE(x) LX_##x = x
+#define LX_GDBPARSED(x) LX_##x = gdb.parse_and_eval(XSTRING(x))
+
+/*
+ * IS_ENABLED generates (a || b) which is not compatible with python
+ * We can only switch on configuration items we know are available
+ * Therefore - IS_BUILTIN() is more appropriate
+ */
+#define LX_CONFIG(x) LX_##x = IS_BUILTIN(x)
+
+/* The build system will take care of deleting everything above this marker */
+<!-- end-c-headers -->
+
+import gdb
+
+/* linux/fs.h */
+LX_VALUE(MS_RDONLY)
+LX_VALUE(MS_SYNCHRONOUS)
+LX_VALUE(MS_MANDLOCK)
+LX_VALUE(MS_DIRSYNC)
+LX_VALUE(MS_NOATIME)
+LX_VALUE(MS_NODIRATIME)
+
+/* linux/mount.h */
+LX_VALUE(MNT_NOSUID)
+LX_VALUE(MNT_NODEV)
+LX_VALUE(MNT_NOEXEC)
+LX_VALUE(MNT_NOATIME)
+LX_VALUE(MNT_NODIRATIME)
+LX_VALUE(MNT_RELATIME)
+
+/* linux/radix-tree.h */
+LX_VALUE(RADIX_TREE_INDIRECT_PTR)
+LX_GDBPARSED(RADIX_TREE_HEIGHT_MASK)
+LX_GDBPARSED(RADIX_TREE_MAP_SHIFT)
+LX_GDBPARSED(RADIX_TREE_MAP_MASK)
diff --git a/scripts/gdb/linux/cpus.py b/scripts/gdb/linux/cpus.py
index 4297b83fedef..ca11e8df31b6 100644
--- a/scripts/gdb/linux/cpus.py
+++ b/scripts/gdb/linux/cpus.py
@@ -97,9 +97,47 @@ def cpu_list(mask_name):
         bits >>= 1
         bit += 1
 
+        yield int(cpu)
+
+
+def each_online_cpu():
+    for cpu in cpu_list("__cpu_online_mask"):
+        yield cpu
+
+
+def each_present_cpu():
+    for cpu in cpu_list("__cpu_present_mask"):
+        yield cpu
+
+
+def each_possible_cpu():
+    for cpu in cpu_list("__cpu_possible_mask"):
+        yield cpu
+
+
+def each_active_cpu():
+    for cpu in cpu_list("__cpu_active_mask"):
         yield cpu
 
 
+class LxCpus(gdb.Command):
+    """List CPU status arrays
+
+Displays the known state of each CPU based on the kernel masks
+and can help identify the state of hotplugged CPUs"""
+
+    def __init__(self):
+        super(LxCpus, self).__init__("lx-cpus", gdb.COMMAND_DATA)
+
+    def invoke(self, arg, from_tty):
+        gdb.write("Possible CPUs : {}\n".format(list(each_possible_cpu())))
+        gdb.write("Present CPUs  : {}\n".format(list(each_present_cpu())))
+        gdb.write("Online CPUs   : {}\n".format(list(each_online_cpu())))
+        gdb.write("Active CPUs   : {}\n".format(list(each_active_cpu())))
+
+LxCpus()
+
+
 class PerCpu(gdb.Function):
     """Return per-cpu variable.
 
diff --git a/scripts/gdb/linux/dmesg.py b/scripts/gdb/linux/dmesg.py
index 927d0d2a3145..f9b92ece7834 100644
--- a/scripts/gdb/linux/dmesg.py
+++ b/scripts/gdb/linux/dmesg.py
@@ -33,11 +33,12 @@ class LxDmesg(gdb.Command):
         if log_first_idx < log_next_idx:
             log_buf_2nd_half = -1
             length = log_next_idx - log_first_idx
-            log_buf = inf.read_memory(start, length)
+            log_buf = utils.read_memoryview(inf, start, length).tobytes()
         else:
             log_buf_2nd_half = log_buf_len - log_first_idx
-            log_buf = inf.read_memory(start, log_buf_2nd_half) + \
-                inf.read_memory(log_buf_addr, log_next_idx)
+            a = utils.read_memoryview(inf, start, log_buf_2nd_half)
+            b = utils.read_memoryview(inf, log_buf_addr, log_next_idx)
+            log_buf = a.tobytes() + b.tobytes()
 
         pos = 0
         while pos < log_buf.__len__():
@@ -50,10 +51,10 @@ class LxDmesg(gdb.Command):
                 continue
 
             text_len = utils.read_u16(log_buf[pos + 10:pos + 12])
-            text = log_buf[pos + 16:pos + 16 + text_len]
+            text = log_buf[pos + 16:pos + 16 + text_len].decode()
             time_stamp = utils.read_u64(log_buf[pos:pos + 8])
 
-            for line in memoryview(text).tobytes().splitlines():
+            for line in text.splitlines():
                 gdb.write("[{time:12.6f}] {line}\n".format(
                     time=time_stamp / 1000000000.0,
                     line=line))
diff --git a/scripts/gdb/linux/lists.py b/scripts/gdb/linux/lists.py
index 3a3775bc162b..2f335fbd86fd 100644
--- a/scripts/gdb/linux/lists.py
+++ b/scripts/gdb/linux/lists.py
@@ -18,6 +18,27 @@ from linux import utils
 list_head = utils.CachedType("struct list_head")
 
 
+def list_for_each(head):
+    if head.type == list_head.get_type().pointer():
+        head = head.dereference()
+    elif head.type != list_head.get_type():
+        raise gdb.GdbError("Must be struct list_head not {}"
+                           .format(head.type))
+
+    node = head['next'].dereference()
+    while node.address != head.address:
+        yield node.address
+        node = node['next'].dereference()
+
+
+def list_for_each_entry(head, gdbtype, member):
+    for node in list_for_each(head):
+        if node.type != list_head.get_type().pointer():
+            raise TypeError("Type {} found. Expected struct list_head *."
+                            .format(node.type))
+        yield utils.container_of(node, gdbtype, member)
+
+
 def list_check(head):
     nb = 0
     if (head.type == list_head.get_type().pointer()):
diff --git a/scripts/gdb/linux/modules.py b/scripts/gdb/linux/modules.py
index 0a35d6dbfb80..441b23239896 100644
--- a/scripts/gdb/linux/modules.py
+++ b/scripts/gdb/linux/modules.py
@@ -13,7 +13,7 @@
 
 import gdb
 
-from linux import cpus, utils
+from linux import cpus, utils, lists
 
 
 module_type = utils.CachedType("struct module")
@@ -21,14 +21,14 @@ module_type = utils.CachedType("struct module")
 
 def module_list():
     global module_type
+    modules = utils.gdb_eval_or_none("modules")
+    if modules is None:
+        return
+
     module_ptr_type = module_type.get_type().pointer()
-    modules = gdb.parse_and_eval("modules")
-    entry = modules['next']
-    end_of_list = modules.address
 
-    while entry != end_of_list:
-        yield utils.container_of(entry, module_ptr_type, "list")
-        entry = entry['next']
+    for module in lists.list_for_each_entry(modules, module_ptr_type, "list"):
+        yield module
 
 
 def find_module_by_name(name):
@@ -78,19 +78,17 @@ class LxLsmod(gdb.Command):
                 address=str(layout['base']).split()[0],
                 name=module['name'].string(),
                 size=str(layout['size']),
-                ref=str(module['refcnt']['counter'])))
+                ref=str(module['refcnt']['counter'] - 1)))
 
-            source_list = module['source_list']
             t = self._module_use_type.get_type().pointer()
-            entry = source_list['next']
             first = True
-            while entry != source_list.address:
-                use = utils.container_of(entry, t, "source_list")
+            sources = module['source_list']
+            for use in lists.list_for_each_entry(sources, t, "source_list"):
                 gdb.write("{separator}{name}".format(
                     separator=" " if first else ",",
                     name=use['source']['name'].string()))
                 first = False
-                entry = entry['next']
+
             gdb.write("\n")
 
 
diff --git a/scripts/gdb/linux/proc.py b/scripts/gdb/linux/proc.py
index 6e6709c1830c..38b1f09d1cd9 100644
--- a/scripts/gdb/linux/proc.py
+++ b/scripts/gdb/linux/proc.py
@@ -12,6 +12,10 @@
 #
 
 import gdb
+from linux import constants
+from linux import utils
+from linux import tasks
+from linux import lists
 
 
 class LxCmdLine(gdb.Command):
@@ -39,3 +43,155 @@ class LxVersion(gdb.Command):
         gdb.write(gdb.parse_and_eval("linux_banner").string())
 
 LxVersion()
+
+
+# Resource Structure Printers
+#  /proc/iomem
+#  /proc/ioports
+
+def get_resources(resource, depth):
+    while resource:
+        yield resource, depth
+
+        child = resource['child']
+        if child:
+            for res, deep in get_resources(child, depth + 1):
+                yield res, deep
+
+        resource = resource['sibling']
+
+
+def show_lx_resources(resource_str):
+        resource = gdb.parse_and_eval(resource_str)
+        width = 4 if resource['end'] < 0x10000 else 8
+        # Iterate straight to the first child
+        for res, depth in get_resources(resource['child'], 0):
+            start = int(res['start'])
+            end = int(res['end'])
+            gdb.write(" " * depth * 2 +
+                      "{0:0{1}x}-".format(start, width) +
+                      "{0:0{1}x} : ".format(end, width) +
+                      res['name'].string() + "\n")
+
+
+class LxIOMem(gdb.Command):
+    """Identify the IO memory resource locations defined by the kernel
+
+Equivalent to cat /proc/iomem on a running target"""
+
+    def __init__(self):
+        super(LxIOMem, self).__init__("lx-iomem", gdb.COMMAND_DATA)
+
+    def invoke(self, arg, from_tty):
+        return show_lx_resources("iomem_resource")
+
+LxIOMem()
+
+
+class LxIOPorts(gdb.Command):
+    """Identify the IO port resource locations defined by the kernel
+
+Equivalent to cat /proc/ioports on a running target"""
+
+    def __init__(self):
+        super(LxIOPorts, self).__init__("lx-ioports", gdb.COMMAND_DATA)
+
+    def invoke(self, arg, from_tty):
+        return show_lx_resources("ioport_resource")
+
+LxIOPorts()
+
+
+# Mount namespace viewer
+#  /proc/mounts
+
+def info_opts(lst, opt):
+    opts = ""
+    for key, string in lst.items():
+        if opt & key:
+            opts += string
+    return opts
+
+
+FS_INFO = {constants.LX_MS_SYNCHRONOUS: ",sync",
+           constants.LX_MS_MANDLOCK: ",mand",
+           constants.LX_MS_DIRSYNC: ",dirsync",
+           constants.LX_MS_NOATIME: ",noatime",
+           constants.LX_MS_NODIRATIME: ",nodiratime"}
+
+MNT_INFO = {constants.LX_MNT_NOSUID: ",nosuid",
+            constants.LX_MNT_NODEV: ",nodev",
+            constants.LX_MNT_NOEXEC: ",noexec",
+            constants.LX_MNT_NOATIME: ",noatime",
+            constants.LX_MNT_NODIRATIME: ",nodiratime",
+            constants.LX_MNT_RELATIME: ",relatime"}
+
+mount_type = utils.CachedType("struct mount")
+mount_ptr_type = mount_type.get_type().pointer()
+
+
+class LxMounts(gdb.Command):
+    """Report the VFS mounts of the current process namespace.
+
+Equivalent to cat /proc/mounts on a running target
+An integer value can be supplied to display the mount
+values of that process namespace"""
+
+    def __init__(self):
+        super(LxMounts, self).__init__("lx-mounts", gdb.COMMAND_DATA)
+
+    # Equivalent to proc_namespace.c:show_vfsmnt
+    # However, that has the ability to call into s_op functions
+    # whereas we cannot and must make do with the information we can obtain.
+    def invoke(self, arg, from_tty):
+        argv = gdb.string_to_argv(arg)
+        if len(argv) >= 1:
+            try:
+                pid = int(argv[0])
+            except:
+                raise gdb.GdbError("Provide a PID as integer value")
+        else:
+            pid = 1
+
+        task = tasks.get_task_by_pid(pid)
+        if not task:
+            raise gdb.GdbError("Couldn't find a process with PID {}"
+                               .format(pid))
+
+        namespace = task['nsproxy']['mnt_ns']
+        if not namespace:
+            raise gdb.GdbError("No namespace for current process")
+
+        for vfs in lists.list_for_each_entry(namespace['list'],
+                                             mount_ptr_type, "mnt_list"):
+            devname = vfs['mnt_devname'].string()
+            devname = devname if devname else "none"
+
+            pathname = ""
+            parent = vfs
+            while True:
+                mntpoint = parent['mnt_mountpoint']
+                pathname = utils.dentry_name(mntpoint) + pathname
+                if (parent == parent['mnt_parent']):
+                    break
+                parent = parent['mnt_parent']
+
+            if (pathname == ""):
+                pathname = "/"
+
+            superblock = vfs['mnt']['mnt_sb']
+            fstype = superblock['s_type']['name'].string()
+            s_flags = int(superblock['s_flags'])
+            m_flags = int(vfs['mnt']['mnt_flags'])
+            rd = "ro" if (s_flags & constants.LX_MS_RDONLY) else "rw"
+
+            gdb.write(
+                "{} {} {} {}{}{} 0 0\n"
+                .format(devname,
+                        pathname,
+                        fstype,
+                        rd,
+                        info_opts(FS_INFO, s_flags),
+                        info_opts(MNT_INFO, m_flags)))
+
+LxMounts()
diff --git a/scripts/gdb/linux/radixtree.py b/scripts/gdb/linux/radixtree.py
new file mode 100644
index 000000000000..0fdef4e2971a
--- /dev/null
+++ b/scripts/gdb/linux/radixtree.py
@@ -0,0 +1,97 @@
+#
+# gdb helper commands and functions for Linux kernel debugging
+#
+#  Radix Tree Parser
+#
+# Copyright (c) 2016 Linaro Ltd
+#
+# Authors:
+#  Kieran Bingham <kieran.bingham@linaro.org>
+#
+# This work is licensed under the terms of the GNU GPL version 2.
+#
+
+import gdb
+
+from linux import utils
+from linux import constants
+
+radix_tree_root_type = utils.CachedType("struct radix_tree_root")
+radix_tree_node_type = utils.CachedType("struct radix_tree_node")
+
+
+def is_indirect_ptr(node):
+    long_type = utils.get_long_type()
+    return (node.cast(long_type) & constants.LX_RADIX_TREE_INDIRECT_PTR)
+
+
+def indirect_to_ptr(node):
+    long_type = utils.get_long_type()
+    node_type = node.type
+    indirect_ptr = node.cast(long_type) & ~constants.LX_RADIX_TREE_INDIRECT_PTR
+    return indirect_ptr.cast(node_type)
+
+
+def maxindex(height):
+    height = height & constants.LX_RADIX_TREE_HEIGHT_MASK
+    return gdb.parse_and_eval("height_to_maxindex["+str(height)+"]")
+
+
+def lookup(root, index):
+    if root.type == radix_tree_root_type.get_type().pointer():
+        root = root.dereference()
+    elif root.type != radix_tree_root_type.get_type():
+        raise gdb.GdbError("Must be struct radix_tree_root not {}"
+                           .format(root.type))
+
+    node = root['rnode']
+    if node is 0:
+        return None
+
+    if not (is_indirect_ptr(node)):
+        if (index > 0):
+            return None
+        return node
+
+    node = indirect_to_ptr(node)
+
+    height = node['path'] & constants.LX_RADIX_TREE_HEIGHT_MASK
+    if (index > maxindex(height)):
+        return None
+
+    shift = (height-1) * constants.LX_RADIX_TREE_MAP_SHIFT
+
+    while True:
+        new_index = (index >> shift) & constants.LX_RADIX_TREE_MAP_MASK
+        slot = node['slots'][new_index]
+
+        node = slot.cast(node.type.pointer()).dereference()
+        if node is 0:
+            return None
+
+        shift -= constants.LX_RADIX_TREE_MAP_SHIFT
+        height -= 1
+
+        if (height <= 0):
+            break
+
+    return node
+
+
+class LxRadixTree(gdb.Function):
+    """ Lookup and return a node from a RadixTree.
+
+$lx_radix_tree_lookup(root_node [, index]): Return the node at the given index.
+If index is omitted, the root node is dereferenced and returned."""
+
+    def __init__(self):
+        super(LxRadixTree, self).__init__("lx_radix_tree_lookup")
+
+    def invoke(self, root, index=0):
+        result = lookup(root, index)
+        if result is None:
+            raise gdb.GdbError("No entry in tree at index {}".format(index))
+
+        return result
+
+LxRadixTree()
diff --git a/scripts/gdb/linux/tasks.py b/scripts/gdb/linux/tasks.py
index 862a4ae24d49..1bf949c43b76 100644
--- a/scripts/gdb/linux/tasks.py
+++ b/scripts/gdb/linux/tasks.py
@@ -114,3 +114,22 @@ variable."""
 
 
 LxThreadInfoFunc()
+
+
+class LxThreadInfoByPidFunc (gdb.Function):
+    """Calculate Linux thread_info from task variable found by pid
+
+$lx_thread_info_by_pid(PID): Given PID, return the corresponding thread_info
+variable."""
+
+    def __init__(self):
+        super(LxThreadInfoByPidFunc, self).__init__("lx_thread_info_by_pid")
+
+    def invoke(self, pid):
+        task = get_task_by_pid(pid)
+        if task:
+            return get_thread_info(task.dereference())
+        else:
+            raise gdb.GdbError("No task of PID " + str(pid))
+
+LxThreadInfoByPidFunc()
diff --git a/scripts/gdb/linux/utils.py b/scripts/gdb/linux/utils.py
index 0893b326a28b..50805874cfc3 100644
--- a/scripts/gdb/linux/utils.py
+++ b/scripts/gdb/linux/utils.py
@@ -87,11 +87,24 @@ def get_target_endianness():
     return target_endianness
 
 
+def read_memoryview(inf, start, length):
+    return memoryview(inf.read_memory(start, length))
+
+
 def read_u16(buffer):
+    value = [0, 0]
+
+    if type(buffer[0]) is str:
+        value[0] = ord(buffer[0])
+        value[1] = ord(buffer[1])
+    else:
+        value[0] = buffer[0]
+        value[1] = buffer[1]
+
     if get_target_endianness() == LITTLE_ENDIAN:
-        return ord(buffer[0]) + (ord(buffer[1]) << 8)
+        return value[0] + (value[1] << 8)
     else:
-        return ord(buffer[1]) + (ord(buffer[0]) << 8)
+        return value[1] + (value[0] << 8)
 
 
 def read_u32(buffer):
@@ -154,3 +167,18 @@ def get_gdbserver_type():
         if gdbserver_type is not None and hasattr(gdb, 'events'):
             gdb.events.exited.connect(exit_handler)
     return gdbserver_type
+
+
+def gdb_eval_or_none(expresssion):
+    try:
+        return gdb.parse_and_eval(expresssion)
+    except:
+        return None
+
+
+def dentry_name(d):
+    parent = d['d_parent']
+    if parent == d or parent == 0:
+        return ""
+    p = dentry_name(d['d_parent']) + "/"
+    return p + d['d_iname'].string()
diff --git a/scripts/gdb/vmlinux-gdb.py b/scripts/gdb/vmlinux-gdb.py
index d5943eca19cd..3a80ad6eecad 100644
--- a/scripts/gdb/vmlinux-gdb.py
+++ b/scripts/gdb/vmlinux-gdb.py
@@ -30,3 +30,5 @@ else:
     import linux.cpus
     import linux.lists
     import linux.proc
+    import linux.constants
+    import linux.radixtree