Merge branch 'akpm' (patches from Andrew Morton) into next

Merge more updates from Andrew Morton:

 - Most of the rest of MM.

   This includes "mark remap_file_pages syscall as deprecated" but the
   actual "replace remap_file_pages syscall with emulation" is held
   back.  I guess we'll need to work out when to pull the trigger on
   that one.

 - various minor cleanups to obscure filesystems

 - the drivers/rtc queue

 - hfsplus updates

 - ufs, hpfs, fatfs, affs, reiserfs

 - Documentation/

 - signals

 - procfs

 - cpu hotplug

 - lib/idr.c

 - rapidio

 - sysctl

 - ipc updates

* emailed patches from Andrew Morton <akpm@linux-foundation.org>: (171 commits)
  ufs: sb mutex merge + mutex_destroy
  powerpc: update comments for generic idle conversion
  cris: update comments for generic idle conversion
  idle: remove cpu_idle() forward declarations
  nbd: zero from and len fields in NBD_CMD_DISCONNECT.
  mm: convert some level-less printks to pr_*
  MAINTAINERS: adi-buildroot-devel is moderated
  MAINTAINERS: add linux-api for review of API/ABI changes
  mm/kmemleak-test.c: use pr_fmt for logging
  fs/dlm/debug_fs.c: replace seq_printf by seq_puts
  fs/dlm/lockspace.c: convert simple_str to kstr
  fs/dlm/config.c: convert simple_str to kstr
  mm: mark remap_file_pages() syscall as deprecated
  mm: memcontrol: remove unnecessary memcg argument from soft limit functions
  mm: memcontrol: clean up memcg zoneinfo lookup
  mm/memblock.c: call kmemleak directly from memblock_(alloc|free)
  mm/mempool.c: update the kmemleak stack trace for mempool allocations
  lib/radix-tree.c: update the kmemleak stack trace for radix tree allocations
  mm: introduce kmemleak_update_trace()
  mm/kmemleak.c: use %u to print ->checksum
  ...

198 files changed, 4205 insertions, 1800 deletions

diff --git a/Documentation/SubmittingPatches b/Documentation/SubmittingPatches
index 2a8e89e13e45..7e9abb8a276b 100644
--- a/Documentation/SubmittingPatches
+++ b/Documentation/SubmittingPatches
@@ -132,6 +132,20 @@ Example:
         platform_set_drvdata(), but left the variable "dev" unused,
         delete it.
 
+If your patch fixes a bug in a specific commit, e.g. you found an issue using
+git-bisect, please use the 'Fixes:' tag with the first 12 characters of the
+SHA-1 ID, and the one line summary.
+Example:
+
+        Fixes: e21d2170f366 ("video: remove unnecessary platform_set_drvdata()")
+
+The following git-config settings can be used to add a pretty format for
+outputting the above style in the git log or git show commands
+
+        [core]
+                abbrev = 12
+        [pretty]
+                fixes = Fixes: %h (\"%s\")
 
 3) Separate your changes.
 
@@ -443,7 +457,7 @@ person it names.  This tag documents that potentially interested parties
 have been included in the discussion
 
 
-14) Using Reported-by:, Tested-by:, Reviewed-by: and Suggested-by:
+14) Using Reported-by:, Tested-by:, Reviewed-by:, Suggested-by: and Fixes:
 
 If this patch fixes a problem reported by somebody else, consider adding a
 Reported-by: tag to credit the reporter for their contribution.  Please
@@ -498,6 +512,12 @@ idea was not posted in a public forum. That said, if we diligently credit our
 idea reporters, they will, hopefully, be inspired to help us again in the
 future.
 
+A Fixes: tag indicates that the patch fixes an issue in a previous commit. It
+is used to make it easy to determine where a bug originated, which can help
+review a bug fix. This tag also assists the stable kernel team in determining
+which stable kernel versions should receive your fix. This is the preferred
+method for indicating a bug fixed by the patch. See #2 above for more details.
+
 
 15) The canonical patch format
 
diff --git a/Documentation/cgroups/memory.txt b/Documentation/cgroups/memory.txt
index 4937e6fff9b4..b3429aec444c 100644
--- a/Documentation/cgroups/memory.txt
+++ b/Documentation/cgroups/memory.txt
@@ -540,14 +540,13 @@ Note:
 
 5.3 swappiness
 
-Similar to /proc/sys/vm/swappiness, but only affecting reclaim that is
-triggered by this cgroup's hard limit.  The tunable in the root cgroup
-corresponds to the global swappiness setting.
-
-Please note that unlike the global swappiness, memcg knob set to 0
-really prevents from any swapping even if there is a swap storage
-available. This might lead to memcg OOM killer if there are no file
-pages to reclaim.
+Overrides /proc/sys/vm/swappiness for the particular group. The tunable
+in the root cgroup corresponds to the global swappiness setting.
+
+Please note that unlike during the global reclaim, limit reclaim
+enforces that 0 swappiness really prevents from any swapping even if
+there is a swap storage available. This might lead to memcg OOM killer
+if there are no file pages to reclaim.
 
 5.4 failcnt
 
diff --git a/Documentation/devicetree/bindings/rtc/haoyu,hym8563.txt b/Documentation/devicetree/bindings/rtc/haoyu,hym8563.txt
index 31406fd4a43e..5c199ee044cb 100644
--- a/Documentation/devicetree/bindings/rtc/haoyu,hym8563.txt
+++ b/Documentation/devicetree/bindings/rtc/haoyu,hym8563.txt
@@ -9,6 +9,9 @@ Required properties:
 - interrupts: rtc alarm/event interrupt
 - #clock-cells: the value should be 0
 
+Optional properties:
+- clock-output-names: From common clock binding
+
 Example:
 
 hym8563: hym8563@51 {
diff --git a/Documentation/devicetree/bindings/rtc/xgene-rtc.txt b/Documentation/devicetree/bindings/rtc/xgene-rtc.txt
new file mode 100644
index 000000000000..fd195c358446
--- /dev/null
+++ b/Documentation/devicetree/bindings/rtc/xgene-rtc.txt
@@ -0,0 +1,28 @@
+* APM X-Gene Real Time Clock
+
+RTC controller for the APM X-Gene Real Time Clock
+
+Required properties:
+- compatible : Should be "apm,xgene-rtc"
+- reg: physical base address of the controller and length of memory mapped
+  region.
+- interrupts: IRQ line for the RTC.
+- #clock-cells: Should be 1.
+- clocks: Reference to the clock entry.
+
+Example:
+
+rtcclk: rtcclk {
+        compatible = "fixed-clock";
+        #clock-cells = <1>;
+        clock-frequency = <100000000>;
+        clock-output-names = "rtcclk";
+};
+
+rtc: rtc@10510000 {
+        compatible = "apm,xgene-rtc";
+        reg = <0x0 0x10510000 0x0 0x400>;
+        interrupts = <0x0 0x46 0x4>;
+        #clock-cells = <1>;
+        clocks = <&rtcclk 0>;
+};
diff --git a/Documentation/filesystems/seq_file.txt b/Documentation/filesystems/seq_file.txt
index a1e2e0dda907..1fe0ccb1af55 100644
--- a/Documentation/filesystems/seq_file.txt
+++ b/Documentation/filesystems/seq_file.txt
@@ -54,6 +54,15 @@ how the mechanism works without getting lost in other details.  (Those
 wanting to see the full source for this module can find it at
 http://lwn.net/Articles/22359/).
 
+Deprecated create_proc_entry
+
+Note that the above article uses create_proc_entry which was removed in
+kernel 3.10. Current versions require the following update
+
+-       entry = create_proc_entry("sequence", 0, NULL);
+-       if (entry)
+-               entry->proc_fops = &ct_file_ops;
++       entry = proc_create("sequence", 0, NULL, &ct_file_ops);
 
 The iterator interface
 
diff --git a/Documentation/filesystems/vfat.txt b/Documentation/filesystems/vfat.txt
index 4a93e98b290a..ce1126aceed8 100644
--- a/Documentation/filesystems/vfat.txt
+++ b/Documentation/filesystems/vfat.txt
@@ -172,6 +172,11 @@ nfs=stale_rw|nostale_ro
                 To maintain backward compatibility, '-o nfs' is also accepted,
                 defaulting to stale_rw
 
+dos1xfloppy  -- If set, use a fallback default BIOS Parameter Block
+                configuration, determined by backing device size. These static
+                parameters match defaults assumed by DOS 1.x for 160 kiB,
+                180 kiB, 320 kiB, and 360 kiB floppies and floppy images.
+
 
 <bool>: 0,1,yes,no,true,false
 
diff --git a/Documentation/kernel-parameters.txt b/Documentation/kernel-parameters.txt
index 9973a7e2e0ac..b9f67781c577 100644
--- a/Documentation/kernel-parameters.txt
+++ b/Documentation/kernel-parameters.txt
@@ -2361,6 +2361,14 @@ bytes respectively. Such letter suffixes can also be entirely omitted.
                         timeout < 0: reboot immediately
                         Format: <timeout>
 
+        crash_kexec_post_notifiers
+                        Run kdump after running panic-notifiers and dumping
+                        kmsg. This only for the users who doubt kdump always
+                        succeeds in any situation.
+                        Note that this also increases risks of kdump failure,
+                        because some panic notifiers can make the crashed
+                        kernel more unstable.
+
         parkbd.port=    [HW] Parallel port number the keyboard adapter is
                         connected to, default is 0.
                         Format: <parport#>
diff --git a/Documentation/kmemleak.txt b/Documentation/kmemleak.txt
index a7563ec4ea7b..b772418bf064 100644
--- a/Documentation/kmemleak.txt
+++ b/Documentation/kmemleak.txt
@@ -142,6 +142,7 @@ kmemleak_alloc_percpu	 - notify of a percpu memory block allocation
 kmemleak_free            - notify of a memory block freeing
 kmemleak_free_part       - notify of a partial memory block freeing
 kmemleak_free_percpu     - notify of a percpu memory block freeing
+kmemleak_update_trace    - update object allocation stack trace
 kmemleak_not_leak        - mark an object as not a leak
 kmemleak_ignore          - do not scan or report an object as leak
 kmemleak_scan_area       - add scan areas inside a memory block
diff --git a/Documentation/memory-barriers.txt b/Documentation/memory-barriers.txt
index 46412bded104..f1dc4a215593 100644
--- a/Documentation/memory-barriers.txt
+++ b/Documentation/memory-barriers.txt
@@ -115,8 +115,8 @@ For example, consider the following sequence of events:
         CPU 1           CPU 2
         =============== ===============
         { A == 1; B == 2 }
-        A = 3;          x = A;
-        B = 4;          y = B;
+        A = 3;          x = B;
+        B = 4;          y = A;
 
 The set of accesses as seen by the memory system in the middle can be arranged
 in 24 different combinations:
diff --git a/Documentation/sysctl/kernel.txt b/Documentation/sysctl/kernel.txt
index 9886c3d57fc2..708bb7f1b7e0 100644
--- a/Documentation/sysctl/kernel.txt
+++ b/Documentation/sysctl/kernel.txt
@@ -77,6 +77,7 @@ show up in /proc/sys/kernel:
 - shmmni
 - stop-a                      [ SPARC only ]
 - sysrq                       ==> Documentation/sysrq.txt
+- sysctl_writes_strict
 - tainted
 - threads-max
 - unknown_nmi_panic
@@ -762,6 +763,26 @@ without users and with a dead originative process will be destroyed.
 
 ==============================================================
 
+sysctl_writes_strict:
+
+Control how file position affects the behavior of updating sysctl values
+via the /proc/sys interface:
+
+  -1 - Legacy per-write sysctl value handling, with no printk warnings.
+       Each write syscall must fully contain the sysctl value to be
+       written, and multiple writes on the same sysctl file descriptor
+       will rewrite the sysctl value, regardless of file position.
+   0 - (default) Same behavior as above, but warn about processes that
+       perform writes to a sysctl file descriptor when the file position
+       is not 0.
+   1 - Respect file position when writing sysctl strings. Multiple writes
+       will append to the sysctl value buffer. Anything past the max length
+       of the sysctl value buffer will be ignored. Writes to numeric sysctl
+       entries must always be at file position 0 and the value must be
+       fully contained in the buffer sent in the write syscall.
+
+==============================================================
+
 tainted:
 
 Non-zero if the kernel has been tainted.  Numeric values, which
diff --git a/Documentation/vm/remap_file_pages.txt b/Documentation/vm/remap_file_pages.txt
new file mode 100644
index 000000000000..560e4363a55d
--- /dev/null
+++ b/Documentation/vm/remap_file_pages.txt
@@ -0,0 +1,28 @@
+The remap_file_pages() system call is used to create a nonlinear mapping,
+that is, a mapping in which the pages of the file are mapped into a
+nonsequential order in memory. The advantage of using remap_file_pages()
+over using repeated calls to mmap(2) is that the former approach does not
+require the kernel to create additional VMA (Virtual Memory Area) data
+structures.
+
+Supporting of nonlinear mapping requires significant amount of non-trivial
+code in kernel virtual memory subsystem including hot paths. Also to get
+nonlinear mapping work kernel need a way to distinguish normal page table
+entries from entries with file offset (pte_file). Kernel reserves flag in
+PTE for this purpose. PTE flags are scarce resource especially on some CPU
+architectures. It would be nice to free up the flag for other usage.
+
+Fortunately, there are not many users of remap_file_pages() in the wild.
+It's only known that one enterprise RDBMS implementation uses the syscall
+on 32-bit systems to map files bigger than can linearly fit into 32-bit
+virtual address space. This use-case is not critical anymore since 64-bit
+systems are widely available.
+
+The plan is to deprecate the syscall and replace it with an emulation.
+The emulation will create new VMAs instead of nonlinear mappings. It's
+going to work slower for rare users of remap_file_pages() but ABI is
+preserved.
+
+One side effect of emulation (apart from performance) is that user can hit
+vm.max_map_count limit more easily due to additional VMAs. See comment for
+DEFAULT_MAX_MAP_COUNT for more details on the limit.
diff --git a/MAINTAINERS b/MAINTAINERS
index 7d101d5ba953..f98da9025d7d 100644
--- a/MAINTAINERS
+++ b/MAINTAINERS
@@ -210,6 +210,13 @@ S:	Supported
 F:      Documentation/scsi/aacraid.txt
 F:      drivers/scsi/aacraid/
 
+ABI/API
+L:      linux-api@vger.kernel.org
+F:      Documentation/ABI/
+F:      include/linux/syscalls.h
+F:      include/uapi/
+F:      kernel/sys_ni.c
+
 ABIT UGURU 1,2 HARDWARE MONITOR DRIVER
 M:      Hans de Goede <hdegoede@redhat.com>
 L:      lm-sensors@lm-sensors.org
@@ -647,7 +654,7 @@ F:	sound/soc/codecs/ssm*
 F:      sound/soc/codecs/sigmadsp.*
 
 ANALOG DEVICES INC ASOC DRIVERS
-L:      adi-buildroot-devel@lists.sourceforge.net
+L:      adi-buildroot-devel@lists.sourceforge.net (moderated for non-subscribers)
 L:      alsa-devel@alsa-project.org (moderated for non-subscribers)
 W:      http://blackfin.uclinux.org/
 S:      Supported
@@ -1758,54 +1765,54 @@ F:	include/uapi/linux/bfs_fs.h
 
 BLACKFIN ARCHITECTURE
 M:      Steven Miao <realmz6@gmail.com>
-L:      adi-buildroot-devel@lists.sourceforge.net
+L:      adi-buildroot-devel@lists.sourceforge.net (moderated for non-subscribers)
 T:      git git://git.code.sf.net/p/adi-linux/code
 W:      http://blackfin.uclinux.org
 S:      Supported
 F:      arch/blackfin/
 
 BLACKFIN EMAC DRIVER
-L:      adi-buildroot-devel@lists.sourceforge.net
+L:      adi-buildroot-devel@lists.sourceforge.net (moderated for non-subscribers)
 W:      http://blackfin.uclinux.org
 S:      Supported
 F:      drivers/net/ethernet/adi/
 
 BLACKFIN RTC DRIVER
-L:      adi-buildroot-devel@lists.sourceforge.net
+L:      adi-buildroot-devel@lists.sourceforge.net (moderated for non-subscribers)
 W:      http://blackfin.uclinux.org
 S:      Supported
 F:      drivers/rtc/rtc-bfin.c
 
 BLACKFIN SDH DRIVER
 M:      Sonic Zhang <sonic.zhang@analog.com>
-L:      adi-buildroot-devel@lists.sourceforge.net
+L:      adi-buildroot-devel@lists.sourceforge.net (moderated for non-subscribers)
 W:      http://blackfin.uclinux.org
 S:      Supported
 F:      drivers/mmc/host/bfin_sdh.c
 
 BLACKFIN SERIAL DRIVER
 M:      Sonic Zhang <sonic.zhang@analog.com>
-L:      adi-buildroot-devel@lists.sourceforge.net
+L:      adi-buildroot-devel@lists.sourceforge.net (moderated for non-subscribers)
 W:      http://blackfin.uclinux.org
 S:      Supported
 F:      drivers/tty/serial/bfin_uart.c
 
 BLACKFIN WATCHDOG DRIVER
-L:      adi-buildroot-devel@lists.sourceforge.net
+L:      adi-buildroot-devel@lists.sourceforge.net (moderated for non-subscribers)
 W:      http://blackfin.uclinux.org
 S:      Supported
 F:      drivers/watchdog/bfin_wdt.c
 
 BLACKFIN I2C TWI DRIVER
 M:      Sonic Zhang <sonic.zhang@analog.com>
-L:      adi-buildroot-devel@lists.sourceforge.net
+L:      adi-buildroot-devel@lists.sourceforge.net (moderated for non-subscribers)
 W:      http://blackfin.uclinux.org/
 S:      Supported
 F:      drivers/i2c/busses/i2c-bfin-twi.c
 
 BLACKFIN MEDIA DRIVER
 M:      Scott Jiang <scott.jiang.linux@gmail.com>
-L:      adi-buildroot-devel@lists.sourceforge.net
+L:      adi-buildroot-devel@lists.sourceforge.net (moderated for non-subscribers)
 W:      http://blackfin.uclinux.org/
 S:      Supported
 F:      drivers/media/platform/blackfin/
diff --git a/arch/arm/kernel/isa.c b/arch/arm/kernel/isa.c
index 346485910732..9d1cf7156895 100644
--- a/arch/arm/kernel/isa.c
+++ b/arch/arm/kernel/isa.c
@@ -20,7 +20,7 @@
 
 static unsigned int isa_membase, isa_portbase, isa_portshift;
 
-static ctl_table ctl_isa_vars[4] = {
+static struct ctl_table ctl_isa_vars[4] = {
         {
                 .procname       = "membase",
                 .data           = &isa_membase, 
@@ -44,7 +44,7 @@ static ctl_table ctl_isa_vars[4] = {
 
 static struct ctl_table_header *isa_sysctl_header;
 
-static ctl_table ctl_isa[2] = {
+static struct ctl_table ctl_isa[2] = {
         {
                 .procname       = "isa",
                 .mode           = 0555,
@@ -52,7 +52,7 @@ static ctl_table ctl_isa[2] = {
         }, {}
 };
 
-static ctl_table ctl_bus[2] = {
+static struct ctl_table ctl_bus[2] = {
         {
                 .procname       = "bus",
                 .mode           = 0555,
diff --git a/arch/arm/mach-at91/sysirq_mask.c b/arch/arm/mach-at91/sysirq_mask.c
index 2ba694f9626b..f8bc3511a8c8 100644
--- a/arch/arm/mach-at91/sysirq_mask.c
+++ b/arch/arm/mach-at91/sysirq_mask.c
@@ -25,24 +25,28 @@
 
 #include "generic.h"
 
-#define AT91_RTC_IDR    0x24    /* Interrupt Disable Register */
-#define AT91_RTC_IMR    0x28    /* Interrupt Mask Register */
+#define AT91_RTC_IDR            0x24    /* Interrupt Disable Register */
+#define AT91_RTC_IMR            0x28    /* Interrupt Mask Register */
+#define AT91_RTC_IRQ_MASK       0x1f    /* Available IRQs mask */
 
 void __init at91_sysirq_mask_rtc(u32 rtc_base)
 {
         void __iomem *base;
-        u32 mask;
 
         base = ioremap(rtc_base, 64);
         if (!base)
                 return;
 
-        mask = readl_relaxed(base + AT91_RTC_IMR);
-        if (mask) {
-                pr_info("AT91: Disabling rtc irq\n");
-                writel_relaxed(mask, base + AT91_RTC_IDR);
-                (void)readl_relaxed(base + AT91_RTC_IMR);       /* flush */
-        }
+        /*
+         * sam9x5 SoCs have the following errata:
+         * "RTC: Interrupt Mask Register cannot be used
+         *  Interrupt Mask Register read always returns 0."
+         *
+         * Hence we're not relying on IMR values to disable
+         * interrupts.
+         */
+        writel_relaxed(AT91_RTC_IRQ_MASK, base + AT91_RTC_IDR);
+        (void)readl_relaxed(base + AT91_RTC_IMR);       /* flush */
 
         iounmap(base);
 }
diff --git a/arch/arm64/boot/dts/apm-storm.dtsi b/arch/arm64/boot/dts/apm-storm.dtsi
index f8c40a66e65d..c5f0a47a1375 100644
--- a/arch/arm64/boot/dts/apm-storm.dtsi
+++ b/arch/arm64/boot/dts/apm-storm.dtsi
@@ -257,6 +257,19 @@
                                 enable-offset = <0x0>;
                                 enable-mask = <0x39>;
                         };
+
+                        rtcclk: rtcclk@17000000 {
+                                compatible = "apm,xgene-device-clock";
+                                #clock-cells = <1>;
+                                clocks = <&socplldiv2 0>;
+                                reg = <0x0 0x17000000 0x0 0x2000>;
+                                reg-names = "csr-reg";
+                                csr-offset = <0xc>;
+                                csr-mask = <0x2>;
+                                enable-offset = <0x10>;
+                                enable-mask = <0x2>;
+                                clock-output-names = "rtcclk";
+                        };
                 };
 
                 serial0: serial@1c020000 {
@@ -342,5 +355,13 @@
                         phys = <&phy3 0>;
                         phy-names = "sata-phy";
                 };
+
+                rtc: rtc@10510000 {
+                        compatible = "apm,xgene-rtc";
+                        reg = <0x0 0x10510000 0x0 0x400>;
+                        interrupts = <0x0 0x46 0x4>;
+                        #clock-cells = <1>;
+                        clocks = <&rtcclk 0>;
+                };
         };
 };
diff --git a/arch/blackfin/kernel/ptrace.c b/arch/blackfin/kernel/ptrace.c
index e1f88e028cfe..8b8fe671b1a6 100644
--- a/arch/blackfin/kernel/ptrace.c
+++ b/arch/blackfin/kernel/ptrace.c
@@ -117,6 +117,7 @@ put_reg(struct task_struct *task, unsigned long regno, unsigned long data)
 int
 is_user_addr_valid(struct task_struct *child, unsigned long start, unsigned long len)
 {
+        bool valid;
         struct vm_area_struct *vma;
         struct sram_list_struct *sraml;
 
@@ -124,9 +125,12 @@ is_user_addr_valid(struct task_struct *child, unsigned long start, unsigned long
         if (start + len < start)
                 return -EIO;
 
+        down_read(&child->mm->mmap_sem);
         vma = find_vma(child->mm, start);
-        if (vma && start >= vma->vm_start && start + len <= vma->vm_end)
-                        return 0;
+        valid = vma && start >= vma->vm_start && start + len <= vma->vm_end;
+        up_read(&child->mm->mmap_sem);
+        if (valid)
+                return 0;
 
         for (sraml = child->mm->context.sram_list; sraml; sraml = sraml->next)
                 if (start >= (unsigned long)sraml->addr
diff --git a/arch/cris/arch-v10/drivers/gpio.c b/arch/cris/arch-v10/drivers/gpio.c
index f4374bae4fb4..64285e0d3481 100644
--- a/arch/cris/arch-v10/drivers/gpio.c
+++ b/arch/cris/arch-v10/drivers/gpio.c
@@ -833,8 +833,8 @@ static int __init gpio_init(void)
         printk(KERN_INFO "ETRAX 100LX GPIO driver v2.5, (c) 2001-2008 "
                 "Axis Communications AB\n");
         /* We call etrax_gpio_wake_up_check() from timer interrupt and
-         * from cpu_idle() in kernel/process.c
-         * The check in cpu_idle() reduces latency from ~15 ms to ~6 ms
+         * from default_idle() in kernel/process.c
+         * The check in default_idle() reduces latency from ~15 ms to ~6 ms
          * in some tests.
          */
         res = request_irq(TIMER0_IRQ_NBR, gpio_poll_timer_interrupt,
diff --git a/arch/cris/arch-v32/drivers/mach-fs/gpio.c b/arch/cris/arch-v32/drivers/mach-fs/gpio.c
index 9e54273af0ca..009f4ee1bd09 100644
--- a/arch/cris/arch-v32/drivers/mach-fs/gpio.c
+++ b/arch/cris/arch-v32/drivers/mach-fs/gpio.c
@@ -958,11 +958,7 @@ gpio_init(void)
 
         printk(KERN_INFO "ETRAX FS GPIO driver v2.5, (c) 2003-2007 "
                 "Axis Communications AB\n");
-        /* We call etrax_gpio_wake_up_check() from timer interrupt and
-         * from cpu_idle() in kernel/process.c
-         * The check in cpu_idle() reduces latency from ~15 ms to ~6 ms
-         * in some tests.
-         */
+        /* We call etrax_gpio_wake_up_check() from timer interrupt */
         if (request_irq(TIMER0_INTR_VECT, gpio_poll_timer_interrupt,
                         IRQF_SHARED, "gpio poll", &alarmlist))
                 printk(KERN_ERR "timer0 irq for gpio\n");
diff --git a/arch/ia64/kernel/crash.c b/arch/ia64/kernel/crash.c
index b942f4032d7a..2955f359e2a7 100644
--- a/arch/ia64/kernel/crash.c
+++ b/arch/ia64/kernel/crash.c
@@ -237,7 +237,7 @@ kdump_init_notifier(struct notifier_block *self, unsigned long val, void *data)
 }
 
 #ifdef CONFIG_SYSCTL
-static ctl_table kdump_ctl_table[] = {
+static struct ctl_table kdump_ctl_table[] = {
         {
                 .procname = "kdump_on_init",
                 .data = &kdump_on_init,
@@ -255,7 +255,7 @@ static ctl_table kdump_ctl_table[] = {
         { }
 };
 
-static ctl_table sys_table[] = {
+static struct ctl_table sys_table[] = {
         {
           .procname = "kernel",
           .mode = 0555,
diff --git a/arch/ia64/kernel/perfmon.c b/arch/ia64/kernel/perfmon.c
index d841c4bd6864..5845ffea67c3 100644
--- a/arch/ia64/kernel/perfmon.c
+++ b/arch/ia64/kernel/perfmon.c
@@ -521,7 +521,7 @@ static pmu_config_t		*pmu_conf;
 pfm_sysctl_t pfm_sysctl;
 EXPORT_SYMBOL(pfm_sysctl);
 
-static ctl_table pfm_ctl_table[]={
+static struct ctl_table pfm_ctl_table[] = {
         {
                 .procname       = "debug",
                 .data           = &pfm_sysctl.debug,
@@ -552,7 +552,7 @@ static ctl_table pfm_ctl_table[]={
         },
         {}
 };
-static ctl_table pfm_sysctl_dir[] = {
+static struct ctl_table pfm_sysctl_dir[] = {
         {
                 .procname       = "perfmon",
                 .mode           = 0555,
@@ -560,7 +560,7 @@ static ctl_table pfm_sysctl_dir[] = {
         },
         {}
 };
-static ctl_table pfm_sysctl_root[] = {
+static struct ctl_table pfm_sysctl_root[] = {
         {
                 .procname       = "kernel",
                 .mode           = 0555,
diff --git a/arch/m68k/include/asm/signal.h b/arch/m68k/include/asm/signal.h
index 214320b50384..8c8ce5e1ee0e 100644
--- a/arch/m68k/include/asm/signal.h
+++ b/arch/m68k/include/asm/signal.h
@@ -60,15 +60,6 @@ static inline int __gen_sigismember(sigset_t *set, int _sig)
          __const_sigismember(set,sig) :         \
          __gen_sigismember(set,sig))
 
-static inline int sigfindinword(unsigned long word)
-{
-        asm ("bfffo %1{#0,#0},%0"
-                : "=d" (word)
-                : "d" (word & -word)
-                : "cc");
-        return word ^ 31;
-}
-
 #endif /* !CONFIG_CPU_HAS_NO_BITFIELDS */
 
 #ifndef __uClinux__
diff --git a/arch/mips/dec/Makefile b/arch/mips/dec/Makefile
index 3d5d2c56de8d..bd74e05c90b0 100644
--- a/arch/mips/dec/Makefile
+++ b/arch/mips/dec/Makefile
@@ -3,7 +3,7 @@
 #
 
 obj-y           := ecc-berr.o int-handler.o ioasic-irq.o kn01-berr.o \
-                   kn02-irq.o kn02xa-berr.o reset.o setup.o time.o
+                   kn02-irq.o kn02xa-berr.o platform.o reset.o setup.o time.o
 
 obj-$(CONFIG_TC)                += tc.o
 obj-$(CONFIG_CPU_HAS_WB)        += wbflush.o
diff --git a/arch/mips/dec/platform.c b/arch/mips/dec/platform.c
new file mode 100644
index 000000000000..c7ac86af847a
--- /dev/null
+++ b/arch/mips/dec/platform.c
@@ -0,0 +1,44 @@
+/*
+ *      DEC platform devices.
+ *
+ *      Copyright (c) 2014  Maciej W. Rozycki
+ *
+ *      This program is free software; you can redistribute it and/or
+ *      modify it under the terms of the GNU General Public License
+ *      as published by the Free Software Foundation; either version
+ *      2 of the License, or (at your option) any later version.
+ */
+
+#include <linux/ioport.h>
+#include <linux/kernel.h>
+#include <linux/mc146818rtc.h>
+#include <linux/platform_device.h>
+
+static struct resource dec_rtc_resources[] = {
+        {
+                .name = "rtc",
+                .flags = IORESOURCE_MEM,
+        },
+};
+
+static struct cmos_rtc_board_info dec_rtc_info = {
+        .flags = CMOS_RTC_FLAGS_NOFREQ,
+        .address_space = 64,
+};
+
+static struct platform_device dec_rtc_device = {
+        .name = "rtc_cmos",
+        .id = PLATFORM_DEVID_NONE,
+        .dev.platform_data = &dec_rtc_info,
+        .resource = dec_rtc_resources,
+        .num_resources = ARRAY_SIZE(dec_rtc_resources),
+};
+
+static int __init dec_add_devices(void)
+{
+        dec_rtc_resources[0].start = RTC_PORT(0);
+        dec_rtc_resources[0].end = RTC_PORT(0) + dec_kn_slot_size - 1;
+        return platform_device_register(&dec_rtc_device);
+}
+
+device_initcall(dec_add_devices);
diff --git a/arch/powerpc/kernel/irq.c b/arch/powerpc/kernel/irq.c
index ca1cd7459c4a..248ee7e5bebd 100644
--- a/arch/powerpc/kernel/irq.c
+++ b/arch/powerpc/kernel/irq.c
@@ -304,7 +304,7 @@ void notrace restore_interrupts(void)
  * being re-enabled and generally sanitized the lazy irq state,
  * and in the latter case it will leave with interrupts hard
  * disabled and marked as such, so the local_irq_enable() call
- * in cpu_idle() will properly re-enable everything.
+ * in arch_cpu_idle() will properly re-enable everything.
  */
 bool prep_irq_for_idle(void)
 {
diff --git a/arch/tile/kernel/proc.c b/arch/tile/kernel/proc.c
index 681100c59fda..6829a9508649 100644
--- a/arch/tile/kernel/proc.c
+++ b/arch/tile/kernel/proc.c
@@ -113,7 +113,7 @@ arch_initcall(proc_tile_init);
  * Support /proc/sys/tile directory
  */
 
-static ctl_table unaligned_subtable[] = {
+static struct ctl_table unaligned_subtable[] = {
         {
                 .procname       = "enabled",
                 .data           = &unaligned_fixup,
@@ -138,7 +138,7 @@ static ctl_table unaligned_subtable[] = {
         {}
 };
 
-static ctl_table unaligned_table[] = {
+static struct ctl_table unaligned_table[] = {
         {
                 .procname       = "unaligned_fixup",
                 .mode           = 0555,
diff --git a/arch/x86/include/asm/signal.h b/arch/x86/include/asm/signal.h
index 35e67a457182..31eab867e6d3 100644
--- a/arch/x86/include/asm/signal.h
+++ b/arch/x86/include/asm/signal.h
@@ -92,12 +92,6 @@ static inline int __gen_sigismember(sigset_t *set, int _sig)
          ? __const_sigismember((set), (sig))    \
          : __gen_sigismember((set), (sig)))
 
-static inline int sigfindinword(unsigned long word)
-{
-        asm("bsfl %1,%0" : "=r"(word) : "rm"(word) : "cc");
-        return word;
-}
-
 struct pt_regs;
 
 #else /* __i386__ */
diff --git a/block/bounce.c b/block/bounce.c
index 523918b8c6dc..ab21ba203d5c 100644
--- a/block/bounce.c
+++ b/block/bounce.c
@@ -3,6 +3,8 @@
  * - Split from highmem.c
  */
 
+#define pr_fmt(fmt) KBUILD_MODNAME ": " fmt
+
 #include <linux/mm.h>
 #include <linux/export.h>
 #include <linux/swap.h>
@@ -15,6 +17,7 @@
 #include <linux/hash.h>
 #include <linux/highmem.h>
 #include <linux/bootmem.h>
+#include <linux/printk.h>
 #include <asm/tlbflush.h>
 
 #include <trace/events/block.h>
@@ -34,7 +37,7 @@ static __init int init_emergency_pool(void)
 
         page_pool = mempool_create_page_pool(POOL_SIZE, 0);
         BUG_ON(!page_pool);
-        printk("bounce pool size: %d pages\n", POOL_SIZE);
+        pr_info("pool size: %d pages\n", POOL_SIZE);
 
         return 0;
 }
@@ -86,7 +89,7 @@ int init_emergency_isa_pool(void)
                                        mempool_free_pages, (void *) 0);
         BUG_ON(!isa_page_pool);
 
-        printk("isa bounce pool size: %d pages\n", ISA_POOL_SIZE);
+        pr_info("isa pool size: %d pages\n", ISA_POOL_SIZE);
         return 0;
 }
 
diff --git a/drivers/block/nbd.c b/drivers/block/nbd.c
index 56a027d6115e..fb31b8ee4372 100644
--- a/drivers/block/nbd.c
+++ b/drivers/block/nbd.c
@@ -243,14 +243,11 @@ static int nbd_send_req(struct nbd_device *nbd, struct request *req)
         struct nbd_request request;
         unsigned long size = blk_rq_bytes(req);
 
+        memset(&request, 0, sizeof(request));
         request.magic = htonl(NBD_REQUEST_MAGIC);
         request.type = htonl(nbd_cmd(req));
 
-        if (nbd_cmd(req) == NBD_CMD_FLUSH) {
-                /* Other values are reserved for FLUSH requests.  */
-                request.from = 0;
-                request.len = 0;
-        } else {
+        if (nbd_cmd(req) != NBD_CMD_FLUSH && nbd_cmd(req) != NBD_CMD_DISC) {
                 request.from = cpu_to_be64((u64)blk_rq_pos(req) << 9);
                 request.len = htonl(size);
         }
diff --git a/drivers/cdrom/cdrom.c b/drivers/cdrom/cdrom.c
index 49ac5662585b..2a44767891f5 100644
--- a/drivers/cdrom/cdrom.c
+++ b/drivers/cdrom/cdrom.c
@@ -3470,7 +3470,7 @@ static int cdrom_print_info(const char *header, int val, char *info,
         return 0;
 }
 
-static int cdrom_sysctl_info(ctl_table *ctl, int write,
+static int cdrom_sysctl_info(struct ctl_table *ctl, int write,
                            void __user *buffer, size_t *lenp, loff_t *ppos)
 {
         int pos;
@@ -3583,7 +3583,7 @@ static void cdrom_update_settings(void)
         mutex_unlock(&cdrom_mutex);
 }
 
-static int cdrom_sysctl_handler(ctl_table *ctl, int write,
+static int cdrom_sysctl_handler(struct ctl_table *ctl, int write,
                                 void __user *buffer, size_t *lenp, loff_t *ppos)
 {
         int ret;
@@ -3609,7 +3609,7 @@ static int cdrom_sysctl_handler(ctl_table *ctl, int write,
 }
 
 /* Place files in /proc/sys/dev/cdrom */
-static ctl_table cdrom_table[] = {
+static struct ctl_table cdrom_table[] = {
         {
                 .procname       = "info",
                 .data           = &cdrom_sysctl_settings.info, 
@@ -3655,7 +3655,7 @@ static ctl_table cdrom_table[] = {
         { }
 };
 
-static ctl_table cdrom_cdrom_table[] = {
+static struct ctl_table cdrom_cdrom_table[] = {
         {
                 .procname       = "cdrom",
                 .maxlen         = 0,
@@ -3666,7 +3666,7 @@ static ctl_table cdrom_cdrom_table[] = {
 };
 
 /* Make sure that /proc/sys/dev is there */
-static ctl_table cdrom_root_table[] = {
+static struct ctl_table cdrom_root_table[] = {
         {
                 .procname       = "dev",
                 .maxlen         = 0,
diff --git a/drivers/char/random.c b/drivers/char/random.c
index 06cea7ff3a7c..4ad71ef2cd59 100644
--- a/drivers/char/random.c
+++ b/drivers/char/random.c
@@ -1582,10 +1582,10 @@ static int proc_do_uuid(struct ctl_table *table, int write,
 /*
  * Return entropy available scaled to integral bits
  */
-static int proc_do_entropy(ctl_table *table, int write,
+static int proc_do_entropy(struct ctl_table *table, int write,
                            void __user *buffer, size_t *lenp, loff_t *ppos)
 {
-        ctl_table fake_table;
+        struct ctl_table fake_table;
         int entropy_count;
 
         entropy_count = *(int *)table->data >> ENTROPY_SHIFT;
diff --git a/drivers/parport/procfs.c b/drivers/parport/procfs.c
index 92ed045a5f93..3b470801a04f 100644
--- a/drivers/parport/procfs.c
+++ b/drivers/parport/procfs.c
@@ -31,7 +31,7 @@
 #define PARPORT_MIN_SPINTIME_VALUE 1
 #define PARPORT_MAX_SPINTIME_VALUE 1000
 
-static int do_active_device(ctl_table *table, int write,
+static int do_active_device(struct ctl_table *table, int write,
                       void __user *result, size_t *lenp, loff_t *ppos)
 {
         struct parport *port = (struct parport *)table->extra1;
@@ -68,7 +68,7 @@ static int do_active_device(ctl_table *table, int write,
 }
 
 #ifdef CONFIG_PARPORT_1284
-static int do_autoprobe(ctl_table *table, int write,
+static int do_autoprobe(struct ctl_table *table, int write,
                         void __user *result, size_t *lenp, loff_t *ppos)
 {
         struct parport_device_info *info = table->extra2;
@@ -110,9 +110,9 @@ static int do_autoprobe(ctl_table *table, int write,
 }
 #endif /* IEEE1284.3 support. */
 
-static int do_hardware_base_addr (ctl_table *table, int write,
-                                  void __user *result,
-                                  size_t *lenp, loff_t *ppos)
+static int do_hardware_base_addr(struct ctl_table *table, int write,
+                                 void __user *result,
+                                 size_t *lenp, loff_t *ppos)
 {
         struct parport *port = (struct parport *)table->extra1;
         char buffer[20];
@@ -138,9 +138,9 @@ static int do_hardware_base_addr (ctl_table *table, int write,
         return copy_to_user(result, buffer, len) ? -EFAULT : 0;
 }
 
-static int do_hardware_irq (ctl_table *table, int write,
-                            void __user *result,
-                            size_t *lenp, loff_t *ppos)
+static int do_hardware_irq(struct ctl_table *table, int write,
+                           void __user *result,
+                           size_t *lenp, loff_t *ppos)
 {
         struct parport *port = (struct parport *)table->extra1;
         char buffer[20];
@@ -166,9 +166,9 @@ static int do_hardware_irq (ctl_table *table, int write,
         return copy_to_user(result, buffer, len) ? -EFAULT : 0;
 }
 
-static int do_hardware_dma (ctl_table *table, int write,
-                            void __user *result,
-                            size_t *lenp, loff_t *ppos)
+static int do_hardware_dma(struct ctl_table *table, int write,
+                           void __user *result,
+                           size_t *lenp, loff_t *ppos)
 {
         struct parport *port = (struct parport *)table->extra1;
         char buffer[20];
@@ -194,9 +194,9 @@ static int do_hardware_dma (ctl_table *table, int write,
         return copy_to_user(result, buffer, len) ? -EFAULT : 0;
 }
 
-static int do_hardware_modes (ctl_table *table, int write,
-                              void __user *result,
-                              size_t *lenp, loff_t *ppos)
+static int do_hardware_modes(struct ctl_table *table, int write,
+                             void __user *result,
+                             size_t *lenp, loff_t *ppos)
 {
         struct parport *port = (struct parport *)table->extra1;
         char buffer[40];
@@ -255,11 +255,11 @@ PARPORT_MAX_SPINTIME_VALUE;
 
 struct parport_sysctl_table {
         struct ctl_table_header *sysctl_header;
-        ctl_table vars[12];
-        ctl_table device_dir[2];
-        ctl_table port_dir[2];
-        ctl_table parport_dir[2];
-        ctl_table dev_dir[2];
+        struct ctl_table vars[12];
+        struct ctl_table device_dir[2];
+        struct ctl_table port_dir[2];
+        struct ctl_table parport_dir[2];
+        struct ctl_table dev_dir[2];
 };
 
 static const struct parport_sysctl_table parport_sysctl_template = {
@@ -369,12 +369,12 @@ static const struct parport_sysctl_table parport_sysctl_template = {
 struct parport_device_sysctl_table
 {
         struct ctl_table_header *sysctl_header;
-        ctl_table vars[2];
-        ctl_table device_dir[2];
-        ctl_table devices_root_dir[2];
-        ctl_table port_dir[2];
-        ctl_table parport_dir[2];
-        ctl_table dev_dir[2];
+        struct ctl_table vars[2];
+        struct ctl_table device_dir[2];
+        struct ctl_table devices_root_dir[2];
+        struct ctl_table port_dir[2];
+        struct ctl_table parport_dir[2];
+        struct ctl_table dev_dir[2];
 };
 
 static const struct parport_device_sysctl_table
@@ -422,10 +422,10 @@ parport_device_sysctl_template = {
 struct parport_default_sysctl_table
 {
         struct ctl_table_header *sysctl_header;
-        ctl_table vars[3];
-        ctl_table default_dir[2];
-        ctl_table parport_dir[2];
-        ctl_table dev_dir[2];
+        struct ctl_table vars[3];
+        struct ctl_table default_dir[2];
+        struct ctl_table parport_dir[2];
+        struct ctl_table dev_dir[2];
 };
 
 static struct parport_default_sysctl_table
diff --git a/drivers/rapidio/devices/tsi721.c b/drivers/rapidio/devices/tsi721.c
index 1753dc693c15..2ca1a0b3ad57 100644
--- a/drivers/rapidio/devices/tsi721.c
+++ b/drivers/rapidio/devices/tsi721.c
@@ -768,15 +768,10 @@ static int tsi721_enable_msix(struct tsi721_device *priv)
         }
 #endif /* CONFIG_RAPIDIO_DMA_ENGINE */
 
-        err = pci_enable_msix(priv->pdev, entries, ARRAY_SIZE(entries));
+        err = pci_enable_msix_exact(priv->pdev, entries, ARRAY_SIZE(entries));
         if (err) {
-                if (err > 0)
-                        dev_info(&priv->pdev->dev,
-                                 "Only %d MSI-X vectors available, "
-                                 "not using MSI-X\n", err);
-                else
-                        dev_err(&priv->pdev->dev,
-                                "Failed to enable MSI-X (err=%d)\n", err);
+                dev_err(&priv->pdev->dev,
+                        "Failed to enable MSI-X (err=%d)\n", err);
                 return err;
         }
 
diff --git a/drivers/rtc/Kconfig b/drivers/rtc/Kconfig
index 2e565f8e5165..71988b69eca6 100644
--- a/drivers/rtc/Kconfig
+++ b/drivers/rtc/Kconfig
@@ -386,12 +386,12 @@ config RTC_DRV_PCF8583
           will be called rtc-pcf8583.
 
 config RTC_DRV_M41T80
-        tristate "ST M41T62/65/M41T80/81/82/83/84/85/87"
+        tristate "ST M41T62/65/M41T80/81/82/83/84/85/87 and compatible"
         help
           If you say Y here you will get support for the ST M41T60
           and M41T80 RTC chips series. Currently, the following chips are
           supported: M41T62, M41T65, M41T80, M41T81, M41T82, M41T83, M41ST84,
-          M41ST85, and M41ST87.
+          M41ST85, M41ST87, and MicroCrystal RV4162.
 
           This driver can also be built as a module. If so, the module
           will be called rtc-m41t80.
@@ -573,6 +573,17 @@ config RTC_DRV_DS1305
           This driver can also be built as a module. If so, the module
           will be called rtc-ds1305.
 
+config RTC_DRV_DS1343
+        select REGMAP_SPI
+        tristate "Dallas/Maxim DS1343/DS1344"
+        help
+          If you say yes here you get support for the
+          Dallas/Maxim DS1343 and DS1344 real time clock chips.
+          Support for trickle charger, alarm is provided.
+
+          This driver can also be built as a module. If so, the module
+          will be called rtc-ds1343.
+
 config RTC_DRV_DS1347
         tristate "Dallas/Maxim DS1347"
         help
@@ -650,6 +661,14 @@ config RTC_DRV_RX4581
           This driver can also be built as a module. If so the module
           will be called rtc-rx4581.
 
+config RTC_DRV_MCP795
+        tristate "Microchip MCP795"
+        help
+          If you say yes here you will get support for the Microchip MCP795.
+
+          This driver can also be built as a module. If so the module
+          will be called rtc-mcp795.
+
 endif # SPI_MASTER
 
 comment "Platform RTC drivers"
@@ -758,6 +777,16 @@ config RTC_DRV_DA9055
           This driver can also be built as a module. If so, the module
           will be called rtc-da9055
 
+config RTC_DRV_DA9063
+        tristate "Dialog Semiconductor DA9063 RTC"
+        depends on MFD_DA9063
+        help
+          If you say yes here you will get support for the RTC subsystem
+          of the Dialog Semiconductor DA9063.
+
+          This driver can also be built as a module. If so, the module
+          will be called "rtc-da9063".
+
 config RTC_DRV_EFI
         tristate "EFI RTC"
         depends on IA64
@@ -1327,6 +1356,15 @@ config RTC_DRV_MOXART
            This driver can also be built as a module. If so, the module
            will be called rtc-moxart
 
+config RTC_DRV_XGENE
+        tristate "APM X-Gene RTC"
+        help
+          If you say yes here you get support for the APM X-Gene SoC real time
+          clock.
+
+          This driver can also be built as a module, if so, the module
+          will be called "rtc-xgene".
+
 comment "HID Sensor RTC drivers"
 
 config RTC_DRV_HID_SENSOR_TIME
diff --git a/drivers/rtc/Makefile b/drivers/rtc/Makefile
index 40a09915c8f6..70347d041d10 100644
--- a/drivers/rtc/Makefile
+++ b/drivers/rtc/Makefile
@@ -32,6 +32,7 @@ obj-$(CONFIG_RTC_DRV_CMOS)	+= rtc-cmos.o
 obj-$(CONFIG_RTC_DRV_COH901331) += rtc-coh901331.o
 obj-$(CONFIG_RTC_DRV_DA9052)    += rtc-da9052.o
 obj-$(CONFIG_RTC_DRV_DA9055)    += rtc-da9055.o
+obj-$(CONFIG_RTC_DRV_DA9063)    += rtc-da9063.o
 obj-$(CONFIG_RTC_DRV_DAVINCI)   += rtc-davinci.o
 obj-$(CONFIG_RTC_DRV_DM355EVM)  += rtc-dm355evm.o
 obj-$(CONFIG_RTC_DRV_VRTC)      += rtc-mrst.o
@@ -40,6 +41,7 @@ obj-$(CONFIG_RTC_DRV_DS1286)	+= rtc-ds1286.o
 obj-$(CONFIG_RTC_DRV_DS1302)    += rtc-ds1302.o
 obj-$(CONFIG_RTC_DRV_DS1305)    += rtc-ds1305.o
 obj-$(CONFIG_RTC_DRV_DS1307)    += rtc-ds1307.o
+obj-$(CONFIG_RTC_DRV_DS1343)    += rtc-ds1343.o
 obj-$(CONFIG_RTC_DRV_DS1347)    += rtc-ds1347.o
 obj-$(CONFIG_RTC_DRV_DS1374)    += rtc-ds1374.o
 obj-$(CONFIG_RTC_DRV_DS1390)    += rtc-ds1390.o
@@ -80,6 +82,7 @@ obj-$(CONFIG_RTC_DRV_MAX8997)	+= rtc-max8997.o
 obj-$(CONFIG_RTC_DRV_MAX6902)   += rtc-max6902.o
 obj-$(CONFIG_RTC_DRV_MAX77686)  += rtc-max77686.o
 obj-$(CONFIG_RTC_DRV_MC13XXX)   += rtc-mc13xxx.o
+obj-$(CONFIG_RTC_DRV_MCP795)    += rtc-mcp795.o
 obj-$(CONFIG_RTC_DRV_MSM6242)   += rtc-msm6242.o
 obj-$(CONFIG_RTC_DRV_MPC5121)   += rtc-mpc5121.o
 obj-$(CONFIG_RTC_DRV_MV)        += rtc-mv.o
@@ -135,5 +138,6 @@ obj-$(CONFIG_RTC_DRV_VT8500)	+= rtc-vt8500.o
 obj-$(CONFIG_RTC_DRV_WM831X)    += rtc-wm831x.o
 obj-$(CONFIG_RTC_DRV_WM8350)    += rtc-wm8350.o
 obj-$(CONFIG_RTC_DRV_X1205)     += rtc-x1205.o
+obj-$(CONFIG_RTC_DRV_XGENE)     += rtc-xgene.o
 obj-$(CONFIG_RTC_DRV_SIRFSOC)   += rtc-sirfsoc.o
 obj-$(CONFIG_RTC_DRV_MOXART)    += rtc-moxart.o
diff --git a/drivers/rtc/interface.c b/drivers/rtc/interface.c
index c2eff6082363..5813fa52c3d4 100644
--- a/drivers/rtc/interface.c
+++ b/drivers/rtc/interface.c
@@ -292,7 +292,8 @@ int __rtc_read_alarm(struct rtc_device *rtc, struct rtc_wkalrm *alarm)
                 dev_dbg(&rtc->dev, "alarm rollover: %s\n", "year");
                 do {
                         alarm->time.tm_year++;
-                } while (rtc_valid_tm(&alarm->time) != 0);
+                } while (!is_leap_year(alarm->time.tm_year + 1900)
+                        && rtc_valid_tm(&alarm->time) != 0);
                 break;
 
         default:
@@ -300,7 +301,16 @@ int __rtc_read_alarm(struct rtc_device *rtc, struct rtc_wkalrm *alarm)
         }
 
 done:
-        return 0;
+        err = rtc_valid_tm(&alarm->time);
+
+        if (err) {
+                dev_warn(&rtc->dev, "invalid alarm value: %d-%d-%d %d:%d:%d\n",
+                        alarm->time.tm_year + 1900, alarm->time.tm_mon + 1,
+                        alarm->time.tm_mday, alarm->time.tm_hour, alarm->time.tm_min,
+                        alarm->time.tm_sec);
+        }
+
+        return err;
 }
 
 int rtc_read_alarm(struct rtc_device *rtc, struct rtc_wkalrm *alarm)
diff --git a/drivers/rtc/rtc-88pm860x.c b/drivers/rtc/rtc-88pm860x.c
index 816504846cdd..0c6add1a38dc 100644
--- a/drivers/rtc/rtc-88pm860x.c
+++ b/drivers/rtc/rtc-88pm860x.c
@@ -293,7 +293,7 @@ static int pm860x_rtc_dt_init(struct platform_device *pdev,
         int ret;
         if (!np)
                 return -ENODEV;
-        np = of_find_node_by_name(np, "rtc");
+        np = of_get_child_by_name(np, "rtc");
         if (!np) {
                 dev_err(&pdev->dev, "failed to find rtc node\n");
                 return -ENODEV;
@@ -301,6 +301,7 @@ static int pm860x_rtc_dt_init(struct platform_device *pdev,
         ret = of_property_read_u32(np, "marvell,88pm860x-vrtc", &info->vrtc);
         if (ret)
                 info->vrtc = 0;
+        of_node_put(np);
         return 0;
 }
 #else
diff --git a/drivers/rtc/rtc-at91rm9200.c b/drivers/rtc/rtc-at91rm9200.c
index 3281c90691c3..44fe83ee9bee 100644
--- a/drivers/rtc/rtc-at91rm9200.c
+++ b/drivers/rtc/rtc-at91rm9200.c
@@ -48,6 +48,7 @@ struct at91_rtc_config {
 
 static const struct at91_rtc_config *at91_rtc_config;
 static DECLARE_COMPLETION(at91_rtc_updated);
+static DECLARE_COMPLETION(at91_rtc_upd_rdy);
 static unsigned int at91_alarm_year = AT91_RTC_EPOCH;
 static void __iomem *at91_rtc_regs;
 static int irq;
@@ -161,6 +162,8 @@ static int at91_rtc_settime(struct device *dev, struct rtc_time *tm)
                 1900 + tm->tm_year, tm->tm_mon, tm->tm_mday,
                 tm->tm_hour, tm->tm_min, tm->tm_sec);
 
+        wait_for_completion(&at91_rtc_upd_rdy);
+
         /* Stop Time/Calendar from counting */
         cr = at91_rtc_read(AT91_RTC_CR);
         at91_rtc_write(AT91_RTC_CR, cr | AT91_RTC_UPDCAL | AT91_RTC_UPDTIM);
@@ -183,7 +186,9 @@ static int at91_rtc_settime(struct device *dev, struct rtc_time *tm)
 
         /* Restart Time/Calendar */
         cr = at91_rtc_read(AT91_RTC_CR);
+        at91_rtc_write(AT91_RTC_SCCR, AT91_RTC_SECEV);
         at91_rtc_write(AT91_RTC_CR, cr & ~(AT91_RTC_UPDCAL | AT91_RTC_UPDTIM));
+        at91_rtc_write_ier(AT91_RTC_SECEV);
 
         return 0;
 }
@@ -290,8 +295,10 @@ static irqreturn_t at91_rtc_interrupt(int irq, void *dev_id)
         if (rtsr) {             /* this interrupt is shared!  Is it ours? */
                 if (rtsr & AT91_RTC_ALARM)
                         events |= (RTC_AF | RTC_IRQF);
-                if (rtsr & AT91_RTC_SECEV)
-                        events |= (RTC_UF | RTC_IRQF);
+                if (rtsr & AT91_RTC_SECEV) {
+                        complete(&at91_rtc_upd_rdy);
+                        at91_rtc_write_idr(AT91_RTC_SECEV);
+                }
                 if (rtsr & AT91_RTC_ACKUPD)
                         complete(&at91_rtc_updated);
 
@@ -413,6 +420,11 @@ static int __init at91_rtc_probe(struct platform_device *pdev)
                 return PTR_ERR(rtc);
         platform_set_drvdata(pdev, rtc);
 
+        /* enable SECEV interrupt in order to initialize at91_rtc_upd_rdy
+         * completion.
+         */
+        at91_rtc_write_ier(AT91_RTC_SECEV);
+
         dev_info(&pdev->dev, "AT91 Real Time Clock driver.\n");
         return 0;
 }
diff --git a/drivers/rtc/rtc-bfin.c b/drivers/rtc/rtc-bfin.c
index 0c53f452849d..fe4bdb06a55a 100644
--- a/drivers/rtc/rtc-bfin.c
+++ b/drivers/rtc/rtc-bfin.c
@@ -346,7 +346,7 @@ static int bfin_rtc_probe(struct platform_device *pdev)
 {
         struct bfin_rtc *rtc;
         struct device *dev = &pdev->dev;
-        int ret = 0;
+        int ret;
         unsigned long timeout = jiffies + HZ;
 
         dev_dbg_stamp(dev);
@@ -361,16 +361,17 @@ static int bfin_rtc_probe(struct platform_device *pdev)
         /* Register our RTC with the RTC framework */
         rtc->rtc_dev = devm_rtc_device_register(dev, pdev->name, &bfin_rtc_ops,
                                                 THIS_MODULE);
-        if (unlikely(IS_ERR(rtc->rtc_dev))) {
-                ret = PTR_ERR(rtc->rtc_dev);
-                goto err;
-        }
+        if (unlikely(IS_ERR(rtc->rtc_dev)))
+                return PTR_ERR(rtc->rtc_dev);
 
         /* Grab the IRQ and init the hardware */
         ret = devm_request_irq(dev, IRQ_RTC, bfin_rtc_interrupt, 0,
                                 pdev->name, dev);
         if (unlikely(ret))
-                goto err;
+                dev_err(&pdev->dev,
+                        "unable to request IRQ; alarm won't work, "
+                        "and writes will be delayed\n");
+
         /* sometimes the bootloader touched things, but the write complete was not
          * enabled, so let's just do a quick timeout here since the IRQ will not fire ...
          */
@@ -381,9 +382,6 @@ static int bfin_rtc_probe(struct platform_device *pdev)
         bfin_write_RTC_SWCNT(0);
 
         return 0;
-
-err:
-        return ret;
 }
 
 static int bfin_rtc_remove(struct platform_device *pdev)
diff --git a/drivers/rtc/rtc-cmos.c b/drivers/rtc/rtc-cmos.c
index 0963c9309c74..b0e4a3eb33c7 100644
--- a/drivers/rtc/rtc-cmos.c
+++ b/drivers/rtc/rtc-cmos.c
@@ -647,6 +647,7 @@ cmos_do_probe(struct device *dev, struct resource *ports, int rtc_irq)
         int                             retval = 0;
         unsigned char                   rtc_control;
         unsigned                        address_space;
+        u32                             flags = 0;
 
         /* there can be only one ... */
         if (cmos_rtc.dev)
@@ -660,9 +661,12 @@ cmos_do_probe(struct device *dev, struct resource *ports, int rtc_irq)
          * REVISIT non-x86 systems may instead use memory space resources
          * (needing ioremap etc), not i/o space resources like this ...
          */
-        ports = request_region(ports->start,
-                        resource_size(ports),
-                        driver_name);
+        if (RTC_IOMAPPED)
+                ports = request_region(ports->start, resource_size(ports),
+                                       driver_name);
+        else
+                ports = request_mem_region(ports->start, resource_size(ports),
+                                           driver_name);
         if (!ports) {
                 dev_dbg(dev, "i/o registers already in use\n");
                 return -EBUSY;
@@ -699,6 +703,11 @@ cmos_do_probe(struct device *dev, struct resource *ports, int rtc_irq)
          * expect CMOS_READ and friends to handle.
          */
         if (info) {
+                if (info->flags)
+                        flags = info->flags;
+                if (info->address_space)
+                        address_space = info->address_space;
+
                 if (info->rtc_day_alarm && info->rtc_day_alarm < 128)
                         cmos_rtc.day_alrm = info->rtc_day_alarm;
                 if (info->rtc_mon_alarm && info->rtc_mon_alarm < 128)
@@ -726,18 +735,21 @@ cmos_do_probe(struct device *dev, struct resource *ports, int rtc_irq)
 
         spin_lock_irq(&rtc_lock);
 
-        /* force periodic irq to CMOS reset default of 1024Hz;
-         *
-         * REVISIT it's been reported that at least one x86_64 ALI mobo
-         * doesn't use 32KHz here ... for portability we might need to
-         * do something about other clock frequencies.
-         */
-        cmos_rtc.rtc->irq_freq = 1024;
-        hpet_set_periodic_freq(cmos_rtc.rtc->irq_freq);
-        CMOS_WRITE(RTC_REF_CLCK_32KHZ | 0x06, RTC_FREQ_SELECT);
+        if (!(flags & CMOS_RTC_FLAGS_NOFREQ)) {
+                /* force periodic irq to CMOS reset default of 1024Hz;
+                 *
+                 * REVISIT it's been reported that at least one x86_64 ALI
+                 * mobo doesn't use 32KHz here ... for portability we might
+                 * need to do something about other clock frequencies.
+                 */
+                cmos_rtc.rtc->irq_freq = 1024;
+                hpet_set_periodic_freq(cmos_rtc.rtc->irq_freq);
+                CMOS_WRITE(RTC_REF_CLCK_32KHZ | 0x06, RTC_FREQ_SELECT);
+        }
 
         /* disable irqs */
-        cmos_irq_disable(&cmos_rtc, RTC_PIE | RTC_AIE | RTC_UIE);
+        if (is_valid_irq(rtc_irq))
+                cmos_irq_disable(&cmos_rtc, RTC_PIE | RTC_AIE | RTC_UIE);
 
         rtc_control = CMOS_READ(RTC_CONTROL);
 
@@ -802,14 +814,18 @@ cleanup1:
         cmos_rtc.dev = NULL;
         rtc_device_unregister(cmos_rtc.rtc);
 cleanup0:
-        release_region(ports->start, resource_size(ports));
+        if (RTC_IOMAPPED)
+                release_region(ports->start, resource_size(ports));
+        else
+                release_mem_region(ports->start, resource_size(ports));
         return retval;
 }
 
-static void cmos_do_shutdown(void)
+static void cmos_do_shutdown(int rtc_irq)
 {
         spin_lock_irq(&rtc_lock);
-        cmos_irq_disable(&cmos_rtc, RTC_IRQMASK);
+        if (is_valid_irq(rtc_irq))
+                cmos_irq_disable(&cmos_rtc, RTC_IRQMASK);
         spin_unlock_irq(&rtc_lock);
 }
 
@@ -818,7 +834,7 @@ static void __exit cmos_do_remove(struct device *dev)
         struct cmos_rtc *cmos = dev_get_drvdata(dev);
         struct resource *ports;
 
-        cmos_do_shutdown();
+        cmos_do_shutdown(cmos->irq);
 
         sysfs_remove_bin_file(&dev->kobj, &nvram);
 
@@ -831,7 +847,10 @@ static void __exit cmos_do_remove(struct device *dev)
         cmos->rtc = NULL;
 
         ports = cmos->iomem;
-        release_region(ports->start, resource_size(ports));
+        if (RTC_IOMAPPED)
+                release_region(ports->start, resource_size(ports));
+        else
+                release_mem_region(ports->start, resource_size(ports));
         cmos->iomem = NULL;
 
         cmos->dev = NULL;
@@ -1065,10 +1084,13 @@ static void __exit cmos_pnp_remove(struct pnp_dev *pnp)
 
 static void cmos_pnp_shutdown(struct pnp_dev *pnp)
 {
-        if (system_state == SYSTEM_POWER_OFF && !cmos_poweroff(&pnp->dev))
+        struct device *dev = &pnp->dev;
+        struct cmos_rtc *cmos = dev_get_drvdata(dev);
+
+        if (system_state == SYSTEM_POWER_OFF && !cmos_poweroff(dev))
                 return;
 
-        cmos_do_shutdown();
+        cmos_do_shutdown(cmos->irq);
 }
 
 static const struct pnp_device_id rtc_ids[] = {
@@ -1143,11 +1165,21 @@ static inline void cmos_of_init(struct platform_device *pdev) {}
 
 static int __init cmos_platform_probe(struct platform_device *pdev)
 {
+        struct resource *resource;
+        int irq;
+
         cmos_of_init(pdev);
         cmos_wake_setup(&pdev->dev);
-        return cmos_do_probe(&pdev->dev,
-                        platform_get_resource(pdev, IORESOURCE_IO, 0),
-                        platform_get_irq(pdev, 0));
+
+        if (RTC_IOMAPPED)
+                resource = platform_get_resource(pdev, IORESOURCE_IO, 0);
+        else
+                resource = platform_get_resource(pdev, IORESOURCE_MEM, 0);
+        irq = platform_get_irq(pdev, 0);
+        if (irq < 0)
+                irq = -1;
+
+        return cmos_do_probe(&pdev->dev, resource, irq);
 }
 
 static int __exit cmos_platform_remove(struct platform_device *pdev)
@@ -1158,10 +1190,13 @@ static int __exit cmos_platform_remove(struct platform_device *pdev)
 
 static void cmos_platform_shutdown(struct platform_device *pdev)
 {
-        if (system_state == SYSTEM_POWER_OFF && !cmos_poweroff(&pdev->dev))
+        struct device *dev = &pdev->dev;
+        struct cmos_rtc *cmos = dev_get_drvdata(dev);
+
+        if (system_state == SYSTEM_POWER_OFF && !cmos_poweroff(dev))
                 return;
 
-        cmos_do_shutdown();
+        cmos_do_shutdown(cmos->irq);
 }
 
 /* work with hotplug and coldplug */
diff --git a/drivers/rtc/rtc-da9052.c b/drivers/rtc/rtc-da9052.c
index a1cbf64242a5..e5c9486cf452 100644
--- a/drivers/rtc/rtc-da9052.c
+++ b/drivers/rtc/rtc-da9052.c
@@ -20,28 +20,28 @@
 #include <linux/mfd/da9052/da9052.h>
 #include <linux/mfd/da9052/reg.h>
 
-#define rtc_err(da9052, fmt, ...) \
-                dev_err(da9052->dev, "%s: " fmt, __func__, ##__VA_ARGS__)
+#define rtc_err(rtc, fmt, ...) \
+                dev_err(rtc->da9052->dev, "%s: " fmt, __func__, ##__VA_ARGS__)
 
 struct da9052_rtc {
         struct rtc_device *rtc;
         struct da9052 *da9052;
 };
 
-static int da9052_rtc_enable_alarm(struct da9052 *da9052, bool enable)
+static int da9052_rtc_enable_alarm(struct da9052_rtc *rtc, bool enable)
 {
         int ret;
         if (enable) {
-                ret = da9052_reg_update(da9052, DA9052_ALARM_Y_REG,
-                                        DA9052_ALARM_Y_ALARM_ON,
-                                        DA9052_ALARM_Y_ALARM_ON);
+                ret = da9052_reg_update(rtc->da9052, DA9052_ALARM_Y_REG,
+                                DA9052_ALARM_Y_ALARM_ON|DA9052_ALARM_Y_TICK_ON,
+                                DA9052_ALARM_Y_ALARM_ON);
                 if (ret != 0)
-                        rtc_err(da9052, "Failed to enable ALM: %d\n", ret);
+                        rtc_err(rtc, "Failed to enable ALM: %d\n", ret);
         } else {
-                ret = da9052_reg_update(da9052, DA9052_ALARM_Y_REG,
-                                        DA9052_ALARM_Y_ALARM_ON, 0);
+                ret = da9052_reg_update(rtc->da9052, DA9052_ALARM_Y_REG,
+                        DA9052_ALARM_Y_ALARM_ON|DA9052_ALARM_Y_TICK_ON, 0);
                 if (ret != 0)
-                        rtc_err(da9052, "Write error: %d\n", ret);
+                        rtc_err(rtc, "Write error: %d\n", ret);
         }
         return ret;
 }
@@ -49,31 +49,20 @@ static int da9052_rtc_enable_alarm(struct da9052 *da9052, bool enable)
 static irqreturn_t da9052_rtc_irq(int irq, void *data)
 {
         struct da9052_rtc *rtc = data;
-        int ret;
 
-        ret = da9052_reg_read(rtc->da9052, DA9052_ALARM_MI_REG);
-        if (ret < 0) {
-                rtc_err(rtc->da9052, "Read error: %d\n", ret);
-                return IRQ_NONE;
-        }
-
-        if (ret & DA9052_ALARMMI_ALARMTYPE) {
-                da9052_rtc_enable_alarm(rtc->da9052, 0);
-                rtc_update_irq(rtc->rtc, 1, RTC_IRQF | RTC_AF);
-        } else
-                rtc_update_irq(rtc->rtc, 1, RTC_IRQF | RTC_PF);
+        rtc_update_irq(rtc->rtc, 1, RTC_IRQF | RTC_AF);
 
         return IRQ_HANDLED;
 }
 
-static int da9052_read_alarm(struct da9052 *da9052, struct rtc_time *rtc_tm)
+static int da9052_read_alarm(struct da9052_rtc *rtc, struct rtc_time *rtc_tm)
 {
         int ret;
         uint8_t v[5];
 
-        ret = da9052_group_read(da9052, DA9052_ALARM_MI_REG, 5, v);
+        ret = da9052_group_read(rtc->da9052, DA9052_ALARM_MI_REG, 5, v);
         if (ret != 0) {
-                rtc_err(da9052, "Failed to group read ALM: %d\n", ret);
+                rtc_err(rtc, "Failed to group read ALM: %d\n", ret);
                 return ret;
         }
 
@@ -84,23 +73,33 @@ static int da9052_read_alarm(struct da9052 *da9052, struct rtc_time *rtc_tm)
         rtc_tm->tm_min  = v[0] & DA9052_RTC_MIN;
 
         ret = rtc_valid_tm(rtc_tm);
-        if (ret != 0)
-                return ret;
         return ret;
 }
 
-static int da9052_set_alarm(struct da9052 *da9052, struct rtc_time *rtc_tm)
+static int da9052_set_alarm(struct da9052_rtc *rtc, struct rtc_time *rtc_tm)
 {
+        struct da9052 *da9052 = rtc->da9052;
+        unsigned long alm_time;
         int ret;
         uint8_t v[3];
 
+        ret = rtc_tm_to_time(rtc_tm, &alm_time);
+        if (ret != 0)
+                return ret;
+
+        if (rtc_tm->tm_sec > 0) {
+                alm_time += 60 - rtc_tm->tm_sec;
+                rtc_time_to_tm(alm_time, rtc_tm);
+        }
+        BUG_ON(rtc_tm->tm_sec); /* it will cause repeated irqs if not zero */
+
         rtc_tm->tm_year -= 100;
         rtc_tm->tm_mon += 1;
 
         ret = da9052_reg_update(da9052, DA9052_ALARM_MI_REG,
                                 DA9052_RTC_MIN, rtc_tm->tm_min);
         if (ret != 0) {
-                rtc_err(da9052, "Failed to write ALRM MIN: %d\n", ret);
+                rtc_err(rtc, "Failed to write ALRM MIN: %d\n", ret);
                 return ret;
         }
 
@@ -115,22 +114,22 @@ static int da9052_set_alarm(struct da9052 *da9052, struct rtc_time *rtc_tm)
         ret = da9052_reg_update(da9052, DA9052_ALARM_Y_REG,
                                 DA9052_RTC_YEAR, rtc_tm->tm_year);
         if (ret != 0)
-                rtc_err(da9052, "Failed to write ALRM YEAR: %d\n", ret);
+                rtc_err(rtc, "Failed to write ALRM YEAR: %d\n", ret);
 
         return ret;
 }
 
-static int da9052_rtc_get_alarm_status(struct da9052 *da9052)
+static int da9052_rtc_get_alarm_status(struct da9052_rtc *rtc)
 {
         int ret;
 
-        ret = da9052_reg_read(da9052, DA9052_ALARM_Y_REG);
+        ret = da9052_reg_read(rtc->da9052, DA9052_ALARM_Y_REG);
         if (ret < 0) {
-                rtc_err(da9052, "Failed to read ALM: %d\n", ret);
+                rtc_err(rtc, "Failed to read ALM: %d\n", ret);
                 return ret;
         }
-        ret &= DA9052_ALARM_Y_ALARM_ON;
-        return (ret > 0) ? 1 : 0;
+
+        return !!(ret&DA9052_ALARM_Y_ALARM_ON);
 }
 
 static int da9052_rtc_read_time(struct device *dev, struct rtc_time *rtc_tm)
@@ -141,7 +140,7 @@ static int da9052_rtc_read_time(struct device *dev, struct rtc_time *rtc_tm)
 
         ret = da9052_group_read(rtc->da9052, DA9052_COUNT_S_REG, 6, v);
         if (ret < 0) {
-                rtc_err(rtc->da9052, "Failed to read RTC time : %d\n", ret);
+                rtc_err(rtc, "Failed to read RTC time : %d\n", ret);
                 return ret;
         }
 
@@ -153,18 +152,14 @@ static int da9052_rtc_read_time(struct device *dev, struct rtc_time *rtc_tm)
         rtc_tm->tm_sec  = v[0] & DA9052_RTC_SEC;
 
         ret = rtc_valid_tm(rtc_tm);
-        if (ret != 0) {
-                rtc_err(rtc->da9052, "rtc_valid_tm failed: %d\n", ret);
-                return ret;
-        }
-
-        return 0;
+        return ret;
 }
 
 static int da9052_rtc_set_time(struct device *dev, struct rtc_time *tm)
 {
         struct da9052_rtc *rtc;
         uint8_t v[6];
+        int ret;
 
         rtc = dev_get_drvdata(dev);
 
@@ -175,7 +170,10 @@ static int da9052_rtc_set_time(struct device *dev, struct rtc_time *tm)
         v[4] = tm->tm_mon + 1;
         v[5] = tm->tm_year - 100;
 
-        return da9052_group_write(rtc->da9052, DA9052_COUNT_S_REG, 6, v);
+        ret = da9052_group_write(rtc->da9052, DA9052_COUNT_S_REG, 6, v);
+        if (ret < 0)
+                rtc_err(rtc, "failed to set RTC time: %d\n", ret);
+        return ret;
 }
 
 static int da9052_rtc_read_alarm(struct device *dev, struct rtc_wkalrm *alrm)
@@ -184,13 +182,13 @@ static int da9052_rtc_read_alarm(struct device *dev, struct rtc_wkalrm *alrm)
         struct rtc_time *tm = &alrm->time;
         struct da9052_rtc *rtc = dev_get_drvdata(dev);
 
-        ret = da9052_read_alarm(rtc->da9052, tm);
-
-        if (ret)
+        ret = da9052_read_alarm(rtc, tm);
+        if (ret < 0) {
+                rtc_err(rtc, "failed to read RTC alarm: %d\n", ret);
                 return ret;
+        }
 
-        alrm->enabled = da9052_rtc_get_alarm_status(rtc->da9052);
-
+        alrm->enabled = da9052_rtc_get_alarm_status(rtc);
         return 0;
 }
 
@@ -200,16 +198,15 @@ static int da9052_rtc_set_alarm(struct device *dev, struct rtc_wkalrm *alrm)
         struct rtc_time *tm = &alrm->time;
         struct da9052_rtc *rtc = dev_get_drvdata(dev);
 
-        ret = da9052_rtc_enable_alarm(rtc->da9052, 0);
+        ret = da9052_rtc_enable_alarm(rtc, 0);
         if (ret < 0)
                 return ret;
 
-        ret = da9052_set_alarm(rtc->da9052, tm);
-        if (ret)
+        ret = da9052_set_alarm(rtc, tm);
+        if (ret < 0)
                 return ret;
 
-        ret = da9052_rtc_enable_alarm(rtc->da9052, 1);
-
+        ret = da9052_rtc_enable_alarm(rtc, 1);
         return ret;
 }
 
@@ -217,7 +214,7 @@ static int da9052_rtc_alarm_irq_enable(struct device *dev, unsigned int enabled)
 {
         struct da9052_rtc *rtc = dev_get_drvdata(dev);
 
-        return da9052_rtc_enable_alarm(rtc->da9052, enabled);
+        return da9052_rtc_enable_alarm(rtc, enabled);
 }
 
 static const struct rtc_class_ops da9052_rtc_ops = {
@@ -239,10 +236,23 @@ static int da9052_rtc_probe(struct platform_device *pdev)
 
         rtc->da9052 = dev_get_drvdata(pdev->dev.parent);
         platform_set_drvdata(pdev, rtc);
+
+        ret = da9052_reg_write(rtc->da9052, DA9052_BBAT_CONT_REG, 0xFE);
+        if (ret < 0) {
+                rtc_err(rtc,
+                        "Failed to setup RTC battery charging: %d\n", ret);
+                return ret;
+        }
+
+        ret = da9052_reg_update(rtc->da9052, DA9052_ALARM_Y_REG,
+                                DA9052_ALARM_Y_TICK_ON, 0);
+        if (ret != 0)
+                rtc_err(rtc, "Failed to disable TICKS: %d\n", ret);
+
         ret = da9052_request_irq(rtc->da9052, DA9052_IRQ_ALARM, "ALM",
                                 da9052_rtc_irq, rtc);
         if (ret != 0) {
-                rtc_err(rtc->da9052, "irq registration failed: %d\n", ret);
+                rtc_err(rtc, "irq registration failed: %d\n", ret);
                 return ret;
         }
 
@@ -261,7 +271,7 @@ static struct platform_driver da9052_rtc_driver = {
 
 module_platform_driver(da9052_rtc_driver);
 
-MODULE_AUTHOR("David Dajun Chen <dchen@diasemi.com>");
+MODULE_AUTHOR("Anthony Olech <Anthony.Olech@diasemi.com>");
 MODULE_DESCRIPTION("RTC driver for Dialog DA9052 PMIC");
 MODULE_LICENSE("GPL");
 MODULE_ALIAS("platform:da9052-rtc");
diff --git a/drivers/rtc/rtc-da9063.c b/drivers/rtc/rtc-da9063.c
new file mode 100644
index 000000000000..595393098b09
--- /dev/null
+++ b/drivers/rtc/rtc-da9063.c
@@ -0,0 +1,333 @@
+/* rtc-da9063.c - Real time clock device driver for DA9063
+ * Copyright (C) 2013-14  Dialog Semiconductor Ltd.
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Library General Public
+ * License as published by the Free Software Foundation; either
+ * version 2 of the License, or (at your option) any later version.
+ *
+ * This library is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * Library General Public License for more details.
+ */
+
+#include <linux/kernel.h>
+#include <linux/module.h>
+#include <linux/init.h>
+#include <linux/platform_device.h>
+#include <linux/interrupt.h>
+#include <linux/rtc.h>
+#include <linux/slab.h>
+#include <linux/delay.h>
+#include <linux/regmap.h>
+#include <linux/mfd/da9063/registers.h>
+#include <linux/mfd/da9063/core.h>
+
+#define YEARS_TO_DA9063(year)           ((year) - 100)
+#define MONTHS_TO_DA9063(month)         ((month) + 1)
+#define YEARS_FROM_DA9063(year)         ((year) + 100)
+#define MONTHS_FROM_DA9063(month)       ((month) - 1)
+
+#define RTC_DATA_LEN    (DA9063_REG_COUNT_Y - DA9063_REG_COUNT_S + 1)
+#define RTC_SEC         0
+#define RTC_MIN         1
+#define RTC_HOUR        2
+#define RTC_DAY         3
+#define RTC_MONTH       4
+#define RTC_YEAR        5
+
+struct da9063_rtc {
+        struct rtc_device       *rtc_dev;
+        struct da9063           *hw;
+        struct rtc_time         alarm_time;
+        bool                    rtc_sync;
+};
+
+static void da9063_data_to_tm(u8 *data, struct rtc_time *tm)
+{
+        tm->tm_sec  = data[RTC_SEC]  & DA9063_COUNT_SEC_MASK;
+        tm->tm_min  = data[RTC_MIN]  & DA9063_COUNT_MIN_MASK;
+        tm->tm_hour = data[RTC_HOUR] & DA9063_COUNT_HOUR_MASK;
+        tm->tm_mday = data[RTC_DAY]  & DA9063_COUNT_DAY_MASK;
+        tm->tm_mon  = MONTHS_FROM_DA9063(data[RTC_MONTH] &
+                                         DA9063_COUNT_MONTH_MASK);
+        tm->tm_year = YEARS_FROM_DA9063(data[RTC_YEAR] &
+                                        DA9063_COUNT_YEAR_MASK);
+}
+
+static void da9063_tm_to_data(struct rtc_time *tm, u8 *data)
+{
+        data[RTC_SEC] &= ~DA9063_COUNT_SEC_MASK;
+        data[RTC_SEC] |= tm->tm_sec & DA9063_COUNT_SEC_MASK;
+
+        data[RTC_MIN] &= ~DA9063_COUNT_MIN_MASK;
+        data[RTC_MIN] |= tm->tm_min & DA9063_COUNT_MIN_MASK;
+
+        data[RTC_HOUR] &= ~DA9063_COUNT_HOUR_MASK;
+        data[RTC_HOUR] |= tm->tm_hour & DA9063_COUNT_HOUR_MASK;
+
+        data[RTC_DAY] &= ~DA9063_COUNT_DAY_MASK;
+        data[RTC_DAY] |= tm->tm_mday & DA9063_COUNT_DAY_MASK;
+
+        data[RTC_MONTH] &= ~DA9063_COUNT_MONTH_MASK;
+        data[RTC_MONTH] |= MONTHS_TO_DA9063(tm->tm_mon) &
+                                DA9063_COUNT_MONTH_MASK;
+
+        data[RTC_YEAR] &= ~DA9063_COUNT_YEAR_MASK;
+        data[RTC_YEAR] |= YEARS_TO_DA9063(tm->tm_year) &
+                                DA9063_COUNT_YEAR_MASK;
+}
+
+static int da9063_rtc_stop_alarm(struct device *dev)
+{
+        struct da9063_rtc *rtc = dev_get_drvdata(dev);
+
+        return regmap_update_bits(rtc->hw->regmap, DA9063_REG_ALARM_Y,
+                                  DA9063_ALARM_ON, 0);
+}
+
+static int da9063_rtc_start_alarm(struct device *dev)
+{
+        struct da9063_rtc *rtc = dev_get_drvdata(dev);
+
+        return regmap_update_bits(rtc->hw->regmap, DA9063_REG_ALARM_Y,
+                                  DA9063_ALARM_ON, DA9063_ALARM_ON);
+}
+
+static int da9063_rtc_read_time(struct device *dev, struct rtc_time *tm)
+{
+        struct da9063_rtc *rtc = dev_get_drvdata(dev);
+        unsigned long tm_secs;
+        unsigned long al_secs;
+        u8 data[RTC_DATA_LEN];
+        int ret;
+
+        ret = regmap_bulk_read(rtc->hw->regmap, DA9063_REG_COUNT_S,
+                               data, RTC_DATA_LEN);
+        if (ret < 0) {
+                dev_err(dev, "Failed to read RTC time data: %d\n", ret);
+                return ret;
+        }
+
+        if (!(data[RTC_SEC] & DA9063_RTC_READ)) {
+                dev_dbg(dev, "RTC not yet ready to be read by the host\n");
+                return -EINVAL;
+        }
+
+        da9063_data_to_tm(data, tm);
+
+        rtc_tm_to_time(tm, &tm_secs);
+        rtc_tm_to_time(&rtc->alarm_time, &al_secs);
+
+        /* handle the rtc synchronisation delay */
+        if (rtc->rtc_sync == true && al_secs - tm_secs == 1)
+                memcpy(tm, &rtc->alarm_time, sizeof(struct rtc_time));
+        else
+                rtc->rtc_sync = false;
+
+        return rtc_valid_tm(tm);
+}
+
+static int da9063_rtc_set_time(struct device *dev, struct rtc_time *tm)
+{
+        struct da9063_rtc *rtc = dev_get_drvdata(dev);
+        u8 data[RTC_DATA_LEN];
+        int ret;
+
+        da9063_tm_to_data(tm, data);
+        ret = regmap_bulk_write(rtc->hw->regmap, DA9063_REG_COUNT_S,
+                                data, RTC_DATA_LEN);
+        if (ret < 0)
+                dev_err(dev, "Failed to set RTC time data: %d\n", ret);
+
+        return ret;
+}
+
+static int da9063_rtc_read_alarm(struct device *dev, struct rtc_wkalrm *alrm)
+{
+        struct da9063_rtc *rtc = dev_get_drvdata(dev);
+        u8 data[RTC_DATA_LEN];
+        int ret;
+        unsigned int val;
+
+        ret = regmap_bulk_read(rtc->hw->regmap, DA9063_REG_ALARM_S,
+                               &data[RTC_SEC], RTC_DATA_LEN);
+        if (ret < 0)
+                return ret;
+
+        da9063_data_to_tm(data, &alrm->time);
+
+        alrm->enabled = !!(data[RTC_YEAR] & DA9063_ALARM_ON);
+
+        ret = regmap_read(rtc->hw->regmap, DA9063_REG_EVENT_A, &val);
+        if (ret < 0)
+                return ret;
+
+        if (val & (DA9063_E_ALARM))
+                alrm->pending = 1;
+        else
+                alrm->pending = 0;
+
+        return 0;
+}
+
+static int da9063_rtc_set_alarm(struct device *dev, struct rtc_wkalrm *alrm)
+{
+        struct da9063_rtc *rtc = dev_get_drvdata(dev);
+        u8 data[RTC_DATA_LEN];
+        int ret;
+
+        da9063_tm_to_data(&alrm->time, data);
+
+        ret = da9063_rtc_stop_alarm(dev);
+        if (ret < 0) {
+                dev_err(dev, "Failed to stop alarm: %d\n", ret);
+                return ret;
+        }
+
+        ret = regmap_bulk_write(rtc->hw->regmap, DA9063_REG_ALARM_S,
+                                data, RTC_DATA_LEN);
+        if (ret < 0) {
+                dev_err(dev, "Failed to write alarm: %d\n", ret);
+                return ret;
+        }
+
+        rtc->alarm_time = alrm->time;
+
+        if (alrm->enabled) {
+                ret = da9063_rtc_start_alarm(dev);
+                if (ret < 0) {
+                        dev_err(dev, "Failed to start alarm: %d\n", ret);
+                        return ret;
+                }
+        }
+
+        return ret;
+}
+
+static int da9063_rtc_alarm_irq_enable(struct device *dev, unsigned int enabled)
+{
+        if (enabled)
+                return da9063_rtc_start_alarm(dev);
+        else
+                return da9063_rtc_stop_alarm(dev);
+}
+
+static irqreturn_t da9063_alarm_event(int irq, void *data)
+{
+        struct da9063_rtc *rtc = data;
+
+        regmap_update_bits(rtc->hw->regmap, DA9063_REG_ALARM_Y,
+                           DA9063_ALARM_ON, 0);
+
+        rtc->rtc_sync = true;
+        rtc_update_irq(rtc->rtc_dev, 1, RTC_IRQF | RTC_AF);
+
+        return IRQ_HANDLED;
+}
+
+static const struct rtc_class_ops da9063_rtc_ops = {
+        .read_time = da9063_rtc_read_time,
+        .set_time = da9063_rtc_set_time,
+        .read_alarm = da9063_rtc_read_alarm,
+        .set_alarm = da9063_rtc_set_alarm,
+        .alarm_irq_enable = da9063_rtc_alarm_irq_enable,
+};
+
+static int da9063_rtc_probe(struct platform_device *pdev)
+{
+        struct da9063 *da9063 = dev_get_drvdata(pdev->dev.parent);
+        struct da9063_rtc *rtc;
+        int irq_alarm;
+        u8 data[RTC_DATA_LEN];
+        int ret;
+
+        ret = regmap_update_bits(da9063->regmap, DA9063_REG_CONTROL_E,
+                                 DA9063_RTC_EN, DA9063_RTC_EN);
+        if (ret < 0) {
+                dev_err(&pdev->dev, "Failed to enable RTC\n");
+                goto err;
+        }
+
+        ret = regmap_update_bits(da9063->regmap, DA9063_REG_EN_32K,
+                                 DA9063_CRYSTAL, DA9063_CRYSTAL);
+        if (ret < 0) {
+                dev_err(&pdev->dev, "Failed to run 32kHz oscillator\n");
+                goto err;
+        }
+
+        ret = regmap_update_bits(da9063->regmap, DA9063_REG_ALARM_S,
+                        DA9063_ALARM_STATUS_TICK | DA9063_ALARM_STATUS_ALARM,
+                        0);
+        if (ret < 0) {
+                dev_err(&pdev->dev, "Failed to access RTC alarm register\n");
+                goto err;
+        }
+
+        ret = regmap_update_bits(da9063->regmap, DA9063_REG_ALARM_S,
+                                 DA9063_ALARM_STATUS_ALARM,
+                                 DA9063_ALARM_STATUS_ALARM);
+        if (ret < 0) {
+                dev_err(&pdev->dev, "Failed to access RTC alarm register\n");
+                goto err;
+        }
+
+        ret = regmap_update_bits(da9063->regmap, DA9063_REG_ALARM_Y,
+                                 DA9063_TICK_ON, 0);
+        if (ret < 0) {
+                dev_err(&pdev->dev, "Failed to disable TICKs\n");
+                goto err;
+        }
+
+        ret = regmap_bulk_read(da9063->regmap, DA9063_REG_ALARM_S,
+                               data, RTC_DATA_LEN);
+        if (ret < 0) {
+                dev_err(&pdev->dev, "Failed to read initial alarm data: %d\n",
+                        ret);
+                goto err;
+        }
+
+        rtc = devm_kzalloc(&pdev->dev, sizeof(*rtc), GFP_KERNEL);
+        if (!rtc)
+                return -ENOMEM;
+
+        platform_set_drvdata(pdev, rtc);
+
+        irq_alarm = platform_get_irq_byname(pdev, "ALARM");
+        ret = devm_request_threaded_irq(&pdev->dev, irq_alarm, NULL,
+                                        da9063_alarm_event,
+                                        IRQF_TRIGGER_LOW | IRQF_ONESHOT,
+                                        "ALARM", rtc);
+        if (ret) {
+                dev_err(&pdev->dev, "Failed to request ALARM IRQ %d: %d\n",
+                        irq_alarm, ret);
+                goto err;
+        }
+
+        rtc->hw = da9063;
+        rtc->rtc_dev = devm_rtc_device_register(&pdev->dev, DA9063_DRVNAME_RTC,
+                                           &da9063_rtc_ops, THIS_MODULE);
+        if (IS_ERR(rtc->rtc_dev))
+                return PTR_ERR(rtc->rtc_dev);
+
+        da9063_data_to_tm(data, &rtc->alarm_time);
+        rtc->rtc_sync = false;
+err:
+        return ret;
+}
+
+static struct platform_driver da9063_rtc_driver = {
+        .probe          = da9063_rtc_probe,
+        .driver         = {
+                .name   = DA9063_DRVNAME_RTC,
+                .owner  = THIS_MODULE,
+        },
+};
+
+module_platform_driver(da9063_rtc_driver);
+
+MODULE_AUTHOR("S Twiss <stwiss.opensource@diasemi.com>");
+MODULE_DESCRIPTION("Real time clock device driver for Dialog DA9063");
+MODULE_LICENSE("GPL v2");
+MODULE_ALIAS("platform:" DA9063_DRVNAME_RTC);
diff --git a/drivers/rtc/rtc-ds1343.c b/drivers/rtc/rtc-ds1343.c
new file mode 100644
index 000000000000..c3719189dd96
--- /dev/null
+++ b/drivers/rtc/rtc-ds1343.c
@@ -0,0 +1,689 @@
+/* rtc-ds1343.c
+ *
+ * Driver for Dallas Semiconductor DS1343 Low Current, SPI Compatible
+ * Real Time Clock
+ *
+ * Author : Raghavendra Chandra Ganiga <ravi23ganiga@gmail.com>
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License version 2 as
+ * published by the Free Software Foundation.
+ *
+ */
+
+#include <linux/init.h>
+#include <linux/module.h>
+#include <linux/interrupt.h>
+#include <linux/device.h>
+#include <linux/spi/spi.h>
+#include <linux/regmap.h>
+#include <linux/rtc.h>
+#include <linux/bcd.h>
+#include <linux/pm.h>
+#include <linux/slab.h>
+
+#define DS1343_DRV_VERSION      "01.00"
+#define DALLAS_MAXIM_DS1343     0
+#define DALLAS_MAXIM_DS1344     1
+
+/* RTC DS1343 Registers */
+#define DS1343_SECONDS_REG      0x00
+#define DS1343_MINUTES_REG      0x01
+#define DS1343_HOURS_REG        0x02
+#define DS1343_DAY_REG          0x03
+#define DS1343_DATE_REG         0x04
+#define DS1343_MONTH_REG        0x05
+#define DS1343_YEAR_REG         0x06
+#define DS1343_ALM0_SEC_REG     0x07
+#define DS1343_ALM0_MIN_REG     0x08
+#define DS1343_ALM0_HOUR_REG    0x09
+#define DS1343_ALM0_DAY_REG     0x0A
+#define DS1343_ALM1_SEC_REG     0x0B
+#define DS1343_ALM1_MIN_REG     0x0C
+#define DS1343_ALM1_HOUR_REG    0x0D
+#define DS1343_ALM1_DAY_REG     0x0E
+#define DS1343_CONTROL_REG      0x0F
+#define DS1343_STATUS_REG       0x10
+#define DS1343_TRICKLE_REG      0x11
+
+/* DS1343 Control Registers bits */
+#define DS1343_EOSC             0x80
+#define DS1343_DOSF             0x20
+#define DS1343_EGFIL            0x10
+#define DS1343_SQW              0x08
+#define DS1343_INTCN            0x04
+#define DS1343_A1IE             0x02
+#define DS1343_A0IE             0x01
+
+/* DS1343 Status Registers bits */
+#define DS1343_OSF              0x80
+#define DS1343_IRQF1            0x02
+#define DS1343_IRQF0            0x01
+
+/* DS1343 Trickle Charger Registers bits */
+#define DS1343_TRICKLE_MAGIC    0xa0
+#define DS1343_TRICKLE_DS1      0x08
+#define DS1343_TRICKLE_1K       0x01
+#define DS1343_TRICKLE_2K       0x02
+#define DS1343_TRICKLE_4K       0x03
+
+static const struct spi_device_id ds1343_id[] = {
+        { "ds1343", DALLAS_MAXIM_DS1343 },
+        { "ds1344", DALLAS_MAXIM_DS1344 },
+        { }
+};
+MODULE_DEVICE_TABLE(spi, ds1343_id);
+
+struct ds1343_priv {
+        struct spi_device *spi;
+        struct rtc_device *rtc;
+        struct regmap *map;
+        struct mutex mutex;
+        unsigned int irqen;
+        int irq;
+        int alarm_sec;
+        int alarm_min;
+        int alarm_hour;
+        int alarm_mday;
+};
+
+static int ds1343_ioctl(struct device *dev, unsigned int cmd, unsigned long arg)
+{
+        switch (cmd) {
+#ifdef RTC_SET_CHARGE
+        case RTC_SET_CHARGE:
+        {
+                int val;
+
+                if (copy_from_user(&val, (int __user *)arg, sizeof(int)))
+                        return -EFAULT;
+
+                return regmap_write(priv->map, DS1343_TRICKLE_REG, val);
+        }
+        break;
+#endif
+        }
+
+        return -ENOIOCTLCMD;
+}
+
+static ssize_t ds1343_show_glitchfilter(struct device *dev,
+                                struct device_attribute *attr, char *buf)
+{
+        struct ds1343_priv *priv = dev_get_drvdata(dev);
+        int glitch_filt_status, data;
+
+        regmap_read(priv->map, DS1343_CONTROL_REG, &data);
+
+        glitch_filt_status = !!(data & DS1343_EGFIL);
+
+        if (glitch_filt_status)
+                return sprintf(buf, "enabled\n");
+        else
+                return sprintf(buf, "disabled\n");
+}
+
+static ssize_t ds1343_store_glitchfilter(struct device *dev,
+                                        struct device_attribute *attr,
+                                        const char *buf, size_t count)
+{
+        struct ds1343_priv *priv = dev_get_drvdata(dev);
+        int data;
+
+        regmap_read(priv->map, DS1343_CONTROL_REG, &data);
+
+        if (strncmp(buf, "enabled", 7) == 0)
+                data |= DS1343_EGFIL;
+
+        else if (strncmp(buf, "disabled", 8) == 0)
+                data &= ~(DS1343_EGFIL);
+
+        else
+                return -EINVAL;
+
+        regmap_write(priv->map, DS1343_CONTROL_REG, data);
+
+        return count;
+}
+
+static DEVICE_ATTR(glitch_filter, S_IRUGO | S_IWUSR, ds1343_show_glitchfilter,
+                        ds1343_store_glitchfilter);
+
+static ssize_t ds1343_show_alarmstatus(struct device *dev,
+                                struct device_attribute *attr, char *buf)
+{
+        struct ds1343_priv *priv = dev_get_drvdata(dev);
+        int alarmstatus, data;
+
+        regmap_read(priv->map, DS1343_CONTROL_REG, &data);
+
+        alarmstatus = !!(data & DS1343_A0IE);
+
+        if (alarmstatus)
+                return sprintf(buf, "enabled\n");
+        else
+                return sprintf(buf, "disabled\n");
+}
+
+static DEVICE_ATTR(alarm_status, S_IRUGO, ds1343_show_alarmstatus, NULL);
+
+static ssize_t ds1343_show_alarmmode(struct device *dev,
+                                struct device_attribute *attr, char *buf)
+{
+        struct ds1343_priv *priv = dev_get_drvdata(dev);
+        int alarm_mode, data;
+        char *alarm_str;
+
+        regmap_read(priv->map, DS1343_ALM0_SEC_REG, &data);
+        alarm_mode = (data & 0x80) >> 4;
+
+        regmap_read(priv->map, DS1343_ALM0_MIN_REG, &data);
+        alarm_mode |= (data & 0x80) >> 5;
+
+        regmap_read(priv->map, DS1343_ALM0_HOUR_REG, &data);
+        alarm_mode |= (data & 0x80) >> 6;
+
+        regmap_read(priv->map, DS1343_ALM0_DAY_REG, &data);
+        alarm_mode |= (data & 0x80) >> 7;
+
+        switch (alarm_mode) {
+        case 15:
+                alarm_str = "each second";
+                break;
+
+        case 7:
+                alarm_str = "seconds match";
+                break;
+
+        case 3:
+                alarm_str = "minutes and seconds match";
+                break;
+
+        case 1:
+                alarm_str = "hours, minutes and seconds match";
+                break;
+
+        case 0:
+                alarm_str = "day, hours, minutes and seconds match";
+                break;
+
+        default:
+                alarm_str = "invalid";
+                break;
+        }
+
+        return sprintf(buf, "%s\n", alarm_str);
+}
+
+static DEVICE_ATTR(alarm_mode, S_IRUGO, ds1343_show_alarmmode, NULL);
+
+static ssize_t ds1343_show_tricklecharger(struct device *dev,
+                                struct device_attribute *attr, char *buf)
+{
+        struct ds1343_priv *priv = dev_get_drvdata(dev);
+        int data;
+        char *diodes = "disabled", *resistors = " ";
+
+        regmap_read(priv->map, DS1343_TRICKLE_REG, &data);
+
+        if ((data & 0xf0) == DS1343_TRICKLE_MAGIC) {
+                switch (data & 0x0c) {
+                case DS1343_TRICKLE_DS1:
+                        diodes = "one diode,";
+                        break;
+
+                default:
+                        diodes = "no diode,";
+                        break;
+                }
+
+                switch (data & 0x03) {
+                case DS1343_TRICKLE_1K:
+                        resistors = "1k Ohm";
+                        break;
+
+                case DS1343_TRICKLE_2K:
+                        resistors = "2k Ohm";
+                        break;
+
+                case DS1343_TRICKLE_4K:
+                        resistors = "4k Ohm";
+                        break;
+
+                default:
+                        diodes = "disabled";
+                        break;
+                }
+        }
+
+        return sprintf(buf, "%s %s\n", diodes, resistors);
+}
+
+static DEVICE_ATTR(trickle_charger, S_IRUGO, ds1343_show_tricklecharger, NULL);
+
+static int ds1343_sysfs_register(struct device *dev)
+{
+        struct ds1343_priv *priv = dev_get_drvdata(dev);
+        int err;
+
+        err = device_create_file(dev, &dev_attr_glitch_filter);
+        if (err)
+                return err;
+
+        err = device_create_file(dev, &dev_attr_trickle_charger);
+        if (err)
+                goto error1;
+
+        if (priv->irq <= 0)
+                return err;
+
+        err = device_create_file(dev, &dev_attr_alarm_mode);
+        if (err)
+                goto error2;
+
+        err = device_create_file(dev, &dev_attr_alarm_status);
+        if (!err)
+                return err;
+
+        device_remove_file(dev, &dev_attr_alarm_mode);
+
+error2:
+        device_remove_file(dev, &dev_attr_trickle_charger);
+
+error1:
+        device_remove_file(dev, &dev_attr_glitch_filter);
+
+        return err;
+}
+
+static void ds1343_sysfs_unregister(struct device *dev)
+{
+        struct ds1343_priv *priv = dev_get_drvdata(dev);
+
+        device_remove_file(dev, &dev_attr_glitch_filter);
+        device_remove_file(dev, &dev_attr_trickle_charger);
+
+        if (priv->irq <= 0)
+                return;
+
+        device_remove_file(dev, &dev_attr_alarm_status);
+        device_remove_file(dev, &dev_attr_alarm_mode);
+}
+
+static int ds1343_read_time(struct device *dev, struct rtc_time *dt)
+{
+        struct ds1343_priv *priv = dev_get_drvdata(dev);
+        unsigned char buf[7];
+        int res;
+
+        res = regmap_bulk_read(priv->map, DS1343_SECONDS_REG, buf, 7);
+        if (res)
+                return res;
+
+        dt->tm_sec      = bcd2bin(buf[0]);
+        dt->tm_min      = bcd2bin(buf[1]);
+        dt->tm_hour     = bcd2bin(buf[2] & 0x3F);
+        dt->tm_wday     = bcd2bin(buf[3]) - 1;
+        dt->tm_mday     = bcd2bin(buf[4]);
+        dt->tm_mon      = bcd2bin(buf[5] & 0x1F) - 1;
+        dt->tm_year     = bcd2bin(buf[6]) + 100; /* year offset from 1900 */
+
+        return rtc_valid_tm(dt);
+}
+
+static int ds1343_set_time(struct device *dev, struct rtc_time *dt)
+{
+        struct ds1343_priv *priv = dev_get_drvdata(dev);
+        int res;
+
+        res = regmap_write(priv->map, DS1343_SECONDS_REG,
+                                bin2bcd(dt->tm_sec));
+        if (res)
+                return res;
+
+        res = regmap_write(priv->map, DS1343_MINUTES_REG,
+                                bin2bcd(dt->tm_min));
+        if (res)
+                return res;
+
+        res = regmap_write(priv->map, DS1343_HOURS_REG,
+                                bin2bcd(dt->tm_hour) & 0x3F);
+        if (res)
+                return res;
+
+        res = regmap_write(priv->map, DS1343_DAY_REG,
+                                bin2bcd(dt->tm_wday + 1));
+        if (res)
+                return res;
+
+        res = regmap_write(priv->map, DS1343_DATE_REG,
+                                bin2bcd(dt->tm_mday));
+        if (res)
+                return res;
+
+        res = regmap_write(priv->map, DS1343_MONTH_REG,
+                                bin2bcd(dt->tm_mon + 1));
+        if (res)
+                return res;
+
+        dt->tm_year %= 100;
+
+        res = regmap_write(priv->map, DS1343_YEAR_REG,
+                                bin2bcd(dt->tm_year));
+        if (res)
+                return res;
+
+        return 0;
+}
+
+static int ds1343_update_alarm(struct device *dev)
+{
+        struct ds1343_priv *priv = dev_get_drvdata(dev);
+        unsigned int control, stat;
+        unsigned char buf[4];
+        int res = 0;
+
+        res = regmap_read(priv->map, DS1343_CONTROL_REG, &control);
+        if (res)
+                return res;
+
+        res = regmap_read(priv->map, DS1343_STATUS_REG, &stat);
+        if (res)
+                return res;
+
+        control &= ~(DS1343_A0IE);
+        stat &= ~(DS1343_IRQF0);
+
+        res = regmap_write(priv->map, DS1343_CONTROL_REG, control);
+        if (res)
+                return res;
+
+        res = regmap_write(priv->map, DS1343_STATUS_REG, stat);
+        if (res)
+                return res;
+
+        buf[0] = priv->alarm_sec < 0 || (priv->irqen & RTC_UF) ?
+                0x80 : bin2bcd(priv->alarm_sec) & 0x7F;
+        buf[1] = priv->alarm_min < 0 || (priv->irqen & RTC_UF) ?
+                0x80 : bin2bcd(priv->alarm_min) & 0x7F;
+        buf[2] = priv->alarm_hour < 0 || (priv->irqen & RTC_UF) ?
+                0x80 : bin2bcd(priv->alarm_hour) & 0x3F;
+        buf[3] = priv->alarm_mday < 0 || (priv->irqen & RTC_UF) ?
+                0x80 : bin2bcd(priv->alarm_mday) & 0x7F;
+
+        res = regmap_bulk_write(priv->map, DS1343_ALM0_SEC_REG, buf, 4);
+        if (res)
+                return res;
+
+        if (priv->irqen) {
+                control |= DS1343_A0IE;
+                res = regmap_write(priv->map, DS1343_CONTROL_REG, control);
+        }
+
+        return res;
+}
+
+static int ds1343_read_alarm(struct device *dev, struct rtc_wkalrm *alarm)
+{
+        struct ds1343_priv *priv = dev_get_drvdata(dev);
+        int res = 0;
+        unsigned int stat;
+
+        if (priv->irq <= 0)
+                return -EINVAL;
+
+        mutex_lock(&priv->mutex);
+
+        res = regmap_read(priv->map, DS1343_STATUS_REG, &stat);
+        if (res)
+                goto out;
+
+        alarm->enabled = !!(priv->irqen & RTC_AF);
+        alarm->pending = !!(stat & DS1343_IRQF0);
+
+        alarm->time.tm_sec = priv->alarm_sec < 0 ? 0 : priv->alarm_sec;
+        alarm->time.tm_min = priv->alarm_min < 0 ? 0 : priv->alarm_min;
+        alarm->time.tm_hour = priv->alarm_hour < 0 ? 0 : priv->alarm_hour;
+        alarm->time.tm_mday = priv->alarm_mday < 0 ? 0 : priv->alarm_mday;
+
+        alarm->time.tm_mon = -1;
+        alarm->time.tm_year = -1;
+        alarm->time.tm_wday = -1;
+        alarm->time.tm_yday = -1;
+        alarm->time.tm_isdst = -1;
+
+out:
+        mutex_unlock(&priv->mutex);
+        return res;
+}
+
+static int ds1343_set_alarm(struct device *dev, struct rtc_wkalrm *alarm)
+{
+        struct ds1343_priv *priv = dev_get_drvdata(dev);
+        int res = 0;
+
+        if (priv->irq <= 0)
+                return -EINVAL;
+
+        mutex_lock(&priv->mutex);
+
+        priv->alarm_sec = alarm->time.tm_sec;
+        priv->alarm_min = alarm->time.tm_min;
+        priv->alarm_hour = alarm->time.tm_hour;
+        priv->alarm_mday = alarm->time.tm_mday;
+
+        if (alarm->enabled)
+                priv->irqen |= RTC_AF;
+
+        res = ds1343_update_alarm(dev);
+
+        mutex_unlock(&priv->mutex);
+
+        return res;
+}
+
+static int ds1343_alarm_irq_enable(struct device *dev, unsigned int enabled)
+{
+        struct ds1343_priv *priv = dev_get_drvdata(dev);
+        int res = 0;
+
+        if (priv->irq <= 0)
+                return -EINVAL;
+
+        mutex_lock(&priv->mutex);
+
+        if (enabled)
+                priv->irqen |= RTC_AF;
+        else
+                priv->irqen &= ~RTC_AF;
+
+        res = ds1343_update_alarm(dev);
+
+        mutex_unlock(&priv->mutex);
+
+        return res;
+}
+
+static irqreturn_t ds1343_thread(int irq, void *dev_id)
+{
+        struct ds1343_priv *priv = dev_id;
+        unsigned int stat, control;
+        int res = 0;
+
+        mutex_lock(&priv->mutex);
+
+        res = regmap_read(priv->map, DS1343_STATUS_REG, &stat);
+        if (res)
+                goto out;
+
+        if (stat & DS1343_IRQF0) {
+                stat &= ~DS1343_IRQF0;
+                regmap_write(priv->map, DS1343_STATUS_REG, stat);
+
+                res = regmap_read(priv->map, DS1343_CONTROL_REG, &control);
+                if (res)
+                        goto out;
+
+                control &= ~DS1343_A0IE;
+                regmap_write(priv->map, DS1343_CONTROL_REG, control);
+
+                rtc_update_irq(priv->rtc, 1, RTC_AF | RTC_IRQF);
+        }
+
+out:
+        mutex_unlock(&priv->mutex);
+        return IRQ_HANDLED;
+}
+
+static const struct rtc_class_ops ds1343_rtc_ops = {
+        .ioctl          = ds1343_ioctl,
+        .read_time      = ds1343_read_time,
+        .set_time       = ds1343_set_time,
+        .read_alarm     = ds1343_read_alarm,
+        .set_alarm      = ds1343_set_alarm,
+        .alarm_irq_enable = ds1343_alarm_irq_enable,
+};
+
+static int ds1343_probe(struct spi_device *spi)
+{
+        struct ds1343_priv *priv;
+        struct regmap_config config;
+        unsigned int data;
+        int res;
+
+        memset(&config, 0, sizeof(config));
+        config.reg_bits = 8;
+        config.val_bits = 8;
+        config.write_flag_mask = 0x80;
+
+        priv = devm_kzalloc(&spi->dev, sizeof(struct ds1343_priv), GFP_KERNEL);
+        if (!priv)
+                return -ENOMEM;
+
+        priv->spi = spi;
+        mutex_init(&priv->mutex);
+
+        /* RTC DS1347 works in spi mode 3 and
+         * its chip select is active high
+         */
+        spi->mode = SPI_MODE_3 | SPI_CS_HIGH;
+        spi->bits_per_word = 8;
+        res = spi_setup(spi);
+        if (res)
+                return res;
+
+        spi_set_drvdata(spi, priv);
+
+        priv->map = devm_regmap_init_spi(spi, &config);
+
+        if (IS_ERR(priv->map)) {
+                dev_err(&spi->dev, "spi regmap init failed for rtc ds1343\n");
+                return PTR_ERR(priv->map);
+        }
+
+        res = regmap_read(priv->map, DS1343_SECONDS_REG, &data);
+        if (res)
+                return res;
+
+        regmap_read(priv->map, DS1343_CONTROL_REG, &data);
+        data |= DS1343_INTCN;
+        data &= ~(DS1343_EOSC | DS1343_A1IE | DS1343_A0IE);
+        regmap_write(priv->map, DS1343_CONTROL_REG, data);
+
+        regmap_read(priv->map, DS1343_STATUS_REG, &data);
+        data &= ~(DS1343_OSF | DS1343_IRQF1 | DS1343_IRQF0);
+        regmap_write(priv->map, DS1343_STATUS_REG, data);
+
+        priv->rtc = devm_rtc_device_register(&spi->dev, "ds1343",
+                                        &ds1343_rtc_ops, THIS_MODULE);
+        if (IS_ERR(priv->rtc)) {
+                dev_err(&spi->dev, "unable to register rtc ds1343\n");
+                return PTR_ERR(priv->rtc);
+        }
+
+        priv->irq = spi->irq;
+
+        if (priv->irq >= 0) {
+                res = devm_request_threaded_irq(&spi->dev, spi->irq, NULL,
+                                                ds1343_thread,
+                                                IRQF_NO_SUSPEND | IRQF_ONESHOT,
+                                                "ds1343", priv);
+                if (res) {
+                        priv->irq = -1;
+                        dev_err(&spi->dev,
+                                "unable to request irq for rtc ds1343\n");
+                } else {
+                        device_set_wakeup_capable(&spi->dev, 1);
+                }
+        }
+
+        res = ds1343_sysfs_register(&spi->dev);
+        if (res)
+                dev_err(&spi->dev,
+                        "unable to create sysfs entries for rtc ds1343\n");
+
+        return 0;
+}
+
+static int ds1343_remove(struct spi_device *spi)
+{
+        struct ds1343_priv *priv = spi_get_drvdata(spi);
+
+        if (spi->irq) {
+                mutex_lock(&priv->mutex);
+                priv->irqen &= ~RTC_AF;
+                mutex_unlock(&priv->mutex);
+
+                devm_free_irq(&spi->dev, spi->irq, priv);
+        }
+
+        spi_set_drvdata(spi, NULL);
+
+        ds1343_sysfs_unregister(&spi->dev);
+
+        return 0;
+}
+
+#ifdef CONFIG_PM_SLEEP
+
+static int ds1343_suspend(struct device *dev)
+{
+        struct spi_device *spi = to_spi_device(dev);
+
+        if (spi->irq >= 0 && device_may_wakeup(dev))
+                enable_irq_wake(spi->irq);
+
+        return 0;
+}
+
+static int ds1343_resume(struct device *dev)
+{
+        struct spi_device *spi = to_spi_device(dev);
+
+        if (spi->irq >= 0 && device_may_wakeup(dev))
+                disable_irq_wake(spi->irq);
+
+        return 0;
+}
+
+#endif
+
+static SIMPLE_DEV_PM_OPS(ds1343_pm, ds1343_suspend, ds1343_resume);
+
+static struct spi_driver ds1343_driver = {
+        .driver = {
+                .name = "ds1343",
+                .owner = THIS_MODULE,
+                .pm = &ds1343_pm,
+        },
+        .probe = ds1343_probe,
+        .remove = ds1343_remove,
+        .id_table = ds1343_id,
+};
+
+module_spi_driver(ds1343_driver);
+
+MODULE_DESCRIPTION("DS1343 RTC SPI Driver");
+MODULE_AUTHOR("Raghavendra Chandra Ganiga <ravi23ganiga@gmail.com>");
+MODULE_LICENSE("GPL v2");
+MODULE_VERSION(DS1343_DRV_VERSION);
diff --git a/drivers/rtc/rtc-ds1742.c b/drivers/rtc/rtc-ds1742.c
index 942103dac30f..c6b2191a4128 100644
--- a/drivers/rtc/rtc-ds1742.c
+++ b/drivers/rtc/rtc-ds1742.c
@@ -219,7 +219,7 @@ static int ds1742_rtc_remove(struct platform_device *pdev)
         return 0;
 }
 
-static struct of_device_id __maybe_unused ds1742_rtc_of_match[] = {
+static const struct of_device_id __maybe_unused ds1742_rtc_of_match[] = {
         { .compatible = "maxim,ds1742", },
         { }
 };
diff --git a/drivers/rtc/rtc-efi.c b/drivers/rtc/rtc-efi.c
index 797aa0252ba9..c4c38431012e 100644
--- a/drivers/rtc/rtc-efi.c
+++ b/drivers/rtc/rtc-efi.c
@@ -35,7 +35,7 @@ static inline int
 compute_yday(efi_time_t *eft)
 {
         /* efi_time_t.month is in the [1-12] so, we need -1 */
-        return rtc_year_days(eft->day - 1, eft->month - 1, eft->year);
+        return rtc_year_days(eft->day, eft->month - 1, eft->year);
 }
 /*
  * returns day of the week [0-6] 0=Sunday
diff --git a/drivers/rtc/rtc-hym8563.c b/drivers/rtc/rtc-hym8563.c
index e5f13c4310fe..b936bb4096b5 100644
--- a/drivers/rtc/rtc-hym8563.c
+++ b/drivers/rtc/rtc-hym8563.c
@@ -418,6 +418,9 @@ static struct clk *hym8563_clkout_register_clk(struct hym8563 *hym8563)
         init.num_parents = 0;
         hym8563->clkout_hw.init = &init;
 
+        /* optional override of the clockname */
+        of_property_read_string(node, "clock-output-names", &init.name);
+
         /* register the clock */
         clk = clk_register(&client->dev, &hym8563->clkout_hw);
 
@@ -585,7 +588,7 @@ static const struct i2c_device_id hym8563_id[] = {
 };
 MODULE_DEVICE_TABLE(i2c, hym8563_id);
 
-static struct of_device_id hym8563_dt_idtable[] = {
+static const struct of_device_id hym8563_dt_idtable[] = {
         { .compatible = "haoyu,hym8563" },
         {},
 };
diff --git a/drivers/rtc/rtc-isl12057.c b/drivers/rtc/rtc-isl12057.c
index 41bd76aaff76..455b601d731d 100644
--- a/drivers/rtc/rtc-isl12057.c
+++ b/drivers/rtc/rtc-isl12057.c
@@ -278,7 +278,7 @@ static int isl12057_probe(struct i2c_client *client,
 }
 
 #ifdef CONFIG_OF
-static struct of_device_id isl12057_dt_match[] = {
+static const struct of_device_id isl12057_dt_match[] = {
         { .compatible = "isl,isl12057" },
         { },
 };
diff --git a/drivers/rtc/rtc-m41t80.c b/drivers/rtc/rtc-m41t80.c
index a5248aa1abf1..7ff7427c2e6a 100644
--- a/drivers/rtc/rtc-m41t80.c
+++ b/drivers/rtc/rtc-m41t80.c
@@ -66,8 +66,6 @@
 #define M41T80_FEATURE_WD       (1 << 3)        /* Extra watchdog resolution */
 #define M41T80_FEATURE_SQ_ALT   (1 << 4)        /* RSx bits are in reg 4 */
 
-#define DRV_VERSION "0.05"
-
 static DEFINE_MUTEX(m41t80_rtc_mutex);
 static const struct i2c_device_id m41t80_id[] = {
         { "m41t62", M41T80_FEATURE_SQ | M41T80_FEATURE_SQ_ALT },
@@ -80,6 +78,7 @@ static const struct i2c_device_id m41t80_id[] = {
         { "m41st84", M41T80_FEATURE_HT | M41T80_FEATURE_BL | M41T80_FEATURE_SQ },
         { "m41st85", M41T80_FEATURE_HT | M41T80_FEATURE_BL | M41T80_FEATURE_SQ },
         { "m41st87", M41T80_FEATURE_HT | M41T80_FEATURE_BL | M41T80_FEATURE_SQ },
+        { "rv4162", M41T80_FEATURE_SQ | M41T80_FEATURE_WD | M41T80_FEATURE_SQ_ALT },
         { }
 };
 MODULE_DEVICE_TABLE(i2c, m41t80_id);
@@ -232,7 +231,7 @@ static ssize_t m41t80_sysfs_show_flags(struct device *dev,
 
         val = i2c_smbus_read_byte_data(client, M41T80_REG_FLAGS);
         if (val < 0)
-                return -EIO;
+                return val;
         return sprintf(buf, "%#x\n", val);
 }
 static DEVICE_ATTR(flags, S_IRUGO, m41t80_sysfs_show_flags, NULL);
@@ -252,7 +251,7 @@ static ssize_t m41t80_sysfs_show_sqwfreq(struct device *dev,
                 reg_sqw = M41T80_REG_WDAY;
         val = i2c_smbus_read_byte_data(client, reg_sqw);
         if (val < 0)
-                return -EIO;
+                return val;
         val = (val >> 4) & 0xf;
         switch (val) {
         case 0:
@@ -271,7 +270,7 @@ static ssize_t m41t80_sysfs_set_sqwfreq(struct device *dev,
 {
         struct i2c_client *client = to_i2c_client(dev);
         struct m41t80_data *clientdata = i2c_get_clientdata(client);
-        int almon, sqw, reg_sqw;
+        int almon, sqw, reg_sqw, rc;
         int val = simple_strtoul(buf, NULL, 0);
 
         if (!(clientdata->features & M41T80_FEATURE_SQ))
@@ -291,21 +290,30 @@ static ssize_t m41t80_sysfs_set_sqwfreq(struct device *dev,
         /* disable SQW, set SQW frequency & re-enable */
         almon = i2c_smbus_read_byte_data(client, M41T80_REG_ALARM_MON);
         if (almon < 0)
-                return -EIO;
+                return almon;
         reg_sqw = M41T80_REG_SQW;
         if (clientdata->features & M41T80_FEATURE_SQ_ALT)
                 reg_sqw = M41T80_REG_WDAY;
         sqw = i2c_smbus_read_byte_data(client, reg_sqw);
         if (sqw < 0)
-                return -EIO;
+                return sqw;
         sqw = (sqw & 0x0f) | (val << 4);
-        if (i2c_smbus_write_byte_data(client, M41T80_REG_ALARM_MON,
-                                      almon & ~M41T80_ALMON_SQWE) < 0 ||
-            i2c_smbus_write_byte_data(client, reg_sqw, sqw) < 0)
-                return -EIO;
-        if (val && i2c_smbus_write_byte_data(client, M41T80_REG_ALARM_MON,
-                                             almon | M41T80_ALMON_SQWE) < 0)
-                return -EIO;
+
+        rc = i2c_smbus_write_byte_data(client, M41T80_REG_ALARM_MON,
+                                      almon & ~M41T80_ALMON_SQWE);
+        if (rc < 0)
+                return rc;
+
+        if (val) {
+                rc = i2c_smbus_write_byte_data(client, reg_sqw, sqw);
+                if (rc < 0)
+                        return rc;
+
+                rc = i2c_smbus_write_byte_data(client, M41T80_REG_ALARM_MON,
+                                             almon | M41T80_ALMON_SQWE);
+                if (rc <0)
+                        return rc;
+        }
         return count;
 }
 static DEVICE_ATTR(sqwfreq, S_IRUGO | S_IWUSR,
@@ -629,40 +637,28 @@ static int m41t80_probe(struct i2c_client *client,
         struct m41t80_data *clientdata = NULL;
 
         if (!i2c_check_functionality(client->adapter, I2C_FUNC_I2C
-                                     | I2C_FUNC_SMBUS_BYTE_DATA)) {
-                rc = -ENODEV;
-                goto exit;
-        }
-
-        dev_info(&client->dev,
-                 "chip found, driver version " DRV_VERSION "\n");
+                                     | I2C_FUNC_SMBUS_BYTE_DATA))
+                return -ENODEV;
 
         clientdata = devm_kzalloc(&client->dev, sizeof(*clientdata),
                                 GFP_KERNEL);
-        if (!clientdata) {
-                rc = -ENOMEM;
-                goto exit;
-        }
+        if (!clientdata)
+                return -ENOMEM;
 
         clientdata->features = id->driver_data;
         i2c_set_clientdata(client, clientdata);
 
         rtc = devm_rtc_device_register(&client->dev, client->name,
                                         &m41t80_rtc_ops, THIS_MODULE);
-        if (IS_ERR(rtc)) {
-                rc = PTR_ERR(rtc);
-                rtc = NULL;
-                goto exit;
-        }
+        if (IS_ERR(rtc))
+                return PTR_ERR(rtc);
 
         clientdata->rtc = rtc;
 
         /* Make sure HT (Halt Update) bit is cleared */
         rc = i2c_smbus_read_byte_data(client, M41T80_REG_ALARM_HOUR);
-        if (rc < 0)
-                goto ht_err;
 
-        if (rc & M41T80_ALHOUR_HT) {
+        if (rc >= 0 && rc & M41T80_ALHOUR_HT) {
                 if (clientdata->features & M41T80_FEATURE_HT) {
                         m41t80_get_datetime(client, &tm);
                         dev_info(&client->dev, "HT bit was set!\n");
@@ -673,53 +669,44 @@ static int m41t80_probe(struct i2c_client *client,
                                  tm.tm_mon + 1, tm.tm_mday, tm.tm_hour,
                                  tm.tm_min, tm.tm_sec);
                 }
-                if (i2c_smbus_write_byte_data(client,
-                                              M41T80_REG_ALARM_HOUR,
-                                              rc & ~M41T80_ALHOUR_HT) < 0)
-                        goto ht_err;
+                rc = i2c_smbus_write_byte_data(client, M41T80_REG_ALARM_HOUR,
+                                              rc & ~M41T80_ALHOUR_HT);
+        }
+
+        if (rc < 0) {
+                dev_err(&client->dev, "Can't clear HT bit\n");
+                return rc;
         }
 
         /* Make sure ST (stop) bit is cleared */
         rc = i2c_smbus_read_byte_data(client, M41T80_REG_SEC);
-        if (rc < 0)
-                goto st_err;
 
-        if (rc & M41T80_SEC_ST) {
-                if (i2c_smbus_write_byte_data(client, M41T80_REG_SEC,
-                                              rc & ~M41T80_SEC_ST) < 0)
-                        goto st_err;
+        if (rc >= 0 && rc & M41T80_SEC_ST)
+                rc = i2c_smbus_write_byte_data(client, M41T80_REG_SEC,
+                                              rc & ~M41T80_SEC_ST);
+        if (rc < 0) {
+                dev_err(&client->dev, "Can't clear ST bit\n");
+                return rc;
         }
 
         rc = m41t80_sysfs_register(&client->dev);
         if (rc)
-                goto exit;
+                return rc;
 
 #ifdef CONFIG_RTC_DRV_M41T80_WDT
         if (clientdata->features & M41T80_FEATURE_HT) {
                 save_client = client;
                 rc = misc_register(&wdt_dev);
                 if (rc)
-                        goto exit;
+                        return rc;
                 rc = register_reboot_notifier(&wdt_notifier);
                 if (rc) {
                         misc_deregister(&wdt_dev);
-                        goto exit;
+                        return rc;
                 }
         }
 #endif
         return 0;
-
-st_err:
-        rc = -EIO;
-        dev_err(&client->dev, "Can't clear ST bit\n");
-        goto exit;
-ht_err:
-        rc = -EIO;
-        dev_err(&client->dev, "Can't clear HT bit\n");
-        goto exit;
-
-exit:
-        return rc;
 }
 
 static int m41t80_remove(struct i2c_client *client)
@@ -750,4 +737,3 @@ module_i2c_driver(m41t80_driver);
 MODULE_AUTHOR("Alexander Bigga <ab@mycable.de>");
 MODULE_DESCRIPTION("ST Microelectronics M41T80 series RTC I2C Client Driver");
 MODULE_LICENSE("GPL");
-MODULE_VERSION(DRV_VERSION);
diff --git a/drivers/rtc/rtc-mcp795.c b/drivers/rtc/rtc-mcp795.c
new file mode 100644
index 000000000000..34295bf00416
--- /dev/null
+++ b/drivers/rtc/rtc-mcp795.c
@@ -0,0 +1,199 @@
+/*
+ * SPI Driver for Microchip MCP795 RTC
+ *
+ * Copyright (C) Josef Gajdusek <atx@atx.name>
+ *
+ * based on other Linux RTC drivers
+ *
+ * Device datasheet:
+ * http://ww1.microchip.com/downloads/en/DeviceDoc/22280A.pdf
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License version 2 as
+ * published by the Free Software Foundation.
+ *
+ * */
+
+#include <linux/module.h>
+#include <linux/kernel.h>
+#include <linux/device.h>
+#include <linux/printk.h>
+#include <linux/spi/spi.h>
+#include <linux/rtc.h>
+
+/* MCP795 Instructions, see datasheet table 3-1 */
+#define MCP795_EEREAD   0x03
+#define MCP795_EEWRITE  0x02
+#define MCP795_EEWRDI   0x04
+#define MCP795_EEWREN   0x06
+#define MCP795_SRREAD   0x05
+#define MCP795_SRWRITE  0x01
+#define MCP795_READ             0x13
+#define MCP795_WRITE    0x12
+#define MCP795_UNLOCK   0x14
+#define MCP795_IDWRITE  0x32
+#define MCP795_IDREAD   0x33
+#define MCP795_CLRWDT   0x44
+#define MCP795_CLRRAM   0x54
+
+#define MCP795_ST_BIT   0x80
+#define MCP795_24_BIT   0x40
+
+static int mcp795_rtcc_read(struct device *dev, u8 addr, u8 *buf, u8 count)
+{
+        struct spi_device *spi = to_spi_device(dev);
+        int ret;
+        u8 tx[2];
+
+        tx[0] = MCP795_READ;
+        tx[1] = addr;
+        ret = spi_write_then_read(spi, tx, sizeof(tx), buf, count);
+
+        if (ret)
+                dev_err(dev, "Failed reading %d bytes from address %x.\n",
+                                        count, addr);
+
+        return ret;
+}
+
+static int mcp795_rtcc_write(struct device *dev, u8 addr, u8 *data, u8 count)
+{
+        struct spi_device *spi = to_spi_device(dev);
+        int ret;
+        u8 tx[2 + count];
+
+        tx[0] = MCP795_WRITE;
+        tx[1] = addr;
+        memcpy(&tx[2], data, count);
+
+        ret = spi_write(spi, tx, 2 + count);
+
+        if (ret)
+                dev_err(dev, "Failed to write %d bytes to address %x.\n",
+                                        count, addr);
+
+        return ret;
+}
+
+static int mcp795_rtcc_set_bits(struct device *dev, u8 addr, u8 mask, u8 state)
+{
+        int ret;
+        u8 tmp;
+
+        ret = mcp795_rtcc_read(dev, addr, &tmp, 1);
+        if (ret)
+                return ret;
+
+        if ((tmp & mask) != state) {
+                tmp = (tmp & ~mask) | state;
+                ret = mcp795_rtcc_write(dev, addr, &tmp, 1);
+        }
+
+        return ret;
+}
+
+static int mcp795_set_time(struct device *dev, struct rtc_time *tim)
+{
+        int ret;
+        u8 data[7];
+
+        /* Read first, so we can leave config bits untouched */
+        ret = mcp795_rtcc_read(dev, 0x01, data, sizeof(data));
+
+        if (ret)
+                return ret;
+
+        data[0] = (data[0] & 0x80) | ((tim->tm_sec / 10) << 4) | (tim->tm_sec % 10);
+        data[1] = (data[1] & 0x80) | ((tim->tm_min / 10) << 4) | (tim->tm_min % 10);
+        data[2] = ((tim->tm_hour / 10) << 4) | (tim->tm_hour % 10);
+        data[4] = ((tim->tm_mday / 10) << 4) | ((tim->tm_mday) % 10);
+        data[5] = (data[5] & 0x10) | (tim->tm_mon / 10) | (tim->tm_mon % 10);
+
+        if (tim->tm_year > 100)
+                tim->tm_year -= 100;
+
+        data[6] = ((tim->tm_year / 10) << 4) | (tim->tm_year % 10);
+
+        ret = mcp795_rtcc_write(dev, 0x01, data, sizeof(data));
+
+        if (ret)
+                return ret;
+
+        dev_dbg(dev, "Set mcp795: %04d-%02d-%02d %02d:%02d:%02d\n",
+                        tim->tm_year + 1900, tim->tm_mon, tim->tm_mday,
+                        tim->tm_hour, tim->tm_min, tim->tm_sec);
+
+        return 0;
+}
+
+static int mcp795_read_time(struct device *dev, struct rtc_time *tim)
+{
+        int ret;
+        u8 data[7];
+
+        ret = mcp795_rtcc_read(dev, 0x01, data, sizeof(data));
+
+        if (ret)
+                return ret;
+
+        tim->tm_sec             = ((data[0] & 0x70) >> 4) * 10 + (data[0] & 0x0f);
+        tim->tm_min             = ((data[1] & 0x70) >> 4) * 10 + (data[1] & 0x0f);
+        tim->tm_hour    = ((data[2] & 0x30) >> 4) * 10 + (data[2] & 0x0f);
+        tim->tm_mday    = ((data[4] & 0x30) >> 4) * 10 + (data[4] & 0x0f);
+        tim->tm_mon             = ((data[5] & 0x10) >> 4) * 10 + (data[5] & 0x0f);
+        tim->tm_year    = ((data[6] & 0xf0) >> 4) * 10 + (data[6] & 0x0f) + 100; /* Assume we are in 20xx */
+
+        dev_dbg(dev, "Read from mcp795: %04d-%02d-%02d %02d:%02d:%02d\n",
+                                tim->tm_year + 1900, tim->tm_mon, tim->tm_mday,
+                                tim->tm_hour, tim->tm_min, tim->tm_sec);
+
+        return rtc_valid_tm(tim);
+}
+
+static struct rtc_class_ops mcp795_rtc_ops = {
+                .read_time = mcp795_read_time,
+                .set_time = mcp795_set_time
+};
+
+static int mcp795_probe(struct spi_device *spi)
+{
+        struct rtc_device *rtc;
+        int ret;
+
+        spi->mode = SPI_MODE_0;
+        spi->bits_per_word = 8;
+        ret = spi_setup(spi);
+        if (ret) {
+                dev_err(&spi->dev, "Unable to setup SPI\n");
+                return ret;
+        }
+
+        /* Start the oscillator */
+        mcp795_rtcc_set_bits(&spi->dev, 0x01, MCP795_ST_BIT, MCP795_ST_BIT);
+        /* Clear the 12 hour mode flag*/
+        mcp795_rtcc_set_bits(&spi->dev, 0x03, MCP795_24_BIT, 0);
+
+        rtc = devm_rtc_device_register(&spi->dev, "rtc-mcp795",
+                                                                &mcp795_rtc_ops, THIS_MODULE);
+        if (IS_ERR(rtc))
+                return PTR_ERR(rtc);
+
+        spi_set_drvdata(spi, rtc);
+
+        return 0;
+}
+
+static struct spi_driver mcp795_driver = {
+                .driver = {
+                                .name = "rtc-mcp795",
+                                .owner = THIS_MODULE,
+                },
+                .probe = mcp795_probe,
+};
+
+module_spi_driver(mcp795_driver);
+
+MODULE_DESCRIPTION("MCP795 RTC SPI Driver");
+MODULE_AUTHOR("Josef Gajdusek <atx@atx.name>");
+MODULE_LICENSE("GPL");
+MODULE_ALIAS("spi:mcp795");
diff --git a/drivers/rtc/rtc-mv.c b/drivers/rtc/rtc-mv.c
index d15a999363fc..6aaec2fc7c0d 100644
--- a/drivers/rtc/rtc-mv.c
+++ b/drivers/rtc/rtc-mv.c
@@ -319,7 +319,7 @@ static int __exit mv_rtc_remove(struct platform_device *pdev)
 }
 
 #ifdef CONFIG_OF
-static struct of_device_id rtc_mv_of_match_table[] = {
+static const struct of_device_id rtc_mv_of_match_table[] = {
         { .compatible = "marvell,orion-rtc", },
         {}
 };
diff --git a/drivers/rtc/rtc-omap.c b/drivers/rtc/rtc-omap.c
index 26de5f8c2ae4..21142e6574a9 100644
--- a/drivers/rtc/rtc-omap.c
+++ b/drivers/rtc/rtc-omap.c
@@ -73,43 +73,52 @@
 #define OMAP_RTC_IRQWAKEEN              0x7c
 
 /* OMAP_RTC_CTRL_REG bit fields: */
-#define OMAP_RTC_CTRL_SPLIT             (1<<7)
-#define OMAP_RTC_CTRL_DISABLE           (1<<6)
-#define OMAP_RTC_CTRL_SET_32_COUNTER    (1<<5)
-#define OMAP_RTC_CTRL_TEST              (1<<4)
-#define OMAP_RTC_CTRL_MODE_12_24        (1<<3)
-#define OMAP_RTC_CTRL_AUTO_COMP         (1<<2)
-#define OMAP_RTC_CTRL_ROUND_30S         (1<<1)
-#define OMAP_RTC_CTRL_STOP              (1<<0)
+#define OMAP_RTC_CTRL_SPLIT             BIT(7)
+#define OMAP_RTC_CTRL_DISABLE           BIT(6)
+#define OMAP_RTC_CTRL_SET_32_COUNTER    BIT(5)
+#define OMAP_RTC_CTRL_TEST              BIT(4)
+#define OMAP_RTC_CTRL_MODE_12_24        BIT(3)
+#define OMAP_RTC_CTRL_AUTO_COMP         BIT(2)
+#define OMAP_RTC_CTRL_ROUND_30S         BIT(1)
+#define OMAP_RTC_CTRL_STOP              BIT(0)
 
 /* OMAP_RTC_STATUS_REG bit fields: */
-#define OMAP_RTC_STATUS_POWER_UP        (1<<7)
-#define OMAP_RTC_STATUS_ALARM           (1<<6)
-#define OMAP_RTC_STATUS_1D_EVENT        (1<<5)
-#define OMAP_RTC_STATUS_1H_EVENT        (1<<4)
-#define OMAP_RTC_STATUS_1M_EVENT        (1<<3)
-#define OMAP_RTC_STATUS_1S_EVENT        (1<<2)
-#define OMAP_RTC_STATUS_RUN             (1<<1)
-#define OMAP_RTC_STATUS_BUSY            (1<<0)
+#define OMAP_RTC_STATUS_POWER_UP        BIT(7)
+#define OMAP_RTC_STATUS_ALARM           BIT(6)
+#define OMAP_RTC_STATUS_1D_EVENT        BIT(5)
+#define OMAP_RTC_STATUS_1H_EVENT        BIT(4)
+#define OMAP_RTC_STATUS_1M_EVENT        BIT(3)
+#define OMAP_RTC_STATUS_1S_EVENT        BIT(2)
+#define OMAP_RTC_STATUS_RUN             BIT(1)
+#define OMAP_RTC_STATUS_BUSY            BIT(0)
 
 /* OMAP_RTC_INTERRUPTS_REG bit fields: */
-#define OMAP_RTC_INTERRUPTS_IT_ALARM    (1<<3)
-#define OMAP_RTC_INTERRUPTS_IT_TIMER    (1<<2)
+#define OMAP_RTC_INTERRUPTS_IT_ALARM    BIT(3)
+#define OMAP_RTC_INTERRUPTS_IT_TIMER    BIT(2)
+
+/* OMAP_RTC_OSC_REG bit fields: */
+#define OMAP_RTC_OSC_32KCLK_EN          BIT(6)
 
 /* OMAP_RTC_IRQWAKEEN bit fields: */
-#define OMAP_RTC_IRQWAKEEN_ALARM_WAKEEN    (1<<1)
+#define OMAP_RTC_IRQWAKEEN_ALARM_WAKEEN BIT(1)
 
 /* OMAP_RTC_KICKER values */
 #define KICK0_VALUE                     0x83e70b13
 #define KICK1_VALUE                     0x95a4f1e0
 
-#define OMAP_RTC_HAS_KICKER             0x1
+#define OMAP_RTC_HAS_KICKER             BIT(0)
 
 /*
  * Few RTC IP revisions has special WAKE-EN Register to enable Wakeup
  * generation for event Alarm.
  */
-#define OMAP_RTC_HAS_IRQWAKEEN          0x2
+#define OMAP_RTC_HAS_IRQWAKEEN          BIT(1)
+
+/*
+ * Some RTC IP revisions (like those in AM335x and DRA7x) need
+ * the 32KHz clock to be explicitly enabled.
+ */
+#define OMAP_RTC_HAS_32KCLK_EN          BIT(2)
 
 static void __iomem     *rtc_base;
 
@@ -162,17 +171,28 @@ static irqreturn_t rtc_irq(int irq, void *rtc)
 
 static int omap_rtc_alarm_irq_enable(struct device *dev, unsigned int enabled)
 {
-        u8 reg;
+        u8 reg, irqwake_reg = 0;
+        struct platform_device *pdev = to_platform_device(dev);
+        const struct platform_device_id *id_entry =
+                                        platform_get_device_id(pdev);
 
         local_irq_disable();
         rtc_wait_not_busy();
         reg = rtc_read(OMAP_RTC_INTERRUPTS_REG);
-        if (enabled)
+        if (id_entry->driver_data & OMAP_RTC_HAS_IRQWAKEEN)
+                irqwake_reg = rtc_read(OMAP_RTC_IRQWAKEEN);
+
+        if (enabled) {
                 reg |= OMAP_RTC_INTERRUPTS_IT_ALARM;
-        else
+                irqwake_reg |= OMAP_RTC_IRQWAKEEN_ALARM_WAKEEN;
+        } else {
                 reg &= ~OMAP_RTC_INTERRUPTS_IT_ALARM;
+                irqwake_reg &= ~OMAP_RTC_IRQWAKEEN_ALARM_WAKEEN;
+        }
         rtc_wait_not_busy();
         rtc_write(reg, OMAP_RTC_INTERRUPTS_REG);
+        if (id_entry->driver_data & OMAP_RTC_HAS_IRQWAKEEN)
+                rtc_write(irqwake_reg, OMAP_RTC_IRQWAKEEN);
         local_irq_enable();
 
         return 0;
@@ -272,7 +292,10 @@ static int omap_rtc_read_alarm(struct device *dev, struct rtc_wkalrm *alm)
 
 static int omap_rtc_set_alarm(struct device *dev, struct rtc_wkalrm *alm)
 {
-        u8 reg;
+        u8 reg, irqwake_reg = 0;
+        struct platform_device *pdev = to_platform_device(dev);
+        const struct platform_device_id *id_entry =
+                                        platform_get_device_id(pdev);
 
         if (tm2bcd(&alm->time) < 0)
                 return -EINVAL;
@@ -288,11 +311,19 @@ static int omap_rtc_set_alarm(struct device *dev, struct rtc_wkalrm *alm)
         rtc_write(alm->time.tm_sec, OMAP_RTC_ALARM_SECONDS_REG);
 
         reg = rtc_read(OMAP_RTC_INTERRUPTS_REG);
-        if (alm->enabled)
+        if (id_entry->driver_data & OMAP_RTC_HAS_IRQWAKEEN)
+                irqwake_reg = rtc_read(OMAP_RTC_IRQWAKEEN);
+
+        if (alm->enabled) {
                 reg |= OMAP_RTC_INTERRUPTS_IT_ALARM;
-        else
+                irqwake_reg |= OMAP_RTC_IRQWAKEEN_ALARM_WAKEEN;
+        } else {
                 reg &= ~OMAP_RTC_INTERRUPTS_IT_ALARM;
+                irqwake_reg &= ~OMAP_RTC_IRQWAKEEN_ALARM_WAKEEN;
+        }
         rtc_write(reg, OMAP_RTC_INTERRUPTS_REG);
+        if (id_entry->driver_data & OMAP_RTC_HAS_IRQWAKEEN)
+                rtc_write(irqwake_reg, OMAP_RTC_IRQWAKEEN);
 
         local_irq_enable();
 
@@ -319,7 +350,8 @@ static struct platform_device_id omap_rtc_devtype[] = {
         },
         [OMAP_RTC_DATA_AM3352_IDX] = {
                 .name   = "am3352-rtc",
-                .driver_data = OMAP_RTC_HAS_KICKER | OMAP_RTC_HAS_IRQWAKEEN,
+                .driver_data = OMAP_RTC_HAS_KICKER | OMAP_RTC_HAS_IRQWAKEEN |
+                               OMAP_RTC_HAS_32KCLK_EN,
         },
         [OMAP_RTC_DATA_DA830_IDX] = {
                 .name   = "da830-rtc",
@@ -352,6 +384,12 @@ static int __init omap_rtc_probe(struct platform_device *pdev)
         if (of_id)
                 pdev->id_entry = of_id->data;
 
+        id_entry = platform_get_device_id(pdev);
+        if (!id_entry) {
+                dev_err(&pdev->dev, "no matching device entry\n");
+                return -ENODEV;
+        }
+
         omap_rtc_timer = platform_get_irq(pdev, 0);
         if (omap_rtc_timer <= 0) {
                 pr_debug("%s: no update irq?\n", pdev->name);
@@ -373,8 +411,7 @@ static int __init omap_rtc_probe(struct platform_device *pdev)
         pm_runtime_enable(&pdev->dev);
         pm_runtime_get_sync(&pdev->dev);
 
-        id_entry = platform_get_device_id(pdev);
-        if (id_entry && (id_entry->driver_data & OMAP_RTC_HAS_KICKER)) {
+        if (id_entry->driver_data & OMAP_RTC_HAS_KICKER) {
                 rtc_writel(KICK0_VALUE, OMAP_RTC_KICK0_REG);
                 rtc_writel(KICK1_VALUE, OMAP_RTC_KICK1_REG);
         }
@@ -393,6 +430,10 @@ static int __init omap_rtc_probe(struct platform_device *pdev)
          */
         rtc_write(0, OMAP_RTC_INTERRUPTS_REG);
 
+        /* enable RTC functional clock */
+        if (id_entry->driver_data & OMAP_RTC_HAS_32KCLK_EN)
+                rtc_writel(OMAP_RTC_OSC_32KCLK_EN, OMAP_RTC_OSC_REG);
+
         /* clear old status */
         reg = rtc_read(OMAP_RTC_STATUS_REG);
         if (reg & (u8) OMAP_RTC_STATUS_POWER_UP) {
@@ -452,7 +493,7 @@ static int __init omap_rtc_probe(struct platform_device *pdev)
         return 0;
 
 fail0:
-        if (id_entry && (id_entry->driver_data & OMAP_RTC_HAS_KICKER))
+        if (id_entry->driver_data & OMAP_RTC_HAS_KICKER)
                 rtc_writel(0, OMAP_RTC_KICK0_REG);
         pm_runtime_put_sync(&pdev->dev);
         pm_runtime_disable(&pdev->dev);
@@ -469,7 +510,7 @@ static int __exit omap_rtc_remove(struct platform_device *pdev)
         /* leave rtc running, but disable irqs */
         rtc_write(0, OMAP_RTC_INTERRUPTS_REG);
 
-        if (id_entry && (id_entry->driver_data & OMAP_RTC_HAS_KICKER))
+        if (id_entry->driver_data & OMAP_RTC_HAS_KICKER)
                 rtc_writel(0, OMAP_RTC_KICK0_REG);
 
         /* Disable the clock/module */
@@ -484,28 +525,16 @@ static u8 irqstat;
 
 static int omap_rtc_suspend(struct device *dev)
 {
-        u8 irqwake_stat;
-        struct platform_device *pdev = to_platform_device(dev);
-        const struct platform_device_id *id_entry =
-                                        platform_get_device_id(pdev);
-
         irqstat = rtc_read(OMAP_RTC_INTERRUPTS_REG);
 
         /* FIXME the RTC alarm is not currently acting as a wakeup event
          * source on some platforms, and in fact this enable() call is just
          * saving a flag that's never used...
          */
-        if (device_may_wakeup(dev)) {
+        if (device_may_wakeup(dev))
                 enable_irq_wake(omap_rtc_alarm);
-
-                if (id_entry->driver_data & OMAP_RTC_HAS_IRQWAKEEN) {
-                        irqwake_stat = rtc_read(OMAP_RTC_IRQWAKEEN);
-                        irqwake_stat |= OMAP_RTC_IRQWAKEEN_ALARM_WAKEEN;
-                        rtc_write(irqwake_stat, OMAP_RTC_IRQWAKEEN);
-                }
-        } else {
+        else
                 rtc_write(0, OMAP_RTC_INTERRUPTS_REG);
-        }
 
         /* Disable the clock/module */
         pm_runtime_put_sync(dev);
@@ -515,25 +544,14 @@ static int omap_rtc_suspend(struct device *dev)
 
 static int omap_rtc_resume(struct device *dev)
 {
-        u8 irqwake_stat;
-        struct platform_device *pdev = to_platform_device(dev);
-        const struct platform_device_id *id_entry =
-                                platform_get_device_id(pdev);
-
         /* Enable the clock/module so that we can access the registers */
         pm_runtime_get_sync(dev);
 
-        if (device_may_wakeup(dev)) {
+        if (device_may_wakeup(dev))
                 disable_irq_wake(omap_rtc_alarm);
-
-                if (id_entry->driver_data & OMAP_RTC_HAS_IRQWAKEEN) {
-                        irqwake_stat = rtc_read(OMAP_RTC_IRQWAKEEN);
-                        irqwake_stat &= ~OMAP_RTC_IRQWAKEEN_ALARM_WAKEEN;
-                        rtc_write(irqwake_stat, OMAP_RTC_IRQWAKEEN);
-                }
-        } else {
+        else
                 rtc_write(irqstat, OMAP_RTC_INTERRUPTS_REG);
-        }
+
         return 0;
 }
 #endif
diff --git a/drivers/rtc/rtc-palmas.c b/drivers/rtc/rtc-palmas.c
index c360d62fb3f6..4dfe2d793fa3 100644
--- a/drivers/rtc/rtc-palmas.c
+++ b/drivers/rtc/rtc-palmas.c
@@ -352,7 +352,7 @@ static SIMPLE_DEV_PM_OPS(palmas_rtc_pm_ops, palmas_rtc_suspend,
                          palmas_rtc_resume);
 
 #ifdef CONFIG_OF
-static struct of_device_id of_palmas_rtc_match[] = {
+static const struct of_device_id of_palmas_rtc_match[] = {
         { .compatible = "ti,palmas-rtc"},
         { },
 };
diff --git a/drivers/rtc/rtc-pxa.c b/drivers/rtc/rtc-pxa.c
index cccbf9d89729..4561f375327d 100644
--- a/drivers/rtc/rtc-pxa.c
+++ b/drivers/rtc/rtc-pxa.c
@@ -389,7 +389,7 @@ static int __exit pxa_rtc_remove(struct platform_device *pdev)
 }
 
 #ifdef CONFIG_OF
-static struct of_device_id pxa_rtc_dt_ids[] = {
+static const struct of_device_id pxa_rtc_dt_ids[] = {
         { .compatible = "marvell,pxa-rtc" },
         {}
 };
diff --git a/drivers/rtc/rtc-sa1100.c b/drivers/rtc/rtc-sa1100.c
index 0f7adeb1944a..b6e1ca08c2c0 100644
--- a/drivers/rtc/rtc-sa1100.c
+++ b/drivers/rtc/rtc-sa1100.c
@@ -338,7 +338,7 @@ static SIMPLE_DEV_PM_OPS(sa1100_rtc_pm_ops, sa1100_rtc_suspend,
                         sa1100_rtc_resume);
 
 #ifdef CONFIG_OF
-static struct of_device_id sa1100_rtc_dt_ids[] = {
+static const struct of_device_id sa1100_rtc_dt_ids[] = {
         { .compatible = "mrvl,sa1100-rtc", },
         { .compatible = "mrvl,mmp-rtc", },
         {}
diff --git a/drivers/rtc/rtc-xgene.c b/drivers/rtc/rtc-xgene.c
new file mode 100644
index 000000000000..14129cc85bdb
--- /dev/null
+++ b/drivers/rtc/rtc-xgene.c
@@ -0,0 +1,278 @@
+/*
+ * APM X-Gene SoC Real Time Clock Driver
+ *
+ * Copyright (c) 2014, Applied Micro Circuits Corporation
+ * Author: Rameshwar Prasad Sahu <rsahu@apm.com>
+ *         Loc Ho <lho@apm.com>
+ *
+ * This program is free software; you can redistribute  it and/or modify it
+ * under  the terms of  the GNU General  Public License as published by the
+ * Free Software Foundation;  either version 2 of the  License, or (at your
+ * option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * 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, see <http://www.gnu.org/licenses/>.
+ *
+ */
+
+#include <linux/init.h>
+#include <linux/module.h>
+#include <linux/of.h>
+#include <linux/platform_device.h>
+#include <linux/io.h>
+#include <linux/slab.h>
+#include <linux/clk.h>
+#include <linux/delay.h>
+#include <linux/rtc.h>
+
+/* RTC CSR Registers */
+#define RTC_CCVR                0x00
+#define RTC_CMR                 0x04
+#define RTC_CLR                 0x08
+#define RTC_CCR                 0x0C
+#define  RTC_CCR_IE             BIT(0)
+#define  RTC_CCR_MASK           BIT(1)
+#define  RTC_CCR_EN             BIT(2)
+#define  RTC_CCR_WEN            BIT(3)
+#define RTC_STAT                0x10
+#define  RTC_STAT_BIT           BIT(0)
+#define RTC_RSTAT               0x14
+#define RTC_EOI                 0x18
+#define RTC_VER                 0x1C
+
+struct xgene_rtc_dev {
+        struct rtc_device *rtc;
+        struct device *dev;
+        unsigned long alarm_time;
+        void __iomem *csr_base;
+        struct clk *clk;
+        unsigned int irq_wake;
+};
+
+static int xgene_rtc_read_time(struct device *dev, struct rtc_time *tm)
+{
+        struct xgene_rtc_dev *pdata = dev_get_drvdata(dev);
+
+        rtc_time_to_tm(readl(pdata->csr_base + RTC_CCVR), tm);
+        return rtc_valid_tm(tm);
+}
+
+static int xgene_rtc_set_mmss(struct device *dev, unsigned long secs)
+{
+        struct xgene_rtc_dev *pdata = dev_get_drvdata(dev);
+
+        /*
+         * NOTE: After the following write, the RTC_CCVR is only reflected
+         *       after the update cycle of 1 seconds.
+         */
+        writel((u32) secs, pdata->csr_base + RTC_CLR);
+        readl(pdata->csr_base + RTC_CLR); /* Force a barrier */
+
+        return 0;
+}
+
+static int xgene_rtc_read_alarm(struct device *dev, struct rtc_wkalrm *alrm)
+{
+        struct xgene_rtc_dev *pdata = dev_get_drvdata(dev);
+
+        rtc_time_to_tm(pdata->alarm_time, &alrm->time);
+        alrm->enabled = readl(pdata->csr_base + RTC_CCR) & RTC_CCR_IE;
+
+        return 0;
+}
+
+static int xgene_rtc_alarm_irq_enable(struct device *dev, u32 enabled)
+{
+        struct xgene_rtc_dev *pdata = dev_get_drvdata(dev);
+        u32 ccr;
+
+        ccr = readl(pdata->csr_base + RTC_CCR);
+        if (enabled) {
+                ccr &= ~RTC_CCR_MASK;
+                ccr |= RTC_CCR_IE;
+        } else {
+                ccr &= ~RTC_CCR_IE;
+                ccr |= RTC_CCR_MASK;
+        }
+        writel(ccr, pdata->csr_base + RTC_CCR);
+
+        return 0;
+}
+
+static int xgene_rtc_set_alarm(struct device *dev, struct rtc_wkalrm *alrm)
+{
+        struct xgene_rtc_dev *pdata = dev_get_drvdata(dev);
+        unsigned long rtc_time;
+        unsigned long alarm_time;
+
+        rtc_time = readl(pdata->csr_base + RTC_CCVR);
+        rtc_tm_to_time(&alrm->time, &alarm_time);
+
+        pdata->alarm_time = alarm_time;
+        writel((u32) pdata->alarm_time, pdata->csr_base + RTC_CMR);
+
+        xgene_rtc_alarm_irq_enable(dev, alrm->enabled);
+
+        return 0;
+}
+
+static const struct rtc_class_ops xgene_rtc_ops = {
+        .read_time      = xgene_rtc_read_time,
+        .set_mmss       = xgene_rtc_set_mmss,
+        .read_alarm     = xgene_rtc_read_alarm,
+        .set_alarm      = xgene_rtc_set_alarm,
+        .alarm_irq_enable = xgene_rtc_alarm_irq_enable,
+};
+
+static irqreturn_t xgene_rtc_interrupt(int irq, void *id)
+{
+        struct xgene_rtc_dev *pdata = (struct xgene_rtc_dev *) id;
+
+        /* Check if interrupt asserted */
+        if (!(readl(pdata->csr_base + RTC_STAT) & RTC_STAT_BIT))
+                return IRQ_NONE;
+
+        /* Clear interrupt */
+        readl(pdata->csr_base + RTC_EOI);
+
+        rtc_update_irq(pdata->rtc, 1, RTC_IRQF | RTC_AF);
+
+        return IRQ_HANDLED;
+}
+
+static int xgene_rtc_probe(struct platform_device *pdev)
+{
+        struct xgene_rtc_dev *pdata;
+        struct resource *res;
+        int ret;
+        int irq;
+
+        pdata = devm_kzalloc(&pdev->dev, sizeof(*pdata), GFP_KERNEL);
+        if (!pdata)
+                return -ENOMEM;
+        platform_set_drvdata(pdev, pdata);
+        pdata->dev = &pdev->dev;
+
+        res = platform_get_resource(pdev, IORESOURCE_MEM, 0);
+        pdata->csr_base = devm_ioremap_resource(&pdev->dev, res);
+        if (IS_ERR(pdata->csr_base))
+                return PTR_ERR(pdata->csr_base);
+
+        irq = platform_get_irq(pdev, 0);
+        if (irq < 0) {
+                dev_err(&pdev->dev, "No IRQ resource\n");
+                return irq;
+        }
+        ret = devm_request_irq(&pdev->dev, irq, xgene_rtc_interrupt, 0,
+                               dev_name(&pdev->dev), pdata);
+        if (ret) {
+                dev_err(&pdev->dev, "Could not request IRQ\n");
+                return ret;
+        }
+
+        pdata->clk = devm_clk_get(&pdev->dev, NULL);
+        if (IS_ERR(pdata->clk)) {
+                dev_err(&pdev->dev, "Couldn't get the clock for RTC\n");
+                return -ENODEV;
+        }
+        clk_prepare_enable(pdata->clk);
+
+        /* Turn on the clock and the crystal */
+        writel(RTC_CCR_EN, pdata->csr_base + RTC_CCR);
+
+        device_init_wakeup(&pdev->dev, 1);
+
+        pdata->rtc = devm_rtc_device_register(&pdev->dev, pdev->name,
+                                         &xgene_rtc_ops, THIS_MODULE);
+        if (IS_ERR(pdata->rtc)) {
+                clk_disable_unprepare(pdata->clk);
+                return PTR_ERR(pdata->rtc);
+        }
+
+        /* HW does not support update faster than 1 seconds */
+        pdata->rtc->uie_unsupported = 1;
+
+        return 0;
+}
+
+static int xgene_rtc_remove(struct platform_device *pdev)
+{
+        struct xgene_rtc_dev *pdata = platform_get_drvdata(pdev);
+
+        xgene_rtc_alarm_irq_enable(&pdev->dev, 0);
+        device_init_wakeup(&pdev->dev, 0);
+        clk_disable_unprepare(pdata->clk);
+        return 0;
+}
+
+#ifdef CONFIG_PM_SLEEP
+static int xgene_rtc_suspend(struct device *dev)
+{
+        struct platform_device *pdev = to_platform_device(dev);
+        struct xgene_rtc_dev *pdata = platform_get_drvdata(pdev);
+        int irq;
+
+        irq = platform_get_irq(pdev, 0);
+        if (device_may_wakeup(&pdev->dev)) {
+                if (!enable_irq_wake(irq))
+                        pdata->irq_wake = 1;
+        } else {
+                xgene_rtc_alarm_irq_enable(dev, 0);
+                clk_disable(pdata->clk);
+        }
+
+        return 0;
+}
+
+static int xgene_rtc_resume(struct device *dev)
+{
+        struct platform_device *pdev = to_platform_device(dev);
+        struct xgene_rtc_dev *pdata = platform_get_drvdata(pdev);
+        int irq;
+
+        irq = platform_get_irq(pdev, 0);
+        if (device_may_wakeup(&pdev->dev)) {
+                if (pdata->irq_wake) {
+                        disable_irq_wake(irq);
+                        pdata->irq_wake = 0;
+                }
+        } else {
+                clk_enable(pdata->clk);
+                xgene_rtc_alarm_irq_enable(dev, 1);
+        }
+
+        return 0;
+}
+#endif
+
+static SIMPLE_DEV_PM_OPS(xgene_rtc_pm_ops, xgene_rtc_suspend, xgene_rtc_resume);
+
+#ifdef CONFIG_OF
+static const struct of_device_id xgene_rtc_of_match[] = {
+        {.compatible = "apm,xgene-rtc" },
+        { }
+};
+MODULE_DEVICE_TABLE(of, xgene_rtc_of_match);
+#endif
+
+static struct platform_driver xgene_rtc_driver = {
+        .probe          = xgene_rtc_probe,
+        .remove         = xgene_rtc_remove,
+        .driver         = {
+                .owner  = THIS_MODULE,
+                .name   = "xgene-rtc",
+                .pm = &xgene_rtc_pm_ops,
+                .of_match_table = of_match_ptr(xgene_rtc_of_match),
+        },
+};
+
+module_platform_driver(xgene_rtc_driver);
+
+MODULE_DESCRIPTION("APM X-Gene SoC RTC driver");
+MODULE_AUTHOR("Rameshwar Sahu <rsahu@apm.com>");
+MODULE_LICENSE("GPL");
diff --git a/drivers/scsi/scsi_sysctl.c b/drivers/scsi/scsi_sysctl.c
index 2b6b93f7d8ef..546f16299ef9 100644
--- a/drivers/scsi/scsi_sysctl.c
+++ b/drivers/scsi/scsi_sysctl.c
@@ -12,7 +12,7 @@
 #include "scsi_priv.h"
 
 
-static ctl_table scsi_table[] = {
+static struct ctl_table scsi_table[] = {
         { .procname     = "logging_level",
           .data         = &scsi_logging_level,
           .maxlen       = sizeof(scsi_logging_level),
@@ -21,14 +21,14 @@ static ctl_table scsi_table[] = {
         { }
 };
 
-static ctl_table scsi_dir_table[] = {
+static struct ctl_table scsi_dir_table[] = {
         { .procname     = "scsi",
           .mode         = 0555,
           .child        = scsi_table },
         { }
 };
 
-static ctl_table scsi_root_table[] = {
+static struct ctl_table scsi_root_table[] = {
         { .procname     = "dev",
           .mode         = 0555,
           .child        = scsi_dir_table },
diff --git a/drivers/tty/sysrq.c b/drivers/tty/sysrq.c
index b767a64e49d9..454b65898e2c 100644
--- a/drivers/tty/sysrq.c
+++ b/drivers/tty/sysrq.c
@@ -46,6 +46,7 @@
 #include <linux/jiffies.h>
 #include <linux/syscalls.h>
 #include <linux/of.h>
+#include <linux/rcupdate.h>
 
 #include <asm/ptrace.h>
 #include <asm/irq_regs.h>
@@ -510,9 +511,9 @@ void __handle_sysrq(int key, bool check_mask)
         struct sysrq_key_op *op_p;
         int orig_log_level;
         int i;
-        unsigned long flags;
 
-        spin_lock_irqsave(&sysrq_key_table_lock, flags);
+        rcu_sysrq_start();
+        rcu_read_lock();
         /*
          * Raise the apparent loglevel to maximum so that the sysrq header
          * is shown to provide the user with positive feedback.  We do not
@@ -554,7 +555,8 @@ void __handle_sysrq(int key, bool check_mask)
                 printk("\n");
                 console_loglevel = orig_log_level;
         }
-        spin_unlock_irqrestore(&sysrq_key_table_lock, flags);
+        rcu_read_unlock();
+        rcu_sysrq_end();
 }
 
 void handle_sysrq(int key)
@@ -1043,16 +1045,23 @@ static int __sysrq_swap_key_ops(int key, struct sysrq_key_op *insert_op_p,
                                 struct sysrq_key_op *remove_op_p)
 {
         int retval;
-        unsigned long flags;
 
-        spin_lock_irqsave(&sysrq_key_table_lock, flags);
+        spin_lock(&sysrq_key_table_lock);
         if (__sysrq_get_key_op(key) == remove_op_p) {
                 __sysrq_put_key_op(key, insert_op_p);
                 retval = 0;
         } else {
                 retval = -1;
         }
-        spin_unlock_irqrestore(&sysrq_key_table_lock, flags);
+        spin_unlock(&sysrq_key_table_lock);
+
+        /*
+         * A concurrent __handle_sysrq either got the old op or the new op.
+         * Wait for it to go away before returning, so the code for an old
+         * op is not freed (eg. on module unload) while it is in use.
+         */
+        synchronize_rcu();
+
         return retval;
 }
 
diff --git a/fs/affs/affs.h b/fs/affs/affs.h
index 25b23b1e7f22..9bca88159725 100644
--- a/fs/affs/affs.h
+++ b/fs/affs/affs.h
@@ -1,3 +1,9 @@
+#ifdef pr_fmt
+#undef pr_fmt
+#endif
+
+#define pr_fmt(fmt) KBUILD_MODNAME ": " fmt
+
 #include <linux/types.h>
 #include <linux/fs.h>
 #include <linux/buffer_head.h>
@@ -206,7 +212,7 @@ affs_set_blocksize(struct super_block *sb, int size)
 static inline struct buffer_head *
 affs_bread(struct super_block *sb, int block)
 {
-        pr_debug("affs_bread: %d\n", block);
+        pr_debug("%s: %d\n", __func__, block);
         if (block >= AFFS_SB(sb)->s_reserved && block < AFFS_SB(sb)->s_partition_size)
                 return sb_bread(sb, block);
         return NULL;
@@ -214,7 +220,7 @@ affs_bread(struct super_block *sb, int block)
 static inline struct buffer_head *
 affs_getblk(struct super_block *sb, int block)
 {
-        pr_debug("affs_getblk: %d\n", block);
+        pr_debug("%s: %d\n", __func__, block);
         if (block >= AFFS_SB(sb)->s_reserved && block < AFFS_SB(sb)->s_partition_size)
                 return sb_getblk(sb, block);
         return NULL;
@@ -223,7 +229,7 @@ static inline struct buffer_head *
 affs_getzeroblk(struct super_block *sb, int block)
 {
         struct buffer_head *bh;
-        pr_debug("affs_getzeroblk: %d\n", block);
+        pr_debug("%s: %d\n", __func__, block);
         if (block >= AFFS_SB(sb)->s_reserved && block < AFFS_SB(sb)->s_partition_size) {
                 bh = sb_getblk(sb, block);
                 lock_buffer(bh);
@@ -238,7 +244,7 @@ static inline struct buffer_head *
 affs_getemptyblk(struct super_block *sb, int block)
 {
         struct buffer_head *bh;
-        pr_debug("affs_getemptyblk: %d\n", block);
+        pr_debug("%s: %d\n", __func__, block);
         if (block >= AFFS_SB(sb)->s_reserved && block < AFFS_SB(sb)->s_partition_size) {
                 bh = sb_getblk(sb, block);
                 wait_on_buffer(bh);
@@ -251,7 +257,7 @@ static inline void
 affs_brelse(struct buffer_head *bh)
 {
         if (bh)
-                pr_debug("affs_brelse: %lld\n", (long long) bh->b_blocknr);
+                pr_debug("%s: %lld\n", __func__, (long long) bh->b_blocknr);
         brelse(bh);
 }
 
diff --git a/fs/affs/amigaffs.c b/fs/affs/amigaffs.c
index 533a322c41c0..406b29836b19 100644
--- a/fs/affs/amigaffs.c
+++ b/fs/affs/amigaffs.c
@@ -34,7 +34,7 @@ affs_insert_hash(struct inode *dir, struct buffer_head *bh)
         ino = bh->b_blocknr;
         offset = affs_hash_name(sb, AFFS_TAIL(sb, bh)->name + 1, AFFS_TAIL(sb, bh)->name[0]);
 
-        pr_debug("AFFS: insert_hash(dir=%u, ino=%d)\n", (u32)dir->i_ino, ino);
+        pr_debug("%s(dir=%u, ino=%d)\n", __func__, (u32)dir->i_ino, ino);
 
         dir_bh = affs_bread(sb, dir->i_ino);
         if (!dir_bh)
@@ -84,7 +84,8 @@ affs_remove_hash(struct inode *dir, struct buffer_head *rem_bh)
         sb = dir->i_sb;
         rem_ino = rem_bh->b_blocknr;
         offset = affs_hash_name(sb, AFFS_TAIL(sb, rem_bh)->name+1, AFFS_TAIL(sb, rem_bh)->name[0]);
-        pr_debug("AFFS: remove_hash(dir=%d, ino=%d, hashval=%d)\n", (u32)dir->i_ino, rem_ino, offset);
+        pr_debug("%s(dir=%d, ino=%d, hashval=%d)\n",
+                 __func__, (u32)dir->i_ino, rem_ino, offset);
 
         bh = affs_bread(sb, dir->i_ino);
         if (!bh)
@@ -147,7 +148,7 @@ affs_remove_link(struct dentry *dentry)
         u32 link_ino, ino;
         int retval;
 
-        pr_debug("AFFS: remove_link(key=%ld)\n", inode->i_ino);
+        pr_debug("%s(key=%ld)\n", __func__, inode->i_ino);
         retval = -EIO;
         bh = affs_bread(sb, inode->i_ino);
         if (!bh)
@@ -279,7 +280,7 @@ affs_remove_header(struct dentry *dentry)
         if (!inode)
                 goto done;
 
-        pr_debug("AFFS: remove_header(key=%ld)\n", inode->i_ino);
+        pr_debug("%s(key=%ld)\n", __func__, inode->i_ino);
         retval = -EIO;
         bh = affs_bread(sb, (u32)(long)dentry->d_fsdata);
         if (!bh)
@@ -451,10 +452,10 @@ affs_error(struct super_block *sb, const char *function, const char *fmt, ...)
         vsnprintf(ErrorBuffer,sizeof(ErrorBuffer),fmt,args);
         va_end(args);
 
-        printk(KERN_CRIT "AFFS error (device %s): %s(): %s\n", sb->s_id,
+        pr_crit("error (device %s): %s(): %s\n", sb->s_id,
                 function,ErrorBuffer);
         if (!(sb->s_flags & MS_RDONLY))
-                printk(KERN_WARNING "AFFS: Remounting filesystem read-only\n");
+                pr_warn("Remounting filesystem read-only\n");
         sb->s_flags |= MS_RDONLY;
 }
 
@@ -467,7 +468,7 @@ affs_warning(struct super_block *sb, const char *function, const char *fmt, ...)
         vsnprintf(ErrorBuffer,sizeof(ErrorBuffer),fmt,args);
         va_end(args);
 
-        printk(KERN_WARNING "AFFS warning (device %s): %s(): %s\n", sb->s_id,
+        pr_warn("(device %s): %s(): %s\n", sb->s_id,
                 function,ErrorBuffer);
 }
 
diff --git a/fs/affs/bitmap.c b/fs/affs/bitmap.c
index a32246b8359e..c8de51185c23 100644
--- a/fs/affs/bitmap.c
+++ b/fs/affs/bitmap.c
@@ -17,7 +17,7 @@ affs_count_free_blocks(struct super_block *sb)
         u32 free;
         int i;
 
-        pr_debug("AFFS: count_free_blocks()\n");
+        pr_debug("%s()\n", __func__);
 
         if (sb->s_flags & MS_RDONLY)
                 return 0;
@@ -43,7 +43,7 @@ affs_free_block(struct super_block *sb, u32 block)
         u32 blk, bmap, bit, mask, tmp;
         __be32 *data;
 
-        pr_debug("AFFS: free_block(%u)\n", block);
+        pr_debug("%s(%u)\n", __func__, block);
 
         if (block > sbi->s_partition_size)
                 goto err_range;
@@ -125,7 +125,7 @@ affs_alloc_block(struct inode *inode, u32 goal)
         sb = inode->i_sb;
         sbi = AFFS_SB(sb);
 
-        pr_debug("AFFS: balloc(inode=%lu,goal=%u): ", inode->i_ino, goal);
+        pr_debug("balloc(inode=%lu,goal=%u): ", inode->i_ino, goal);
 
         if (AFFS_I(inode)->i_pa_cnt) {
                 pr_debug("%d\n", AFFS_I(inode)->i_lastalloc+1);
@@ -254,8 +254,7 @@ int affs_init_bitmap(struct super_block *sb, int *flags)
                 return 0;
 
         if (!AFFS_ROOT_TAIL(sb, sbi->s_root_bh)->bm_flag) {
-                printk(KERN_NOTICE "AFFS: Bitmap invalid - mounting %s read only\n",
-                        sb->s_id);
+                pr_notice("Bitmap invalid - mounting %s read only\n", sb->s_id);
                 *flags |= MS_RDONLY;
                 return 0;
         }
@@ -268,7 +267,7 @@ int affs_init_bitmap(struct super_block *sb, int *flags)
         size = sbi->s_bmap_count * sizeof(*bm);
         bm = sbi->s_bitmap = kzalloc(size, GFP_KERNEL);
         if (!sbi->s_bitmap) {
-                printk(KERN_ERR "AFFS: Bitmap allocation failed\n");
+                pr_err("Bitmap allocation failed\n");
                 return -ENOMEM;
         }
 
@@ -282,17 +281,17 @@ int affs_init_bitmap(struct super_block *sb, int *flags)
                 bm->bm_key = be32_to_cpu(bmap_blk[blk]);
                 bh = affs_bread(sb, bm->bm_key);
                 if (!bh) {
-                        printk(KERN_ERR "AFFS: Cannot read bitmap\n");
+                        pr_err("Cannot read bitmap\n");
                         res = -EIO;
                         goto out;
                 }
                 if (affs_checksum_block(sb, bh)) {
-                        printk(KERN_WARNING "AFFS: Bitmap %u invalid - mounting %s read only.\n",
-                               bm->bm_key, sb->s_id);
+                        pr_warn("Bitmap %u invalid - mounting %s read only.\n",
+                                bm->bm_key, sb->s_id);
                         *flags |= MS_RDONLY;
                         goto out;
                 }
-                pr_debug("AFFS: read bitmap block %d: %d\n", blk, bm->bm_key);
+                pr_debug("read bitmap block %d: %d\n", blk, bm->bm_key);
                 bm->bm_free = memweight(bh->b_data + 4, sb->s_blocksize - 4);
 
                 /* Don't try read the extension if this is the last block,
@@ -304,7 +303,7 @@ int affs_init_bitmap(struct super_block *sb, int *flags)
                         affs_brelse(bmap_bh);
                 bmap_bh = affs_bread(sb, be32_to_cpu(bmap_blk[blk]));
                 if (!bmap_bh) {
-                        printk(KERN_ERR "AFFS: Cannot read bitmap extension\n");
+                        pr_err("Cannot read bitmap extension\n");
                         res = -EIO;
                         goto out;
                 }
diff --git a/fs/affs/dir.c b/fs/affs/dir.c
index cbbda476a805..59f07bec92a6 100644
--- a/fs/affs/dir.c
+++ b/fs/affs/dir.c
@@ -54,8 +54,8 @@ affs_readdir(struct file *file, struct dir_context *ctx)
         u32                      ino;
         int                      error = 0;
 
-        pr_debug("AFFS: readdir(ino=%lu,f_pos=%lx)\n",
-                 inode->i_ino, (unsigned long)ctx->pos);
+        pr_debug("%s(ino=%lu,f_pos=%lx)\n",
+                 __func__, inode->i_ino, (unsigned long)ctx->pos);
 
         if (ctx->pos < 2) {
                 file->private_data = (void *)0;
@@ -81,7 +81,7 @@ affs_readdir(struct file *file, struct dir_context *ctx)
          */
         ino = (u32)(long)file->private_data;
         if (ino && file->f_version == inode->i_version) {
-                pr_debug("AFFS: readdir() left off=%d\n", ino);
+                pr_debug("readdir() left off=%d\n", ino);
                 goto inside;
         }
 
@@ -117,7 +117,7 @@ inside:
 
                         namelen = min(AFFS_TAIL(sb, fh_bh)->name[0], (u8)30);
                         name = AFFS_TAIL(sb, fh_bh)->name + 1;
-                        pr_debug("AFFS: readdir(): dir_emit(\"%.*s\", "
+                        pr_debug("readdir(): dir_emit(\"%.*s\", "
                                  "ino=%u), hash=%d, f_pos=%x\n",
                                  namelen, name, ino, hash_pos, (u32)ctx->pos);
 
diff --git a/fs/affs/file.c b/fs/affs/file.c
index 8669b6ecddee..0270303388ee 100644
--- a/fs/affs/file.c
+++ b/fs/affs/file.c
@@ -45,7 +45,7 @@ const struct inode_operations affs_file_inode_operations = {
 static int
 affs_file_open(struct inode *inode, struct file *filp)
 {
-        pr_debug("AFFS: open(%lu,%d)\n",
+        pr_debug("open(%lu,%d)\n",
                  inode->i_ino, atomic_read(&AFFS_I(inode)->i_opencnt));
         atomic_inc(&AFFS_I(inode)->i_opencnt);
         return 0;
@@ -54,7 +54,7 @@ affs_file_open(struct inode *inode, struct file *filp)
 static int
 affs_file_release(struct inode *inode, struct file *filp)
 {
-        pr_debug("AFFS: release(%lu, %d)\n",
+        pr_debug("release(%lu, %d)\n",
                  inode->i_ino, atomic_read(&AFFS_I(inode)->i_opencnt));
 
         if (atomic_dec_and_test(&AFFS_I(inode)->i_opencnt)) {
@@ -324,7 +324,8 @@ affs_get_block(struct inode *inode, sector_t block, struct buffer_head *bh_resul
         struct buffer_head      *ext_bh;
         u32                      ext;
 
-        pr_debug("AFFS: get_block(%u, %lu)\n", (u32)inode->i_ino, (unsigned long)block);
+        pr_debug("%s(%u, %lu)\n",
+                 __func__, (u32)inode->i_ino, (unsigned long)block);
 
         BUG_ON(block > (sector_t)0x7fffffffUL);
 
@@ -498,34 +499,36 @@ affs_getemptyblk_ino(struct inode *inode, int block)
 }
 
 static int
-affs_do_readpage_ofs(struct file *file, struct page *page, unsigned from, unsigned to)
+affs_do_readpage_ofs(struct page *page, unsigned to)
 {
         struct inode *inode = page->mapping->host;
         struct super_block *sb = inode->i_sb;
         struct buffer_head *bh;
         char *data;
+        unsigned pos = 0;
         u32 bidx, boff, bsize;
         u32 tmp;
 
-        pr_debug("AFFS: read_page(%u, %ld, %d, %d)\n", (u32)inode->i_ino, page->index, from, to);
-        BUG_ON(from > to || to > PAGE_CACHE_SIZE);
+        pr_debug("%s(%u, %ld, 0, %d)\n", __func__, (u32)inode->i_ino,
+                 page->index, to);
+        BUG_ON(to > PAGE_CACHE_SIZE);
         kmap(page);
         data = page_address(page);
         bsize = AFFS_SB(sb)->s_data_blksize;
-        tmp = (page->index << PAGE_CACHE_SHIFT) + from;
+        tmp = page->index << PAGE_CACHE_SHIFT;
         bidx = tmp / bsize;
         boff = tmp % bsize;
 
-        while (from < to) {
+        while (pos < to) {
                 bh = affs_bread_ino(inode, bidx, 0);
                 if (IS_ERR(bh))
                         return PTR_ERR(bh);
-                tmp = min(bsize - boff, to - from);
-                BUG_ON(from + tmp > to || tmp > bsize);
-                memcpy(data + from, AFFS_DATA(bh) + boff, tmp);
+                tmp = min(bsize - boff, to - pos);
+                BUG_ON(pos + tmp > to || tmp > bsize);
+                memcpy(data + pos, AFFS_DATA(bh) + boff, tmp);
                 affs_brelse(bh);
                 bidx++;
-                from += tmp;
+                pos += tmp;
                 boff = 0;
         }
         flush_dcache_page(page);
@@ -542,7 +545,7 @@ affs_extent_file_ofs(struct inode *inode, u32 newsize)
         u32 size, bsize;
         u32 tmp;
 
-        pr_debug("AFFS: extent_file(%u, %d)\n", (u32)inode->i_ino, newsize);
+        pr_debug("%s(%u, %d)\n", __func__, (u32)inode->i_ino, newsize);
         bsize = AFFS_SB(sb)->s_data_blksize;
         bh = NULL;
         size = AFFS_I(inode)->mmu_private;
@@ -608,14 +611,14 @@ affs_readpage_ofs(struct file *file, struct page *page)
         u32 to;
         int err;
 
-        pr_debug("AFFS: read_page(%u, %ld)\n", (u32)inode->i_ino, page->index);
+        pr_debug("%s(%u, %ld)\n", __func__, (u32)inode->i_ino, page->index);
         to = PAGE_CACHE_SIZE;
         if (((page->index + 1) << PAGE_CACHE_SHIFT) > inode->i_size) {
                 to = inode->i_size & ~PAGE_CACHE_MASK;
                 memset(page_address(page) + to, 0, PAGE_CACHE_SIZE - to);
         }
 
-        err = affs_do_readpage_ofs(file, page, 0, to);
+        err = affs_do_readpage_ofs(page, to);
         if (!err)
                 SetPageUptodate(page);
         unlock_page(page);
@@ -631,7 +634,8 @@ static int affs_write_begin_ofs(struct file *file, struct address_space *mapping
         pgoff_t index;
         int err = 0;
 
-        pr_debug("AFFS: write_begin(%u, %llu, %llu)\n", (u32)inode->i_ino, (unsigned long long)pos, (unsigned long long)pos + len);
+        pr_debug("%s(%u, %llu, %llu)\n", __func__, (u32)inode->i_ino,
+                 (unsigned long long)pos, (unsigned long long)pos + len);
         if (pos > AFFS_I(inode)->mmu_private) {
                 /* XXX: this probably leaves a too-big i_size in case of
                  * failure. Should really be updating i_size at write_end time
@@ -651,7 +655,7 @@ static int affs_write_begin_ofs(struct file *file, struct address_space *mapping
                 return 0;
 
         /* XXX: inefficient but safe in the face of short writes */
-        err = affs_do_readpage_ofs(file, page, 0, PAGE_CACHE_SIZE);
+        err = affs_do_readpage_ofs(page, PAGE_CACHE_SIZE);
         if (err) {
                 unlock_page(page);
                 page_cache_release(page);
@@ -680,7 +684,9 @@ static int affs_write_end_ofs(struct file *file, struct address_space *mapping,
          * due to write_begin.
          */
 
-        pr_debug("AFFS: write_begin(%u, %llu, %llu)\n", (u32)inode->i_ino, (unsigned long long)pos, (unsigned long long)pos + len);
+        pr_debug("%s(%u, %llu, %llu)\n",
+                 __func__, (u32)inode->i_ino, (unsigned long long)pos,
+                (unsigned long long)pos + len);
         bsize = AFFS_SB(sb)->s_data_blksize;
         data = page_address(page);
 
@@ -802,7 +808,7 @@ affs_free_prealloc(struct inode *inode)
 {
         struct super_block *sb = inode->i_sb;
 
-        pr_debug("AFFS: free_prealloc(ino=%lu)\n", inode->i_ino);
+        pr_debug("free_prealloc(ino=%lu)\n", inode->i_ino);
 
         while (AFFS_I(inode)->i_pa_cnt) {
                 AFFS_I(inode)->i_pa_cnt--;
@@ -822,7 +828,7 @@ affs_truncate(struct inode *inode)
         struct buffer_head *ext_bh;
         int i;
 
-        pr_debug("AFFS: truncate(inode=%d, oldsize=%u, newsize=%u)\n",
+        pr_debug("truncate(inode=%d, oldsize=%u, newsize=%u)\n",
                  (u32)inode->i_ino, (u32)AFFS_I(inode)->mmu_private, (u32)inode->i_size);
 
         last_blk = 0;
diff --git a/fs/affs/inode.c b/fs/affs/inode.c
index 96df91e8c334..bec2d1a0c91c 100644
--- a/fs/affs/inode.c
+++ b/fs/affs/inode.c
@@ -34,7 +34,7 @@ struct inode *affs_iget(struct super_block *sb, unsigned long ino)
         if (!(inode->i_state & I_NEW))
                 return inode;
 
-        pr_debug("AFFS: affs_iget(%lu)\n", inode->i_ino);
+        pr_debug("affs_iget(%lu)\n", inode->i_ino);
 
         block = inode->i_ino;
         bh = affs_bread(sb, block);
@@ -175,7 +175,7 @@ affs_write_inode(struct inode *inode, struct writeback_control *wbc)
         uid_t                    uid;
         gid_t                    gid;
 
-        pr_debug("AFFS: write_inode(%lu)\n",inode->i_ino);
+        pr_debug("write_inode(%lu)\n", inode->i_ino);
 
         if (!inode->i_nlink)
                 // possibly free block
@@ -220,7 +220,7 @@ affs_notify_change(struct dentry *dentry, struct iattr *attr)
         struct inode *inode = dentry->d_inode;
         int error;
 
-        pr_debug("AFFS: notify_change(%lu,0x%x)\n",inode->i_ino,attr->ia_valid);
+        pr_debug("notify_change(%lu,0x%x)\n", inode->i_ino, attr->ia_valid);
 
         error = inode_change_ok(inode,attr);
         if (error)
@@ -258,7 +258,8 @@ void
 affs_evict_inode(struct inode *inode)
 {
         unsigned long cache_page;
-        pr_debug("AFFS: evict_inode(ino=%lu, nlink=%u)\n", inode->i_ino, inode->i_nlink);
+        pr_debug("evict_inode(ino=%lu, nlink=%u)\n",
+                 inode->i_ino, inode->i_nlink);
         truncate_inode_pages_final(&inode->i_data);
 
         if (!inode->i_nlink) {
@@ -271,7 +272,7 @@ affs_evict_inode(struct inode *inode)
         affs_free_prealloc(inode);
         cache_page = (unsigned long)AFFS_I(inode)->i_lc;
         if (cache_page) {
-                pr_debug("AFFS: freeing ext cache\n");
+                pr_debug("freeing ext cache\n");
                 AFFS_I(inode)->i_lc = NULL;
                 AFFS_I(inode)->i_ac = NULL;
                 free_page(cache_page);
@@ -350,7 +351,8 @@ affs_add_entry(struct inode *dir, struct inode *inode, struct dentry *dentry, s3
         u32 block = 0;
         int retval;
 
-        pr_debug("AFFS: add_entry(dir=%u, inode=%u, \"%*s\", type=%d)\n", (u32)dir->i_ino,
+        pr_debug("%s(dir=%u, inode=%u, \"%*s\", type=%d)\n",
+                 __func__, (u32)dir->i_ino,
                  (u32)inode->i_ino, (int)dentry->d_name.len, dentry->d_name.name, type);
 
         retval = -EIO;
diff --git a/fs/affs/namei.c b/fs/affs/namei.c
index 6dae1ccd176d..035bd31556fc 100644
--- a/fs/affs/namei.c
+++ b/fs/affs/namei.c
@@ -190,7 +190,8 @@ affs_find_entry(struct inode *dir, struct dentry *dentry)
         toupper_t toupper = affs_get_toupper(sb);
         u32 key;
 
-        pr_debug("AFFS: find_entry(\"%.*s\")\n", (int)dentry->d_name.len, dentry->d_name.name);
+        pr_debug("%s(\"%.*s\")\n",
+                 __func__, (int)dentry->d_name.len, dentry->d_name.name);
 
         bh = affs_bread(sb, dir->i_ino);
         if (!bh)
@@ -218,7 +219,8 @@ affs_lookup(struct inode *dir, struct dentry *dentry, unsigned int flags)
         struct buffer_head *bh;
         struct inode *inode = NULL;
 
-        pr_debug("AFFS: lookup(\"%.*s\")\n",(int)dentry->d_name.len,dentry->d_name.name);
+        pr_debug("%s(\"%.*s\")\n",
+                 __func__, (int)dentry->d_name.len, dentry->d_name.name);
 
         affs_lock_dir(dir);
         bh = affs_find_entry(dir, dentry);
@@ -248,9 +250,9 @@ affs_lookup(struct inode *dir, struct dentry *dentry, unsigned int flags)
 int
 affs_unlink(struct inode *dir, struct dentry *dentry)
 {
-        pr_debug("AFFS: unlink(dir=%d, %lu \"%.*s\")\n", (u32)dir->i_ino,
-                 dentry->d_inode->i_ino,
-                 (int)dentry->d_name.len, dentry->d_name.name);
+        pr_debug("%s(dir=%d, %lu \"%.*s\")\n",
+                 __func__, (u32)dir->i_ino, dentry->d_inode->i_ino,
+                (int)dentry->d_name.len, dentry->d_name.name);
 
         return affs_remove_header(dentry);
 }
@@ -262,7 +264,8 @@ affs_create(struct inode *dir, struct dentry *dentry, umode_t mode, bool excl)
         struct inode    *inode;
         int              error;
 
-        pr_debug("AFFS: create(%lu,\"%.*s\",0%ho)\n",dir->i_ino,(int)dentry->d_name.len,
+        pr_debug("%s(%lu,\"%.*s\",0%ho)\n",
+                 __func__, dir->i_ino, (int)dentry->d_name.len,
                  dentry->d_name.name,mode);
 
         inode = affs_new_inode(dir);
@@ -291,8 +294,9 @@ affs_mkdir(struct inode *dir, struct dentry *dentry, umode_t mode)
         struct inode            *inode;
         int                      error;
 
-        pr_debug("AFFS: mkdir(%lu,\"%.*s\",0%ho)\n",dir->i_ino,
-                 (int)dentry->d_name.len,dentry->d_name.name,mode);
+        pr_debug("%s(%lu,\"%.*s\",0%ho)\n",
+                 __func__, dir->i_ino, (int)dentry->d_name.len,
+                 dentry->d_name.name, mode);
 
         inode = affs_new_inode(dir);
         if (!inode)
@@ -317,8 +321,8 @@ affs_mkdir(struct inode *dir, struct dentry *dentry, umode_t mode)
 int
 affs_rmdir(struct inode *dir, struct dentry *dentry)
 {
-        pr_debug("AFFS: rmdir(dir=%u, %lu \"%.*s\")\n", (u32)dir->i_ino,
-                 dentry->d_inode->i_ino,
+        pr_debug("%s(dir=%u, %lu \"%.*s\")\n",
+                __func__, (u32)dir->i_ino, dentry->d_inode->i_ino,
                  (int)dentry->d_name.len, dentry->d_name.name);
 
         return affs_remove_header(dentry);
@@ -334,8 +338,9 @@ affs_symlink(struct inode *dir, struct dentry *dentry, const char *symname)
         int                      i, maxlen, error;
         char                     c, lc;
 
-        pr_debug("AFFS: symlink(%lu,\"%.*s\" -> \"%s\")\n",dir->i_ino,
-                 (int)dentry->d_name.len,dentry->d_name.name,symname);
+        pr_debug("%s(%lu,\"%.*s\" -> \"%s\")\n",
+                 __func__, dir->i_ino, (int)dentry->d_name.len,
+                 dentry->d_name.name, symname);
 
         maxlen = AFFS_SB(sb)->s_hashsize * sizeof(u32) - 1;
         inode  = affs_new_inode(dir);
@@ -404,7 +409,8 @@ affs_link(struct dentry *old_dentry, struct inode *dir, struct dentry *dentry)
 {
         struct inode *inode = old_dentry->d_inode;
 
-        pr_debug("AFFS: link(%u, %u, \"%.*s\")\n", (u32)inode->i_ino, (u32)dir->i_ino,
+        pr_debug("%s(%u, %u, \"%.*s\")\n",
+                 __func__, (u32)inode->i_ino, (u32)dir->i_ino,
                  (int)dentry->d_name.len,dentry->d_name.name);
 
         return affs_add_entry(dir, inode, dentry, ST_LINKFILE);
@@ -418,9 +424,10 @@ affs_rename(struct inode *old_dir, struct dentry *old_dentry,
         struct buffer_head *bh = NULL;
         int retval;
 
-        pr_debug("AFFS: rename(old=%u,\"%*s\" to new=%u,\"%*s\")\n",
-                 (u32)old_dir->i_ino, (int)old_dentry->d_name.len, old_dentry->d_name.name,
-                 (u32)new_dir->i_ino, (int)new_dentry->d_name.len, new_dentry->d_name.name);
+        pr_debug("%s(old=%u,\"%*s\" to new=%u,\"%*s\")\n",
+                 __func__, (u32)old_dir->i_ino, (int)old_dentry->d_name.len,
+                 old_dentry->d_name.name, (u32)new_dir->i_ino,
+                (int)new_dentry->d_name.len, new_dentry->d_name.name);
 
         retval = affs_check_name(new_dentry->d_name.name,
                                  new_dentry->d_name.len,
diff --git a/fs/affs/super.c b/fs/affs/super.c
index 895ac7dc9dbf..51f1a95bff73 100644
--- a/fs/affs/super.c
+++ b/fs/affs/super.c
@@ -46,7 +46,7 @@ static void
 affs_put_super(struct super_block *sb)
 {
         struct affs_sb_info *sbi = AFFS_SB(sb);
-        pr_debug("AFFS: put_super()\n");
+        pr_debug("%s()\n", __func__);
 
         cancel_delayed_work_sync(&sbi->sb_work);
 }
@@ -220,7 +220,7 @@ parse_options(char *options, kuid_t *uid, kgid_t *gid, int *mode, int *reserved,
                                 return 0;
                         if (n != 512 && n != 1024 && n != 2048
                             && n != 4096) {
-                                printk ("AFFS: Invalid blocksize (512, 1024, 2048, 4096 allowed)\n");
+                                pr_warn("Invalid blocksize (512, 1024, 2048, 4096 allowed)\n");
                                 return 0;
                         }
                         *blocksize = n;
@@ -285,8 +285,8 @@ parse_options(char *options, kuid_t *uid, kgid_t *gid, int *mode, int *reserved,
                         /* Silently ignore the quota options */
                         break;
                 default:
-                        printk("AFFS: Unrecognized mount option \"%s\" "
-                                        "or missing value\n", p);
+                        pr_warn("Unrecognized mount option \"%s\" or missing value\n",
+                                p);
                         return 0;
                 }
         }
@@ -319,7 +319,7 @@ static int affs_fill_super(struct super_block *sb, void *data, int silent)
 
         save_mount_options(sb, data);
 
-        pr_debug("AFFS: read_super(%s)\n",data ? (const char *)data : "no options");
+        pr_debug("read_super(%s)\n", data ? (const char *)data : "no options");
 
         sb->s_magic             = AFFS_SUPER_MAGIC;
         sb->s_op                = &affs_sops;
@@ -339,7 +339,7 @@ static int affs_fill_super(struct super_block *sb, void *data, int silent)
         if (!parse_options(data,&uid,&gid,&i,&reserved,&root_block,
                                 &blocksize,&sbi->s_prefix,
                                 sbi->s_volume, &mount_flags)) {
-                printk(KERN_ERR "AFFS: Error parsing options\n");
+                pr_err("Error parsing options\n");
                 return -EINVAL;
         }
         /* N.B. after this point s_prefix must be released */
@@ -356,7 +356,7 @@ static int affs_fill_super(struct super_block *sb, void *data, int silent)
          */
 
         size = sb->s_bdev->bd_inode->i_size >> 9;
-        pr_debug("AFFS: initial blocksize=%d, #blocks=%d\n", 512, size);
+        pr_debug("initial blocksize=%d, #blocks=%d\n", 512, size);
 
         affs_set_blocksize(sb, PAGE_SIZE);
         /* Try to find root block. Its location depends on the block size. */
@@ -371,7 +371,7 @@ static int affs_fill_super(struct super_block *sb, void *data, int silent)
                 sbi->s_root_block = root_block;
                 if (root_block < 0)
                         sbi->s_root_block = (reserved + size - 1) / 2;
-                pr_debug("AFFS: setting blocksize to %d\n", blocksize);
+                pr_debug("setting blocksize to %d\n", blocksize);
                 affs_set_blocksize(sb, blocksize);
                 sbi->s_partition_size = size;
 
@@ -386,7 +386,7 @@ static int affs_fill_super(struct super_block *sb, void *data, int silent)
                  * block behind the calculated one. So we check this one, too.
                  */
                 for (num_bm = 0; num_bm < 2; num_bm++) {
-                        pr_debug("AFFS: Dev %s, trying root=%u, bs=%d, "
+                        pr_debug("Dev %s, trying root=%u, bs=%d, "
                                 "size=%d, reserved=%d\n",
                                 sb->s_id,
                                 sbi->s_root_block + num_bm,
@@ -407,8 +407,7 @@ static int affs_fill_super(struct super_block *sb, void *data, int silent)
                 }
         }
         if (!silent)
-                printk(KERN_ERR "AFFS: No valid root block on device %s\n",
-                        sb->s_id);
+                pr_err("No valid root block on device %s\n", sb->s_id);
         return -EINVAL;
 
         /* N.B. after this point bh must be released */
@@ -420,7 +419,7 @@ got_root:
         /* Find out which kind of FS we have */
         boot_bh = sb_bread(sb, 0);
         if (!boot_bh) {
-                printk(KERN_ERR "AFFS: Cannot read boot block\n");
+                pr_err("Cannot read boot block\n");
                 return -EINVAL;
         }
         memcpy(sig, boot_bh->b_data, 4);
@@ -433,8 +432,7 @@ got_root:
          */
         if ((chksum == FS_DCFFS || chksum == MUFS_DCFFS || chksum == FS_DCOFS
              || chksum == MUFS_DCOFS) && !(sb->s_flags & MS_RDONLY)) {
-                printk(KERN_NOTICE "AFFS: Dircache FS - mounting %s read only\n",
-                        sb->s_id);
+                pr_notice("Dircache FS - mounting %s read only\n", sb->s_id);
                 sb->s_flags |= MS_RDONLY;
         }
         switch (chksum) {
@@ -468,14 +466,14 @@ got_root:
                         sb->s_flags |= MS_NOEXEC;
                         break;
                 default:
-                        printk(KERN_ERR "AFFS: Unknown filesystem on device %s: %08X\n",
-                                sb->s_id, chksum);
+                        pr_err("Unknown filesystem on device %s: %08X\n",
+                               sb->s_id, chksum);
                         return -EINVAL;
         }
 
         if (mount_flags & SF_VERBOSE) {
                 u8 len = AFFS_ROOT_TAIL(sb, root_bh)->disk_name[0];
-                printk(KERN_NOTICE "AFFS: Mounting volume \"%.*s\": Type=%.3s\\%c, Blocksize=%d\n",
+                pr_notice("Mounting volume \"%.*s\": Type=%.3s\\%c, Blocksize=%d\n",
                         len > 31 ? 31 : len,
                         AFFS_ROOT_TAIL(sb, root_bh)->disk_name + 1,
                         sig, sig[3] + '0', blocksize);
@@ -506,11 +504,11 @@ got_root:
 
         sb->s_root = d_make_root(root_inode);
         if (!sb->s_root) {
-                printk(KERN_ERR "AFFS: Get root inode failed\n");
+                pr_err("AFFS: Get root inode failed\n");
                 return -ENOMEM;
         }
 
-        pr_debug("AFFS: s_flags=%lX\n",sb->s_flags);
+        pr_debug("s_flags=%lX\n", sb->s_flags);
         return 0;
 }
 
@@ -530,7 +528,7 @@ affs_remount(struct super_block *sb, int *flags, char *data)
         char                     volume[32];
         char                    *prefix = NULL;
 
-        pr_debug("AFFS: remount(flags=0x%x,opts=\"%s\")\n",*flags,data);
+        pr_debug("%s(flags=0x%x,opts=\"%s\")\n", __func__, *flags, data);
 
         sync_filesystem(sb);
         *flags |= MS_NODIRATIME;
@@ -578,8 +576,9 @@ affs_statfs(struct dentry *dentry, struct kstatfs *buf)
         int              free;
         u64              id = huge_encode_dev(sb->s_bdev->bd_dev);
 
-        pr_debug("AFFS: statfs() partsize=%d, reserved=%d\n",AFFS_SB(sb)->s_partition_size,
-             AFFS_SB(sb)->s_reserved);
+        pr_debug("%s() partsize=%d, reserved=%d\n",
+                 __func__, AFFS_SB(sb)->s_partition_size,
+                 AFFS_SB(sb)->s_reserved);
 
         free          = affs_count_free_blocks(sb);
         buf->f_type    = AFFS_SUPER_MAGIC;
diff --git a/fs/affs/symlink.c b/fs/affs/symlink.c
index ee00f08c4f53..f39b71c3981e 100644
--- a/fs/affs/symlink.c
+++ b/fs/affs/symlink.c
@@ -21,7 +21,7 @@ static int affs_symlink_readpage(struct file *file, struct page *page)
         char                     c;
         char                     lc;
 
-        pr_debug("AFFS: follow_link(ino=%lu)\n",inode->i_ino);
+        pr_debug("follow_link(ino=%lu)\n", inode->i_ino);
 
         err = -EIO;
         bh = affs_bread(inode->i_sb, inode->i_ino);
diff --git a/fs/befs/btree.c b/fs/befs/btree.c
index a2cd305a993a..9c7faa8a9288 100644
--- a/fs/befs/btree.c
+++ b/fs/befs/btree.c
@@ -318,7 +318,7 @@ befs_btree_find(struct super_block *sb, befs_data_stream * ds,
  * befs_find_key - Search for a key within a node
  * @sb: Filesystem superblock
  * @node: Node to find the key within
- * @key: Keystring to search for
+ * @findkey: Keystring to search for
  * @value: If key is found, the value stored with the key is put here
  *
  * finds exact match if one exists, and returns BEFS_BT_MATCH
@@ -405,7 +405,7 @@ befs_find_key(struct super_block *sb, befs_btree_node * node,
  * Heres how it works: Key_no is the index of the key/value pair to 
  * return in keybuf/value.
  * Bufsize is the size of keybuf (BEFS_NAME_LEN+1 is a good size). Keysize is 
- * the number of charecters in the key (just a convenience).
+ * the number of characters in the key (just a convenience).
  *
  * Algorithm:
  *   Get the first leafnode of the tree. See if the requested key is in that
@@ -502,12 +502,11 @@ befs_btree_read(struct super_block *sb, befs_data_stream * ds,
                            "for key of size %d", __func__, bufsize, keylen);
                 brelse(this_node->bh);
                 goto error_alloc;
-        };
+        }
 
-        strncpy(keybuf, keystart, keylen);
+        strlcpy(keybuf, keystart, keylen + 1);
         *value = fs64_to_cpu(sb, valarray[cur_key]);
         *keysize = keylen;
-        keybuf[keylen] = '\0';
 
         befs_debug(sb, "Read [%llu,%d]: Key \"%.*s\", Value %llu", node_off,
                    cur_key, keylen, keybuf, *value);
@@ -707,7 +706,7 @@ befs_bt_get_key(struct super_block *sb, befs_btree_node * node,
  * @key1: pointer to the first key to be compared 
  * @keylen1: length in bytes of key1
  * @key2: pointer to the second key to be compared
- * @kelen2: length in bytes of key2
+ * @keylen2: length in bytes of key2
  *
  * Returns 0 if @key1 and @key2 are equal.
  * Returns >0 if @key1 is greater.
diff --git a/fs/befs/datastream.c b/fs/befs/datastream.c
index c467bebd50af..1e8e0b8d8836 100644
--- a/fs/befs/datastream.c
+++ b/fs/befs/datastream.c
@@ -116,7 +116,7 @@ befs_fblock2brun(struct super_block *sb, befs_data_stream * data,
  * befs_read_lsmylink - read long symlink from datastream.
  * @sb: Filesystem superblock 
  * @ds: Datastrem to read from
- * @buf: Buffer in which to place long symlink data
+ * @buff: Buffer in which to place long symlink data
  * @len: Length of the long symlink in bytes
  *
  * Returns the number of bytes read
diff --git a/fs/befs/linuxvfs.c b/fs/befs/linuxvfs.c
index d626756ff721..a16fbd4e8241 100644
--- a/fs/befs/linuxvfs.c
+++ b/fs/befs/linuxvfs.c
@@ -133,14 +133,6 @@ befs_get_block(struct inode *inode, sector_t block,
 
         befs_debug(sb, "---> befs_get_block() for inode %lu, block %ld",
                    (unsigned long)inode->i_ino, (long)block);
-
-        if (block < 0) {
-                befs_error(sb, "befs_get_block() was asked for a block "
-                           "number less than zero: block %ld in inode %lu",
-                           (long)block, (unsigned long)inode->i_ino);
-                return -EIO;
-        }
-
         if (create) {
                 befs_error(sb, "befs_get_block() was asked to write to "
                            "block %ld in inode %lu", (long)block,
@@ -396,9 +388,8 @@ static struct inode *befs_iget(struct super_block *sb, unsigned long ino)
         if (S_ISLNK(inode->i_mode) && !(befs_ino->i_flags & BEFS_LONG_SYMLINK)){
                 inode->i_size = 0;
                 inode->i_blocks = befs_sb->block_size / VFS_BLOCK_SIZE;
-                strncpy(befs_ino->i_data.symlink, raw_inode->data.symlink,
-                        BEFS_SYMLINK_LEN - 1);
-                befs_ino->i_data.symlink[BEFS_SYMLINK_LEN - 1] = '\0';
+                strlcpy(befs_ino->i_data.symlink, raw_inode->data.symlink,
+                        BEFS_SYMLINK_LEN);
         } else {
                 int num_blks;
 
@@ -591,21 +582,21 @@ befs_utf2nls(struct super_block *sb, const char *in,
 /**
  * befs_nls2utf - Convert NLS string to utf8 encodeing
  * @sb: Superblock
- * @src: Input string buffer in NLS format
- * @srclen: Length of input string in bytes
- * @dest: The output string in UTF-8 format
- * @destlen: Length of the output buffer
+ * @in: Input string buffer in NLS format
+ * @in_len: Length of input string in bytes
+ * @out: The output string in UTF-8 format
+ * @out_len: Length of the output buffer
  * 
- * Converts input string @src, which is in the format of the loaded NLS map,
+ * Converts input string @in, which is in the format of the loaded NLS map,
  * into a utf8 string.
  * 
- * The destination string @dest is allocated by this function and the caller is
+ * The destination string @out is allocated by this function and the caller is
  * responsible for freeing it with kfree()
  * 
- * On return, *@destlen is the length of @dest in bytes.
+ * On return, *@out_len is the length of @out in bytes.
  *
  * On success, the return value is the number of utf8 characters written to
- * the output buffer @dest.
+ * the output buffer @out.
  *  
  * On Failure, a negative number coresponding to the error code is returned.
  */
diff --git a/fs/cachefiles/bind.c b/fs/cachefiles/bind.c
index 5b99bafc31d1..d749731dc0ee 100644
--- a/fs/cachefiles/bind.c
+++ b/fs/cachefiles/bind.c
@@ -50,18 +50,18 @@ int cachefiles_daemon_bind(struct cachefiles_cache *cache, char *args)
                cache->brun_percent  < 100);
 
         if (*args) {
-                kerror("'bind' command doesn't take an argument");
+                pr_err("'bind' command doesn't take an argument");
                 return -EINVAL;
         }
 
         if (!cache->rootdirname) {
-                kerror("No cache directory specified");
+                pr_err("No cache directory specified");
                 return -EINVAL;
         }
 
         /* don't permit already bound caches to be re-bound */
         if (test_bit(CACHEFILES_READY, &cache->flags)) {
-                kerror("Cache already bound");
+                pr_err("Cache already bound");
                 return -EBUSY;
         }
 
@@ -228,9 +228,7 @@ static int cachefiles_daemon_add_cache(struct cachefiles_cache *cache)
         set_bit(CACHEFILES_READY, &cache->flags);
         dput(root);
 
-        printk(KERN_INFO "CacheFiles:"
-               " File cache on %s registered\n",
-               cache->cache.identifier);
+        pr_info("File cache on %s registered\n", cache->cache.identifier);
 
         /* check how much space the cache has */
         cachefiles_has_space(cache, 0, 0);
@@ -250,7 +248,7 @@ error_open_root:
         kmem_cache_free(cachefiles_object_jar, fsdef);
 error_root_object:
         cachefiles_end_secure(cache, saved_cred);
-        kerror("Failed to register: %d", ret);
+        pr_err("Failed to register: %d", ret);
         return ret;
 }
 
@@ -262,9 +260,8 @@ void cachefiles_daemon_unbind(struct cachefiles_cache *cache)
         _enter("");
 
         if (test_bit(CACHEFILES_READY, &cache->flags)) {
-                printk(KERN_INFO "CacheFiles:"
-                       " File cache on %s unregistering\n",
-                       cache->cache.identifier);
+                pr_info("File cache on %s unregistering\n",
+                        cache->cache.identifier);
 
                 fscache_withdraw_cache(&cache->cache);
         }
diff --git a/fs/cachefiles/daemon.c b/fs/cachefiles/daemon.c
index 0a1467b15516..b078d3081d6c 100644
--- a/fs/cachefiles/daemon.c
+++ b/fs/cachefiles/daemon.c
@@ -315,8 +315,7 @@ static unsigned int cachefiles_daemon_poll(struct file *file,
 static int cachefiles_daemon_range_error(struct cachefiles_cache *cache,
                                          char *args)
 {
-        kerror("Free space limits must be in range"
-               " 0%%<=stop<cull<run<100%%");
+        pr_err("Free space limits must be in range 0%%<=stop<cull<run<100%%");
 
         return -EINVAL;
 }
@@ -476,12 +475,12 @@ static int cachefiles_daemon_dir(struct cachefiles_cache *cache, char *args)
         _enter(",%s", args);
 
         if (!*args) {
-                kerror("Empty directory specified");
+                pr_err("Empty directory specified");
                 return -EINVAL;
         }
 
         if (cache->rootdirname) {
-                kerror("Second cache directory specified");
+                pr_err("Second cache directory specified");
                 return -EEXIST;
         }
 
@@ -504,12 +503,12 @@ static int cachefiles_daemon_secctx(struct cachefiles_cache *cache, char *args)
         _enter(",%s", args);
 
         if (!*args) {
-                kerror("Empty security context specified");
+                pr_err("Empty security context specified");
                 return -EINVAL;
         }
 
         if (cache->secctx) {
-                kerror("Second security context specified");
+                pr_err("Second security context specified");
                 return -EINVAL;
         }
 
@@ -532,7 +531,7 @@ static int cachefiles_daemon_tag(struct cachefiles_cache *cache, char *args)
         _enter(",%s", args);
 
         if (!*args) {
-                kerror("Empty tag specified");
+                pr_err("Empty tag specified");
                 return -EINVAL;
         }
 
@@ -563,12 +562,12 @@ static int cachefiles_daemon_cull(struct cachefiles_cache *cache, char *args)
                 goto inval;
 
         if (!test_bit(CACHEFILES_READY, &cache->flags)) {
-                kerror("cull applied to unready cache");
+                pr_err("cull applied to unready cache");
                 return -EIO;
         }
 
         if (test_bit(CACHEFILES_DEAD, &cache->flags)) {
-                kerror("cull applied to dead cache");
+                pr_err("cull applied to dead cache");
                 return -EIO;
         }
 
@@ -588,11 +587,11 @@ static int cachefiles_daemon_cull(struct cachefiles_cache *cache, char *args)
 
 notdir:
         path_put(&path);
-        kerror("cull command requires dirfd to be a directory");
+        pr_err("cull command requires dirfd to be a directory");
         return -ENOTDIR;
 
 inval:
-        kerror("cull command requires dirfd and filename");
+        pr_err("cull command requires dirfd and filename");
         return -EINVAL;
 }
 
@@ -615,7 +614,7 @@ static int cachefiles_daemon_debug(struct cachefiles_cache *cache, char *args)
         return 0;
 
 inval:
-        kerror("debug command requires mask");
+        pr_err("debug command requires mask");
         return -EINVAL;
 }
 
@@ -635,12 +634,12 @@ static int cachefiles_daemon_inuse(struct cachefiles_cache *cache, char *args)
                 goto inval;
 
         if (!test_bit(CACHEFILES_READY, &cache->flags)) {
-                kerror("inuse applied to unready cache");
+                pr_err("inuse applied to unready cache");
                 return -EIO;
         }
 
         if (test_bit(CACHEFILES_DEAD, &cache->flags)) {
-                kerror("inuse applied to dead cache");
+                pr_err("inuse applied to dead cache");
                 return -EIO;
         }
 
@@ -660,11 +659,11 @@ static int cachefiles_daemon_inuse(struct cachefiles_cache *cache, char *args)
 
 notdir:
         path_put(&path);
-        kerror("inuse command requires dirfd to be a directory");
+        pr_err("inuse command requires dirfd to be a directory");
         return -ENOTDIR;
 
 inval:
-        kerror("inuse command requires dirfd and filename");
+        pr_err("inuse command requires dirfd and filename");
         return -EINVAL;
 }
 
diff --git a/fs/cachefiles/interface.c b/fs/cachefiles/interface.c
index 57e17fe6121a..584743d456c3 100644
--- a/fs/cachefiles/interface.c
+++ b/fs/cachefiles/interface.c
@@ -146,8 +146,7 @@ static int cachefiles_lookup_object(struct fscache_object *_object)
 
         if (ret < 0 && ret != -ETIMEDOUT) {
                 if (ret != -ENOBUFS)
-                        printk(KERN_WARNING
-                               "CacheFiles: Lookup failed error %d\n", ret);
+                        pr_warn("Lookup failed error %d\n", ret);
                 fscache_object_lookup_error(&object->fscache);
         }
 
diff --git a/fs/cachefiles/internal.h b/fs/cachefiles/internal.h
index 5349473df1b1..3d50998abf57 100644
--- a/fs/cachefiles/internal.h
+++ b/fs/cachefiles/internal.h
@@ -9,6 +9,13 @@
  * 2 of the Licence, or (at your option) any later version.
  */
 
+#ifdef pr_fmt
+#undef pr_fmt
+#endif
+
+#define pr_fmt(fmt) "CacheFiles: " fmt
+
+
 #include <linux/fscache-cache.h>
 #include <linux/timer.h>
 #include <linux/wait.h>
@@ -245,11 +252,10 @@ extern int cachefiles_remove_object_xattr(struct cachefiles_cache *cache,
 /*
  * error handling
  */
-#define kerror(FMT, ...) printk(KERN_ERR "CacheFiles: "FMT"\n", ##__VA_ARGS__)
 
 #define cachefiles_io_error(___cache, FMT, ...)         \
 do {                                                    \
-        kerror("I/O Error: " FMT, ##__VA_ARGS__);       \
+        pr_err("I/O Error: " FMT, ##__VA_ARGS__);       \
         fscache_io_error(&(___cache)->cache);           \
         set_bit(CACHEFILES_DEAD, &(___cache)->flags);   \
 } while (0)
@@ -310,8 +316,8 @@ do {							\
 #define ASSERT(X)                                                       \
 do {                                                                    \
         if (unlikely(!(X))) {                                           \
-                printk(KERN_ERR "\n");                                  \
-                printk(KERN_ERR "CacheFiles: Assertion failed\n");      \
+                pr_err("\n");                                           \
+                pr_err("Assertion failed\n");           \
                 BUG();                                                  \
         }                                                               \
 } while (0)
@@ -319,9 +325,9 @@ do {									\
 #define ASSERTCMP(X, OP, Y)                                             \
 do {                                                                    \
         if (unlikely(!((X) OP (Y)))) {                                  \
-                printk(KERN_ERR "\n");                                  \
-                printk(KERN_ERR "CacheFiles: Assertion failed\n");      \
-                printk(KERN_ERR "%lx " #OP " %lx is false\n",           \
+                pr_err("\n");                                           \
+                pr_err("Assertion failed\n");           \
+                pr_err("%lx " #OP " %lx is false\n",                    \
                        (unsigned long)(X), (unsigned long)(Y));         \
                 BUG();                                                  \
         }                                                               \
@@ -330,8 +336,8 @@ do {									\
 #define ASSERTIF(C, X)                                                  \
 do {                                                                    \
         if (unlikely((C) && !(X))) {                                    \
-                printk(KERN_ERR "\n");                                  \
-                printk(KERN_ERR "CacheFiles: Assertion failed\n");      \
+                pr_err("\n");                                           \
+                pr_err("Assertion failed\n");           \
                 BUG();                                                  \
         }                                                               \
 } while (0)
@@ -339,9 +345,9 @@ do {									\
 #define ASSERTIFCMP(C, X, OP, Y)                                        \
 do {                                                                    \
         if (unlikely((C) && !((X) OP (Y)))) {                           \
-                printk(KERN_ERR "\n");                                  \
-                printk(KERN_ERR "CacheFiles: Assertion failed\n");      \
-                printk(KERN_ERR "%lx " #OP " %lx is false\n",           \
+                pr_err("\n");                                           \
+                pr_err("Assertion failed\n");           \
+                pr_err("%lx " #OP " %lx is false\n",                    \
                        (unsigned long)(X), (unsigned long)(Y));         \
                 BUG();                                                  \
         }                                                               \
diff --git a/fs/cachefiles/main.c b/fs/cachefiles/main.c
index 4bfa8cf43bf5..180edfb45f66 100644
--- a/fs/cachefiles/main.c
+++ b/fs/cachefiles/main.c
@@ -68,8 +68,7 @@ static int __init cachefiles_init(void)
                                   SLAB_HWCACHE_ALIGN,
                                   cachefiles_object_init_once);
         if (!cachefiles_object_jar) {
-                printk(KERN_NOTICE
-                       "CacheFiles: Failed to allocate an object jar\n");
+                pr_notice("Failed to allocate an object jar\n");
                 goto error_object_jar;
         }
 
@@ -77,7 +76,7 @@ static int __init cachefiles_init(void)
         if (ret < 0)
                 goto error_proc;
 
-        printk(KERN_INFO "CacheFiles: Loaded\n");
+        pr_info("Loaded\n");
         return 0;
 
 error_proc:
@@ -85,7 +84,7 @@ error_proc:
 error_object_jar:
         misc_deregister(&cachefiles_dev);
 error_dev:
-        kerror("failed to register: %d", ret);
+        pr_err("failed to register: %d", ret);
         return ret;
 }
 
@@ -96,7 +95,7 @@ fs_initcall(cachefiles_init);
  */
 static void __exit cachefiles_exit(void)
 {
-        printk(KERN_INFO "CacheFiles: Unloading\n");
+        pr_info("Unloading\n");
 
         cachefiles_proc_cleanup();
         kmem_cache_destroy(cachefiles_object_jar);
diff --git a/fs/cachefiles/namei.c b/fs/cachefiles/namei.c
index c0a681705104..5bf2b41e66d3 100644
--- a/fs/cachefiles/namei.c
+++ b/fs/cachefiles/namei.c
@@ -35,22 +35,21 @@ void __cachefiles_printk_object(struct cachefiles_object *object,
         struct fscache_cookie *cookie;
         unsigned keylen, loop;
 
-        printk(KERN_ERR "%sobject: OBJ%x\n",
-               prefix, object->fscache.debug_id);
-        printk(KERN_ERR "%sobjstate=%s fl=%lx wbusy=%x ev=%lx[%lx]\n",
+        pr_err("%sobject: OBJ%x\n", prefix, object->fscache.debug_id);
+        pr_err("%sobjstate=%s fl=%lx wbusy=%x ev=%lx[%lx]\n",
                prefix, object->fscache.state->name,
                object->fscache.flags, work_busy(&object->fscache.work),
                object->fscache.events, object->fscache.event_mask);
-        printk(KERN_ERR "%sops=%u inp=%u exc=%u\n",
+        pr_err("%sops=%u inp=%u exc=%u\n",
                prefix, object->fscache.n_ops, object->fscache.n_in_progress,
                object->fscache.n_exclusive);
-        printk(KERN_ERR "%sparent=%p\n",
+        pr_err("%sparent=%p\n",
                prefix, object->fscache.parent);
 
         spin_lock(&object->fscache.lock);
         cookie = object->fscache.cookie;
         if (cookie) {
-                printk(KERN_ERR "%scookie=%p [pr=%p nd=%p fl=%lx]\n",
+                pr_err("%scookie=%p [pr=%p nd=%p fl=%lx]\n",
                        prefix,
                        object->fscache.cookie,
                        object->fscache.cookie->parent,
@@ -62,16 +61,16 @@ void __cachefiles_printk_object(struct cachefiles_object *object,
                 else
                         keylen = 0;
         } else {
-                printk(KERN_ERR "%scookie=NULL\n", prefix);
+                pr_err("%scookie=NULL\n", prefix);
                 keylen = 0;
         }
         spin_unlock(&object->fscache.lock);
 
         if (keylen) {
-                printk(KERN_ERR "%skey=[%u] '", prefix, keylen);
+                pr_err("%skey=[%u] '", prefix, keylen);
                 for (loop = 0; loop < keylen; loop++)
-                        printk("%02x", keybuf[loop]);
-                printk("'\n");
+                        pr_cont("%02x", keybuf[loop]);
+                pr_cont("'\n");
         }
 }
 
@@ -131,13 +130,11 @@ found_dentry:
                dentry);
 
         if (fscache_object_is_live(&object->fscache)) {
-                printk(KERN_ERR "\n");
-                printk(KERN_ERR "CacheFiles: Error:"
-                       " Can't preemptively bury live object\n");
+                pr_err("\n");
+                pr_err("Error: Can't preemptively bury live object\n");
                 cachefiles_printk_object(object, NULL);
         } else if (test_and_set_bit(CACHEFILES_OBJECT_BURIED, &object->flags)) {
-                printk(KERN_ERR "CacheFiles: Error:"
-                       " Object already preemptively buried\n");
+                pr_err("Error: Object already preemptively buried\n");
         }
 
         write_unlock(&cache->active_lock);
@@ -160,7 +157,7 @@ try_again:
         write_lock(&cache->active_lock);
 
         if (test_and_set_bit(CACHEFILES_OBJECT_ACTIVE, &object->flags)) {
-                printk(KERN_ERR "CacheFiles: Error: Object already active\n");
+                pr_err("Error: Object already active\n");
                 cachefiles_printk_object(object, NULL);
                 BUG();
         }
@@ -193,9 +190,8 @@ try_again:
          * need to wait for it to be destroyed */
 wait_for_old_object:
         if (fscache_object_is_live(&object->fscache)) {
-                printk(KERN_ERR "\n");
-                printk(KERN_ERR "CacheFiles: Error:"
-                       " Unexpected object collision\n");
+                pr_err("\n");
+                pr_err("Error: Unexpected object collision\n");
                 cachefiles_printk_object(object, xobject);
                 BUG();
         }
@@ -241,9 +237,8 @@ wait_for_old_object:
                 }
 
                 if (timeout <= 0) {
-                        printk(KERN_ERR "\n");
-                        printk(KERN_ERR "CacheFiles: Error: Overlong"
-                               " wait for old active object to go away\n");
+                        pr_err("\n");
+                        pr_err("Error: Overlong wait for old active object to go away\n");
                         cachefiles_printk_object(object, xobject);
                         goto requeue;
                 }
@@ -548,7 +543,7 @@ lookup_again:
                                next, next->d_inode, next->d_inode->i_ino);
 
                 } else if (!S_ISDIR(next->d_inode->i_mode)) {
-                        kerror("inode %lu is not a directory",
+                        pr_err("inode %lu is not a directory",
                                next->d_inode->i_ino);
                         ret = -ENOBUFS;
                         goto error;
@@ -579,7 +574,7 @@ lookup_again:
                 } else if (!S_ISDIR(next->d_inode->i_mode) &&
                            !S_ISREG(next->d_inode->i_mode)
                            ) {
-                        kerror("inode %lu is not a file or directory",
+                        pr_err("inode %lu is not a file or directory",
                                next->d_inode->i_ino);
                         ret = -ENOBUFS;
                         goto error;
@@ -773,7 +768,7 @@ struct dentry *cachefiles_get_directory(struct cachefiles_cache *cache,
         ASSERT(subdir->d_inode);
 
         if (!S_ISDIR(subdir->d_inode->i_mode)) {
-                kerror("%s is not a directory", dirname);
+                pr_err("%s is not a directory", dirname);
                 ret = -EIO;
                 goto check_error;
         }
@@ -800,13 +795,13 @@ check_error:
 mkdir_error:
         mutex_unlock(&dir->d_inode->i_mutex);
         dput(subdir);
-        kerror("mkdir %s failed with error %d", dirname, ret);
+        pr_err("mkdir %s failed with error %d", dirname, ret);
         return ERR_PTR(ret);
 
 lookup_error:
         mutex_unlock(&dir->d_inode->i_mutex);
         ret = PTR_ERR(subdir);
-        kerror("Lookup %s failed with error %d", dirname, ret);
+        pr_err("Lookup %s failed with error %d", dirname, ret);
         return ERR_PTR(ret);
 
 nomem_d_alloc:
@@ -896,7 +891,7 @@ lookup_error:
         if (ret == -EIO) {
                 cachefiles_io_error(cache, "Lookup failed");
         } else if (ret != -ENOMEM) {
-                kerror("Internal error: %d", ret);
+                pr_err("Internal error: %d", ret);
                 ret = -EIO;
         }
 
@@ -955,7 +950,7 @@ error:
         }
 
         if (ret != -ENOMEM) {
-                kerror("Internal error: %d", ret);
+                pr_err("Internal error: %d", ret);
                 ret = -EIO;
         }
 
diff --git a/fs/cachefiles/security.c b/fs/cachefiles/security.c
index 039b5011d83b..396c18ea2764 100644
--- a/fs/cachefiles/security.c
+++ b/fs/cachefiles/security.c
@@ -34,9 +34,7 @@ int cachefiles_get_security_ID(struct cachefiles_cache *cache)
                 ret = set_security_override_from_ctx(new, cache->secctx);
                 if (ret < 0) {
                         put_cred(new);
-                        printk(KERN_ERR "CacheFiles:"
-                               " Security denies permission to nominate"
-                               " security context: error %d\n",
+                        pr_err("Security denies permission to nominate security context: error %d\n",
                                ret);
                         goto error;
                 }
@@ -59,16 +57,14 @@ static int cachefiles_check_cache_dir(struct cachefiles_cache *cache,
 
         ret = security_inode_mkdir(root->d_inode, root, 0);
         if (ret < 0) {
-                printk(KERN_ERR "CacheFiles:"
-                       " Security denies permission to make dirs: error %d",
+                pr_err("Security denies permission to make dirs: error %d",
                        ret);
                 return ret;
         }
 
         ret = security_inode_create(root->d_inode, root, 0);
         if (ret < 0)
-                printk(KERN_ERR "CacheFiles:"
-                       " Security denies permission to create files: error %d",
+                pr_err("Security denies permission to create files: error %d",
                        ret);
 
         return ret;
diff --git a/fs/cachefiles/xattr.c b/fs/cachefiles/xattr.c
index 12b0eef84183..1ad51ffbb275 100644
--- a/fs/cachefiles/xattr.c
+++ b/fs/cachefiles/xattr.c
@@ -51,7 +51,7 @@ int cachefiles_check_object_type(struct cachefiles_object *object)
         }
 
         if (ret != -EEXIST) {
-                kerror("Can't set xattr on %*.*s [%lu] (err %d)",
+                pr_err("Can't set xattr on %*.*s [%lu] (err %d)",
                        dentry->d_name.len, dentry->d_name.len,
                        dentry->d_name.name, dentry->d_inode->i_ino,
                        -ret);
@@ -64,7 +64,7 @@ int cachefiles_check_object_type(struct cachefiles_object *object)
                 if (ret == -ERANGE)
                         goto bad_type_length;
 
-                kerror("Can't read xattr on %*.*s [%lu] (err %d)",
+                pr_err("Can't read xattr on %*.*s [%lu] (err %d)",
                        dentry->d_name.len, dentry->d_name.len,
                        dentry->d_name.name, dentry->d_inode->i_ino,
                        -ret);
@@ -85,14 +85,14 @@ error:
         return ret;
 
 bad_type_length:
-        kerror("Cache object %lu type xattr length incorrect",
+        pr_err("Cache object %lu type xattr length incorrect",
                dentry->d_inode->i_ino);
         ret = -EIO;
         goto error;
 
 bad_type:
         xtype[2] = 0;
-        kerror("Cache object %*.*s [%lu] type %s not %s",
+        pr_err("Cache object %*.*s [%lu] type %s not %s",
                dentry->d_name.len, dentry->d_name.len,
                dentry->d_name.name, dentry->d_inode->i_ino,
                xtype, type);
@@ -293,7 +293,7 @@ error:
         return ret;
 
 bad_type_length:
-        kerror("Cache object %lu xattr length incorrect",
+        pr_err("Cache object %lu xattr length incorrect",
                dentry->d_inode->i_ino);
         ret = -EIO;
         goto error;
diff --git a/fs/ceph/addr.c b/fs/ceph/addr.c
index b53278c9fd97..65a30e817dd8 100644
--- a/fs/ceph/addr.c
+++ b/fs/ceph/addr.c
@@ -694,7 +694,7 @@ static int ceph_writepages_start(struct address_space *mapping,
              (wbc->sync_mode == WB_SYNC_ALL ? "ALL" : "HOLD"));
 
         if (fsc->mount_state == CEPH_MOUNT_SHUTDOWN) {
-                pr_warning("writepage_start %p on forced umount\n", inode);
+                pr_warn("writepage_start %p on forced umount\n", inode);
                 return -EIO; /* we're in a forced umount, don't write! */
         }
         if (fsc->mount_options->wsize && fsc->mount_options->wsize < wsize)
diff --git a/fs/ceph/debugfs.c b/fs/ceph/debugfs.c
index 16b54aa31f08..5a743ac141ab 100644
--- a/fs/ceph/debugfs.c
+++ b/fs/ceph/debugfs.c
@@ -71,9 +71,9 @@ static int mdsc_show(struct seq_file *s, void *p)
                 seq_printf(s, "%s", ceph_mds_op_name(req->r_op));
 
                 if (req->r_got_unsafe)
-                        seq_printf(s, "\t(unsafe)");
+                        seq_puts(s, "\t(unsafe)");
                 else
-                        seq_printf(s, "\t");
+                        seq_puts(s, "\t");
 
                 if (req->r_inode) {
                         seq_printf(s, " #%llx", ceph_ino(req->r_inode));
@@ -119,7 +119,7 @@ static int mdsc_show(struct seq_file *s, void *p)
                                 seq_printf(s, " %s", req->r_path2);
                 }
 
-                seq_printf(s, "\n");
+                seq_puts(s, "\n");
         }
         mutex_unlock(&mdsc->mutex);
 
diff --git a/fs/ceph/inode.c b/fs/ceph/inode.c
index 233c6f96910a..e4fff9ff1c27 100644
--- a/fs/ceph/inode.c
+++ b/fs/ceph/inode.c
@@ -821,7 +821,7 @@ no_change:
                         spin_unlock(&ci->i_ceph_lock);
                 }
         } else if (cap_fmode >= 0) {
-                pr_warning("mds issued no caps on %llx.%llx\n",
+                pr_warn("mds issued no caps on %llx.%llx\n",
                            ceph_vinop(inode));
                 __ceph_get_fmode(ci, cap_fmode);
         }
diff --git a/fs/ceph/mds_client.c b/fs/ceph/mds_client.c
index 2b4d093d0563..9a33b98cb000 100644
--- a/fs/ceph/mds_client.c
+++ b/fs/ceph/mds_client.c
@@ -2218,13 +2218,13 @@ static void handle_reply(struct ceph_mds_session *session, struct ceph_msg *msg)
         /* dup? */
         if ((req->r_got_unsafe && !head->safe) ||
             (req->r_got_safe && head->safe)) {
-                pr_warning("got a dup %s reply on %llu from mds%d\n",
+                pr_warn("got a dup %s reply on %llu from mds%d\n",
                            head->safe ? "safe" : "unsafe", tid, mds);
                 mutex_unlock(&mdsc->mutex);
                 goto out;
         }
         if (req->r_got_safe && !head->safe) {
-                pr_warning("got unsafe after safe on %llu from mds%d\n",
+                pr_warn("got unsafe after safe on %llu from mds%d\n",
                            tid, mds);
                 mutex_unlock(&mdsc->mutex);
                 goto out;
@@ -3525,7 +3525,7 @@ static void peer_reset(struct ceph_connection *con)
         struct ceph_mds_session *s = con->private;
         struct ceph_mds_client *mdsc = s->s_mdsc;
 
-        pr_warning("mds%d closed our session\n", s->s_mds);
+        pr_warn("mds%d closed our session\n", s->s_mds);
         send_mds_reconnect(mdsc, s);
 }
 
diff --git a/fs/ceph/mdsmap.c b/fs/ceph/mdsmap.c
index 132b64eeecd4..261531e55e9d 100644
--- a/fs/ceph/mdsmap.c
+++ b/fs/ceph/mdsmap.c
@@ -62,7 +62,7 @@ struct ceph_mdsmap *ceph_mdsmap_decode(void **p, void *end)
 
         ceph_decode_16_safe(p, end, version, bad);
         if (version > 3) {
-                pr_warning("got mdsmap version %d > 3, failing", version);
+                pr_warn("got mdsmap version %d > 3, failing", version);
                 goto bad;
         }
 
diff --git a/fs/coda/cnode.c b/fs/coda/cnode.c
index 911cf30d057d..7740b1c871c1 100644
--- a/fs/coda/cnode.c
+++ b/fs/coda/cnode.c
@@ -101,7 +101,7 @@ struct inode *coda_cnode_make(struct CodaFid *fid, struct super_block *sb)
 
         inode = coda_iget(sb, fid, &attr);
         if (IS_ERR(inode))
-                printk("coda_cnode_make: coda_iget failed\n");
+                pr_warn("%s: coda_iget failed\n", __func__);
         return inode;
 }
 
@@ -137,7 +137,7 @@ struct inode *coda_fid_to_inode(struct CodaFid *fid, struct super_block *sb)
         unsigned long hash = coda_f2i(fid);
 
         if ( !sb ) {
-                printk("coda_fid_to_inode: no sb!\n");
+                pr_warn("%s: no sb!\n", __func__);
                 return NULL;
         }
 
diff --git a/fs/coda/coda_linux.h b/fs/coda/coda_linux.h
index e7550cb9fb74..d42b725b1d21 100644
--- a/fs/coda/coda_linux.h
+++ b/fs/coda/coda_linux.h
@@ -12,6 +12,12 @@
 #ifndef _LINUX_CODA_FS
 #define _LINUX_CODA_FS
 
+#ifdef pr_fmt
+#undef pr_fmt
+#endif
+
+#define pr_fmt(fmt) KBUILD_MODNAME ": " fmt
+
 #include <linux/kernel.h>
 #include <linux/param.h>
 #include <linux/mm.h>
@@ -63,7 +69,7 @@ void coda_sysctl_clean(void);
     else \
         ptr = (cast)vzalloc((unsigned long) size); \
     if (!ptr) \
-        printk("kernel malloc returns 0 at %s:%d\n", __FILE__, __LINE__); \
+        pr_warn("kernel malloc returns 0 at %s:%d\n", __FILE__, __LINE__); \
 } while (0)
 
 
diff --git a/fs/coda/dir.c b/fs/coda/dir.c
index 5efbb5ee0adc..cd8a63238b11 100644
--- a/fs/coda/dir.c
+++ b/fs/coda/dir.c
@@ -102,7 +102,7 @@ static struct dentry *coda_lookup(struct inode *dir, struct dentry *entry, unsig
         int type = 0;
 
         if (length > CODA_MAXNAMLEN) {
-                printk(KERN_ERR "name too long: lookup, %s (%*s)\n",
+                pr_err("name too long: lookup, %s (%*s)\n",
                        coda_i2s(dir), (int)length, name);
                 return ERR_PTR(-ENAMETOOLONG);
         }
@@ -453,23 +453,23 @@ static int coda_venus_readdir(struct file *coda_file, struct dir_context *ctx)
                 ret = kernel_read(host_file, ctx->pos - 2, (char *)vdir,
                                   sizeof(*vdir));
                 if (ret < 0) {
-                        printk(KERN_ERR "coda readdir: read dir %s failed %d\n",
-                               coda_f2s(&cii->c_fid), ret);
+                        pr_err("%s: read dir %s failed %d\n",
+                               __func__, coda_f2s(&cii->c_fid), ret);
                         break;
                 }
                 if (ret == 0) break; /* end of directory file reached */
 
                 /* catch truncated reads */
                 if (ret < vdir_size || ret < vdir_size + vdir->d_namlen) {
-                        printk(KERN_ERR "coda readdir: short read on %s\n",
-                               coda_f2s(&cii->c_fid));
+                        pr_err("%s: short read on %s\n",
+                               __func__, coda_f2s(&cii->c_fid));
                         ret = -EBADF;
                         break;
                 }
                 /* validate whether the directory file actually makes sense */
                 if (vdir->d_reclen < vdir_size + vdir->d_namlen) {
-                        printk(KERN_ERR "coda readdir: invalid dir %s\n",
-                               coda_f2s(&cii->c_fid));
+                        pr_err("%s: invalid dir %s\n",
+                               __func__, coda_f2s(&cii->c_fid));
                         ret = -EBADF;
                         break;
                 }
@@ -589,8 +589,8 @@ int coda_revalidate_inode(struct inode *inode)
                 coda_vattr_to_iattr(inode, &attr);
 
                 if ((old_mode & S_IFMT) != (inode->i_mode & S_IFMT)) {
-                        printk("Coda: inode %ld, fid %s changed type!\n",
-                               inode->i_ino, coda_f2s(&(cii->c_fid)));
+                        pr_warn("inode %ld, fid %s changed type!\n",
+                                inode->i_ino, coda_f2s(&(cii->c_fid)));
                 }
 
                 /* the following can happen when a local fid is replaced 
diff --git a/fs/coda/inode.c b/fs/coda/inode.c
index d9c7751f10ac..fe3afb2de880 100644
--- a/fs/coda/inode.c
+++ b/fs/coda/inode.c
@@ -119,12 +119,12 @@ static int get_device_index(struct coda_mount_data *data)
         int idx;
 
         if (data == NULL) {
-                printk("coda_read_super: Bad mount data\n");
+                pr_warn("%s: Bad mount data\n", __func__);
                 return -1;
         }
 
         if (data->version != CODA_MOUNT_VERSION) {
-                printk("coda_read_super: Bad mount version\n");
+                pr_warn("%s: Bad mount version\n", __func__);
                 return -1;
         }
 
@@ -141,13 +141,13 @@ static int get_device_index(struct coda_mount_data *data)
         fdput(f);
 
         if (idx < 0 || idx >= MAX_CODADEVS) {
-                printk("coda_read_super: Bad minor number\n");
+                pr_warn("%s: Bad minor number\n", __func__);
                 return -1;
         }
 
         return idx;
 Ebadf:
-        printk("coda_read_super: Bad file\n");
+        pr_warn("%s: Bad file\n", __func__);
         return -1;
 }
 
@@ -168,19 +168,19 @@ static int coda_fill_super(struct super_block *sb, void *data, int silent)
         if(idx == -1)
                 idx = 0;
         
-        printk(KERN_INFO "coda_read_super: device index: %i\n", idx);
+        pr_info("%s: device index: %i\n", __func__,  idx);
 
         vc = &coda_comms[idx];
         mutex_lock(&vc->vc_mutex);
 
         if (!vc->vc_inuse) {
-                printk("coda_read_super: No pseudo device\n");
+                pr_warn("%s: No pseudo device\n", __func__);
                 error = -EINVAL;
                 goto unlock_out;
         }
 
         if (vc->vc_sb) {
-                printk("coda_read_super: Device already mounted\n");
+                pr_warn("%s: Device already mounted\n", __func__);
                 error = -EBUSY;
                 goto unlock_out;
         }
@@ -204,22 +204,23 @@ static int coda_fill_super(struct super_block *sb, void *data, int silent)
         /* get root fid from Venus: this needs the root inode */
         error = venus_rootfid(sb, &fid);
         if ( error ) {
-                printk("coda_read_super: coda_get_rootfid failed with %d\n",
-                       error);
+                pr_warn("%s: coda_get_rootfid failed with %d\n",
+                        __func__, error);
                 goto error;
         }
-        printk("coda_read_super: rootfid is %s\n", coda_f2s(&fid));
+        pr_info("%s: rootfid is %s\n", __func__, coda_f2s(&fid));
         
         /* make root inode */
         root = coda_cnode_make(&fid, sb);
         if (IS_ERR(root)) {
                 error = PTR_ERR(root);
-                printk("Failure of coda_cnode_make for root: error %d\n", error);
+                pr_warn("Failure of coda_cnode_make for root: error %d\n",
+                        error);
                 goto error;
         } 
 
-        printk("coda_read_super: rootinode is %ld dev %s\n", 
-               root->i_ino, root->i_sb->s_id);
+        pr_info("%s: rootinode is %ld dev %s\n",
+                __func__, root->i_ino, root->i_sb->s_id);
         sb->s_root = d_make_root(root);
         if (!sb->s_root) {
                 error = -EINVAL;
@@ -246,7 +247,7 @@ static void coda_put_super(struct super_block *sb)
         sb->s_fs_info = NULL;
         mutex_unlock(&vcp->vc_mutex);
 
-        printk("Coda: Bye bye.\n");
+        pr_info("Bye bye.\n");
 }
 
 static void coda_evict_inode(struct inode *inode)
diff --git a/fs/coda/psdev.c b/fs/coda/psdev.c
index ebc2bae6c289..5c1e4242368b 100644
--- a/fs/coda/psdev.c
+++ b/fs/coda/psdev.c
@@ -114,14 +114,14 @@ static ssize_t coda_psdev_write(struct file *file, const char __user *buf,
                 int size = sizeof(*dcbuf);
 
                 if  ( nbytes < sizeof(struct coda_out_hdr) ) {
-                        printk("coda_downcall opc %d uniq %d, not enough!\n",
-                               hdr.opcode, hdr.unique);
+                        pr_warn("coda_downcall opc %d uniq %d, not enough!\n",
+                                hdr.opcode, hdr.unique);
                         count = nbytes;
                         goto out;
                 }
                 if ( nbytes > size ) {
-                        printk("Coda: downcall opc %d, uniq %d, too much!",
-                               hdr.opcode, hdr.unique);
+                        pr_warn("downcall opc %d, uniq %d, too much!",
+                                hdr.opcode, hdr.unique);
                         nbytes = size;
                 }
                 CODA_ALLOC(dcbuf, union outputArgs *, nbytes);
@@ -136,7 +136,8 @@ static ssize_t coda_psdev_write(struct file *file, const char __user *buf,
 
                 CODA_FREE(dcbuf, nbytes);
                 if (error) {
-                        printk("psdev_write: coda_downcall error: %d\n", error);
+                        pr_warn("%s: coda_downcall error: %d\n",
+                                __func__, error);
                         retval = error;
                         goto out;
                 }
@@ -157,16 +158,17 @@ static ssize_t coda_psdev_write(struct file *file, const char __user *buf,
         mutex_unlock(&vcp->vc_mutex);
 
         if (!req) {
-                printk("psdev_write: msg (%d, %d) not found\n", 
-                        hdr.opcode, hdr.unique);
+                pr_warn("%s: msg (%d, %d) not found\n",
+                        __func__, hdr.opcode, hdr.unique);
                 retval = -ESRCH;
                 goto out;
         }
 
         /* move data into response buffer. */
         if (req->uc_outSize < nbytes) {
-                printk("psdev_write: too much cnt: %d, cnt: %ld, opc: %d, uniq: %d.\n",
-                       req->uc_outSize, (long)nbytes, hdr.opcode, hdr.unique);
+                pr_warn("%s: too much cnt: %d, cnt: %ld, opc: %d, uniq: %d.\n",
+                        __func__, req->uc_outSize, (long)nbytes,
+                        hdr.opcode, hdr.unique);
                 nbytes = req->uc_outSize; /* don't have more space! */
         }
         if (copy_from_user(req->uc_data, buf, nbytes)) {
@@ -240,8 +242,8 @@ static ssize_t coda_psdev_read(struct file * file, char __user * buf,
         /* Move the input args into userspace */
         count = req->uc_inSize;
         if (nbytes < req->uc_inSize) {
-                printk ("psdev_read: Venus read %ld bytes of %d in message\n",
-                        (long)nbytes, req->uc_inSize);
+                pr_warn("%s: Venus read %ld bytes of %d in message\n",
+                        __func__, (long)nbytes, req->uc_inSize);
                 count = nbytes;
         }
 
@@ -305,7 +307,7 @@ static int coda_psdev_release(struct inode * inode, struct file * file)
         struct upc_req *req, *tmp;
 
         if (!vcp || !vcp->vc_inuse ) {
-                printk("psdev_release: Not open.\n");
+                pr_warn("%s: Not open.\n", __func__);
                 return -1;
         }
 
@@ -354,8 +356,8 @@ static int init_coda_psdev(void)
 {
         int i, err = 0;
         if (register_chrdev(CODA_PSDEV_MAJOR, "coda", &coda_psdev_fops)) {
-              printk(KERN_ERR "coda_psdev: unable to get major %d\n", 
-                     CODA_PSDEV_MAJOR);
+                pr_err("%s: unable to get major %d\n",
+                       __func__, CODA_PSDEV_MAJOR);
               return -EIO;
         }
         coda_psdev_class = class_create(THIS_MODULE, "coda");
@@ -393,13 +395,13 @@ static int __init init_coda(void)
                 goto out2;
         status = init_coda_psdev();
         if ( status ) {
-                printk("Problem (%d) in init_coda_psdev\n", status);
+                pr_warn("Problem (%d) in init_coda_psdev\n", status);
                 goto out1;
         }
         
         status = register_filesystem(&coda_fs_type);
         if (status) {
-                printk("coda: failed to register filesystem!\n");
+                pr_warn("failed to register filesystem!\n");
                 goto out;
         }
         return 0;
@@ -420,9 +422,8 @@ static void __exit exit_coda(void)
         int err, i;
 
         err = unregister_filesystem(&coda_fs_type);
-        if ( err != 0 ) {
-                printk("coda: failed to unregister filesystem\n");
-        }
+        if (err != 0)
+                pr_warn("failed to unregister filesystem\n");
         for (i = 0; i < MAX_CODADEVS; i++)
                 device_destroy(coda_psdev_class, MKDEV(CODA_PSDEV_MAJOR, i));
         class_destroy(coda_psdev_class);
diff --git a/fs/coda/sysctl.c b/fs/coda/sysctl.c
index af56ad56a89a..34218a8a28cd 100644
--- a/fs/coda/sysctl.c
+++ b/fs/coda/sysctl.c
@@ -14,7 +14,7 @@
 #ifdef CONFIG_SYSCTL
 static struct ctl_table_header *fs_table_header;
 
-static ctl_table coda_table[] = {
+static struct ctl_table coda_table[] = {
         {
                 .procname       = "timeout",
                 .data           = &coda_timeout,
@@ -39,7 +39,7 @@ static ctl_table coda_table[] = {
         {}
 };
 
-static ctl_table fs_table[] = {
+static struct ctl_table fs_table[] = {
         {
                 .procname       = "coda",
                 .mode           = 0555,
diff --git a/fs/coda/upcall.c b/fs/coda/upcall.c
index 3a731976dc5e..21fcf8dcb9cd 100644
--- a/fs/coda/upcall.c
+++ b/fs/coda/upcall.c
@@ -508,8 +508,8 @@ int venus_pioctl(struct super_block *sb, struct CodaFid *fid,
         inp->coda_ioctl.data = (char *)(INSIZE(ioctl));
      
         /* get the data out of user space */
-        if ( copy_from_user((char*)inp + (long)inp->coda_ioctl.data,
-                            data->vi.in, data->vi.in_size) ) {
+        if (copy_from_user((char *)inp + (long)inp->coda_ioctl.data,
+                           data->vi.in, data->vi.in_size)) {
                 error = -EINVAL;
                 goto exit;
         }
@@ -518,8 +518,8 @@ int venus_pioctl(struct super_block *sb, struct CodaFid *fid,
                             &outsize, inp);
 
         if (error) {
-                printk("coda_pioctl: Venus returns: %d for %s\n", 
-                       error, coda_f2s(fid));
+                pr_warn("%s: Venus returns: %d for %s\n",
+                        __func__, error, coda_f2s(fid));
                 goto exit; 
         }
 
@@ -675,7 +675,7 @@ static int coda_upcall(struct venus_comm *vcp,
         mutex_lock(&vcp->vc_mutex);
 
         if (!vcp->vc_inuse) {
-                printk(KERN_NOTICE "coda: Venus dead, not sending upcall\n");
+                pr_notice("Venus dead, not sending upcall\n");
                 error = -ENXIO;
                 goto exit;
         }
@@ -725,7 +725,7 @@ static int coda_upcall(struct venus_comm *vcp,
 
         error = -EINTR;
         if ((req->uc_flags & CODA_REQ_ABORT) || !signal_pending(current)) {
-                printk(KERN_WARNING "coda: Unexpected interruption.\n");
+                pr_warn("Unexpected interruption.\n");
                 goto exit;
         }
 
@@ -735,7 +735,7 @@ static int coda_upcall(struct venus_comm *vcp,
 
         /* Venus saw the upcall, make sure we can send interrupt signal */
         if (!vcp->vc_inuse) {
-                printk(KERN_INFO "coda: Venus dead, not sending signal.\n");
+                pr_info("Venus dead, not sending signal.\n");
                 goto exit;
         }
 
diff --git a/fs/dcache.c b/fs/dcache.c
index be2bea834bf4..1792d6075b4f 100644
--- a/fs/dcache.c
+++ b/fs/dcache.c
@@ -150,7 +150,7 @@ static long get_nr_dentry_unused(void)
         return sum < 0 ? 0 : sum;
 }
 
-int proc_nr_dentry(ctl_table *table, int write, void __user *buffer,
+int proc_nr_dentry(struct ctl_table *table, int write, void __user *buffer,
                    size_t *lenp, loff_t *ppos)
 {
         dentry_stat.nr_dentry = get_nr_dentry();
diff --git a/fs/devpts/inode.c b/fs/devpts/inode.c
index c71038079b47..cfe8466f7fef 100644
--- a/fs/devpts/inode.c
+++ b/fs/devpts/inode.c
@@ -10,6 +10,8 @@
  *
  * ------------------------------------------------------------------------- */
 
+#define pr_fmt(fmt) KBUILD_MODNAME ": " fmt
+
 #include <linux/module.h>
 #include <linux/init.h>
 #include <linux/fs.h>
@@ -148,10 +150,10 @@ static inline struct super_block *pts_sb_from_inode(struct inode *inode)
 
 /*
  * parse_mount_options():
- *      Set @opts to mount options specified in @data. If an option is not
- *      specified in @data, set it to its default value. The exception is
- *      'newinstance' option which can only be set/cleared on a mount (i.e.
- *      cannot be changed during remount).
+ *      Set @opts to mount options specified in @data. If an option is not
+ *      specified in @data, set it to its default value. The exception is
+ *      'newinstance' option which can only be set/cleared on a mount (i.e.
+ *      cannot be changed during remount).
  *
  * Note: @data may be NULL (in which case all options are set to default).
  */
@@ -225,7 +227,7 @@ static int parse_mount_options(char *data, int op, struct pts_mount_opts *opts)
                         break;
 #endif
                 default:
-                        printk(KERN_ERR "devpts: called with bogus options\n");
+                        pr_err("called with bogus options\n");
                         return -EINVAL;
                 }
         }
@@ -261,7 +263,7 @@ static int mknod_ptmx(struct super_block *sb)
 
         dentry = d_alloc_name(root, "ptmx");
         if (!dentry) {
-                printk(KERN_NOTICE "Unable to alloc dentry for ptmx node\n");
+                pr_err("Unable to alloc dentry for ptmx node\n");
                 goto out;
         }
 
@@ -270,7 +272,7 @@ static int mknod_ptmx(struct super_block *sb)
          */
         inode = new_inode(sb);
         if (!inode) {
-                printk(KERN_ERR "Unable to alloc inode for ptmx node\n");
+                pr_err("Unable to alloc inode for ptmx node\n");
                 dput(dentry);
                 goto out;
         }
@@ -303,7 +305,7 @@ static void update_ptmx_mode(struct pts_fs_info *fsi)
 #else
 static inline void update_ptmx_mode(struct pts_fs_info *fsi)
 {
-       return;
+        return;
 }
 #endif
 
@@ -333,9 +335,11 @@ static int devpts_show_options(struct seq_file *seq, struct dentry *root)
         struct pts_mount_opts *opts = &fsi->mount_opts;
 
         if (opts->setuid)
-                seq_printf(seq, ",uid=%u", from_kuid_munged(&init_user_ns, opts->uid));
+                seq_printf(seq, ",uid=%u",
+                           from_kuid_munged(&init_user_ns, opts->uid));
         if (opts->setgid)
-                seq_printf(seq, ",gid=%u", from_kgid_munged(&init_user_ns, opts->gid));
+                seq_printf(seq, ",gid=%u",
+                           from_kgid_munged(&init_user_ns, opts->gid));
         seq_printf(seq, ",mode=%03o", opts->mode);
 #ifdef CONFIG_DEVPTS_MULTIPLE_INSTANCES
         seq_printf(seq, ",ptmxmode=%03o", opts->ptmxmode);
@@ -396,7 +400,7 @@ devpts_fill_super(struct super_block *s, void *data, int silent)
         if (s->s_root)
                 return 0;
 
-        printk(KERN_ERR "devpts: get root dentry failed\n");
+        pr_err("get root dentry failed\n");
 
 fail:
         return -ENOMEM;
diff --git a/fs/dlm/config.c b/fs/dlm/config.c
index 76feb4b60fa6..d521bddf876d 100644
--- a/fs/dlm/config.c
+++ b/fs/dlm/config.c
@@ -157,11 +157,13 @@ static ssize_t cluster_set(struct dlm_cluster *cl, unsigned int *cl_field,
                            const char *buf, size_t len)
 {
         unsigned int x;
+        int rc;
 
         if (!capable(CAP_SYS_ADMIN))
                 return -EPERM;
-
-        x = simple_strtoul(buf, NULL, 0);
+        rc = kstrtouint(buf, 0, &x);
+        if (rc)
+                return rc;
 
         if (check_zero && !x)
                 return -EINVAL;
@@ -730,7 +732,10 @@ static ssize_t comm_nodeid_read(struct dlm_comm *cm, char *buf)
 static ssize_t comm_nodeid_write(struct dlm_comm *cm, const char *buf,
                                  size_t len)
 {
-        cm->nodeid = simple_strtol(buf, NULL, 0);
+        int rc = kstrtoint(buf, 0, &cm->nodeid);
+
+        if (rc)
+                return rc;
         return len;
 }
 
@@ -742,7 +747,10 @@ static ssize_t comm_local_read(struct dlm_comm *cm, char *buf)
 static ssize_t comm_local_write(struct dlm_comm *cm, const char *buf,
                                 size_t len)
 {
-        cm->local= simple_strtol(buf, NULL, 0);
+        int rc = kstrtoint(buf, 0, &cm->local);
+
+        if (rc)
+                return rc;
         if (cm->local && !local_comm)
                 local_comm = cm;
         return len;
@@ -846,7 +854,10 @@ static ssize_t node_nodeid_write(struct dlm_node *nd, const char *buf,
                                  size_t len)
 {
         uint32_t seq = 0;
-        nd->nodeid = simple_strtol(buf, NULL, 0);
+        int rc = kstrtoint(buf, 0, &nd->nodeid);
+
+        if (rc)
+                return rc;
         dlm_comm_seq(nd->nodeid, &seq);
         nd->comm_seq = seq;
         return len;
@@ -860,7 +871,10 @@ static ssize_t node_weight_read(struct dlm_node *nd, char *buf)
 static ssize_t node_weight_write(struct dlm_node *nd, const char *buf,
                                  size_t len)
 {
-        nd->weight = simple_strtol(buf, NULL, 0);
+        int rc = kstrtoint(buf, 0, &nd->weight);
+
+        if (rc)
+                return rc;
         return len;
 }
 
diff --git a/fs/dlm/debug_fs.c b/fs/dlm/debug_fs.c
index b969deef9ebb..8d77ba7b1756 100644
--- a/fs/dlm/debug_fs.c
+++ b/fs/dlm/debug_fs.c
@@ -68,7 +68,7 @@ static int print_format1_lock(struct seq_file *s, struct dlm_lkb *lkb,
         if (lkb->lkb_wait_type)
                 seq_printf(s, " wait_type: %d", lkb->lkb_wait_type);
 
-        return seq_printf(s, "\n");
+        return seq_puts(s, "\n");
 }
 
 static int print_format1(struct dlm_rsb *res, struct seq_file *s)
@@ -92,31 +92,31 @@ static int print_format1(struct dlm_rsb *res, struct seq_file *s)
         }
 
         if (res->res_nodeid > 0)
-                rv = seq_printf(s, "\"  \nLocal Copy, Master is node %d\n",
+                rv = seq_printf(s, "\"\nLocal Copy, Master is node %d\n",
                                 res->res_nodeid);
         else if (res->res_nodeid == 0)
-                rv = seq_printf(s, "\"  \nMaster Copy\n");
+                rv = seq_puts(s, "\"\nMaster Copy\n");
         else if (res->res_nodeid == -1)
-                rv = seq_printf(s, "\"  \nLooking up master (lkid %x)\n",
+                rv = seq_printf(s, "\"\nLooking up master (lkid %x)\n",
                                 res->res_first_lkid);
         else
-                rv = seq_printf(s, "\"  \nInvalid master %d\n",
+                rv = seq_printf(s, "\"\nInvalid master %d\n",
                                 res->res_nodeid);
         if (rv)
                 goto out;
 
         /* Print the LVB: */
         if (res->res_lvbptr) {
-                seq_printf(s, "LVB: ");
+                seq_puts(s, "LVB: ");
                 for (i = 0; i < lvblen; i++) {
                         if (i == lvblen / 2)
-                                seq_printf(s, "\n     ");
+                                seq_puts(s, "\n     ");
                         seq_printf(s, "%02x ",
                                    (unsigned char) res->res_lvbptr[i]);
                 }
                 if (rsb_flag(res, RSB_VALNOTVALID))
-                        seq_printf(s, " (INVALID)");
-                rv = seq_printf(s, "\n");
+                        seq_puts(s, " (INVALID)");
+                rv = seq_puts(s, "\n");
                 if (rv)
                         goto out;
         }
@@ -133,21 +133,21 @@ static int print_format1(struct dlm_rsb *res, struct seq_file *s)
         }
 
         /* Print the locks attached to this resource */
-        seq_printf(s, "Granted Queue\n");
+        seq_puts(s, "Granted Queue\n");
         list_for_each_entry(lkb, &res->res_grantqueue, lkb_statequeue) {
                 rv = print_format1_lock(s, lkb, res);
                 if (rv)
                         goto out;
         }
 
-        seq_printf(s, "Conversion Queue\n");
+        seq_puts(s, "Conversion Queue\n");
         list_for_each_entry(lkb, &res->res_convertqueue, lkb_statequeue) {
                 rv = print_format1_lock(s, lkb, res);
                 if (rv)
                         goto out;
         }
 
-        seq_printf(s, "Waiting Queue\n");
+        seq_puts(s, "Waiting Queue\n");
         list_for_each_entry(lkb, &res->res_waitqueue, lkb_statequeue) {
                 rv = print_format1_lock(s, lkb, res);
                 if (rv)
@@ -157,13 +157,13 @@ static int print_format1(struct dlm_rsb *res, struct seq_file *s)
         if (list_empty(&res->res_lookup))
                 goto out;
 
-        seq_printf(s, "Lookup Queue\n");
+        seq_puts(s, "Lookup Queue\n");
         list_for_each_entry(lkb, &res->res_lookup, lkb_rsb_lookup) {
                 rv = seq_printf(s, "%08x %s", lkb->lkb_id,
                                 print_lockmode(lkb->lkb_rqmode));
                 if (lkb->lkb_wait_type)
                         seq_printf(s, " wait_type: %d", lkb->lkb_wait_type);
-                rv = seq_printf(s, "\n");
+                rv = seq_puts(s, "\n");
         }
  out:
         unlock_rsb(res);
@@ -300,7 +300,7 @@ static int print_format3(struct dlm_rsb *r, struct seq_file *s)
                 else
                         seq_printf(s, " %02x", (unsigned char)r->res_name[i]);
         }
-        rv = seq_printf(s, "\n");
+        rv = seq_puts(s, "\n");
         if (rv)
                 goto out;
 
@@ -311,7 +311,7 @@ static int print_format3(struct dlm_rsb *r, struct seq_file *s)
 
         for (i = 0; i < lvblen; i++)
                 seq_printf(s, " %02x", (unsigned char)r->res_lvbptr[i]);
-        rv = seq_printf(s, "\n");
+        rv = seq_puts(s, "\n");
         if (rv)
                 goto out;
 
@@ -377,7 +377,7 @@ static int print_format4(struct dlm_rsb *r, struct seq_file *s)
                 else
                         seq_printf(s, " %02x", (unsigned char)r->res_name[i]);
         }
-        rv = seq_printf(s, "\n");
+        rv = seq_puts(s, "\n");
  out:
         unlock_rsb(r);
         return rv;
diff --git a/fs/dlm/lockspace.c b/fs/dlm/lockspace.c
index 04d6398c1f1c..f3e72787e7f9 100644
--- a/fs/dlm/lockspace.c
+++ b/fs/dlm/lockspace.c
@@ -35,8 +35,11 @@ static struct task_struct *	scand_task;
 static ssize_t dlm_control_store(struct dlm_ls *ls, const char *buf, size_t len)
 {
         ssize_t ret = len;
-        int n = simple_strtol(buf, NULL, 0);
+        int n;
+        int rc = kstrtoint(buf, 0, &n);
 
+        if (rc)
+                return rc;
         ls = dlm_find_lockspace_local(ls->ls_local_handle);
         if (!ls)
                 return -EINVAL;
@@ -57,7 +60,10 @@ static ssize_t dlm_control_store(struct dlm_ls *ls, const char *buf, size_t len)
 
 static ssize_t dlm_event_store(struct dlm_ls *ls, const char *buf, size_t len)
 {
-        ls->ls_uevent_result = simple_strtol(buf, NULL, 0);
+        int rc = kstrtoint(buf, 0, &ls->ls_uevent_result);
+
+        if (rc)
+                return rc;
         set_bit(LSFL_UEVENT_WAIT, &ls->ls_flags);
         wake_up(&ls->ls_uevent_wait);
         return len;
@@ -70,7 +76,10 @@ static ssize_t dlm_id_show(struct dlm_ls *ls, char *buf)
 
 static ssize_t dlm_id_store(struct dlm_ls *ls, const char *buf, size_t len)
 {
-        ls->ls_global_id = simple_strtoul(buf, NULL, 0);
+        int rc = kstrtouint(buf, 0, &ls->ls_global_id);
+
+        if (rc)
+                return rc;
         return len;
 }
 
@@ -81,7 +90,11 @@ static ssize_t dlm_nodir_show(struct dlm_ls *ls, char *buf)
 
 static ssize_t dlm_nodir_store(struct dlm_ls *ls, const char *buf, size_t len)
 {
-        int val = simple_strtoul(buf, NULL, 0);
+        int val;
+        int rc = kstrtoint(buf, 0, &val);
+
+        if (rc)
+                return rc;
         if (val == 1)
                 set_bit(LSFL_NODIR, &ls->ls_flags);
         return len;
diff --git a/fs/drop_caches.c b/fs/drop_caches.c
index 9280202e488c..1de7294aad20 100644
--- a/fs/drop_caches.c
+++ b/fs/drop_caches.c
@@ -50,7 +50,7 @@ static void drop_slab(void)
         } while (nr_objects > 10);
 }
 
-int drop_caches_sysctl_handler(ctl_table *table, int write,
+int drop_caches_sysctl_handler(struct ctl_table *table, int write,
         void __user *buffer, size_t *length, loff_t *ppos)
 {
         int ret;
diff --git a/fs/eventpoll.c b/fs/eventpoll.c
index af903128891c..b73e0621ce9e 100644
--- a/fs/eventpoll.c
+++ b/fs/eventpoll.c
@@ -293,7 +293,7 @@ static LIST_HEAD(tfile_check_list);
 static long zero;
 static long long_max = LONG_MAX;
 
-ctl_table epoll_table[] = {
+struct ctl_table epoll_table[] = {
         {
                 .procname       = "max_user_watches",
                 .data           = &max_user_watches,
diff --git a/fs/fat/fat.h b/fs/fat/fat.h
index 7c31f4bc74a9..e0c4ba39a377 100644
--- a/fs/fat/fat.h
+++ b/fs/fat/fat.h
@@ -52,7 +52,8 @@ struct fat_mount_options {
                  usefree:1,        /* Use free_clusters for FAT32 */
                  tz_set:1,         /* Filesystem timestamps' offset set */
                  rodir:1,          /* allow ATTR_RO for directory */
-                 discard:1;        /* Issue discard requests on deletions */
+                 discard:1,        /* Issue discard requests on deletions */
+                 dos1xfloppy:1;    /* Assume default BPB for DOS 1.x floppies */
 };
 
 #define FAT_HASH_BITS   8
diff --git a/fs/fat/inode.c b/fs/fat/inode.c
index b3361fe2bcb5..9c83594d7fb5 100644
--- a/fs/fat/inode.c
+++ b/fs/fat/inode.c
@@ -35,9 +35,71 @@
 #define CONFIG_FAT_DEFAULT_IOCHARSET    ""
 #endif
 
+#define KB_IN_SECTORS 2
+
+/*
+ * A deserialized copy of the on-disk structure laid out in struct
+ * fat_boot_sector.
+ */
+struct fat_bios_param_block {
+        u16     fat_sector_size;
+        u8      fat_sec_per_clus;
+        u16     fat_reserved;
+        u8      fat_fats;
+        u16     fat_dir_entries;
+        u16     fat_sectors;
+        u16     fat_fat_length;
+        u32     fat_total_sect;
+
+        u8      fat16_state;
+        u32     fat16_vol_id;
+
+        u32     fat32_length;
+        u32     fat32_root_cluster;
+        u16     fat32_info_sector;
+        u8      fat32_state;
+        u32     fat32_vol_id;
+};
+
 static int fat_default_codepage = CONFIG_FAT_DEFAULT_CODEPAGE;
 static char fat_default_iocharset[] = CONFIG_FAT_DEFAULT_IOCHARSET;
 
+static struct fat_floppy_defaults {
+        unsigned nr_sectors;
+        unsigned sec_per_clus;
+        unsigned dir_entries;
+        unsigned media;
+        unsigned fat_length;
+} floppy_defaults[] = {
+{
+        .nr_sectors = 160 * KB_IN_SECTORS,
+        .sec_per_clus = 1,
+        .dir_entries = 64,
+        .media = 0xFE,
+        .fat_length = 1,
+},
+{
+        .nr_sectors = 180 * KB_IN_SECTORS,
+        .sec_per_clus = 1,
+        .dir_entries = 64,
+        .media = 0xFC,
+        .fat_length = 2,
+},
+{
+        .nr_sectors = 320 * KB_IN_SECTORS,
+        .sec_per_clus = 2,
+        .dir_entries = 112,
+        .media = 0xFF,
+        .fat_length = 1,
+},
+{
+        .nr_sectors = 360 * KB_IN_SECTORS,
+        .sec_per_clus = 2,
+        .dir_entries = 112,
+        .media = 0xFD,
+        .fat_length = 2,
+},
+};
 
 static int fat_add_cluster(struct inode *inode)
 {
@@ -359,7 +421,7 @@ struct inode *fat_iget(struct super_block *sb, loff_t i_pos)
 
 static int is_exec(unsigned char *extension)
 {
-        unsigned char *exe_extensions = "EXECOMBAT", *walk;
+        unsigned char exe_extensions[] = "EXECOMBAT", *walk;
 
         for (walk = exe_extensions; *walk; walk += 3)
                 if (!strncmp(extension, walk, 3))
@@ -853,6 +915,8 @@ static int fat_show_options(struct seq_file *m, struct dentry *root)
                 seq_puts(m, ",nfs=stale_rw");
         if (opts->discard)
                 seq_puts(m, ",discard");
+        if (opts->dos1xfloppy)
+                seq_puts(m, ",dos1xfloppy");
 
         return 0;
 }
@@ -867,7 +931,7 @@ enum {
         Opt_uni_xl_no, Opt_uni_xl_yes, Opt_nonumtail_no, Opt_nonumtail_yes,
         Opt_obsolete, Opt_flush, Opt_tz_utc, Opt_rodir, Opt_err_cont,
         Opt_err_panic, Opt_err_ro, Opt_discard, Opt_nfs, Opt_time_offset,
-        Opt_nfs_stale_rw, Opt_nfs_nostale_ro, Opt_err,
+        Opt_nfs_stale_rw, Opt_nfs_nostale_ro, Opt_err, Opt_dos1xfloppy,
 };
 
 static const match_table_t fat_tokens = {
@@ -900,6 +964,7 @@ static const match_table_t fat_tokens = {
         {Opt_nfs_stale_rw, "nfs"},
         {Opt_nfs_stale_rw, "nfs=stale_rw"},
         {Opt_nfs_nostale_ro, "nfs=nostale_ro"},
+        {Opt_dos1xfloppy, "dos1xfloppy"},
         {Opt_obsolete, "conv=binary"},
         {Opt_obsolete, "conv=text"},
         {Opt_obsolete, "conv=auto"},
@@ -1102,6 +1167,9 @@ static int parse_options(struct super_block *sb, char *options, int is_vfat,
                 case Opt_nfs_nostale_ro:
                         opts->nfs = FAT_NFS_NOSTALE_RO;
                         break;
+                case Opt_dos1xfloppy:
+                        opts->dos1xfloppy = 1;
+                        break;
 
                 /* msdos specific */
                 case Opt_dots:
@@ -1247,6 +1315,169 @@ static unsigned long calc_fat_clusters(struct super_block *sb)
         return sbi->fat_length * sb->s_blocksize * 8 / sbi->fat_bits;
 }
 
+static bool fat_bpb_is_zero(struct fat_boot_sector *b)
+{
+        if (get_unaligned_le16(&b->sector_size))
+                return false;
+        if (b->sec_per_clus)
+                return false;
+        if (b->reserved)
+                return false;
+        if (b->fats)
+                return false;
+        if (get_unaligned_le16(&b->dir_entries))
+                return false;
+        if (get_unaligned_le16(&b->sectors))
+                return false;
+        if (b->media)
+                return false;
+        if (b->fat_length)
+                return false;
+        if (b->secs_track)
+                return false;
+        if (b->heads)
+                return false;
+        return true;
+}
+
+static int fat_read_bpb(struct super_block *sb, struct fat_boot_sector *b,
+        int silent, struct fat_bios_param_block *bpb)
+{
+        int error = -EINVAL;
+
+        /* Read in BPB ... */
+        memset(bpb, 0, sizeof(*bpb));
+        bpb->fat_sector_size = get_unaligned_le16(&b->sector_size);
+        bpb->fat_sec_per_clus = b->sec_per_clus;
+        bpb->fat_reserved = le16_to_cpu(b->reserved);
+        bpb->fat_fats = b->fats;
+        bpb->fat_dir_entries = get_unaligned_le16(&b->dir_entries);
+        bpb->fat_sectors = get_unaligned_le16(&b->sectors);
+        bpb->fat_fat_length = le16_to_cpu(b->fat_length);
+        bpb->fat_total_sect = le32_to_cpu(b->total_sect);
+
+        bpb->fat16_state = b->fat16.state;
+        bpb->fat16_vol_id = get_unaligned_le32(b->fat16.vol_id);
+
+        bpb->fat32_length = le32_to_cpu(b->fat32.length);
+        bpb->fat32_root_cluster = le32_to_cpu(b->fat32.root_cluster);
+        bpb->fat32_info_sector = le16_to_cpu(b->fat32.info_sector);
+        bpb->fat32_state = b->fat32.state;
+        bpb->fat32_vol_id = get_unaligned_le32(b->fat32.vol_id);
+
+        /* Validate this looks like a FAT filesystem BPB */
+        if (!bpb->fat_reserved) {
+                if (!silent)
+                        fat_msg(sb, KERN_ERR,
+                                "bogus number of reserved sectors");
+                goto out;
+        }
+        if (!bpb->fat_fats) {
+                if (!silent)
+                        fat_msg(sb, KERN_ERR, "bogus number of FAT structure");
+                goto out;
+        }
+
+        /*
+         * Earlier we checked here that b->secs_track and b->head are nonzero,
+         * but it turns out valid FAT filesystems can have zero there.
+         */
+
+        if (!fat_valid_media(b->media)) {
+                if (!silent)
+                        fat_msg(sb, KERN_ERR, "invalid media value (0x%02x)",
+                                (unsigned)b->media);
+                goto out;
+        }
+
+        if (!is_power_of_2(bpb->fat_sector_size)
+            || (bpb->fat_sector_size < 512)
+            || (bpb->fat_sector_size > 4096)) {
+                if (!silent)
+                        fat_msg(sb, KERN_ERR, "bogus logical sector size %u",
+                               (unsigned)bpb->fat_sector_size);
+                goto out;
+        }
+
+        if (!is_power_of_2(bpb->fat_sec_per_clus)) {
+                if (!silent)
+                        fat_msg(sb, KERN_ERR, "bogus sectors per cluster %u",
+                                (unsigned)bpb->fat_sec_per_clus);
+                goto out;
+        }
+
+        error = 0;
+
+out:
+        return error;
+}
+
+static int fat_read_static_bpb(struct super_block *sb,
+        struct fat_boot_sector *b, int silent,
+        struct fat_bios_param_block *bpb)
+{
+        static const char *notdos1x = "This doesn't look like a DOS 1.x volume";
+
+        struct fat_floppy_defaults *fdefaults = NULL;
+        int error = -EINVAL;
+        sector_t bd_sects;
+        unsigned i;
+
+        bd_sects = i_size_read(sb->s_bdev->bd_inode) / SECTOR_SIZE;
+
+        /* 16-bit DOS 1.x reliably wrote bootstrap short-jmp code */
+        if (b->ignored[0] != 0xeb || b->ignored[2] != 0x90) {
+                if (!silent)
+                        fat_msg(sb, KERN_ERR,
+                                "%s; no bootstrapping code", notdos1x);
+                goto out;
+        }
+
+        /*
+         * If any value in this region is non-zero, it isn't archaic
+         * DOS.
+         */
+        if (!fat_bpb_is_zero(b)) {
+                if (!silent)
+                        fat_msg(sb, KERN_ERR,
+                                "%s; DOS 2.x BPB is non-zero", notdos1x);
+                goto out;
+        }
+
+        for (i = 0; i < ARRAY_SIZE(floppy_defaults); i++) {
+                if (floppy_defaults[i].nr_sectors == bd_sects) {
+                        fdefaults = &floppy_defaults[i];
+                        break;
+                }
+        }
+
+        if (fdefaults == NULL) {
+                if (!silent)
+                        fat_msg(sb, KERN_WARNING,
+                                "This looks like a DOS 1.x volume, but isn't a recognized floppy size (%llu sectors)",
+                                (u64)bd_sects);
+                goto out;
+        }
+
+        if (!silent)
+                fat_msg(sb, KERN_INFO,
+                        "This looks like a DOS 1.x volume; assuming default BPB values");
+
+        memset(bpb, 0, sizeof(*bpb));
+        bpb->fat_sector_size = SECTOR_SIZE;
+        bpb->fat_sec_per_clus = fdefaults->sec_per_clus;
+        bpb->fat_reserved = 1;
+        bpb->fat_fats = 2;
+        bpb->fat_dir_entries = fdefaults->dir_entries;
+        bpb->fat_sectors = fdefaults->nr_sectors;
+        bpb->fat_fat_length = fdefaults->fat_length;
+
+        error = 0;
+
+out:
+        return error;
+}
+
 /*
  * Read the super block of an MS-DOS FS.
  */
@@ -1256,12 +1487,11 @@ int fat_fill_super(struct super_block *sb, void *data, int silent, int isvfat,
         struct inode *root_inode = NULL, *fat_inode = NULL;
         struct inode *fsinfo_inode = NULL;
         struct buffer_head *bh;
-        struct fat_boot_sector *b;
+        struct fat_bios_param_block bpb;
         struct msdos_sb_info *sbi;
         u16 logical_sector_size;
         u32 total_sectors, total_clusters, fat_clusters, rootdir_sectors;
         int debug;
-        unsigned int media;
         long error;
         char buf[50];
 
@@ -1298,100 +1528,72 @@ int fat_fill_super(struct super_block *sb, void *data, int silent, int isvfat,
                 goto out_fail;
         }
 
-        b = (struct fat_boot_sector *) bh->b_data;
-        if (!b->reserved) {
-                if (!silent)
-                        fat_msg(sb, KERN_ERR, "bogus number of reserved sectors");
-                brelse(bh);
-                goto out_invalid;
-        }
-        if (!b->fats) {
-                if (!silent)
-                        fat_msg(sb, KERN_ERR, "bogus number of FAT structure");
-                brelse(bh);
-                goto out_invalid;
-        }
-
-        /*
-         * Earlier we checked here that b->secs_track and b->head are nonzero,
-         * but it turns out valid FAT filesystems can have zero there.
-         */
+        error = fat_read_bpb(sb, (struct fat_boot_sector *)bh->b_data, silent,
+                &bpb);
+        if (error == -EINVAL && sbi->options.dos1xfloppy)
+                error = fat_read_static_bpb(sb,
+                        (struct fat_boot_sector *)bh->b_data, silent, &bpb);
+        brelse(bh);
 
-        media = b->media;
-        if (!fat_valid_media(media)) {
-                if (!silent)
-                        fat_msg(sb, KERN_ERR, "invalid media value (0x%02x)",
-                               media);
-                brelse(bh);
-                goto out_invalid;
-        }
-        logical_sector_size = get_unaligned_le16(&b->sector_size);
-        if (!is_power_of_2(logical_sector_size)
-            || (logical_sector_size < 512)
-            || (logical_sector_size > 4096)) {
-                if (!silent)
-                        fat_msg(sb, KERN_ERR, "bogus logical sector size %u",
-                               logical_sector_size);
-                brelse(bh);
-                goto out_invalid;
-        }
-        sbi->sec_per_clus = b->sec_per_clus;
-        if (!is_power_of_2(sbi->sec_per_clus)) {
-                if (!silent)
-                        fat_msg(sb, KERN_ERR, "bogus sectors per cluster %u",
-                               sbi->sec_per_clus);
-                brelse(bh);
+        if (error == -EINVAL)
                 goto out_invalid;
-        }
+        else if (error)
+                goto out_fail;
+
+        logical_sector_size = bpb.fat_sector_size;
+        sbi->sec_per_clus = bpb.fat_sec_per_clus;
 
+        error = -EIO;
         if (logical_sector_size < sb->s_blocksize) {
                 fat_msg(sb, KERN_ERR, "logical sector size too small for device"
                        " (logical sector size = %u)", logical_sector_size);
-                brelse(bh);
                 goto out_fail;
         }
+
         if (logical_sector_size > sb->s_blocksize) {
-                brelse(bh);
+                struct buffer_head *bh_resize;
 
                 if (!sb_set_blocksize(sb, logical_sector_size)) {
                         fat_msg(sb, KERN_ERR, "unable to set blocksize %u",
                                logical_sector_size);
                         goto out_fail;
                 }
-                bh = sb_bread(sb, 0);
-                if (bh == NULL) {
+
+                /* Verify that the larger boot sector is fully readable */
+                bh_resize = sb_bread(sb, 0);
+                if (bh_resize == NULL) {
                         fat_msg(sb, KERN_ERR, "unable to read boot sector"
                                " (logical sector size = %lu)",
                                sb->s_blocksize);
                         goto out_fail;
                 }
-                b = (struct fat_boot_sector *) bh->b_data;
+                brelse(bh_resize);
         }
 
         mutex_init(&sbi->s_lock);
         sbi->cluster_size = sb->s_blocksize * sbi->sec_per_clus;
         sbi->cluster_bits = ffs(sbi->cluster_size) - 1;
-        sbi->fats = b->fats;
+        sbi->fats = bpb.fat_fats;
         sbi->fat_bits = 0;              /* Don't know yet */
-        sbi->fat_start = le16_to_cpu(b->reserved);
-        sbi->fat_length = le16_to_cpu(b->fat_length);
+        sbi->fat_start = bpb.fat_reserved;
+        sbi->fat_length = bpb.fat_fat_length;
         sbi->root_cluster = 0;
         sbi->free_clusters = -1;        /* Don't know yet */
         sbi->free_clus_valid = 0;
         sbi->prev_free = FAT_START_ENT;
         sb->s_maxbytes = 0xffffffff;
 
-        if (!sbi->fat_length && b->fat32.length) {
+        if (!sbi->fat_length && bpb.fat32_length) {
                 struct fat_boot_fsinfo *fsinfo;
                 struct buffer_head *fsinfo_bh;
 
                 /* Must be FAT32 */
                 sbi->fat_bits = 32;
-                sbi->fat_length = le32_to_cpu(b->fat32.length);
-                sbi->root_cluster = le32_to_cpu(b->fat32.root_cluster);
+                sbi->fat_length = bpb.fat32_length;
+                sbi->root_cluster = bpb.fat32_root_cluster;
 
                 /* MC - if info_sector is 0, don't multiply by 0 */
-                sbi->fsinfo_sector = le16_to_cpu(b->fat32.info_sector);
+                sbi->fsinfo_sector = bpb.fat32_info_sector;
                 if (sbi->fsinfo_sector == 0)
                         sbi->fsinfo_sector = 1;
 
@@ -1399,7 +1601,6 @@ int fat_fill_super(struct super_block *sb, void *data, int silent, int isvfat,
                 if (fsinfo_bh == NULL) {
                         fat_msg(sb, KERN_ERR, "bread failed, FSINFO block"
                                " (sector = %lu)", sbi->fsinfo_sector);
-                        brelse(bh);
                         goto out_fail;
                 }
 
@@ -1422,35 +1623,28 @@ int fat_fill_super(struct super_block *sb, void *data, int silent, int isvfat,
 
         /* interpret volume ID as a little endian 32 bit integer */
         if (sbi->fat_bits == 32)
-                sbi->vol_id = (((u32)b->fat32.vol_id[0]) |
-                                        ((u32)b->fat32.vol_id[1] << 8) |
-                                        ((u32)b->fat32.vol_id[2] << 16) |
-                                        ((u32)b->fat32.vol_id[3] << 24));
+                sbi->vol_id = bpb.fat32_vol_id;
         else /* fat 16 or 12 */
-                sbi->vol_id = (((u32)b->fat16.vol_id[0]) |
-                                        ((u32)b->fat16.vol_id[1] << 8) |
-                                        ((u32)b->fat16.vol_id[2] << 16) |
-                                        ((u32)b->fat16.vol_id[3] << 24));
+                sbi->vol_id = bpb.fat16_vol_id;
 
         sbi->dir_per_block = sb->s_blocksize / sizeof(struct msdos_dir_entry);
         sbi->dir_per_block_bits = ffs(sbi->dir_per_block) - 1;
 
         sbi->dir_start = sbi->fat_start + sbi->fats * sbi->fat_length;
-        sbi->dir_entries = get_unaligned_le16(&b->dir_entries);
+        sbi->dir_entries = bpb.fat_dir_entries;
         if (sbi->dir_entries & (sbi->dir_per_block - 1)) {
                 if (!silent)
                         fat_msg(sb, KERN_ERR, "bogus directory-entries per block"
                                " (%u)", sbi->dir_entries);
-                brelse(bh);
                 goto out_invalid;
         }
 
         rootdir_sectors = sbi->dir_entries
                 * sizeof(struct msdos_dir_entry) / sb->s_blocksize;
         sbi->data_start = sbi->dir_start + rootdir_sectors;
-        total_sectors = get_unaligned_le16(&b->sectors);
+        total_sectors = bpb.fat_sectors;
         if (total_sectors == 0)
-                total_sectors = le32_to_cpu(b->total_sect);
+                total_sectors = bpb.fat_total_sect;
 
         total_clusters = (total_sectors - sbi->data_start) / sbi->sec_per_clus;
 
@@ -1459,9 +1653,9 @@ int fat_fill_super(struct super_block *sb, void *data, int silent, int isvfat,
 
         /* some OSes set FAT_STATE_DIRTY and clean it on unmount. */
         if (sbi->fat_bits == 32)
-                sbi->dirty = b->fat32.state & FAT_STATE_DIRTY;
+                sbi->dirty = bpb.fat32_state & FAT_STATE_DIRTY;
         else /* fat 16 or 12 */
-                sbi->dirty = b->fat16.state & FAT_STATE_DIRTY;
+                sbi->dirty = bpb.fat16_state & FAT_STATE_DIRTY;
 
         /* check that FAT table does not overflow */
         fat_clusters = calc_fat_clusters(sb);
@@ -1470,7 +1664,6 @@ int fat_fill_super(struct super_block *sb, void *data, int silent, int isvfat,
                 if (!silent)
                         fat_msg(sb, KERN_ERR, "count of clusters too big (%u)",
                                total_clusters);
-                brelse(bh);
                 goto out_invalid;
         }
 
@@ -1483,8 +1676,6 @@ int fat_fill_super(struct super_block *sb, void *data, int silent, int isvfat,
         if (sbi->prev_free < FAT_START_ENT)
                 sbi->prev_free = FAT_START_ENT;
 
-        brelse(bh);
-
         /* set up enough so that it can read an inode */
         fat_hash_init(sb);
         dir_hash_init(sb);
diff --git a/fs/file_table.c b/fs/file_table.c
index a374f5033e97..40bf4660f0a3 100644
--- a/fs/file_table.c
+++ b/fs/file_table.c
@@ -76,14 +76,14 @@ EXPORT_SYMBOL_GPL(get_max_files);
  * Handle nr_files sysctl
  */
 #if defined(CONFIG_SYSCTL) && defined(CONFIG_PROC_FS)
-int proc_nr_files(ctl_table *table, int write,
+int proc_nr_files(struct ctl_table *table, int write,
                      void __user *buffer, size_t *lenp, loff_t *ppos)
 {
         files_stat.nr_files = get_nr_files();
         return proc_doulongvec_minmax(table, write, buffer, lenp, ppos);
 }
 #else
-int proc_nr_files(ctl_table *table, int write,
+int proc_nr_files(struct ctl_table *table, int write,
                      void __user *buffer, size_t *lenp, loff_t *ppos)
 {
         return -ENOSYS;
diff --git a/fs/fscache/main.c b/fs/fscache/main.c
index acd4bf1fc277..63f868e869b9 100644
--- a/fs/fscache/main.c
+++ b/fs/fscache/main.c
@@ -67,7 +67,7 @@ static int fscache_max_active_sysctl(struct ctl_table *table, int write,
         return ret;
 }
 
-ctl_table fscache_sysctls[] = {
+struct ctl_table fscache_sysctls[] = {
         {
                 .procname       = "object_max_active",
                 .data           = &fscache_object_max_active,
@@ -87,7 +87,7 @@ ctl_table fscache_sysctls[] = {
         {}
 };
 
-ctl_table fscache_sysctls_root[] = {
+struct ctl_table fscache_sysctls_root[] = {
         {
                 .procname       = "fscache",
                 .mode           = 0555,
diff --git a/fs/hfsplus/attributes.c b/fs/hfsplus/attributes.c
index caf89a7be0a1..e5b221de7de6 100644
--- a/fs/hfsplus/attributes.c
+++ b/fs/hfsplus/attributes.c
@@ -54,14 +54,11 @@ int hfsplus_attr_build_key(struct super_block *sb, hfsplus_btree_key *key,
         memset(key, 0, sizeof(struct hfsplus_attr_key));
         key->attr.cnid = cpu_to_be32(cnid);
         if (name) {
-                len = strlen(name);
-                if (len > HFSPLUS_ATTR_MAX_STRLEN) {
-                        pr_err("invalid xattr name's length\n");
-                        return -EINVAL;
-                }
-                hfsplus_asc2uni(sb,
+                int res = hfsplus_asc2uni(sb,
                                 (struct hfsplus_unistr *)&key->attr.key_name,
-                                HFSPLUS_ATTR_MAX_STRLEN, name, len);
+                                HFSPLUS_ATTR_MAX_STRLEN, name, strlen(name));
+                if (res)
+                        return res;
                 len = be16_to_cpu(key->attr.key_name.length);
         } else {
                 key->attr.key_name.length = 0;
@@ -82,31 +79,6 @@ int hfsplus_attr_build_key(struct super_block *sb, hfsplus_btree_key *key,
         return 0;
 }
 
-void hfsplus_attr_build_key_uni(hfsplus_btree_key *key,
-                                        u32 cnid,
-                                        struct hfsplus_attr_unistr *name)
-{
-        int ustrlen;
-
-        memset(key, 0, sizeof(struct hfsplus_attr_key));
-        ustrlen = be16_to_cpu(name->length);
-        key->attr.cnid = cpu_to_be32(cnid);
-        key->attr.key_name.length = cpu_to_be16(ustrlen);
-        ustrlen *= 2;
-        memcpy(key->attr.key_name.unicode, name->unicode, ustrlen);
-
-        /* The length of the key, as stored in key_len field, does not include
-         * the size of the key_len field itself.
-         * So, offsetof(hfsplus_attr_key, key_name) is a trick because
-         * it takes into consideration key_len field (__be16) of
-         * hfsplus_attr_key structure instead of length field (__be16) of
-         * hfsplus_attr_unistr structure.
-         */
-        key->key_len =
-                cpu_to_be16(offsetof(struct hfsplus_attr_key, key_name) +
-                                ustrlen);
-}
-
 hfsplus_attr_entry *hfsplus_alloc_attr_entry(void)
 {
         return kmem_cache_alloc(hfsplus_attr_tree_cachep, GFP_KERNEL);
diff --git a/fs/hfsplus/bnode.c b/fs/hfsplus/bnode.c
index 11c860204520..759708fd9331 100644
--- a/fs/hfsplus/bnode.c
+++ b/fs/hfsplus/bnode.c
@@ -27,13 +27,13 @@ void hfs_bnode_read(struct hfs_bnode *node, void *buf, int off, int len)
         pagep = node->page + (off >> PAGE_CACHE_SHIFT);
         off &= ~PAGE_CACHE_MASK;
 
-        l = min(len, (int)PAGE_CACHE_SIZE - off);
+        l = min_t(int, len, PAGE_CACHE_SIZE - off);
         memcpy(buf, kmap(*pagep) + off, l);
         kunmap(*pagep);
 
         while ((len -= l) != 0) {
                 buf += l;
-                l = min(len, (int)PAGE_CACHE_SIZE);
+                l = min_t(int, len, PAGE_CACHE_SIZE);
                 memcpy(buf, kmap(*++pagep), l);
                 kunmap(*pagep);
         }
@@ -80,14 +80,14 @@ void hfs_bnode_write(struct hfs_bnode *node, void *buf, int off, int len)
         pagep = node->page + (off >> PAGE_CACHE_SHIFT);
         off &= ~PAGE_CACHE_MASK;
 
-        l = min(len, (int)PAGE_CACHE_SIZE - off);
+        l = min_t(int, len, PAGE_CACHE_SIZE - off);
         memcpy(kmap(*pagep) + off, buf, l);
         set_page_dirty(*pagep);
         kunmap(*pagep);
 
         while ((len -= l) != 0) {
                 buf += l;
-                l = min(len, (int)PAGE_CACHE_SIZE);
+                l = min_t(int, len, PAGE_CACHE_SIZE);
                 memcpy(kmap(*++pagep), buf, l);
                 set_page_dirty(*pagep);
                 kunmap(*pagep);
@@ -110,13 +110,13 @@ void hfs_bnode_clear(struct hfs_bnode *node, int off, int len)
         pagep = node->page + (off >> PAGE_CACHE_SHIFT);
         off &= ~PAGE_CACHE_MASK;
 
-        l = min(len, (int)PAGE_CACHE_SIZE - off);
+        l = min_t(int, len, PAGE_CACHE_SIZE - off);
         memset(kmap(*pagep) + off, 0, l);
         set_page_dirty(*pagep);
         kunmap(*pagep);
 
         while ((len -= l) != 0) {
-                l = min(len, (int)PAGE_CACHE_SIZE);
+                l = min_t(int, len, PAGE_CACHE_SIZE);
                 memset(kmap(*++pagep), 0, l);
                 set_page_dirty(*pagep);
                 kunmap(*pagep);
@@ -142,14 +142,14 @@ void hfs_bnode_copy(struct hfs_bnode *dst_node, int dst,
         dst &= ~PAGE_CACHE_MASK;
 
         if (src == dst) {
-                l = min(len, (int)PAGE_CACHE_SIZE - src);
+                l = min_t(int, len, PAGE_CACHE_SIZE - src);
                 memcpy(kmap(*dst_page) + src, kmap(*src_page) + src, l);
                 kunmap(*src_page);
                 set_page_dirty(*dst_page);
                 kunmap(*dst_page);
 
                 while ((len -= l) != 0) {
-                        l = min(len, (int)PAGE_CACHE_SIZE);
+                        l = min_t(int, len, PAGE_CACHE_SIZE);
                         memcpy(kmap(*++dst_page), kmap(*++src_page), l);
                         kunmap(*src_page);
                         set_page_dirty(*dst_page);
@@ -251,7 +251,7 @@ void hfs_bnode_move(struct hfs_bnode *node, int dst, int src, int len)
                 dst &= ~PAGE_CACHE_MASK;
 
                 if (src == dst) {
-                        l = min(len, (int)PAGE_CACHE_SIZE - src);
+                        l = min_t(int, len, PAGE_CACHE_SIZE - src);
                         memmove(kmap(*dst_page) + src,
                                 kmap(*src_page) + src, l);
                         kunmap(*src_page);
@@ -259,7 +259,7 @@ void hfs_bnode_move(struct hfs_bnode *node, int dst, int src, int len)
                         kunmap(*dst_page);
 
                         while ((len -= l) != 0) {
-                                l = min(len, (int)PAGE_CACHE_SIZE);
+                                l = min_t(int, len, PAGE_CACHE_SIZE);
                                 memmove(kmap(*++dst_page),
                                         kmap(*++src_page), l);
                                 kunmap(*src_page);
@@ -386,9 +386,8 @@ struct hfs_bnode *hfs_bnode_findhash(struct hfs_btree *tree, u32 cnid)
         struct hfs_bnode *node;
 
         if (cnid >= tree->node_count) {
-                pr_err("request for non-existent node "
-                                "%d in B*Tree\n",
-                        cnid);
+                pr_err("request for non-existent node %d in B*Tree\n",
+                       cnid);
                 return NULL;
         }
 
@@ -409,9 +408,8 @@ static struct hfs_bnode *__hfs_bnode_create(struct hfs_btree *tree, u32 cnid)
         loff_t off;
 
         if (cnid >= tree->node_count) {
-                pr_err("request for non-existent node "
-                                "%d in B*Tree\n",
-                        cnid);
+                pr_err("request for non-existent node %d in B*Tree\n",
+                       cnid);
                 return NULL;
         }
 
@@ -602,7 +600,7 @@ struct hfs_bnode *hfs_bnode_create(struct hfs_btree *tree, u32 num)
 
         pagep = node->page;
         memset(kmap(*pagep) + node->page_offset, 0,
-               min((int)PAGE_CACHE_SIZE, (int)tree->node_size));
+               min_t(int, PAGE_CACHE_SIZE, tree->node_size));
         set_page_dirty(*pagep);
         kunmap(*pagep);
         for (i = 1; i < tree->pages_per_bnode; i++) {
@@ -648,8 +646,8 @@ void hfs_bnode_put(struct hfs_bnode *node)
                 if (test_bit(HFS_BNODE_DELETED, &node->flags)) {
                         hfs_bnode_unhash(node);
                         spin_unlock(&tree->hash_lock);
-                        hfs_bnode_clear(node, 0,
-                                PAGE_CACHE_SIZE * tree->pages_per_bnode);
+                        if (hfs_bnode_need_zeroout(tree))
+                                hfs_bnode_clear(node, 0, tree->node_size);
                         hfs_bmap_free(node);
                         hfs_bnode_free(node);
                         return;
@@ -658,3 +656,16 @@ void hfs_bnode_put(struct hfs_bnode *node)
         }
 }
 
+/*
+ * Unused nodes have to be zeroed if this is the catalog tree and
+ * a corresponding flag in the volume header is set.
+ */
+bool hfs_bnode_need_zeroout(struct hfs_btree *tree)
+{
+        struct super_block *sb = tree->inode->i_sb;
+        struct hfsplus_sb_info *sbi = HFSPLUS_SB(sb);
+        const u32 volume_attr = be32_to_cpu(sbi->s_vhdr->attributes);
+
+        return tree->cnid == HFSPLUS_CAT_CNID &&
+                volume_attr & HFSPLUS_VOL_UNUSED_NODE_FIX;
+}
diff --git a/fs/hfsplus/btree.c b/fs/hfsplus/btree.c
index 0fcec8b2a90b..3345c7553edc 100644
--- a/fs/hfsplus/btree.c
+++ b/fs/hfsplus/btree.c
@@ -358,7 +358,7 @@ struct hfs_bnode *hfs_bmap_alloc(struct hfs_btree *tree)
                 u32 count;
                 int res;
 
-                res = hfsplus_file_extend(inode);
+                res = hfsplus_file_extend(inode, hfs_bnode_need_zeroout(tree));
                 if (res)
                         return ERR_PTR(res);
                 hip->phys_size = inode->i_size =
diff --git a/fs/hfsplus/dir.c b/fs/hfsplus/dir.c
index bdec66522de3..610a3260bef1 100644
--- a/fs/hfsplus/dir.c
+++ b/fs/hfsplus/dir.c
@@ -12,6 +12,7 @@
 #include <linux/fs.h>
 #include <linux/slab.h>
 #include <linux/random.h>
+#include <linux/nls.h>
 
 #include "hfsplus_fs.h"
 #include "hfsplus_raw.h"
@@ -127,7 +128,7 @@ static int hfsplus_readdir(struct file *file, struct dir_context *ctx)
         struct inode *inode = file_inode(file);
         struct super_block *sb = inode->i_sb;
         int len, err;
-        char strbuf[HFSPLUS_MAX_STRLEN + 1];
+        char *strbuf;
         hfsplus_cat_entry entry;
         struct hfs_find_data fd;
         struct hfsplus_readdir_data *rd;
@@ -139,6 +140,11 @@ static int hfsplus_readdir(struct file *file, struct dir_context *ctx)
         err = hfs_find_init(HFSPLUS_SB(sb)->cat_tree, &fd);
         if (err)
                 return err;
+        strbuf = kmalloc(NLS_MAX_CHARSET_SIZE * HFSPLUS_MAX_STRLEN + 1, GFP_KERNEL);
+        if (!strbuf) {
+                err = -ENOMEM;
+                goto out;
+        }
         hfsplus_cat_build_key(sb, fd.search_key, inode->i_ino, NULL);
         err = hfs_brec_find(&fd, hfs_find_rec_by_key);
         if (err)
@@ -193,7 +199,7 @@ static int hfsplus_readdir(struct file *file, struct dir_context *ctx)
                 hfs_bnode_read(fd.bnode, &entry, fd.entryoffset,
                         fd.entrylength);
                 type = be16_to_cpu(entry.type);
-                len = HFSPLUS_MAX_STRLEN;
+                len = NLS_MAX_CHARSET_SIZE * HFSPLUS_MAX_STRLEN;
                 err = hfsplus_uni2asc(sb, &fd.key->cat.name, strbuf, &len);
                 if (err)
                         goto out;
@@ -212,13 +218,31 @@ static int hfsplus_readdir(struct file *file, struct dir_context *ctx)
                                     be32_to_cpu(entry.folder.id), DT_DIR))
                                 break;
                 } else if (type == HFSPLUS_FILE) {
+                        u16 mode;
+                        unsigned type = DT_UNKNOWN;
+
                         if (fd.entrylength < sizeof(struct hfsplus_cat_file)) {
                                 pr_err("small file entry\n");
                                 err = -EIO;
                                 goto out;
                         }
+
+                        mode = be16_to_cpu(entry.file.permissions.mode);
+                        if (S_ISREG(mode))
+                                type = DT_REG;
+                        else if (S_ISLNK(mode))
+                                type = DT_LNK;
+                        else if (S_ISFIFO(mode))
+                                type = DT_FIFO;
+                        else if (S_ISCHR(mode))
+                                type = DT_CHR;
+                        else if (S_ISBLK(mode))
+                                type = DT_BLK;
+                        else if (S_ISSOCK(mode))
+                                type = DT_SOCK;
+
                         if (!dir_emit(ctx, strbuf, len,
-                                    be32_to_cpu(entry.file.id), DT_REG))
+                                      be32_to_cpu(entry.file.id), type))
                                 break;
                 } else {
                         pr_err("bad catalog entry type\n");
@@ -246,6 +270,7 @@ next:
         }
         memcpy(&rd->key, fd.key, sizeof(struct hfsplus_cat_key));
 out:
+        kfree(strbuf);
         hfs_find_exit(&fd);
         return err;
 }
diff --git a/fs/hfsplus/extents.c b/fs/hfsplus/extents.c
index a7aafb35b624..feca524ce2a5 100644
--- a/fs/hfsplus/extents.c
+++ b/fs/hfsplus/extents.c
@@ -235,7 +235,7 @@ int hfsplus_get_block(struct inode *inode, sector_t iblock,
                 if (iblock > hip->fs_blocks || !create)
                         return -EIO;
                 if (ablock >= hip->alloc_blocks) {
-                        res = hfsplus_file_extend(inode);
+                        res = hfsplus_file_extend(inode, false);
                         if (res)
                                 return res;
                 }
@@ -425,7 +425,7 @@ int hfsplus_free_fork(struct super_block *sb, u32 cnid,
         return res;
 }
 
-int hfsplus_file_extend(struct inode *inode)
+int hfsplus_file_extend(struct inode *inode, bool zeroout)
 {
         struct super_block *sb = inode->i_sb;
         struct hfsplus_sb_info *sbi = HFSPLUS_SB(sb);
@@ -436,10 +436,9 @@ int hfsplus_file_extend(struct inode *inode)
         if (sbi->alloc_file->i_size * 8 <
             sbi->total_blocks - sbi->free_blocks + 8) {
                 /* extend alloc file */
-                pr_err("extend alloc file! "
-                                "(%llu,%u,%u)\n",
-                        sbi->alloc_file->i_size * 8,
-                        sbi->total_blocks, sbi->free_blocks);
+                pr_err("extend alloc file! (%llu,%u,%u)\n",
+                       sbi->alloc_file->i_size * 8,
+                       sbi->total_blocks, sbi->free_blocks);
                 return -ENOSPC;
         }
 
@@ -463,6 +462,12 @@ int hfsplus_file_extend(struct inode *inode)
                 }
         }
 
+        if (zeroout) {
+                res = sb_issue_zeroout(sb, start, len, GFP_NOFS);
+                if (res)
+                        goto out;
+        }
+
         hfs_dbg(EXTENT, "extend %lu: %u,%u\n", inode->i_ino, start, len);
 
         if (hip->alloc_blocks <= hip->first_blocks) {
diff --git a/fs/hfsplus/hfsplus_fs.h b/fs/hfsplus/hfsplus_fs.h
index 83dc29286b10..eb5e059f481a 100644
--- a/fs/hfsplus/hfsplus_fs.h
+++ b/fs/hfsplus/hfsplus_fs.h
@@ -369,114 +369,119 @@ typedef int (*search_strategy_t)(struct hfs_bnode *,
 /* attributes.c */
 int __init hfsplus_create_attr_tree_cache(void);
 void hfsplus_destroy_attr_tree_cache(void);
+int hfsplus_attr_bin_cmp_key(const hfsplus_btree_key *k1,
+                             const hfsplus_btree_key *k2);
+int hfsplus_attr_build_key(struct super_block *sb, hfsplus_btree_key *key,
+                           u32 cnid, const char *name);
 hfsplus_attr_entry *hfsplus_alloc_attr_entry(void);
-void hfsplus_destroy_attr_entry(hfsplus_attr_entry *entry_p);
-int hfsplus_attr_bin_cmp_key(const hfsplus_btree_key *,
-                const hfsplus_btree_key *);
-int hfsplus_attr_build_key(struct super_block *, hfsplus_btree_key *,
-                        u32, const char *);
-void hfsplus_attr_build_key_uni(hfsplus_btree_key *key,
-                                        u32 cnid,
-                                        struct hfsplus_attr_unistr *name);
-int hfsplus_find_attr(struct super_block *, u32,
-                        const char *, struct hfs_find_data *);
+void hfsplus_destroy_attr_entry(hfsplus_attr_entry *entry);
+int hfsplus_find_attr(struct super_block *sb, u32 cnid, const char *name,
+                      struct hfs_find_data *fd);
 int hfsplus_attr_exists(struct inode *inode, const char *name);
-int hfsplus_create_attr(struct inode *, const char *, const void *, size_t);
-int hfsplus_delete_attr(struct inode *, const char *);
+int hfsplus_create_attr(struct inode *inode, const char *name,
+                        const void *value, size_t size);
+int hfsplus_delete_attr(struct inode *inode, const char *name);
 int hfsplus_delete_all_attrs(struct inode *dir, u32 cnid);
 
 /* bitmap.c */
-int hfsplus_block_allocate(struct super_block *, u32, u32, u32 *);
-int hfsplus_block_free(struct super_block *, u32, u32);
+int hfsplus_block_allocate(struct super_block *sb, u32 size, u32 offset,
+                           u32 *max);
+int hfsplus_block_free(struct super_block *sb, u32 offset, u32 count);
 
 /* btree.c */
-u32 hfsplus_calc_btree_clump_size(u32, u32, u64, int);
-struct hfs_btree *hfs_btree_open(struct super_block *, u32);
-void hfs_btree_close(struct hfs_btree *);
-int hfs_btree_write(struct hfs_btree *);
-struct hfs_bnode *hfs_bmap_alloc(struct hfs_btree *);
-void hfs_bmap_free(struct hfs_bnode *);
+u32 hfsplus_calc_btree_clump_size(u32 block_size, u32 node_size, u64 sectors,
+                                  int file_id);
+struct hfs_btree *hfs_btree_open(struct super_block *sb, u32 id);
+void hfs_btree_close(struct hfs_btree *tree);
+int hfs_btree_write(struct hfs_btree *tree);
+struct hfs_bnode *hfs_bmap_alloc(struct hfs_btree *tree);
+void hfs_bmap_free(struct hfs_bnode *node);
 
 /* bnode.c */
-void hfs_bnode_read(struct hfs_bnode *, void *, int, int);
-u16 hfs_bnode_read_u16(struct hfs_bnode *, int);
-u8 hfs_bnode_read_u8(struct hfs_bnode *, int);
-void hfs_bnode_read_key(struct hfs_bnode *, void *, int);
-void hfs_bnode_write(struct hfs_bnode *, void *, int, int);
-void hfs_bnode_write_u16(struct hfs_bnode *, int, u16);
-void hfs_bnode_clear(struct hfs_bnode *, int, int);
-void hfs_bnode_copy(struct hfs_bnode *, int,
-                    struct hfs_bnode *, int, int);
-void hfs_bnode_move(struct hfs_bnode *, int, int, int);
-void hfs_bnode_dump(struct hfs_bnode *);
-void hfs_bnode_unlink(struct hfs_bnode *);
-struct hfs_bnode *hfs_bnode_findhash(struct hfs_btree *, u32);
-struct hfs_bnode *hfs_bnode_find(struct hfs_btree *, u32);
-void hfs_bnode_unhash(struct hfs_bnode *);
-void hfs_bnode_free(struct hfs_bnode *);
-struct hfs_bnode *hfs_bnode_create(struct hfs_btree *, u32);
-void hfs_bnode_get(struct hfs_bnode *);
-void hfs_bnode_put(struct hfs_bnode *);
+void hfs_bnode_read(struct hfs_bnode *node, void *buf, int off, int len);
+u16 hfs_bnode_read_u16(struct hfs_bnode *node, int off);
+u8 hfs_bnode_read_u8(struct hfs_bnode *node, int off);
+void hfs_bnode_read_key(struct hfs_bnode *node, void *key, int off);
+void hfs_bnode_write(struct hfs_bnode *node, void *buf, int off, int len);
+void hfs_bnode_write_u16(struct hfs_bnode *node, int off, u16 data);
+void hfs_bnode_clear(struct hfs_bnode *node, int off, int len);
+void hfs_bnode_copy(struct hfs_bnode *dst_node, int dst,
+                    struct hfs_bnode *src_node, int src, int len);
+void hfs_bnode_move(struct hfs_bnode *node, int dst, int src, int len);
+void hfs_bnode_dump(struct hfs_bnode *node);
+void hfs_bnode_unlink(struct hfs_bnode *node);
+struct hfs_bnode *hfs_bnode_findhash(struct hfs_btree *tree, u32 cnid);
+void hfs_bnode_unhash(struct hfs_bnode *node);
+struct hfs_bnode *hfs_bnode_find(struct hfs_btree *tree, u32 num);
+void hfs_bnode_free(struct hfs_bnode *node);
+struct hfs_bnode *hfs_bnode_create(struct hfs_btree *tree, u32 num);
+void hfs_bnode_get(struct hfs_bnode *node);
+void hfs_bnode_put(struct hfs_bnode *node);
+bool hfs_bnode_need_zeroout(struct hfs_btree *tree);
 
 /* brec.c */
-u16 hfs_brec_lenoff(struct hfs_bnode *, u16, u16 *);
-u16 hfs_brec_keylen(struct hfs_bnode *, u16);
-int hfs_brec_insert(struct hfs_find_data *, void *, int);
-int hfs_brec_remove(struct hfs_find_data *);
+u16 hfs_brec_lenoff(struct hfs_bnode *node, u16 rec, u16 *off);
+u16 hfs_brec_keylen(struct hfs_bnode *node, u16 rec);
+int hfs_brec_insert(struct hfs_find_data *fd, void *entry, int entry_len);
+int hfs_brec_remove(struct hfs_find_data *fd);
 
 /* bfind.c */
-int hfs_find_init(struct hfs_btree *, struct hfs_find_data *);
-void hfs_find_exit(struct hfs_find_data *);
-int hfs_find_1st_rec_by_cnid(struct hfs_bnode *,
-                                struct hfs_find_data *,
-                                int *, int *, int *);
-int hfs_find_rec_by_key(struct hfs_bnode *,
-                                struct hfs_find_data *,
-                                int *, int *, int *);
-int __hfs_brec_find(struct hfs_bnode *, struct hfs_find_data *,
-                                search_strategy_t);
-int hfs_brec_find(struct hfs_find_data *, search_strategy_t);
-int hfs_brec_read(struct hfs_find_data *, void *, int);
-int hfs_brec_goto(struct hfs_find_data *, int);
+int hfs_find_init(struct hfs_btree *tree, struct hfs_find_data *fd);
+void hfs_find_exit(struct hfs_find_data *fd);
+int hfs_find_1st_rec_by_cnid(struct hfs_bnode *bnode, struct hfs_find_data *fd,
+                             int *begin, int *end, int *cur_rec);
+int hfs_find_rec_by_key(struct hfs_bnode *bnode, struct hfs_find_data *fd,
+                        int *begin, int *end, int *cur_rec);
+int __hfs_brec_find(struct hfs_bnode *bnode, struct hfs_find_data *fd,
+                    search_strategy_t rec_found);
+int hfs_brec_find(struct hfs_find_data *fd, search_strategy_t do_key_compare);
+int hfs_brec_read(struct hfs_find_data *fd, void *rec, int rec_len);
+int hfs_brec_goto(struct hfs_find_data *fd, int cnt);
 
 /* catalog.c */
-int hfsplus_cat_case_cmp_key(const hfsplus_btree_key *,
-                const hfsplus_btree_key *);
-int hfsplus_cat_bin_cmp_key(const hfsplus_btree_key *,
-                const hfsplus_btree_key *);
-void hfsplus_cat_build_key(struct super_block *sb,
-                hfsplus_btree_key *, u32, struct qstr *);
-int hfsplus_find_cat(struct super_block *, u32, struct hfs_find_data *);
-int hfsplus_create_cat(u32, struct inode *, struct qstr *, struct inode *);
-int hfsplus_delete_cat(u32, struct inode *, struct qstr *);
-int hfsplus_rename_cat(u32, struct inode *, struct qstr *,
-                       struct inode *, struct qstr *);
+int hfsplus_cat_case_cmp_key(const hfsplus_btree_key *k1,
+                             const hfsplus_btree_key *k2);
+int hfsplus_cat_bin_cmp_key(const hfsplus_btree_key *k1,
+                            const hfsplus_btree_key *k2);
+void hfsplus_cat_build_key(struct super_block *sb, hfsplus_btree_key *key,
+                           u32 parent, struct qstr *str);
 void hfsplus_cat_set_perms(struct inode *inode, struct hfsplus_perm *perms);
+int hfsplus_find_cat(struct super_block *sb, u32 cnid,
+                     struct hfs_find_data *fd);
+int hfsplus_create_cat(u32 cnid, struct inode *dir, struct qstr *str,
+                       struct inode *inode);
+int hfsplus_delete_cat(u32 cnid, struct inode *dir, struct qstr *str);
+int hfsplus_rename_cat(u32 cnid, struct inode *src_dir, struct qstr *src_name,
+                       struct inode *dst_dir, struct qstr *dst_name);
 
 /* dir.c */
 extern const struct inode_operations hfsplus_dir_inode_operations;
 extern const struct file_operations hfsplus_dir_operations;
 
 /* extents.c */
-int hfsplus_ext_cmp_key(const hfsplus_btree_key *, const hfsplus_btree_key *);
-int hfsplus_ext_write_extent(struct inode *);
-int hfsplus_get_block(struct inode *, sector_t, struct buffer_head *, int);
-int hfsplus_free_fork(struct super_block *, u32,
-                struct hfsplus_fork_raw *, int);
-int hfsplus_file_extend(struct inode *);
-void hfsplus_file_truncate(struct inode *);
+int hfsplus_ext_cmp_key(const hfsplus_btree_key *k1,
+                        const hfsplus_btree_key *k2);
+int hfsplus_ext_write_extent(struct inode *inode);
+int hfsplus_get_block(struct inode *inode, sector_t iblock,
+                      struct buffer_head *bh_result, int create);
+int hfsplus_free_fork(struct super_block *sb, u32 cnid,
+                      struct hfsplus_fork_raw *fork, int type);
+int hfsplus_file_extend(struct inode *inode, bool zeroout);
+void hfsplus_file_truncate(struct inode *inode);
 
 /* inode.c */
 extern const struct address_space_operations hfsplus_aops;
 extern const struct address_space_operations hfsplus_btree_aops;
 extern const struct dentry_operations hfsplus_dentry_operations;
 
-void hfsplus_inode_read_fork(struct inode *, struct hfsplus_fork_raw *);
-void hfsplus_inode_write_fork(struct inode *, struct hfsplus_fork_raw *);
-int hfsplus_cat_read_inode(struct inode *, struct hfs_find_data *);
-int hfsplus_cat_write_inode(struct inode *);
-struct inode *hfsplus_new_inode(struct super_block *, umode_t);
-void hfsplus_delete_inode(struct inode *);
+struct inode *hfsplus_new_inode(struct super_block *sb, umode_t mode);
+void hfsplus_delete_inode(struct inode *inode);
+void hfsplus_inode_read_fork(struct inode *inode,
+                             struct hfsplus_fork_raw *fork);
+void hfsplus_inode_write_fork(struct inode *inode,
+                              struct hfsplus_fork_raw *fork);
+int hfsplus_cat_read_inode(struct inode *inode, struct hfs_find_data *fd);
+int hfsplus_cat_write_inode(struct inode *inode);
 int hfsplus_file_fsync(struct file *file, loff_t start, loff_t end,
                        int datasync);
 
@@ -484,13 +489,17 @@ int hfsplus_file_fsync(struct file *file, loff_t start, loff_t end,
 long hfsplus_ioctl(struct file *filp, unsigned int cmd, unsigned long arg);
 
 /* options.c */
-int hfsplus_parse_options(char *, struct hfsplus_sb_info *);
+void hfsplus_fill_defaults(struct hfsplus_sb_info *opts);
 int hfsplus_parse_options_remount(char *input, int *force);
-void hfsplus_fill_defaults(struct hfsplus_sb_info *);
-int hfsplus_show_options(struct seq_file *, struct dentry *);
+int hfsplus_parse_options(char *input, struct hfsplus_sb_info *sbi);
+int hfsplus_show_options(struct seq_file *seq, struct dentry *root);
+
+/* part_tbl.c */
+int hfs_part_find(struct super_block *sb, sector_t *part_start,
+                  sector_t *part_size);
 
 /* super.c */
-struct inode *hfsplus_iget(struct super_block *, unsigned long);
+struct inode *hfsplus_iget(struct super_block *sb, unsigned long ino);
 void hfsplus_mark_mdb_dirty(struct super_block *sb);
 
 /* tables.c */
@@ -499,23 +508,23 @@ extern u16 hfsplus_decompose_table[];
 extern u16 hfsplus_compose_table[];
 
 /* unicode.c */
-int hfsplus_strcasecmp(const struct hfsplus_unistr *,
-                const struct hfsplus_unistr *);
-int hfsplus_strcmp(const struct hfsplus_unistr *,
-                const struct hfsplus_unistr *);
-int hfsplus_uni2asc(struct super_block *,
-                const struct hfsplus_unistr *, char *, int *);
-int hfsplus_asc2uni(struct super_block *,
-                struct hfsplus_unistr *, int, const char *, int);
+int hfsplus_strcasecmp(const struct hfsplus_unistr *s1,
+                       const struct hfsplus_unistr *s2);
+int hfsplus_strcmp(const struct hfsplus_unistr *s1,
+                   const struct hfsplus_unistr *s2);
+int hfsplus_uni2asc(struct super_block *sb, const struct hfsplus_unistr *ustr,
+                    char *astr, int *len_p);
+int hfsplus_asc2uni(struct super_block *sb, struct hfsplus_unistr *ustr,
+                    int max_unistr_len, const char *astr, int len);
 int hfsplus_hash_dentry(const struct dentry *dentry, struct qstr *str);
-int hfsplus_compare_dentry(const struct dentry *parent, const struct dentry *dentry,
-                unsigned int len, const char *str, const struct qstr *name);
+int hfsplus_compare_dentry(const struct dentry *parent,
+                           const struct dentry *dentry, unsigned int len,
+                           const char *str, const struct qstr *name);
 
 /* wrapper.c */
-int hfsplus_read_wrapper(struct super_block *);
-int hfs_part_find(struct super_block *, sector_t *, sector_t *);
-int hfsplus_submit_bio(struct super_block *sb, sector_t sector,
-                void *buf, void **data, int rw);
+int hfsplus_submit_bio(struct super_block *sb, sector_t sector, void *buf,
+                       void **data, int rw);
+int hfsplus_read_wrapper(struct super_block *sb);
 
 /* time macros */
 #define __hfsp_mt2ut(t)         (be32_to_cpu(t) - 2082844800U)
diff --git a/fs/hfsplus/hfsplus_raw.h b/fs/hfsplus/hfsplus_raw.h
index 5a126828d85e..8298d0985f81 100644
--- a/fs/hfsplus/hfsplus_raw.h
+++ b/fs/hfsplus/hfsplus_raw.h
@@ -144,6 +144,7 @@ struct hfsplus_vh {
 #define HFSPLUS_VOL_NODEID_REUSED       (1 << 12)
 #define HFSPLUS_VOL_JOURNALED           (1 << 13)
 #define HFSPLUS_VOL_SOFTLOCK            (1 << 15)
+#define HFSPLUS_VOL_UNUSED_NODE_FIX     (1 << 31)
 
 /* HFS+ BTree node descriptor */
 struct hfs_bnode_desc {
diff --git a/fs/hfsplus/options.c b/fs/hfsplus/options.c
index 68537e8b7a09..c90b72ee676d 100644
--- a/fs/hfsplus/options.c
+++ b/fs/hfsplus/options.c
@@ -173,9 +173,8 @@ int hfsplus_parse_options(char *input, struct hfsplus_sb_info *sbi)
                         if (p)
                                 sbi->nls = load_nls(p);
                         if (!sbi->nls) {
-                                pr_err("unable to load "
-                                                "nls mapping \"%s\"\n",
-                                        p);
+                                pr_err("unable to load nls mapping \"%s\"\n",
+                                       p);
                                 kfree(p);
                                 return 0;
                         }
@@ -232,8 +231,8 @@ int hfsplus_show_options(struct seq_file *seq, struct dentry *root)
         if (sbi->nls)
                 seq_printf(seq, ",nls=%s", sbi->nls->charset);
         if (test_bit(HFSPLUS_SB_NODECOMPOSE, &sbi->flags))
-                seq_printf(seq, ",nodecompose");
+                seq_puts(seq, ",nodecompose");
         if (test_bit(HFSPLUS_SB_NOBARRIER, &sbi->flags))
-                seq_printf(seq, ",nobarrier");
+                seq_puts(seq, ",nobarrier");
         return 0;
 }
diff --git a/fs/hfsplus/super.c b/fs/hfsplus/super.c
index a513d2d36be9..4cf2024b87da 100644
--- a/fs/hfsplus/super.c
+++ b/fs/hfsplus/super.c
@@ -131,9 +131,10 @@ static int hfsplus_system_write_inode(struct inode *inode)
         hfsplus_inode_write_fork(inode, fork);
         if (tree) {
                 int err = hfs_btree_write(tree);
+
                 if (err) {
                         pr_err("b-tree write err: %d, ino %lu\n",
-                                        err, inode->i_ino);
+                               err, inode->i_ino);
                         return err;
                 }
         }
diff --git a/fs/hfsplus/wrapper.c b/fs/hfsplus/wrapper.c
index 3f999649587f..cc6235671437 100644
--- a/fs/hfsplus/wrapper.c
+++ b/fs/hfsplus/wrapper.c
@@ -24,8 +24,8 @@ struct hfsplus_wd {
         u16 embed_count;
 };
 
-/*
- * hfsplus_submit_bio - Perfrom block I/O
+/**
+ * hfsplus_submit_bio - Perform block I/O
  * @sb: super block of volume for I/O
  * @sector: block to read or write, for blocks of HFSPLUS_SECTOR_SIZE bytes
  * @buf: buffer for I/O
@@ -231,10 +231,8 @@ reread:
         if (blocksize < HFSPLUS_SECTOR_SIZE || ((blocksize - 1) & blocksize))
                 goto out_free_backup_vhdr;
         sbi->alloc_blksz = blocksize;
-        sbi->alloc_blksz_shift = 0;
-        while ((blocksize >>= 1) != 0)
-                sbi->alloc_blksz_shift++;
-        blocksize = min(sbi->alloc_blksz, (u32)PAGE_SIZE);
+        sbi->alloc_blksz_shift = ilog2(blocksize);
+        blocksize = min_t(u32, sbi->alloc_blksz, PAGE_SIZE);
 
         /*
          * Align block size to block offset.
diff --git a/fs/hfsplus/xattr.c b/fs/hfsplus/xattr.c
index 4e27edc082a4..d98094a9f476 100644
--- a/fs/hfsplus/xattr.c
+++ b/fs/hfsplus/xattr.c
@@ -8,6 +8,7 @@
 
 #include "hfsplus_fs.h"
 #include <linux/posix_acl_xattr.h>
+#include <linux/nls.h>
 #include "xattr.h"
 #include "acl.h"
 
@@ -66,10 +67,10 @@ static void hfsplus_init_header_node(struct inode *attr_file,
         char *bmp;
         u32 used_nodes;
         u32 used_bmp_bytes;
-        loff_t tmp;
+        u64 tmp;
 
         hfs_dbg(ATTR_MOD, "init_hdr_attr_file: clump %u, node_size %u\n",
-                                clump_size, node_size);
+                clump_size, node_size);
 
         /* The end of the node contains list of record offsets */
         rec_offsets = (__be16 *)(buf + node_size);
@@ -195,7 +196,7 @@ check_attr_tree_state_again:
         }
 
         while (hip->alloc_blocks < hip->clump_blocks) {
-                err = hfsplus_file_extend(attr_file);
+                err = hfsplus_file_extend(attr_file, false);
                 if (unlikely(err)) {
                         pr_err("failed to extend attributes file\n");
                         goto end_attr_file_creation;
@@ -645,8 +646,7 @@ ssize_t hfsplus_listxattr(struct dentry *dentry, char *buffer, size_t size)
         struct hfs_find_data fd;
         u16 key_len = 0;
         struct hfsplus_attr_key attr_key;
-        char strbuf[HFSPLUS_ATTR_MAX_STRLEN +
-                        XATTR_MAC_OSX_PREFIX_LEN + 1] = {0};
+        char *strbuf;
         int xattr_name_len;
 
         if ((!S_ISREG(inode->i_mode) &&
@@ -666,6 +666,13 @@ ssize_t hfsplus_listxattr(struct dentry *dentry, char *buffer, size_t size)
                 return err;
         }
 
+        strbuf = kmalloc(NLS_MAX_CHARSET_SIZE * HFSPLUS_ATTR_MAX_STRLEN +
+                        XATTR_MAC_OSX_PREFIX_LEN + 1, GFP_KERNEL);
+        if (!strbuf) {
+                res = -ENOMEM;
+                goto out;
+        }
+
         err = hfsplus_find_attr(inode->i_sb, inode->i_ino, NULL, &fd);
         if (err) {
                 if (err == -ENOENT) {
@@ -692,7 +699,7 @@ ssize_t hfsplus_listxattr(struct dentry *dentry, char *buffer, size_t size)
                 if (be32_to_cpu(attr_key.cnid) != inode->i_ino)
                         goto end_listxattr;
 
-                xattr_name_len = HFSPLUS_ATTR_MAX_STRLEN;
+                xattr_name_len = NLS_MAX_CHARSET_SIZE * HFSPLUS_ATTR_MAX_STRLEN;
                 if (hfsplus_uni2asc(inode->i_sb,
                         (const struct hfsplus_unistr *)&fd.key->attr.key_name,
                                         strbuf, &xattr_name_len)) {
@@ -718,6 +725,8 @@ ssize_t hfsplus_listxattr(struct dentry *dentry, char *buffer, size_t size)
         }
 
 end_listxattr:
+        kfree(strbuf);
+out:
         hfs_find_exit(&fd);
         return res;
 }
@@ -797,47 +806,55 @@ end_removexattr:
 static int hfsplus_osx_getxattr(struct dentry *dentry, const char *name,
                                         void *buffer, size_t size, int type)
 {
-        char xattr_name[HFSPLUS_ATTR_MAX_STRLEN +
-                                XATTR_MAC_OSX_PREFIX_LEN + 1] = {0};
-        size_t len = strlen(name);
+        char *xattr_name;
+        int res;
 
         if (!strcmp(name, ""))
                 return -EINVAL;
 
-        if (len > HFSPLUS_ATTR_MAX_STRLEN)
-                return -EOPNOTSUPP;
-
         /*
          * Don't allow retrieving properly prefixed attributes
          * by prepending them with "osx."
          */
         if (is_known_namespace(name))
                 return -EOPNOTSUPP;
+        xattr_name = kmalloc(NLS_MAX_CHARSET_SIZE * HFSPLUS_ATTR_MAX_STRLEN
+                + XATTR_MAC_OSX_PREFIX_LEN + 1, GFP_KERNEL);
+        if (!xattr_name)
+                return -ENOMEM;
+        strcpy(xattr_name, XATTR_MAC_OSX_PREFIX);
+        strcpy(xattr_name + XATTR_MAC_OSX_PREFIX_LEN, name);
 
-        return hfsplus_getxattr(dentry, xattr_name, buffer, size);
+        res = hfsplus_getxattr(dentry, xattr_name, buffer, size);
+        kfree(xattr_name);
+        return res;
 }
 
 static int hfsplus_osx_setxattr(struct dentry *dentry, const char *name,
                 const void *buffer, size_t size, int flags, int type)
 {
-        char xattr_name[HFSPLUS_ATTR_MAX_STRLEN +
-                                XATTR_MAC_OSX_PREFIX_LEN + 1] = {0};
-        size_t len = strlen(name);
+        char *xattr_name;
+        int res;
 
         if (!strcmp(name, ""))
                 return -EINVAL;
 
-        if (len > HFSPLUS_ATTR_MAX_STRLEN)
-                return -EOPNOTSUPP;
-
         /*
          * Don't allow setting properly prefixed attributes
          * by prepending them with "osx."
          */
         if (is_known_namespace(name))
                 return -EOPNOTSUPP;
+        xattr_name = kmalloc(NLS_MAX_CHARSET_SIZE * HFSPLUS_ATTR_MAX_STRLEN
+                + XATTR_MAC_OSX_PREFIX_LEN + 1, GFP_KERNEL);
+        if (!xattr_name)
+                return -ENOMEM;
+        strcpy(xattr_name, XATTR_MAC_OSX_PREFIX);
+        strcpy(xattr_name + XATTR_MAC_OSX_PREFIX_LEN, name);
 
-        return hfsplus_setxattr(dentry, xattr_name, buffer, size, flags);
+        res = hfsplus_setxattr(dentry, xattr_name, buffer, size, flags);
+        kfree(xattr_name);
+        return res;
 }
 
 static size_t hfsplus_osx_listxattr(struct dentry *dentry, char *list,
diff --git a/fs/hfsplus/xattr_security.c b/fs/hfsplus/xattr_security.c
index 00722765ea79..6ec5e107691f 100644
--- a/fs/hfsplus/xattr_security.c
+++ b/fs/hfsplus/xattr_security.c
@@ -7,6 +7,8 @@
  */
 
 #include <linux/security.h>
+#include <linux/nls.h>
+
 #include "hfsplus_fs.h"
 #include "xattr.h"
 #include "acl.h"
@@ -14,37 +16,43 @@
 static int hfsplus_security_getxattr(struct dentry *dentry, const char *name,
                                         void *buffer, size_t size, int type)
 {
-        char xattr_name[HFSPLUS_ATTR_MAX_STRLEN + 1] = {0};
-        size_t len = strlen(name);
+        char *xattr_name;
+        int res;
 
         if (!strcmp(name, ""))
                 return -EINVAL;
 
-        if (len + XATTR_SECURITY_PREFIX_LEN > HFSPLUS_ATTR_MAX_STRLEN)
-                return -EOPNOTSUPP;
-
+        xattr_name = kmalloc(NLS_MAX_CHARSET_SIZE * HFSPLUS_ATTR_MAX_STRLEN + 1,
+                GFP_KERNEL);
+        if (!xattr_name)
+                return -ENOMEM;
         strcpy(xattr_name, XATTR_SECURITY_PREFIX);
         strcpy(xattr_name + XATTR_SECURITY_PREFIX_LEN, name);
 
-        return hfsplus_getxattr(dentry, xattr_name, buffer, size);
+        res = hfsplus_getxattr(dentry, xattr_name, buffer, size);
+        kfree(xattr_name);
+        return res;
 }
 
 static int hfsplus_security_setxattr(struct dentry *dentry, const char *name,
                 const void *buffer, size_t size, int flags, int type)
 {
-        char xattr_name[HFSPLUS_ATTR_MAX_STRLEN + 1] = {0};
-        size_t len = strlen(name);
+        char *xattr_name;
+        int res;
 
         if (!strcmp(name, ""))
                 return -EINVAL;
 
-        if (len + XATTR_SECURITY_PREFIX_LEN > HFSPLUS_ATTR_MAX_STRLEN)
-                return -EOPNOTSUPP;
-
+        xattr_name = kmalloc(NLS_MAX_CHARSET_SIZE * HFSPLUS_ATTR_MAX_STRLEN + 1,
+                GFP_KERNEL);
+        if (!xattr_name)
+                return -ENOMEM;
         strcpy(xattr_name, XATTR_SECURITY_PREFIX);
         strcpy(xattr_name + XATTR_SECURITY_PREFIX_LEN, name);
 
-        return hfsplus_setxattr(dentry, xattr_name, buffer, size, flags);
+        res = hfsplus_setxattr(dentry, xattr_name, buffer, size, flags);
+        kfree(xattr_name);
+        return res;
 }
 
 static size_t hfsplus_security_listxattr(struct dentry *dentry, char *list,
@@ -62,31 +70,30 @@ static int hfsplus_initxattrs(struct inode *inode,
                                 void *fs_info)
 {
         const struct xattr *xattr;
-        char xattr_name[HFSPLUS_ATTR_MAX_STRLEN + 1] = {0};
-        size_t xattr_name_len;
+        char *xattr_name;
         int err = 0;
 
+        xattr_name = kmalloc(NLS_MAX_CHARSET_SIZE * HFSPLUS_ATTR_MAX_STRLEN + 1,
+                GFP_KERNEL);
+        if (!xattr_name)
+                return -ENOMEM;
         for (xattr = xattr_array; xattr->name != NULL; xattr++) {
-                xattr_name_len = strlen(xattr->name);
 
-                if (xattr_name_len == 0)
+                if (!strcmp(xattr->name, ""))
                         continue;
 
-                if (xattr_name_len + XATTR_SECURITY_PREFIX_LEN >
-                                HFSPLUS_ATTR_MAX_STRLEN)
-                        return -EOPNOTSUPP;
-
                 strcpy(xattr_name, XATTR_SECURITY_PREFIX);
                 strcpy(xattr_name +
                         XATTR_SECURITY_PREFIX_LEN, xattr->name);
                 memset(xattr_name +
-                        XATTR_SECURITY_PREFIX_LEN + xattr_name_len, 0, 1);
+                        XATTR_SECURITY_PREFIX_LEN + strlen(xattr->name), 0, 1);
 
                 err = __hfsplus_setxattr(inode, xattr_name,
                                         xattr->value, xattr->value_len, 0);
                 if (err)
                         break;
         }
+        kfree(xattr_name);
         return err;
 }
 
diff --git a/fs/hfsplus/xattr_trusted.c b/fs/hfsplus/xattr_trusted.c
index 426cee277542..3c5f27e4746a 100644
--- a/fs/hfsplus/xattr_trusted.c
+++ b/fs/hfsplus/xattr_trusted.c
@@ -6,43 +6,51 @@
  * Handler for trusted extended attributes.
  */
 
+#include <linux/nls.h>
+
 #include "hfsplus_fs.h"
 #include "xattr.h"
 
 static int hfsplus_trusted_getxattr(struct dentry *dentry, const char *name,
                                         void *buffer, size_t size, int type)
 {
-        char xattr_name[HFSPLUS_ATTR_MAX_STRLEN + 1] = {0};
-        size_t len = strlen(name);
+        char *xattr_name;
+        int res;
 
         if (!strcmp(name, ""))
                 return -EINVAL;
 
-        if (len + XATTR_TRUSTED_PREFIX_LEN > HFSPLUS_ATTR_MAX_STRLEN)
-                return -EOPNOTSUPP;
-
+        xattr_name = kmalloc(NLS_MAX_CHARSET_SIZE * HFSPLUS_ATTR_MAX_STRLEN + 1,
+                GFP_KERNEL);
+        if (!xattr_name)
+                return -ENOMEM;
         strcpy(xattr_name, XATTR_TRUSTED_PREFIX);
         strcpy(xattr_name + XATTR_TRUSTED_PREFIX_LEN, name);
 
-        return hfsplus_getxattr(dentry, xattr_name, buffer, size);
+        res = hfsplus_getxattr(dentry, xattr_name, buffer, size);
+        kfree(xattr_name);
+        return res;
 }
 
 static int hfsplus_trusted_setxattr(struct dentry *dentry, const char *name,
                 const void *buffer, size_t size, int flags, int type)
 {
-        char xattr_name[HFSPLUS_ATTR_MAX_STRLEN + 1] = {0};
-        size_t len = strlen(name);
+        char *xattr_name;
+        int res;
 
         if (!strcmp(name, ""))
                 return -EINVAL;
 
-        if (len + XATTR_TRUSTED_PREFIX_LEN > HFSPLUS_ATTR_MAX_STRLEN)
-                return -EOPNOTSUPP;
-
+        xattr_name = kmalloc(NLS_MAX_CHARSET_SIZE * HFSPLUS_ATTR_MAX_STRLEN + 1,
+                GFP_KERNEL);
+        if (!xattr_name)
+                return -ENOMEM;
         strcpy(xattr_name, XATTR_TRUSTED_PREFIX);
         strcpy(xattr_name + XATTR_TRUSTED_PREFIX_LEN, name);
 
-        return hfsplus_setxattr(dentry, xattr_name, buffer, size, flags);
+        res = hfsplus_setxattr(dentry, xattr_name, buffer, size, flags);
+        kfree(xattr_name);
+        return res;
 }
 
 static size_t hfsplus_trusted_listxattr(struct dentry *dentry, char *list,
diff --git a/fs/hfsplus/xattr_user.c b/fs/hfsplus/xattr_user.c
index e34016561ae0..2b625a538b64 100644
--- a/fs/hfsplus/xattr_user.c
+++ b/fs/hfsplus/xattr_user.c
@@ -6,43 +6,51 @@
  * Handler for user extended attributes.
  */
 
+#include <linux/nls.h>
+
 #include "hfsplus_fs.h"
 #include "xattr.h"
 
 static int hfsplus_user_getxattr(struct dentry *dentry, const char *name,
                                         void *buffer, size_t size, int type)
 {
-        char xattr_name[HFSPLUS_ATTR_MAX_STRLEN + 1] = {0};
-        size_t len = strlen(name);
+        char *xattr_name;
+        int res;
 
         if (!strcmp(name, ""))
                 return -EINVAL;
 
-        if (len + XATTR_USER_PREFIX_LEN > HFSPLUS_ATTR_MAX_STRLEN)
-                return -EOPNOTSUPP;
-
+        xattr_name = kmalloc(NLS_MAX_CHARSET_SIZE * HFSPLUS_ATTR_MAX_STRLEN + 1,
+                GFP_KERNEL);
+        if (!xattr_name)
+                return -ENOMEM;
         strcpy(xattr_name, XATTR_USER_PREFIX);
         strcpy(xattr_name + XATTR_USER_PREFIX_LEN, name);
 
-        return hfsplus_getxattr(dentry, xattr_name, buffer, size);
+        res = hfsplus_getxattr(dentry, xattr_name, buffer, size);
+        kfree(xattr_name);
+        return res;
 }
 
 static int hfsplus_user_setxattr(struct dentry *dentry, const char *name,
                 const void *buffer, size_t size, int flags, int type)
 {
-        char xattr_name[HFSPLUS_ATTR_MAX_STRLEN + 1] = {0};
-        size_t len = strlen(name);
+        char *xattr_name;
+        int res;
 
         if (!strcmp(name, ""))
                 return -EINVAL;
 
-        if (len + XATTR_USER_PREFIX_LEN > HFSPLUS_ATTR_MAX_STRLEN)
-                return -EOPNOTSUPP;
-
+        xattr_name = kmalloc(NLS_MAX_CHARSET_SIZE * HFSPLUS_ATTR_MAX_STRLEN + 1,
+                GFP_KERNEL);
+        if (!xattr_name)
+                return -ENOMEM;
         strcpy(xattr_name, XATTR_USER_PREFIX);
         strcpy(xattr_name + XATTR_USER_PREFIX_LEN, name);
 
-        return hfsplus_setxattr(dentry, xattr_name, buffer, size, flags);
+        res = hfsplus_setxattr(dentry, xattr_name, buffer, size, flags);
+        kfree(xattr_name);
+        return res;
 }
 
 static size_t hfsplus_user_listxattr(struct dentry *dentry, char *list,
diff --git a/fs/hpfs/alloc.c b/fs/hpfs/alloc.c
index 58b5106186d0..f005046e1591 100644
--- a/fs/hpfs/alloc.c
+++ b/fs/hpfs/alloc.c
@@ -316,7 +316,7 @@ void hpfs_free_sectors(struct super_block *s, secno sec, unsigned n)
         struct quad_buffer_head qbh;
         __le32 *bmp;
         struct hpfs_sb_info *sbi = hpfs_sb(s);
-        /*printk("2 - ");*/
+        /*pr_info("2 - ");*/
         if (!n) return;
         if (sec < 0x12) {
                 hpfs_error(s, "Trying to free reserved sector %08x", sec);
diff --git a/fs/hpfs/buffer.c b/fs/hpfs/buffer.c
index 139ef1684d07..8057fe4e6574 100644
--- a/fs/hpfs/buffer.c
+++ b/fs/hpfs/buffer.c
@@ -55,7 +55,7 @@ void *hpfs_map_sector(struct super_block *s, unsigned secno, struct buffer_head
         if (bh != NULL)
                 return bh->b_data;
         else {
-                printk("HPFS: hpfs_map_sector: read error\n");
+                pr_err("%s(): read error\n", __func__);
                 return NULL;
         }
 }
@@ -76,7 +76,7 @@ void *hpfs_get_sector(struct super_block *s, unsigned secno, struct buffer_head
                 set_buffer_uptodate(bh);
                 return bh->b_data;
         } else {
-                printk("HPFS: hpfs_get_sector: getblk failed\n");
+                pr_err("%s(): getblk failed\n", __func__);
                 return NULL;
         }
 }
@@ -93,7 +93,7 @@ void *hpfs_map_4sectors(struct super_block *s, unsigned secno, struct quad_buffe
         cond_resched();
 
         if (secno & 3) {
-                printk("HPFS: hpfs_map_4sectors: unaligned read\n");
+                pr_err("%s(): unaligned read\n", __func__);
                 return NULL;
         }
 
@@ -112,7 +112,7 @@ void *hpfs_map_4sectors(struct super_block *s, unsigned secno, struct quad_buffe
 
         qbh->data = data = kmalloc(2048, GFP_NOFS);
         if (!data) {
-                printk("HPFS: hpfs_map_4sectors: out of memory\n");
+                pr_err("%s(): out of memory\n", __func__);
                 goto bail4;
         }
 
@@ -145,7 +145,7 @@ void *hpfs_get_4sectors(struct super_block *s, unsigned secno,
         hpfs_lock_assert(s);
 
         if (secno & 3) {
-                printk("HPFS: hpfs_get_4sectors: unaligned read\n");
+                pr_err("%s(): unaligned read\n", __func__);
                 return NULL;
         }
 
@@ -161,7 +161,7 @@ void *hpfs_get_4sectors(struct super_block *s, unsigned secno,
         }
 
         if (!(qbh->data = kmalloc(2048, GFP_NOFS))) {
-                printk("HPFS: hpfs_get_4sectors: out of memory\n");
+                pr_err("%s(): out of memory\n", __func__);
                 goto bail4;
         }
         return qbh->data;
diff --git a/fs/hpfs/dir.c b/fs/hpfs/dir.c
index 292b1acb9b81..2a8e07425de0 100644
--- a/fs/hpfs/dir.c
+++ b/fs/hpfs/dir.c
@@ -36,7 +36,7 @@ static loff_t hpfs_dir_lseek(struct file *filp, loff_t off, int whence)
         mutex_lock(&i->i_mutex);
         hpfs_lock(s);
 
-        /*printk("dir lseek\n");*/
+        /*pr_info("dir lseek\n");*/
         if (new_off == 0 || new_off == 1 || new_off == 11 || new_off == 12 || new_off == 13) goto ok;
         pos = ((loff_t) hpfs_de_as_down_as_possible(s, hpfs_inode->i_dno) << 4) + 1;
         while (pos != new_off) {
@@ -51,7 +51,7 @@ ok:
         mutex_unlock(&i->i_mutex);
         return new_off;
 fail:
-        /*printk("illegal lseek: %016llx\n", new_off);*/
+        /*pr_warn("illegal lseek: %016llx\n", new_off);*/
         hpfs_unlock(s);
         mutex_unlock(&i->i_mutex);
         return -ESPIPE;
@@ -127,7 +127,7 @@ static int hpfs_readdir(struct file *file, struct dir_context *ctx)
                 if (ctx->pos == 12)
                         goto out;
                 if (ctx->pos == 3 || ctx->pos == 4 || ctx->pos == 5) {
-                        printk("HPFS: warning: pos==%d\n",(int)ctx->pos);
+                        pr_err("pos==%d\n", (int)ctx->pos);
                         goto out;
                 }
                 if (ctx->pos == 0) {
diff --git a/fs/hpfs/dnode.c b/fs/hpfs/dnode.c
index 4364b2a02c5d..f36fc010fccb 100644
--- a/fs/hpfs/dnode.c
+++ b/fs/hpfs/dnode.c
@@ -17,7 +17,7 @@ static loff_t get_pos(struct dnode *d, struct hpfs_dirent *fde)
                 if (de == fde) return ((loff_t) le32_to_cpu(d->self) << 4) | (loff_t)i;
                 i++;
         }
-        printk("HPFS: get_pos: not_found\n");
+        pr_info("%s(): not_found\n", __func__);
         return ((loff_t)le32_to_cpu(d->self) << 4) | (loff_t)1;
 }
 
@@ -32,7 +32,7 @@ void hpfs_add_pos(struct inode *inode, loff_t *pos)
                         if (hpfs_inode->i_rddir_off[i] == pos) return;
         if (!(i&0x0f)) {
                 if (!(ppos = kmalloc((i+0x11) * sizeof(loff_t*), GFP_NOFS))) {
-                        printk("HPFS: out of memory for position list\n");
+                        pr_err("out of memory for position list\n");
                         return;
                 }
                 if (hpfs_inode->i_rddir_off) {
@@ -63,7 +63,8 @@ void hpfs_del_pos(struct inode *inode, loff_t *pos)
         }
         return;
         not_f:
-        /*printk("HPFS: warning: position pointer %p->%08x not found\n", pos, (int)*pos);*/
+        /*pr_warn("position pointer %p->%08x not found\n",
+                  pos, (int)*pos);*/
         return;
 }
 
@@ -92,8 +93,11 @@ static void hpfs_pos_ins(loff_t *p, loff_t d, loff_t c)
 {
         if ((*p & ~0x3f) == (d & ~0x3f) && (*p & 0x3f) >= (d & 0x3f)) {
                 int n = (*p & 0x3f) + c;
-                if (n > 0x3f) printk("HPFS: hpfs_pos_ins: %08x + %d\n", (int)*p, (int)c >> 8);
-                else *p = (*p & ~0x3f) | n;
+                if (n > 0x3f)
+                        pr_err("%s(): %08x + %d\n",
+                                __func__, (int)*p, (int)c >> 8);
+                else
+                        *p = (*p & ~0x3f) | n;
         }
 }
 
@@ -101,8 +105,11 @@ static void hpfs_pos_del(loff_t *p, loff_t d, loff_t c)
 {
         if ((*p & ~0x3f) == (d & ~0x3f) && (*p & 0x3f) >= (d & 0x3f)) {
                 int n = (*p & 0x3f) - c;
-                if (n < 1) printk("HPFS: hpfs_pos_ins: %08x - %d\n", (int)*p, (int)c >> 8);
-                else *p = (*p & ~0x3f) | n;
+                if (n < 1)
+                        pr_err("%s(): %08x - %d\n",
+                                __func__, (int)*p, (int)c >> 8);
+                else
+                        *p = (*p & ~0x3f) | n;
         }
 }
 
@@ -239,12 +246,12 @@ static int hpfs_add_to_dnode(struct inode *i, dnode_secno dno,
         struct fnode *fnode;
         int c1, c2 = 0;
         if (!(nname = kmalloc(256, GFP_NOFS))) {
-                printk("HPFS: out of memory, can't add to dnode\n");
+                pr_err("out of memory, can't add to dnode\n");
                 return 1;
         }
         go_up:
         if (namelen >= 256) {
-                hpfs_error(i->i_sb, "hpfs_add_to_dnode: namelen == %d", namelen);
+                hpfs_error(i->i_sb, "%s(): namelen == %d", __func__, namelen);
                 kfree(nd);
                 kfree(nname);
                 return 1;
@@ -281,7 +288,7 @@ static int hpfs_add_to_dnode(struct inode *i, dnode_secno dno,
                    not be any error while splitting dnodes, otherwise the
                    whole directory, not only file we're adding, would
                    be lost. */
-                printk("HPFS: out of memory for dnode splitting\n");
+                pr_err("out of memory for dnode splitting\n");
                 hpfs_brelse4(&qbh);
                 kfree(nname);
                 return 1;
@@ -597,7 +604,7 @@ static void delete_empty_dnode(struct inode *i, dnode_secno dno)
                 if (!de_next->down) goto endm;
                 ndown = de_down_pointer(de_next);
                 if (!(de_cp = kmalloc(le16_to_cpu(de->length), GFP_NOFS))) {
-                        printk("HPFS: out of memory for dtree balancing\n");
+                        pr_err("out of memory for dtree balancing\n");
                         goto endm;
                 }
                 memcpy(de_cp, de, le16_to_cpu(de->length));
@@ -612,7 +619,8 @@ static void delete_empty_dnode(struct inode *i, dnode_secno dno)
                         hpfs_brelse4(&qbh1);
                 }
                 hpfs_add_to_dnode(i, ndown, de_cp->name, de_cp->namelen, de_cp, de_cp->down ? de_down_pointer(de_cp) : 0);
-                /*printk("UP-TO-DNODE: %08x (ndown = %08x, down = %08x, dno = %08x)\n", up, ndown, down, dno);*/
+                /*pr_info("UP-TO-DNODE: %08x (ndown = %08x, down = %08x, dno = %08x)\n",
+                  up, ndown, down, dno);*/
                 dno = up;
                 kfree(de_cp);
                 goto try_it_again;
@@ -637,15 +645,15 @@ static void delete_empty_dnode(struct inode *i, dnode_secno dno)
                         if (!dlp && down) {
                                 if (le32_to_cpu(d1->first_free) > 2044) {
                                         if (hpfs_sb(i->i_sb)->sb_chk >= 2) {
-                                                printk("HPFS: warning: unbalanced dnode tree, see hpfs.txt 4 more info\n");
-                                                printk("HPFS: warning: terminating balancing operation\n");
+                                                pr_err("unbalanced dnode tree, see hpfs.txt 4 more info\n");
+                                                pr_err("terminating balancing operation\n");
                                         }
                                         hpfs_brelse4(&qbh1);
                                         goto endm;
                                 }
                                 if (hpfs_sb(i->i_sb)->sb_chk >= 2) {
-                                        printk("HPFS: warning: unbalanced dnode tree, see hpfs.txt 4 more info\n");
-                                        printk("HPFS: warning: goin'on\n");
+                                        pr_err("unbalanced dnode tree, see hpfs.txt 4 more info\n");
+                                        pr_err("goin'on\n");
                                 }
                                 le16_add_cpu(&del->length, 4);
                                 del->down = 1;
@@ -659,7 +667,7 @@ static void delete_empty_dnode(struct inode *i, dnode_secno dno)
                                 *(__le32 *) ((void *) del + le16_to_cpu(del->length) - 4) = cpu_to_le32(down);
                 } else goto endm;
                 if (!(de_cp = kmalloc(le16_to_cpu(de_prev->length), GFP_NOFS))) {
-                        printk("HPFS: out of memory for dtree balancing\n");
+                        pr_err("out of memory for dtree balancing\n");
                         hpfs_brelse4(&qbh1);
                         goto endm;
                 }
@@ -1000,7 +1008,7 @@ struct hpfs_dirent *map_fnode_dirent(struct super_block *s, fnode_secno fno,
         int d1, d2 = 0;
         name1 = f->name;
         if (!(name2 = kmalloc(256, GFP_NOFS))) {
-                printk("HPFS: out of memory, can't map dirent\n");
+                pr_err("out of memory, can't map dirent\n");
                 return NULL;
         }
         if (f->len <= 15)
diff --git a/fs/hpfs/ea.c b/fs/hpfs/ea.c
index bcaafcd2666a..ce3f98ba993a 100644
--- a/fs/hpfs/ea.c
+++ b/fs/hpfs/ea.c
@@ -51,7 +51,7 @@ static char *get_indirect_ea(struct super_block *s, int ano, secno a, int size)
 {
         char *ret;
         if (!(ret = kmalloc(size + 1, GFP_NOFS))) {
-                printk("HPFS: out of memory for EA\n");
+                pr_err("out of memory for EA\n");
                 return NULL;
         }
         if (hpfs_ea_read(s, a, ano, 0, size, ret)) {
@@ -139,7 +139,7 @@ char *hpfs_get_ea(struct super_block *s, struct fnode *fnode, char *key, int *si
                         if (ea_indirect(ea))
                                 return get_indirect_ea(s, ea_in_anode(ea), ea_sec(ea), *size = ea_len(ea));
                         if (!(ret = kmalloc((*size = ea_valuelen(ea)) + 1, GFP_NOFS))) {
-                                printk("HPFS: out of memory for EA\n");
+                                pr_err("out of memory for EA\n");
                                 return NULL;
                         }
                         memcpy(ret, ea_data(ea), ea_valuelen(ea));
@@ -165,7 +165,7 @@ char *hpfs_get_ea(struct super_block *s, struct fnode *fnode, char *key, int *si
                         if (ea_indirect(ea))
                                 return get_indirect_ea(s, ea_in_anode(ea), ea_sec(ea), *size = ea_len(ea));
                         if (!(ret = kmalloc((*size = ea_valuelen(ea)) + 1, GFP_NOFS))) {
-                                printk("HPFS: out of memory for EA\n");
+                                pr_err("out of memory for EA\n");
                                 return NULL;
                         }
                         if (hpfs_ea_read(s, a, ano, pos + 4 + ea->namelen + 1, ea_valuelen(ea), ret)) {
diff --git a/fs/hpfs/hpfs_fn.h b/fs/hpfs/hpfs_fn.h
index 3ba49c080e42..b63b75fa00e7 100644
--- a/fs/hpfs/hpfs_fn.h
+++ b/fs/hpfs/hpfs_fn.h
@@ -8,6 +8,11 @@
 
 //#define DBG
 //#define DEBUG_LOCKS
+#ifdef pr_fmt
+#undef pr_fmt
+#endif
+
+#define pr_fmt(fmt) KBUILD_MODNAME ": " fmt
 
 #include <linux/mutex.h>
 #include <linux/pagemap.h>
diff --git a/fs/hpfs/inode.c b/fs/hpfs/inode.c
index 50a427313835..7ce4b74234a1 100644
--- a/fs/hpfs/inode.c
+++ b/fs/hpfs/inode.c
@@ -183,7 +183,8 @@ void hpfs_write_inode(struct inode *i)
         struct inode *parent;
         if (i->i_ino == hpfs_sb(i->i_sb)->sb_root) return;
         if (hpfs_inode->i_rddir_off && !atomic_read(&i->i_count)) {
-                if (*hpfs_inode->i_rddir_off) printk("HPFS: write_inode: some position still there\n");
+                if (*hpfs_inode->i_rddir_off)
+                        pr_err("write_inode: some position still there\n");
                 kfree(hpfs_inode->i_rddir_off);
                 hpfs_inode->i_rddir_off = NULL;
         }
diff --git a/fs/hpfs/map.c b/fs/hpfs/map.c
index 3aa66ae1031e..442770edcdc7 100644
--- a/fs/hpfs/map.c
+++ b/fs/hpfs/map.c
@@ -65,12 +65,13 @@ unsigned char *hpfs_load_code_page(struct super_block *s, secno cps)
         struct code_page_directory *cp = hpfs_map_sector(s, cps, &bh, 0);
         if (!cp) return NULL;
         if (le32_to_cpu(cp->magic) != CP_DIR_MAGIC) {
-                printk("HPFS: Code page directory magic doesn't match (magic = %08x)\n", le32_to_cpu(cp->magic));
+                pr_err("Code page directory magic doesn't match (magic = %08x)\n",
+                        le32_to_cpu(cp->magic));
                 brelse(bh);
                 return NULL;
         }
         if (!le32_to_cpu(cp->n_code_pages)) {
-                printk("HPFS: n_code_pages == 0\n");
+                pr_err("n_code_pages == 0\n");
                 brelse(bh);
                 return NULL;
         }
@@ -79,19 +80,19 @@ unsigned char *hpfs_load_code_page(struct super_block *s, secno cps)
         brelse(bh);
 
         if (cpi >= 3) {
-                printk("HPFS: Code page index out of array\n");
+                pr_err("Code page index out of array\n");
                 return NULL;
         }
         
         if (!(cpd = hpfs_map_sector(s, cpds, &bh, 0))) return NULL;
         if (le16_to_cpu(cpd->offs[cpi]) > 0x178) {
-                printk("HPFS: Code page index out of sector\n");
+                pr_err("Code page index out of sector\n");
                 brelse(bh);
                 return NULL;
         }
         ptr = (unsigned char *)cpd + le16_to_cpu(cpd->offs[cpi]) + 6;
         if (!(cp_table = kmalloc(256, GFP_KERNEL))) {
-                printk("HPFS: out of memory for code page table\n");
+                pr_err("out of memory for code page table\n");
                 brelse(bh);
                 return NULL;
         }
@@ -114,7 +115,7 @@ __le32 *hpfs_load_bitmap_directory(struct super_block *s, secno bmp)
         int i;
         __le32 *b;
         if (!(b = kmalloc(n * 512, GFP_KERNEL))) {
-                printk("HPFS: can't allocate memory for bitmap directory\n");
+                pr_err("can't allocate memory for bitmap directory\n");
                 return NULL;
         }       
         for (i=0;i<n;i++) {
@@ -281,7 +282,9 @@ struct dnode *hpfs_map_dnode(struct super_block *s, unsigned secno,
                                 hpfs_error(s, "dnode %08x does not end with \\377 entry", secno);
                                 goto bail;
                         }
-                        if (b == 3) printk("HPFS: warning: unbalanced dnode tree, dnode %08x; see hpfs.txt 4 more info\n", secno);
+                        if (b == 3)
+                                pr_err("unbalanced dnode tree, dnode %08x; see hpfs.txt 4 more info\n",
+                                        secno);
                 }
         return dnode;
         bail:
diff --git a/fs/hpfs/name.c b/fs/hpfs/name.c
index 9acdf338def0..b00d396d22c6 100644
--- a/fs/hpfs/name.c
+++ b/fs/hpfs/name.c
@@ -56,14 +56,15 @@ unsigned char *hpfs_translate_name(struct super_block *s, unsigned char *from,
         unsigned char *to;
         int i;
         if (hpfs_sb(s)->sb_chk >= 2) if (hpfs_is_name_long(from, len) != lng) {
-                printk("HPFS: Long name flag mismatch - name ");
-                for (i=0; i<len; i++) printk("%c", from[i]);
-                printk(" misidentified as %s.\n", lng ? "short" : "long");
-                printk("HPFS: It's nothing serious. It could happen because of bug in OS/2.\nHPFS: Set checks=normal to disable this message.\n");
+                pr_err("Long name flag mismatch - name ");
+                for (i = 0; i < len; i++)
+                        pr_cont("%c", from[i]);
+                pr_cont(" misidentified as %s.\n", lng ? "short" : "long");
+                pr_err("It's nothing serious. It could happen because of bug in OS/2.\nSet checks=normal to disable this message.\n");
         }
         if (!lc) return from;
         if (!(to = kmalloc(len, GFP_KERNEL))) {
-                printk("HPFS: can't allocate memory for name conversion buffer\n");
+                pr_err("can't allocate memory for name conversion buffer\n");
                 return from;
         }
         for (i = 0; i < len; i++) to[i] = locase(hpfs_sb(s)->sb_cp_table,from[i]);
diff --git a/fs/hpfs/namei.c b/fs/hpfs/namei.c
index 1b39afdd86fd..bdbc2c3080a4 100644
--- a/fs/hpfs/namei.c
+++ b/fs/hpfs/namei.c
@@ -404,7 +404,7 @@ again:
                         d_rehash(dentry);
                 } else {
                         struct iattr newattrs;
-                        /*printk("HPFS: truncating file before delete.\n");*/
+                        /*pr_info("truncating file before delete.\n");*/
                         newattrs.ia_size = 0;
                         newattrs.ia_valid = ATTR_SIZE | ATTR_CTIME;
                         err = notify_change(dentry, &newattrs, NULL);
diff --git a/fs/hpfs/super.c b/fs/hpfs/super.c
index fe3463a43236..7cd00d3a7c9b 100644
--- a/fs/hpfs/super.c
+++ b/fs/hpfs/super.c
@@ -62,22 +62,26 @@ void hpfs_error(struct super_block *s, const char *fmt, ...)
         vsnprintf(err_buf, sizeof(err_buf), fmt, args);
         va_end(args);
 
-        printk("HPFS: filesystem error: %s", err_buf);
+        pr_err("filesystem error: %s", err_buf);
         if (!hpfs_sb(s)->sb_was_error) {
                 if (hpfs_sb(s)->sb_err == 2) {
-                        printk("; crashing the system because you wanted it\n");
+                        pr_cont("; crashing the system because you wanted it\n");
                         mark_dirty(s, 0);
                         panic("HPFS panic");
                 } else if (hpfs_sb(s)->sb_err == 1) {
-                        if (s->s_flags & MS_RDONLY) printk("; already mounted read-only\n");
+                        if (s->s_flags & MS_RDONLY)
+                                pr_cont("; already mounted read-only\n");
                         else {
-                                printk("; remounting read-only\n");
+                                pr_cont("; remounting read-only\n");
                                 mark_dirty(s, 0);
                                 s->s_flags |= MS_RDONLY;
                         }
-                } else if (s->s_flags & MS_RDONLY) printk("; going on - but anything won't be destroyed because it's read-only\n");
-                else printk("; corrupted filesystem mounted read/write - your computer will explode within 20 seconds ... but you wanted it so!\n");
-        } else printk("\n");
+                } else if (s->s_flags & MS_RDONLY)
+                                pr_cont("; going on - but anything won't be destroyed because it's read-only\n");
+                else
+                        pr_cont("; corrupted filesystem mounted read/write - your computer will explode within 20 seconds ... but you wanted it so!\n");
+        } else
+                pr_cont("\n");
         hpfs_sb(s)->sb_was_error = 1;
 }
 
@@ -292,7 +296,7 @@ static int parse_opts(char *opts, kuid_t *uid, kgid_t *gid, umode_t *umask,
         if (!opts)
                 return 1;
 
-        /*printk("Parsing opts: '%s'\n",opts);*/
+        /*pr_info("Parsing opts: '%s'\n",opts);*/
 
         while ((p = strsep(&opts, ",")) != NULL) {
                 substring_t args[MAX_OPT_ARGS];
@@ -387,7 +391,7 @@ static int parse_opts(char *opts, kuid_t *uid, kgid_t *gid, umode_t *umask,
 
 static inline void hpfs_help(void)
 {
-        printk("\n\
+        pr_info("\n\
 HPFS filesystem options:\n\
       help              do not mount and display this text\n\
       uid=xxx           set uid of files that don't have uid specified in eas\n\
@@ -434,7 +438,7 @@ static int hpfs_remount_fs(struct super_block *s, int *flags, char *data)
 
         if (!(o = parse_opts(data, &uid, &gid, &umask, &lowercase,
             &eas, &chk, &errs, &chkdsk, &timeshift))) {
-                printk("HPFS: bad mount options.\n");
+                pr_err("bad mount options.\n");
                 goto out_err;
         }
         if (o == 2) {
@@ -442,7 +446,7 @@ static int hpfs_remount_fs(struct super_block *s, int *flags, char *data)
                 goto out_err;
         }
         if (timeshift != sbi->sb_timeshift) {
-                printk("HPFS: timeshift can't be changed using remount.\n");
+                pr_err("timeshift can't be changed using remount.\n");
                 goto out_err;
         }
 
@@ -523,7 +527,7 @@ static int hpfs_fill_super(struct super_block *s, void *options, int silent)
 
         if (!(o = parse_opts(options, &uid, &gid, &umask, &lowercase,
             &eas, &chk, &errs, &chkdsk, &timeshift))) {
-                printk("HPFS: bad mount options.\n");
+                pr_err("bad mount options.\n");
                 goto bail0;
         }
         if (o==2) {
@@ -542,16 +546,17 @@ static int hpfs_fill_super(struct super_block *s, void *options, int silent)
         if (/*le16_to_cpu(bootblock->magic) != BB_MAGIC
             ||*/ le32_to_cpu(superblock->magic) != SB_MAGIC
             || le32_to_cpu(spareblock->magic) != SP_MAGIC) {
-                if (!silent) printk("HPFS: Bad magic ... probably not HPFS\n");
+                if (!silent)
+                        pr_err("Bad magic ... probably not HPFS\n");
                 goto bail4;
         }
 
         /* Check version */
         if (!(s->s_flags & MS_RDONLY) &&
               superblock->funcversion != 2 && superblock->funcversion != 3) {
-                printk("HPFS: Bad version %d,%d. Mount readonly to go around\n",
+                pr_err("Bad version %d,%d. Mount readonly to go around\n",
                         (int)superblock->version, (int)superblock->funcversion);
-                printk("HPFS: please try recent version of HPFS driver at http://artax.karlin.mff.cuni.cz/~mikulas/vyplody/hpfs/index-e.cgi and if it still can't understand this format, contact author - mikulas@artax.karlin.mff.cuni.cz\n");
+                pr_err("please try recent version of HPFS driver at http://artax.karlin.mff.cuni.cz/~mikulas/vyplody/hpfs/index-e.cgi and if it still can't understand this format, contact author - mikulas@artax.karlin.mff.cuni.cz\n");
                 goto bail4;
         }
 
@@ -597,7 +602,7 @@ static int hpfs_fill_super(struct super_block *s, void *options, int silent)
         /* Check for general fs errors*/
         if (spareblock->dirty && !spareblock->old_wrote) {
                 if (errs == 2) {
-                        printk("HPFS: Improperly stopped, not mounted\n");
+                        pr_err("Improperly stopped, not mounted\n");
                         goto bail4;
                 }
                 hpfs_error(s, "improperly stopped");
@@ -611,22 +616,25 @@ static int hpfs_fill_super(struct super_block *s, void *options, int silent)
 
         if (spareblock->hotfixes_used || spareblock->n_spares_used) {
                 if (errs >= 2) {
-                        printk("HPFS: Hotfixes not supported here, try chkdsk\n");
+                        pr_err("Hotfixes not supported here, try chkdsk\n");
                         mark_dirty(s, 0);
                         goto bail4;
                 }
                 hpfs_error(s, "hotfixes not supported here, try chkdsk");
-                if (errs == 0) printk("HPFS: Proceeding, but your filesystem will be probably corrupted by this driver...\n");
-                else printk("HPFS: This driver may read bad files or crash when operating on disk with hotfixes.\n");
+                if (errs == 0)
+                        pr_err("Proceeding, but your filesystem will be probably corrupted by this driver...\n");
+                else
+                        pr_err("This driver may read bad files or crash when operating on disk with hotfixes.\n");
         }
         if (le32_to_cpu(spareblock->n_dnode_spares) != le32_to_cpu(spareblock->n_dnode_spares_free)) {
                 if (errs >= 2) {
-                        printk("HPFS: Spare dnodes used, try chkdsk\n");
+                        pr_err("Spare dnodes used, try chkdsk\n");
                         mark_dirty(s, 0);
                         goto bail4;
                 }
                 hpfs_error(s, "warning: spare dnodes used, try chkdsk");
-                if (errs == 0) printk("HPFS: Proceeding, but your filesystem could be corrupted if you delete files or directories\n");
+                if (errs == 0)
+                        pr_err("Proceeding, but your filesystem could be corrupted if you delete files or directories\n");
         }
         if (chk) {
                 unsigned a;
@@ -645,12 +653,13 @@ static int hpfs_fill_super(struct super_block *s, void *options, int silent)
                         goto bail4;
                 }
                 sbi->sb_dirband_size = a;
-        } else printk("HPFS: You really don't want any checks? You are crazy...\n");
+        } else
+                pr_err("You really don't want any checks? You are crazy...\n");
 
         /* Load code page table */
         if (le32_to_cpu(spareblock->n_code_pages))
                 if (!(sbi->sb_cp_table = hpfs_load_code_page(s, le32_to_cpu(spareblock->code_page_dir))))
-                        printk("HPFS: Warning: code page support is disabled\n");
+                        pr_err("code page support is disabled\n");
 
         brelse(bh2);
         brelse(bh1);
diff --git a/fs/inode.c b/fs/inode.c
index f96d2a6f88cc..2feb9b69f1be 100644
--- a/fs/inode.c
+++ b/fs/inode.c
@@ -105,7 +105,7 @@ long get_nr_dirty_inodes(void)
  * Handle nr_inode sysctl
  */
 #ifdef CONFIG_SYSCTL
-int proc_nr_inodes(ctl_table *table, int write,
+int proc_nr_inodes(struct ctl_table *table, int write,
                    void __user *buffer, size_t *lenp, loff_t *ppos)
 {
         inodes_stat.nr_inodes = get_nr_inodes();
diff --git a/fs/jffs2/background.c b/fs/jffs2/background.c
index 2b60ce1996aa..bb9cebc9ca8a 100644
--- a/fs/jffs2/background.c
+++ b/fs/jffs2/background.c
@@ -75,10 +75,13 @@ void jffs2_stop_garbage_collect_thread(struct jffs2_sb_info *c)
 static int jffs2_garbage_collect_thread(void *_c)
 {
         struct jffs2_sb_info *c = _c;
+        sigset_t hupmask;
 
+        siginitset(&hupmask, sigmask(SIGHUP));
         allow_signal(SIGKILL);
         allow_signal(SIGSTOP);
         allow_signal(SIGCONT);
+        allow_signal(SIGHUP);
 
         c->gc_task = current;
         complete(&c->gc_thread_start);
@@ -87,7 +90,7 @@ static int jffs2_garbage_collect_thread(void *_c)
 
         set_freezable();
         for (;;) {
-                allow_signal(SIGHUP);
+                sigprocmask(SIG_UNBLOCK, &hupmask, NULL);
         again:
                 spin_lock(&c->erase_completion_lock);
                 if (!jffs2_thread_should_wake(c)) {
@@ -95,10 +98,9 @@ static int jffs2_garbage_collect_thread(void *_c)
                         spin_unlock(&c->erase_completion_lock);
                         jffs2_dbg(1, "%s(): sleeping...\n", __func__);
                         schedule();
-                } else
+                } else {
                         spin_unlock(&c->erase_completion_lock);
-                        
-
+                }
                 /* Problem - immediately after bootup, the GCD spends a lot
                  * of time in places like jffs2_kill_fragtree(); so much so
                  * that userspace processes (like gdm and X) are starved
@@ -150,7 +152,7 @@ static int jffs2_garbage_collect_thread(void *_c)
                         }
                 }
                 /* We don't want SIGHUP to interrupt us. STOP and KILL are OK though. */
-                disallow_signal(SIGHUP);
+                sigprocmask(SIG_BLOCK, &hupmask, NULL);
 
                 jffs2_dbg(1, "%s(): pass\n", __func__);
                 if (jffs2_garbage_collect_pass(c) == -ENOSPC) {
diff --git a/fs/lockd/svc.c b/fs/lockd/svc.c
index 6bf06a07f3e0..de051cb1f553 100644
--- a/fs/lockd/svc.c
+++ b/fs/lockd/svc.c
@@ -436,7 +436,7 @@ EXPORT_SYMBOL_GPL(lockd_down);
  * Sysctl parameters (same as module parameters, different interface).
  */
 
-static ctl_table nlm_sysctls[] = {
+static struct ctl_table nlm_sysctls[] = {
         {
                 .procname       = "nlm_grace_period",
                 .data           = &nlm_grace_period,
@@ -490,7 +490,7 @@ static ctl_table nlm_sysctls[] = {
         { }
 };
 
-static ctl_table nlm_sysctl_dir[] = {
+static struct ctl_table nlm_sysctl_dir[] = {
         {
                 .procname       = "nfs",
                 .mode           = 0555,
@@ -499,7 +499,7 @@ static ctl_table nlm_sysctl_dir[] = {
         { }
 };
 
-static ctl_table nlm_sysctl_root[] = {
+static struct ctl_table nlm_sysctl_root[] = {
         {
                 .procname       = "fs",
                 .mode           = 0555,
diff --git a/fs/nfs/nfs4sysctl.c b/fs/nfs/nfs4sysctl.c
index 2628d921b7e3..b6ebe7e445f6 100644
--- a/fs/nfs/nfs4sysctl.c
+++ b/fs/nfs/nfs4sysctl.c
@@ -16,7 +16,7 @@ static const int nfs_set_port_min = 0;
 static const int nfs_set_port_max = 65535;
 static struct ctl_table_header *nfs4_callback_sysctl_table;
 
-static ctl_table nfs4_cb_sysctls[] = {
+static struct ctl_table nfs4_cb_sysctls[] = {
         {
                 .procname = "nfs_callback_tcpport",
                 .data = &nfs_callback_set_tcpport,
@@ -36,7 +36,7 @@ static ctl_table nfs4_cb_sysctls[] = {
         { }
 };
 
-static ctl_table nfs4_cb_sysctl_dir[] = {
+static struct ctl_table nfs4_cb_sysctl_dir[] = {
         {
                 .procname = "nfs",
                 .mode = 0555,
@@ -45,7 +45,7 @@ static ctl_table nfs4_cb_sysctl_dir[] = {
         { }
 };
 
-static ctl_table nfs4_cb_sysctl_root[] = {
+static struct ctl_table nfs4_cb_sysctl_root[] = {
         {
                 .procname = "fs",
                 .mode = 0555,
diff --git a/fs/nfs/sysctl.c b/fs/nfs/sysctl.c
index 6b3f2535a3ec..bb6ed810fa6f 100644
--- a/fs/nfs/sysctl.c
+++ b/fs/nfs/sysctl.c
@@ -13,7 +13,7 @@
 
 static struct ctl_table_header *nfs_callback_sysctl_table;
 
-static ctl_table nfs_cb_sysctls[] = {
+static struct ctl_table nfs_cb_sysctls[] = {
         {
                 .procname       = "nfs_mountpoint_timeout",
                 .data           = &nfs_mountpoint_expiry_timeout,
@@ -31,7 +31,7 @@ static ctl_table nfs_cb_sysctls[] = {
         { }
 };
 
-static ctl_table nfs_cb_sysctl_dir[] = {
+static struct ctl_table nfs_cb_sysctl_dir[] = {
         {
                 .procname = "nfs",
                 .mode = 0555,
@@ -40,7 +40,7 @@ static ctl_table nfs_cb_sysctl_dir[] = {
         { }
 };
 
-static ctl_table nfs_cb_sysctl_root[] = {
+static struct ctl_table nfs_cb_sysctl_root[] = {
         {
                 .procname = "fs",
                 .mode = 0555,
diff --git a/fs/notify/inotify/inotify_user.c b/fs/notify/inotify/inotify_user.c
index 78a2ca3966c3..cc423a30a0c8 100644
--- a/fs/notify/inotify/inotify_user.c
+++ b/fs/notify/inotify/inotify_user.c
@@ -57,7 +57,7 @@ static struct kmem_cache *inotify_inode_mark_cachep __read_mostly;
 
 static int zero;
 
-ctl_table inotify_table[] = {
+struct ctl_table inotify_table[] = {
         {
                 .procname       = "max_user_instances",
                 .data           = &inotify_max_user_instances,
diff --git a/fs/ntfs/sysctl.c b/fs/ntfs/sysctl.c
index 1927170a35ce..a503156ec15f 100644
--- a/fs/ntfs/sysctl.c
+++ b/fs/ntfs/sysctl.c
@@ -34,7 +34,7 @@
 #include "debug.h"
 
 /* Definition of the ntfs sysctl. */
-static ctl_table ntfs_sysctls[] = {
+static struct ctl_table ntfs_sysctls[] = {
         {
                 .procname       = "ntfs-debug",
                 .data           = &debug_msgs,          /* Data pointer and size. */
@@ -46,7 +46,7 @@ static ctl_table ntfs_sysctls[] = {
 };
 
 /* Define the parent directory /proc/sys/fs. */
-static ctl_table sysctls_root[] = {
+static struct ctl_table sysctls_root[] = {
         {
                 .procname       = "fs",
                 .mode           = 0555,
diff --git a/fs/proc/task_mmu.c b/fs/proc/task_mmu.c
index 48cbe4c0b2a5..5d9da22e29b0 100644
--- a/fs/proc/task_mmu.c
+++ b/fs/proc/task_mmu.c
@@ -1418,10 +1418,10 @@ static int show_numa_map(struct seq_file *m, void *v, int is_pid)
         seq_printf(m, "%08lx %s", vma->vm_start, buffer);
 
         if (file) {
-                seq_printf(m, " file=");
+                seq_puts(m, " file=");
                 seq_path(m, &file->f_path, "\n\t= ");
         } else if (vma->vm_start <= mm->brk && vma->vm_end >= mm->start_brk) {
-                seq_printf(m, " heap");
+                seq_puts(m, " heap");
         } else {
                 pid_t tid = vm_is_stack(task, vma, is_pid);
                 if (tid != 0) {
@@ -1431,14 +1431,14 @@ static int show_numa_map(struct seq_file *m, void *v, int is_pid)
                          */
                         if (!is_pid || (vma->vm_start <= mm->start_stack &&
                             vma->vm_end >= mm->start_stack))
-                                seq_printf(m, " stack");
+                                seq_puts(m, " stack");
                         else
                                 seq_printf(m, " stack:%d", tid);
                 }
         }
 
         if (is_vm_hugetlb_page(vma))
-                seq_printf(m, " huge");
+                seq_puts(m, " huge");
 
         walk_page_range(vma->vm_start, vma->vm_end, &walk);
 
diff --git a/fs/proc/vmcore.c b/fs/proc/vmcore.c
index 6a8e785b29da..382aa890e228 100644
--- a/fs/proc/vmcore.c
+++ b/fs/proc/vmcore.c
@@ -42,7 +42,7 @@ static size_t elfnotes_sz;
 /* Total size of vmcore file. */
 static u64 vmcore_size;
 
-static struct proc_dir_entry *proc_vmcore = NULL;
+static struct proc_dir_entry *proc_vmcore;
 
 /*
  * Returns > 0 for RAM pages, 0 for non-RAM pages, < 0 on error
diff --git a/fs/pstore/platform.c b/fs/pstore/platform.c
index 46d269e38706..0a9b72cdfeca 100644
--- a/fs/pstore/platform.c
+++ b/fs/pstore/platform.c
@@ -18,6 +18,8 @@
  *  Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
  */
 
+#define pr_fmt(fmt) "pstore: " fmt
+
 #include <linux/atomic.h>
 #include <linux/types.h>
 #include <linux/errno.h>
@@ -224,14 +226,12 @@ static void allocate_buf_for_compression(void)
                         zlib_inflate_workspacesize());
                 stream.workspace = kmalloc(size, GFP_KERNEL);
                 if (!stream.workspace) {
-                        pr_err("pstore: No memory for compression workspace; "
-                                "skipping compression\n");
+                        pr_err("No memory for compression workspace; skipping compression\n");
                         kfree(big_oops_buf);
                         big_oops_buf = NULL;
                 }
         } else {
-                pr_err("No memory for uncompressed data; "
-                        "skipping compression\n");
+                pr_err("No memory for uncompressed data; skipping compression\n");
                 stream.workspace = NULL;
         }
 
@@ -455,8 +455,7 @@ int pstore_register(struct pstore_info *psi)
                 add_timer(&pstore_timer);
         }
 
-        pr_info("pstore: Registered %s as persistent store backend\n",
-                psi->name);
+        pr_info("Registered %s as persistent store backend\n", psi->name);
 
         return 0;
 }
@@ -502,8 +501,8 @@ void pstore_get_records(int quiet)
                                 size = unzipped_len;
                                 compressed = false;
                         } else {
-                                pr_err("pstore: decompression failed;"
-                                        "returned %d\n", unzipped_len);
+                                pr_err("decompression failed;returned %d\n",
+                                       unzipped_len);
                                 compressed = true;
                         }
                 }
@@ -524,8 +523,8 @@ out:
         mutex_unlock(&psi->read_mutex);
 
         if (failed)
-                printk(KERN_WARNING "pstore: failed to load %d record(s) from '%s'\n",
-                       failed, psi->name);
+                pr_warn("failed to load %d record(s) from '%s'\n",
+                        failed, psi->name);
 }
 
 static void pstore_dowork(struct work_struct *work)
diff --git a/fs/pstore/ram_core.c b/fs/pstore/ram_core.c
index ff7e3d4df5a1..34a1e5aa848c 100644
--- a/fs/pstore/ram_core.c
+++ b/fs/pstore/ram_core.c
@@ -12,6 +12,8 @@
  *
  */
 
+#define pr_fmt(fmt) "persistent_ram: " fmt
+
 #include <linux/device.h>
 #include <linux/err.h>
 #include <linux/errno.h>
@@ -205,12 +207,10 @@ static void persistent_ram_ecc_old(struct persistent_ram_zone *prz)
                         size = buffer->data + prz->buffer_size - block;
                 numerr = persistent_ram_decode_rs8(prz, block, size, par);
                 if (numerr > 0) {
-                        pr_devel("persistent_ram: error in block %p, %d\n",
-                               block, numerr);
+                        pr_devel("error in block %p, %d\n", block, numerr);
                         prz->corrected_bytes += numerr;
                 } else if (numerr < 0) {
-                        pr_devel("persistent_ram: uncorrectable error in block %p\n",
-                                block);
+                        pr_devel("uncorrectable error in block %p\n", block);
                         prz->bad_blocks++;
                 }
                 block += prz->ecc_info.block_size;
@@ -257,7 +257,7 @@ static int persistent_ram_init_ecc(struct persistent_ram_zone *prz,
         prz->rs_decoder = init_rs(prz->ecc_info.symsize, prz->ecc_info.poly,
                                   0, 1, prz->ecc_info.ecc_size);
         if (prz->rs_decoder == NULL) {
-                pr_info("persistent_ram: init_rs failed\n");
+                pr_info("init_rs failed\n");
                 return -EINVAL;
         }
 
@@ -267,10 +267,10 @@ static int persistent_ram_init_ecc(struct persistent_ram_zone *prz,
         numerr = persistent_ram_decode_rs8(prz, buffer, sizeof(*buffer),
                                            prz->par_header);
         if (numerr > 0) {
-                pr_info("persistent_ram: error in header, %d\n", numerr);
+                pr_info("error in header, %d\n", numerr);
                 prz->corrected_bytes += numerr;
         } else if (numerr < 0) {
-                pr_info("persistent_ram: uncorrectable error in header\n");
+                pr_info("uncorrectable error in header\n");
                 prz->bad_blocks++;
         }
 
@@ -317,7 +317,7 @@ void persistent_ram_save_old(struct persistent_ram_zone *prz)
                 prz->old_log = kmalloc(size, GFP_KERNEL);
         }
         if (!prz->old_log) {
-                pr_err("persistent_ram: failed to allocate buffer\n");
+                pr_err("failed to allocate buffer\n");
                 return;
         }
 
@@ -396,8 +396,8 @@ static void *persistent_ram_vmap(phys_addr_t start, size_t size)
 
         pages = kmalloc(sizeof(struct page *) * page_count, GFP_KERNEL);
         if (!pages) {
-                pr_err("%s: Failed to allocate array for %u pages\n", __func__,
-                        page_count);
+                pr_err("%s: Failed to allocate array for %u pages\n",
+                       __func__, page_count);
                 return NULL;
         }
 
@@ -462,19 +462,17 @@ static int persistent_ram_post_init(struct persistent_ram_zone *prz, u32 sig,
         if (prz->buffer->sig == sig) {
                 if (buffer_size(prz) > prz->buffer_size ||
                     buffer_start(prz) > buffer_size(prz))
-                        pr_info("persistent_ram: found existing invalid buffer,"
-                                " size %zu, start %zu\n",
-                               buffer_size(prz), buffer_start(prz));
+                        pr_info("found existing invalid buffer, size %zu, start %zu\n",
+                                buffer_size(prz), buffer_start(prz));
                 else {
-                        pr_debug("persistent_ram: found existing buffer,"
-                                " size %zu, start %zu\n",
-                               buffer_size(prz), buffer_start(prz));
+                        pr_debug("found existing buffer, size %zu, start %zu\n",
+                                 buffer_size(prz), buffer_start(prz));
                         persistent_ram_save_old(prz);
                         return 0;
                 }
         } else {
-                pr_debug("persistent_ram: no valid data in buffer"
-                        " (sig = 0x%08x)\n", prz->buffer->sig);
+                pr_debug("no valid data in buffer (sig = 0x%08x)\n",
+                         prz->buffer->sig);
         }
 
         prz->buffer->sig = sig;
@@ -509,7 +507,7 @@ struct persistent_ram_zone *persistent_ram_new(phys_addr_t start, size_t size,
 
         prz = kzalloc(sizeof(struct persistent_ram_zone), GFP_KERNEL);
         if (!prz) {
-                pr_err("persistent_ram: failed to allocate persistent ram zone\n");
+                pr_err("failed to allocate persistent ram zone\n");
                 goto err;
         }
 
diff --git a/fs/reiserfs/bitmap.c b/fs/reiserfs/bitmap.c
index dc9a6829f7c6..1bcffeab713c 100644
--- a/fs/reiserfs/bitmap.c
+++ b/fs/reiserfs/bitmap.c
@@ -142,7 +142,6 @@ static int scan_bitmap_block(struct reiserfs_transaction_handle *th,
         int org = *beg;
 
         BUG_ON(!th->t_trans_id);
-
         RFALSE(bmap_n >= reiserfs_bmap_count(s), "Bitmap %u is out of "
                "range (0..%u)", bmap_n, reiserfs_bmap_count(s) - 1);
         PROC_INFO_INC(s, scan_bitmap.bmap);
@@ -321,7 +320,6 @@ static int scan_bitmap(struct reiserfs_transaction_handle *th,
         unsigned int off_max = s->s_blocksize << 3;
 
         BUG_ON(!th->t_trans_id);
-
         PROC_INFO_INC(s, scan_bitmap.call);
         if (SB_FREE_BLOCKS(s) <= 0)
                 return 0;       // No point in looking for more free blocks
@@ -388,9 +386,7 @@ static void _reiserfs_free_block(struct reiserfs_transaction_handle *th,
         unsigned int nr, offset;
 
         BUG_ON(!th->t_trans_id);
-
         PROC_INFO_INC(s, free_block);
-
         rs = SB_DISK_SUPER_BLOCK(s);
         sbh = SB_BUFFER_WITH_SB(s);
         apbi = SB_AP_BITMAP(s);
@@ -435,8 +431,8 @@ void reiserfs_free_block(struct reiserfs_transaction_handle *th,
                          int for_unformatted)
 {
         struct super_block *s = th->t_super;
-        BUG_ON(!th->t_trans_id);
 
+        BUG_ON(!th->t_trans_id);
         RFALSE(!s, "vs-4061: trying to free block on nonexistent device");
         if (!is_reusable(s, block, 1))
                 return;
@@ -471,6 +467,7 @@ static void __discard_prealloc(struct reiserfs_transaction_handle *th,
         unsigned long save = ei->i_prealloc_block;
         int dirty = 0;
         struct inode *inode = &ei->vfs_inode;
+
         BUG_ON(!th->t_trans_id);
 #ifdef CONFIG_REISERFS_CHECK
         if (ei->i_prealloc_count < 0)
@@ -494,6 +491,7 @@ void reiserfs_discard_prealloc(struct reiserfs_transaction_handle *th,
                                struct inode *inode)
 {
         struct reiserfs_inode_info *ei = REISERFS_I(inode);
+
         BUG_ON(!th->t_trans_id);
         if (ei->i_prealloc_count)
                 __discard_prealloc(th, ei);
@@ -504,7 +502,6 @@ void reiserfs_discard_all_prealloc(struct reiserfs_transaction_handle *th)
         struct list_head *plist = &SB_JOURNAL(th->t_super)->j_prealloc_list;
 
         BUG_ON(!th->t_trans_id);
-
         while (!list_empty(plist)) {
                 struct reiserfs_inode_info *ei;
                 ei = list_entry(plist->next, struct reiserfs_inode_info,
@@ -562,7 +559,7 @@ int reiserfs_parse_alloc_options(struct super_block *s, char *options)
                 if (!strcmp(this_char, "displacing_new_packing_localities")) {
                         SET_OPTION(displacing_new_packing_localities);
                         continue;
-                };
+                }
 
                 if (!strcmp(this_char, "old_hashed_relocation")) {
                         SET_OPTION(old_hashed_relocation);
@@ -729,6 +726,7 @@ void show_alloc_options(struct seq_file *seq, struct super_block *s)
 static inline void new_hashed_relocation(reiserfs_blocknr_hint_t * hint)
 {
         char *hash_in;
+
         if (hint->formatted_node) {
                 hash_in = (char *)&hint->key.k_dir_id;
         } else {
@@ -757,6 +755,7 @@ static void dirid_groups(reiserfs_blocknr_hint_t * hint)
         __u32 dirid = 0;
         int bm = 0;
         struct super_block *sb = hint->th->t_super;
+
         if (hint->inode)
                 dirid = le32_to_cpu(INODE_PKEY(hint->inode)->k_dir_id);
         else if (hint->formatted_node)
diff --git a/fs/reiserfs/stree.c b/fs/reiserfs/stree.c
index b14706a05d52..615cd9ab7940 100644
--- a/fs/reiserfs/stree.c
+++ b/fs/reiserfs/stree.c
@@ -228,10 +228,10 @@ const struct reiserfs_key MIN_KEY = { 0, 0, {{0, 0},} };
 
 /* Maximal possible key. It is never in the tree. */
 static const struct reiserfs_key MAX_KEY = {
-        __constant_cpu_to_le32(0xffffffff),
-        __constant_cpu_to_le32(0xffffffff),
-        {{__constant_cpu_to_le32(0xffffffff),
-          __constant_cpu_to_le32(0xffffffff)},}
+        cpu_to_le32(0xffffffff),
+        cpu_to_le32(0xffffffff),
+        {{cpu_to_le32(0xffffffff),
+          cpu_to_le32(0xffffffff)},}
 };
 
 /* Get delimiting key of the buffer by looking for it in the buffers in the path, starting from the bottom
diff --git a/fs/ufs/balloc.c b/fs/ufs/balloc.c
index 0ab1de4b39a5..7bc20809c99e 100644
--- a/fs/ufs/balloc.c
+++ b/fs/ufs/balloc.c
@@ -24,7 +24,7 @@
 
 #define INVBLOCK ((u64)-1L)
 
-static u64 ufs_add_fragments(struct inode *, u64, unsigned, unsigned, int *);
+static u64 ufs_add_fragments(struct inode *, u64, unsigned, unsigned);
 static u64 ufs_alloc_fragments(struct inode *, unsigned, u64, unsigned, int *);
 static u64 ufs_alloccg_block(struct inode *, struct ufs_cg_private_info *, u64, int *);
 static u64 ufs_bitmap_search (struct super_block *, struct ufs_cg_private_info *, u64, unsigned);
@@ -52,7 +52,7 @@ void ufs_free_fragments(struct inode *inode, u64 fragment, unsigned count)
         if (ufs_fragnum(fragment) + count > uspi->s_fpg)
                 ufs_error (sb, "ufs_free_fragments", "internal error");
         
-        mutex_lock(&UFS_SB(sb)->s_lock);
+        lock_ufs(sb);
         
         cgno = ufs_dtog(uspi, fragment);
         bit = ufs_dtogd(uspi, fragment);
@@ -116,12 +116,12 @@ void ufs_free_fragments(struct inode *inode, u64 fragment, unsigned count)
                 ubh_sync_block(UCPI_UBH(ucpi));
         ufs_mark_sb_dirty(sb);
         
-        mutex_unlock(&UFS_SB(sb)->s_lock);
+        unlock_ufs(sb);
         UFSD("EXIT\n");
         return;
 
 failed:
-        mutex_unlock(&UFS_SB(sb)->s_lock);
+        unlock_ufs(sb);
         UFSD("EXIT (FAILED)\n");
         return;
 }
@@ -151,7 +151,7 @@ void ufs_free_blocks(struct inode *inode, u64 fragment, unsigned count)
                 goto failed;
         }
 
-        mutex_lock(&UFS_SB(sb)->s_lock);
+        lock_ufs(sb);
         
 do_more:
         overflow = 0;
@@ -211,12 +211,12 @@ do_more:
         }
 
         ufs_mark_sb_dirty(sb);
-        mutex_unlock(&UFS_SB(sb)->s_lock);
+        unlock_ufs(sb);
         UFSD("EXIT\n");
         return;
 
 failed_unlock:
-        mutex_unlock(&UFS_SB(sb)->s_lock);
+        unlock_ufs(sb);
 failed:
         UFSD("EXIT (FAILED)\n");
         return;
@@ -357,7 +357,7 @@ u64 ufs_new_fragments(struct inode *inode, void *p, u64 fragment,
         usb1 = ubh_get_usb_first(uspi);
         *err = -ENOSPC;
 
-        mutex_lock(&UFS_SB(sb)->s_lock);
+        lock_ufs(sb);
         tmp = ufs_data_ptr_to_cpu(sb, p);
 
         if (count + ufs_fragnum(fragment) > uspi->s_fpb) {
@@ -378,19 +378,19 @@ u64 ufs_new_fragments(struct inode *inode, void *p, u64 fragment,
                                   "fragment %llu, tmp %llu\n",
                                   (unsigned long long)fragment,
                                   (unsigned long long)tmp);
-                        mutex_unlock(&UFS_SB(sb)->s_lock);
+                        unlock_ufs(sb);
                         return INVBLOCK;
                 }
                 if (fragment < UFS_I(inode)->i_lastfrag) {
                         UFSD("EXIT (ALREADY ALLOCATED)\n");
-                        mutex_unlock(&UFS_SB(sb)->s_lock);
+                        unlock_ufs(sb);
                         return 0;
                 }
         }
         else {
                 if (tmp) {
                         UFSD("EXIT (ALREADY ALLOCATED)\n");
-                        mutex_unlock(&UFS_SB(sb)->s_lock);
+                        unlock_ufs(sb);
                         return 0;
                 }
         }
@@ -399,7 +399,7 @@ u64 ufs_new_fragments(struct inode *inode, void *p, u64 fragment,
          * There is not enough space for user on the device
          */
         if (!capable(CAP_SYS_RESOURCE) && ufs_freespace(uspi, UFS_MINFREE) <= 0) {
-                mutex_unlock(&UFS_SB(sb)->s_lock);
+                unlock_ufs(sb);
                 UFSD("EXIT (FAILED)\n");
                 return 0;
         }
@@ -424,7 +424,7 @@ u64 ufs_new_fragments(struct inode *inode, void *p, u64 fragment,
                         ufs_clear_frags(inode, result + oldcount,
                                         newcount - oldcount, locked_page != NULL);
                 }
-                mutex_unlock(&UFS_SB(sb)->s_lock);
+                unlock_ufs(sb);
                 UFSD("EXIT, result %llu\n", (unsigned long long)result);
                 return result;
         }
@@ -432,14 +432,14 @@ u64 ufs_new_fragments(struct inode *inode, void *p, u64 fragment,
         /*
          * resize block
          */
-        result = ufs_add_fragments (inode, tmp, oldcount, newcount, err);
+        result = ufs_add_fragments(inode, tmp, oldcount, newcount);
         if (result) {
                 *err = 0;
                 UFS_I(inode)->i_lastfrag = max(UFS_I(inode)->i_lastfrag,
                                                 fragment + count);
                 ufs_clear_frags(inode, result + oldcount, newcount - oldcount,
                                 locked_page != NULL);
-                mutex_unlock(&UFS_SB(sb)->s_lock);
+                unlock_ufs(sb);
                 UFSD("EXIT, result %llu\n", (unsigned long long)result);
                 return result;
         }
@@ -477,7 +477,7 @@ u64 ufs_new_fragments(struct inode *inode, void *p, u64 fragment,
                 *err = 0;
                 UFS_I(inode)->i_lastfrag = max(UFS_I(inode)->i_lastfrag,
                                                 fragment + count);
-                mutex_unlock(&UFS_SB(sb)->s_lock);
+                unlock_ufs(sb);
                 if (newcount < request)
                         ufs_free_fragments (inode, result + newcount, request - newcount);
                 ufs_free_fragments (inode, tmp, oldcount);
@@ -485,13 +485,13 @@ u64 ufs_new_fragments(struct inode *inode, void *p, u64 fragment,
                 return result;
         }
 
-        mutex_unlock(&UFS_SB(sb)->s_lock);
+        unlock_ufs(sb);
         UFSD("EXIT (FAILED)\n");
         return 0;
 }               
 
 static u64 ufs_add_fragments(struct inode *inode, u64 fragment,
-                             unsigned oldcount, unsigned newcount, int *err)
+                             unsigned oldcount, unsigned newcount)
 {
         struct super_block * sb;
         struct ufs_sb_private_info * uspi;
diff --git a/fs/ufs/ialloc.c b/fs/ufs/ialloc.c
index 98f7211599ff..a9cc75ffa925 100644
--- a/fs/ufs/ialloc.c
+++ b/fs/ufs/ialloc.c
@@ -69,11 +69,11 @@ void ufs_free_inode (struct inode * inode)
         
         ino = inode->i_ino;
 
-        mutex_lock(&UFS_SB(sb)->s_lock);
+        lock_ufs(sb);
 
         if (!((ino > 1) && (ino < (uspi->s_ncg * uspi->s_ipg )))) {
                 ufs_warning(sb, "ufs_free_inode", "reserved inode or nonexistent inode %u\n", ino);
-                mutex_unlock(&UFS_SB(sb)->s_lock);
+                unlock_ufs(sb);
                 return;
         }
         
@@ -81,7 +81,7 @@ void ufs_free_inode (struct inode * inode)
         bit = ufs_inotocgoff (ino);
         ucpi = ufs_load_cylinder (sb, cg);
         if (!ucpi) {
-                mutex_unlock(&UFS_SB(sb)->s_lock);
+                unlock_ufs(sb);
                 return;
         }
         ucg = ubh_get_ucg(UCPI_UBH(ucpi));
@@ -115,7 +115,7 @@ void ufs_free_inode (struct inode * inode)
                 ubh_sync_block(UCPI_UBH(ucpi));
         
         ufs_mark_sb_dirty(sb);
-        mutex_unlock(&UFS_SB(sb)->s_lock);
+        unlock_ufs(sb);
         UFSD("EXIT\n");
 }
 
@@ -193,7 +193,7 @@ struct inode *ufs_new_inode(struct inode *dir, umode_t mode)
         sbi = UFS_SB(sb);
         uspi = sbi->s_uspi;
 
-        mutex_lock(&sbi->s_lock);
+        lock_ufs(sb);
 
         /*
          * Try to place the inode in its parent directory
@@ -328,21 +328,20 @@ cg_found:
                         sync_dirty_buffer(bh);
                 brelse(bh);
         }
-
-        mutex_unlock(&sbi->s_lock);
+        unlock_ufs(sb);
 
         UFSD("allocating inode %lu\n", inode->i_ino);
         UFSD("EXIT\n");
         return inode;
 
 fail_remove_inode:
-        mutex_unlock(&sbi->s_lock);
+        unlock_ufs(sb);
         clear_nlink(inode);
         iput(inode);
         UFSD("EXIT (FAILED): err %d\n", err);
         return ERR_PTR(err);
 failed:
-        mutex_unlock(&sbi->s_lock);
+        unlock_ufs(sb);
         make_bad_inode(inode);
         iput (inode);
         UFSD("EXIT (FAILED): err %d\n", err);
diff --git a/fs/ufs/super.c b/fs/ufs/super.c
index c1183f9f69dc..b879f1ba3439 100644
--- a/fs/ufs/super.c
+++ b/fs/ufs/super.c
@@ -697,7 +697,6 @@ static int ufs_sync_fs(struct super_block *sb, int wait)
         unsigned flags;
 
         lock_ufs(sb);
-        mutex_lock(&UFS_SB(sb)->s_lock);
 
         UFSD("ENTER\n");
 
@@ -715,7 +714,6 @@ static int ufs_sync_fs(struct super_block *sb, int wait)
         ufs_put_cstotal(sb);
 
         UFSD("EXIT\n");
-        mutex_unlock(&UFS_SB(sb)->s_lock);
         unlock_ufs(sb);
 
         return 0;
@@ -760,6 +758,7 @@ static void ufs_put_super(struct super_block *sb)
 
         ubh_brelse_uspi (sbi->s_uspi);
         kfree (sbi->s_uspi);
+        mutex_destroy(&sbi->mutex);
         kfree (sbi);
         sb->s_fs_info = NULL;
         UFSD("EXIT\n");
@@ -786,6 +785,14 @@ static int ufs_fill_super(struct super_block *sb, void *data, int silent)
         flags = 0;
         
         UFSD("ENTER\n");
+
+#ifndef CONFIG_UFS_FS_WRITE
+        if (!(sb->s_flags & MS_RDONLY)) {
+                printk("ufs was compiled with read-only support, "
+                       "can't be mounted as read-write\n");
+                return -EROFS;
+        }
+#endif
                 
         sbi = kzalloc(sizeof(struct ufs_sb_info), GFP_KERNEL);
         if (!sbi)
@@ -795,15 +802,7 @@ static int ufs_fill_super(struct super_block *sb, void *data, int silent)
 
         UFSD("flag %u\n", (int)(sb->s_flags & MS_RDONLY));
         
-#ifndef CONFIG_UFS_FS_WRITE
-        if (!(sb->s_flags & MS_RDONLY)) {
-                printk("ufs was compiled with read-only support, "
-                "can't be mounted as read-write\n");
-                goto failed;
-        }
-#endif
         mutex_init(&sbi->mutex);
-        mutex_init(&sbi->s_lock);
         spin_lock_init(&sbi->work_lock);
         INIT_DELAYED_WORK(&sbi->sync_work, delayed_sync_fs);
         /*
@@ -1257,6 +1256,7 @@ magic_found:
         return 0;
 
 failed:
+        mutex_destroy(&sbi->mutex);
         if (ubh)
                 ubh_brelse_uspi (uspi);
         kfree (uspi);
@@ -1280,7 +1280,6 @@ static int ufs_remount (struct super_block *sb, int *mount_flags, char *data)
 
         sync_filesystem(sb);
         lock_ufs(sb);
-        mutex_lock(&UFS_SB(sb)->s_lock);
         uspi = UFS_SB(sb)->s_uspi;
         flags = UFS_SB(sb)->s_flags;
         usb1 = ubh_get_usb_first(uspi);
@@ -1294,7 +1293,6 @@ static int ufs_remount (struct super_block *sb, int *mount_flags, char *data)
         new_mount_opt = 0;
         ufs_set_opt (new_mount_opt, ONERROR_LOCK);
         if (!ufs_parse_options (data, &new_mount_opt)) {
-                mutex_unlock(&UFS_SB(sb)->s_lock);
                 unlock_ufs(sb);
                 return -EINVAL;
         }
@@ -1302,14 +1300,12 @@ static int ufs_remount (struct super_block *sb, int *mount_flags, char *data)
                 new_mount_opt |= ufstype;
         } else if ((new_mount_opt & UFS_MOUNT_UFSTYPE) != ufstype) {
                 printk("ufstype can't be changed during remount\n");
-                mutex_unlock(&UFS_SB(sb)->s_lock);
                 unlock_ufs(sb);
                 return -EINVAL;
         }
 
         if ((*mount_flags & MS_RDONLY) == (sb->s_flags & MS_RDONLY)) {
                 UFS_SB(sb)->s_mount_opt = new_mount_opt;
-                mutex_unlock(&UFS_SB(sb)->s_lock);
                 unlock_ufs(sb);
                 return 0;
         }
@@ -1334,7 +1330,6 @@ static int ufs_remount (struct super_block *sb, int *mount_flags, char *data)
 #ifndef CONFIG_UFS_FS_WRITE
                 printk("ufs was compiled with read-only support, "
                 "can't be mounted as read-write\n");
-                mutex_unlock(&UFS_SB(sb)->s_lock);
                 unlock_ufs(sb);
                 return -EINVAL;
 #else
@@ -1344,13 +1339,11 @@ static int ufs_remount (struct super_block *sb, int *mount_flags, char *data)
                     ufstype != UFS_MOUNT_UFSTYPE_SUNx86 &&
                     ufstype != UFS_MOUNT_UFSTYPE_UFS2) {
                         printk("this ufstype is read-only supported\n");
-                        mutex_unlock(&UFS_SB(sb)->s_lock);
                         unlock_ufs(sb);
                         return -EINVAL;
                 }
                 if (!ufs_read_cylinder_structures(sb)) {
                         printk("failed during remounting\n");
-                        mutex_unlock(&UFS_SB(sb)->s_lock);
                         unlock_ufs(sb);
                         return -EPERM;
                 }
@@ -1358,7 +1351,6 @@ static int ufs_remount (struct super_block *sb, int *mount_flags, char *data)
 #endif
         }
         UFS_SB(sb)->s_mount_opt = new_mount_opt;
-        mutex_unlock(&UFS_SB(sb)->s_lock);
         unlock_ufs(sb);
         return 0;
 }
diff --git a/fs/ufs/ufs.h b/fs/ufs/ufs.h
index ff2c15ab81aa..343e6fc571e5 100644
--- a/fs/ufs/ufs.h
+++ b/fs/ufs/ufs.h
@@ -24,7 +24,6 @@ struct ufs_sb_info {
         int work_queued; /* non-zero if the delayed work is queued */
         struct delayed_work sync_work; /* FS sync delayed work */
         spinlock_t work_lock; /* protects sync_work and work_queued */
-        struct mutex s_lock;
 };
 
 struct ufs_inode_info {
diff --git a/include/asm-generic/ioctl.h b/include/asm-generic/ioctl.h
index d17295b290fa..297fb0d7cd6c 100644
--- a/include/asm-generic/ioctl.h
+++ b/include/asm-generic/ioctl.h
@@ -3,10 +3,15 @@
 
 #include <uapi/asm-generic/ioctl.h>
 
+#ifdef __CHECKER__
+#define _IOC_TYPECHECK(t) (sizeof(t))
+#else
 /* provoke compile error for invalid uses of size argument */
 extern unsigned int __invalid_size_argument_for_IOC;
 #define _IOC_TYPECHECK(t) \
         ((sizeof(t) == sizeof(t[1]) && \
           sizeof(t) < (1 << _IOC_SIZEBITS)) ? \
           sizeof(t) : __invalid_size_argument_for_IOC)
+#endif
+
 #endif /* _ASM_GENERIC_IOCTL_H */
diff --git a/include/linux/cpu.h b/include/linux/cpu.h
index 81887120395c..95978ad7fcdd 100644
--- a/include/linux/cpu.h
+++ b/include/linux/cpu.h
@@ -256,7 +256,6 @@ enum cpuhp_state {
 };
 
 void cpu_startup_entry(enum cpuhp_state state);
-void cpu_idle(void);
 
 void cpu_idle_poll_ctrl(bool enable);
 
diff --git a/include/linux/idr.h b/include/linux/idr.h
index 6af3400b9b2f..013fd9bc4cb6 100644
--- a/include/linux/idr.h
+++ b/include/linux/idr.h
@@ -29,21 +29,24 @@
 
 struct idr_layer {
         int                     prefix; /* the ID prefix of this idr_layer */
-        DECLARE_BITMAP(bitmap, IDR_SIZE); /* A zero bit means "space here" */
+        int                     layer;  /* distance from leaf */
         struct idr_layer __rcu  *ary[1<<IDR_BITS];
         int                     count;  /* When zero, we can release it */
-        int                     layer;  /* distance from leaf */
-        struct rcu_head         rcu_head;
+        union {
+                /* A zero bit means "space here" */
+                DECLARE_BITMAP(bitmap, IDR_SIZE);
+                struct rcu_head         rcu_head;
+        };
 };
 
 struct idr {
         struct idr_layer __rcu  *hint;  /* the last layer allocated from */
         struct idr_layer __rcu  *top;
-        struct idr_layer        *id_free;
         int                     layers; /* only valid w/o concurrent changes */
-        int                     id_free_cnt;
         int                     cur;    /* current pos for cyclic allocation */
         spinlock_t              lock;
+        int                     id_free_cnt;
+        struct idr_layer        *id_free;
 };
 
 #define IDR_INIT(name)                                                  \
diff --git a/include/linux/key.h b/include/linux/key.h
index 80d677483e31..3ae45f09589b 100644
--- a/include/linux/key.h
+++ b/include/linux/key.h
@@ -332,7 +332,7 @@ do {									\
 } while (0)
 
 #ifdef CONFIG_SYSCTL
-extern ctl_table key_sysctls[];
+extern struct ctl_table key_sysctls[];
 #endif
 /*
  * the userspace interface
diff --git a/include/linux/kmemleak.h b/include/linux/kmemleak.h
index 5bb424659c04..057e95971014 100644
--- a/include/linux/kmemleak.h
+++ b/include/linux/kmemleak.h
@@ -30,6 +30,7 @@ extern void kmemleak_alloc_percpu(const void __percpu *ptr, size_t size) __ref;
 extern void kmemleak_free(const void *ptr) __ref;
 extern void kmemleak_free_part(const void *ptr, size_t size) __ref;
 extern void kmemleak_free_percpu(const void __percpu *ptr) __ref;
+extern void kmemleak_update_trace(const void *ptr) __ref;
 extern void kmemleak_not_leak(const void *ptr) __ref;
 extern void kmemleak_ignore(const void *ptr) __ref;
 extern void kmemleak_scan_area(const void *ptr, size_t size, gfp_t gfp) __ref;
@@ -83,6 +84,9 @@ static inline void kmemleak_free_recursive(const void *ptr, unsigned long flags)
 static inline void kmemleak_free_percpu(const void __percpu *ptr)
 {
 }
+static inline void kmemleak_update_trace(const void *ptr)
+{
+}
 static inline void kmemleak_not_leak(const void *ptr)
 {
 }
diff --git a/include/linux/mc146818rtc.h b/include/linux/mc146818rtc.h
index 2f4e957af656..433e0c74d643 100644
--- a/include/linux/mc146818rtc.h
+++ b/include/linux/mc146818rtc.h
@@ -31,6 +31,10 @@ struct cmos_rtc_board_info {
         void    (*wake_on)(struct device *dev);
         void    (*wake_off)(struct device *dev);
 
+        u32     flags;
+#define CMOS_RTC_FLAGS_NOFREQ   (1 << 0)
+        int     address_space;
+
         u8      rtc_day_alarm;          /* zero, or register index */
         u8      rtc_mon_alarm;          /* zero, or register index */
         u8      rtc_century;            /* zero, or register index */
diff --git a/include/linux/ptrace.h b/include/linux/ptrace.h
index 07d0df6bf768..077904c8b70d 100644
--- a/include/linux/ptrace.h
+++ b/include/linux/ptrace.h
@@ -5,6 +5,7 @@
 #include <linux/sched.h>                /* For struct task_struct.  */
 #include <linux/err.h>                  /* for IS_ERR_VALUE */
 #include <linux/bug.h>                  /* For BUG_ON.  */
+#include <linux/pid_namespace.h>        /* For task_active_pid_ns.  */
 #include <uapi/linux/ptrace.h>
 
 /*
@@ -129,6 +130,37 @@ static inline void ptrace_event(int event, unsigned long message)
 }
 
 /**
+ * ptrace_event_pid - possibly stop for a ptrace event notification
+ * @event:      %PTRACE_EVENT_* value to report
+ * @pid:        process identifier for %PTRACE_GETEVENTMSG to return
+ *
+ * Check whether @event is enabled and, if so, report @event and @pid
+ * to the ptrace parent.  @pid is reported as the pid_t seen from the
+ * the ptrace parent's pid namespace.
+ *
+ * Called without locks.
+ */
+static inline void ptrace_event_pid(int event, struct pid *pid)
+{
+        /*
+         * FIXME: There's a potential race if a ptracer in a different pid
+         * namespace than parent attaches between computing message below and
+         * when we acquire tasklist_lock in ptrace_stop().  If this happens,
+         * the ptracer will get a bogus pid from PTRACE_GETEVENTMSG.
+         */
+        unsigned long message = 0;
+        struct pid_namespace *ns;
+
+        rcu_read_lock();
+        ns = task_active_pid_ns(rcu_dereference(current->parent));
+        if (ns)
+                message = pid_nr_ns(pid, ns);
+        rcu_read_unlock();
+
+        ptrace_event(event, message);
+}
+
+/**
  * ptrace_init_task - initialize ptrace state for a new child
  * @child:              new child task
  * @ptrace:             true if child should be ptrace'd by parent's tracer
diff --git a/include/linux/sched.h b/include/linux/sched.h
index 8fcd0e6098d9..ea74596014a2 100644
--- a/include/linux/sched.h
+++ b/include/linux/sched.h
@@ -2414,9 +2414,6 @@ extern void flush_itimer_signals(void);
 
 extern void do_group_exit(int);
 
-extern int allow_signal(int);
-extern int disallow_signal(int);
-
 extern int do_execve(struct filename *,
                      const char __user * const __user *,
                      const char __user * const __user *);
diff --git a/include/linux/shm.h b/include/linux/shm.h
index 1e2cd2e6b540..57d77709fbe2 100644
--- a/include/linux/shm.h
+++ b/include/linux/shm.h
@@ -3,9 +3,8 @@
 
 #include <asm/page.h>
 #include <uapi/linux/shm.h>
-
-#define SHMALL (SHMMAX/PAGE_SIZE*(SHMMNI/16)) /* max shm system wide (pages) */
 #include <asm/shmparam.h>
+
 struct shmid_kernel /* private to the kernel */
 {       
         struct kern_ipc_perm    shm_perm;
diff --git a/include/linux/signal.h b/include/linux/signal.h
index 2ac423bdb676..c9e65360c49a 100644
--- a/include/linux/signal.h
+++ b/include/linux/signal.h
@@ -63,11 +63,6 @@ static inline int sigismember(sigset_t *set, int _sig)
                 return 1 & (set->sig[sig / _NSIG_BPW] >> (sig % _NSIG_BPW));
 }
 
-static inline int sigfindinword(unsigned long word)
-{
-        return ffz(~word);
-}
-
 #endif /* __HAVE_ARCH_SIG_BITOPS */
 
 static inline int sigisemptyset(sigset_t *set)
@@ -289,6 +284,22 @@ extern int get_signal_to_deliver(siginfo_t *info, struct k_sigaction *return_ka,
 extern void signal_setup_done(int failed, struct ksignal *ksig, int stepping);
 extern void signal_delivered(int sig, siginfo_t *info, struct k_sigaction *ka, struct pt_regs *regs, int stepping);
 extern void exit_signals(struct task_struct *tsk);
+extern void kernel_sigaction(int, __sighandler_t);
+
+static inline void allow_signal(int sig)
+{
+        /*
+         * Kernel threads handle their own signals. Let the signal code
+         * know it'll be handled, so that they don't get converted to
+         * SIGKILL or just silently dropped.
+         */
+        kernel_sigaction(sig, (__force __sighandler_t)2);
+}
+
+static inline void disallow_signal(int sig)
+{
+        kernel_sigaction(sig, SIG_IGN);
+}
 
 /*
  * Eventually that'll replace get_signal_to_deliver(); macro for now,
diff --git a/include/linux/smp.h b/include/linux/smp.h
index 633f5edd7470..34347f26be9b 100644
--- a/include/linux/smp.h
+++ b/include/linux/smp.h
@@ -13,8 +13,6 @@
 #include <linux/init.h>
 #include <linux/llist.h>
 
-extern void cpu_idle(void);
-
 typedef void (*smp_call_func_t)(void *info);
 struct call_single_data {
         struct llist_node llist;
diff --git a/include/uapi/linux/shm.h b/include/uapi/linux/shm.h
index 78b69413f582..1fbf24ea37fd 100644
--- a/include/uapi/linux/shm.h
+++ b/include/uapi/linux/shm.h
@@ -8,19 +8,20 @@
 #endif
 
 /*
- * SHMMAX, SHMMNI and SHMALL are upper limits are defaults which can
- * be increased by sysctl
+ * SHMMNI, SHMMAX and SHMALL are default upper limits which can be
+ * modified by sysctl. The SHMMAX and SHMALL values have been chosen to
+ * be as large possible without facilitating scenarios where userspace
+ * causes overflows when adjusting the limits via operations of the form
+ * "retrieve current limit; add X; update limit". It is therefore not
+ * advised to make SHMMAX and SHMALL any larger. These limits are
+ * suitable for both 32 and 64-bit systems.
  */
-
-#define SHMMAX 0x2000000                 /* max shared seg size (bytes) */
 #define SHMMIN 1                         /* min shared seg size (bytes) */
 #define SHMMNI 4096                      /* max num of segs system wide */
-#ifndef __KERNEL__
-#define SHMALL (SHMMAX/getpagesize()*(SHMMNI/16))
-#endif
+#define SHMMAX (ULONG_MAX - (1UL << 24)) /* max shared seg size (bytes) */
+#define SHMALL (ULONG_MAX - (1UL << 24)) /* max shm system wide (pages) */
 #define SHMSEG SHMMNI                    /* max shared segs per process */
 
-
 /* Obsolete, used only for backwards compatibility and libc5 compiles */
 struct shmid_ds {
         struct ipc_perm         shm_perm;       /* operation perms */
diff --git a/ipc/compat.c b/ipc/compat.c
index 45d035d4cedc..b5ef4f7946dc 100644
--- a/ipc/compat.c
+++ b/ipc/compat.c
@@ -30,7 +30,7 @@
 #include <linux/ptrace.h>
 
 #include <linux/mutex.h>
-#include <asm/uaccess.h>
+#include <linux/uaccess.h>
 
 #include "util.h"
 
diff --git a/ipc/compat_mq.c b/ipc/compat_mq.c
index 90d29f59cac6..ef6f91cc4490 100644
--- a/ipc/compat_mq.c
+++ b/ipc/compat_mq.c
@@ -12,7 +12,7 @@
 #include <linux/mqueue.h>
 #include <linux/syscalls.h>
 
-#include <asm/uaccess.h>
+#include <linux/uaccess.h>
 
 struct compat_mq_attr {
         compat_long_t mq_flags;      /* message queue flags                  */
diff --git a/ipc/ipc_sysctl.c b/ipc/ipc_sysctl.c
index 998d31b230f1..c3f0326e98db 100644
--- a/ipc/ipc_sysctl.c
+++ b/ipc/ipc_sysctl.c
@@ -18,7 +18,7 @@
 #include <linux/msg.h>
 #include "util.h"
 
-static void *get_ipc(ctl_table *table)
+static void *get_ipc(struct ctl_table *table)
 {
         char *which = table->data;
         struct ipc_namespace *ipc_ns = current->nsproxy->ipc_ns;
@@ -27,7 +27,7 @@ static void *get_ipc(ctl_table *table)
 }
 
 #ifdef CONFIG_PROC_SYSCTL
-static int proc_ipc_dointvec(ctl_table *table, int write,
+static int proc_ipc_dointvec(struct ctl_table *table, int write,
         void __user *buffer, size_t *lenp, loff_t *ppos)
 {
         struct ctl_table ipc_table;
@@ -38,7 +38,7 @@ static int proc_ipc_dointvec(ctl_table *table, int write,
         return proc_dointvec(&ipc_table, write, buffer, lenp, ppos);
 }
 
-static int proc_ipc_dointvec_minmax(ctl_table *table, int write,
+static int proc_ipc_dointvec_minmax(struct ctl_table *table, int write,
         void __user *buffer, size_t *lenp, loff_t *ppos)
 {
         struct ctl_table ipc_table;
@@ -49,7 +49,7 @@ static int proc_ipc_dointvec_minmax(ctl_table *table, int write,
         return proc_dointvec_minmax(&ipc_table, write, buffer, lenp, ppos);
 }
 
-static int proc_ipc_dointvec_minmax_orphans(ctl_table *table, int write,
+static int proc_ipc_dointvec_minmax_orphans(struct ctl_table *table, int write,
         void __user *buffer, size_t *lenp, loff_t *ppos)
 {
         struct ipc_namespace *ns = current->nsproxy->ipc_ns;
@@ -62,7 +62,7 @@ static int proc_ipc_dointvec_minmax_orphans(ctl_table *table, int write,
         return err;
 }
 
-static int proc_ipc_callback_dointvec_minmax(ctl_table *table, int write,
+static int proc_ipc_callback_dointvec_minmax(struct ctl_table *table, int write,
         void __user *buffer, size_t *lenp, loff_t *ppos)
 {
         struct ctl_table ipc_table;
@@ -85,7 +85,7 @@ static int proc_ipc_callback_dointvec_minmax(ctl_table *table, int write,
         return rc;
 }
 
-static int proc_ipc_doulongvec_minmax(ctl_table *table, int write,
+static int proc_ipc_doulongvec_minmax(struct ctl_table *table, int write,
         void __user *buffer, size_t *lenp, loff_t *ppos)
 {
         struct ctl_table ipc_table;
@@ -119,7 +119,7 @@ static void ipc_auto_callback(int val)
         }
 }
 
-static int proc_ipcauto_dointvec_minmax(ctl_table *table, int write,
+static int proc_ipcauto_dointvec_minmax(struct ctl_table *table, int write,
         void __user *buffer, size_t *lenp, loff_t *ppos)
 {
         struct ctl_table ipc_table;
diff --git a/ipc/mq_sysctl.c b/ipc/mq_sysctl.c
index 5bb8bfe67149..68d4e953762c 100644
--- a/ipc/mq_sysctl.c
+++ b/ipc/mq_sysctl.c
@@ -14,7 +14,7 @@
 #include <linux/sysctl.h>
 
 #ifdef CONFIG_PROC_SYSCTL
-static void *get_mq(ctl_table *table)
+static void *get_mq(struct ctl_table *table)
 {
         char *which = table->data;
         struct ipc_namespace *ipc_ns = current->nsproxy->ipc_ns;
@@ -22,7 +22,7 @@ static void *get_mq(ctl_table *table)
         return which;
 }
 
-static int proc_mq_dointvec(ctl_table *table, int write,
+static int proc_mq_dointvec(struct ctl_table *table, int write,
                             void __user *buffer, size_t *lenp, loff_t *ppos)
 {
         struct ctl_table mq_table;
@@ -32,7 +32,7 @@ static int proc_mq_dointvec(ctl_table *table, int write,
         return proc_dointvec(&mq_table, write, buffer, lenp, ppos);
 }
 
-static int proc_mq_dointvec_minmax(ctl_table *table, int write,
+static int proc_mq_dointvec_minmax(struct ctl_table *table, int write,
         void __user *buffer, size_t *lenp, loff_t *ppos)
 {
         struct ctl_table mq_table;
@@ -53,7 +53,7 @@ static int msg_max_limit_max = HARD_MSGMAX;
 static int msg_maxsize_limit_min = MIN_MSGSIZEMAX;
 static int msg_maxsize_limit_max = HARD_MSGSIZEMAX;
 
-static ctl_table mq_sysctls[] = {
+static struct ctl_table mq_sysctls[] = {
         {
                 .procname       = "queues_max",
                 .data           = &init_ipc_ns.mq_queues_max,
@@ -100,7 +100,7 @@ static ctl_table mq_sysctls[] = {
         {}
 };
 
-static ctl_table mq_sysctl_dir[] = {
+static struct ctl_table mq_sysctl_dir[] = {
         {
                 .procname       = "mqueue",
                 .mode           = 0555,
@@ -109,7 +109,7 @@ static ctl_table mq_sysctl_dir[] = {
         {}
 };
 
-static ctl_table mq_sysctl_root[] = {
+static struct ctl_table mq_sysctl_root[] = {
         {
                 .procname       = "fs",
                 .mode           = 0555,
diff --git a/ipc/msg.c b/ipc/msg.c
index 649853105a5d..c5d8e3749985 100644
--- a/ipc/msg.c
+++ b/ipc/msg.c
@@ -39,12 +39,10 @@
 #include <linux/ipc_namespace.h>
 
 #include <asm/current.h>
-#include <asm/uaccess.h>
+#include <linux/uaccess.h>
 #include "util.h"
 
-/*
- * one msg_receiver structure for each sleeping receiver:
- */
+/* one msg_receiver structure for each sleeping receiver */
 struct msg_receiver {
         struct list_head        r_list;
         struct task_struct      *r_tsk;
@@ -53,6 +51,12 @@ struct msg_receiver {
         long                    r_msgtype;
         long                    r_maxsize;
 
+        /*
+         * Mark r_msg volatile so that the compiler
+         * does not try to get smart and optimize
+         * it. We rely on this for the lockless
+         * receive algorithm.
+         */
         struct msg_msg          *volatile r_msg;
 };
 
@@ -70,75 +74,6 @@ struct msg_sender {
 
 #define msg_ids(ns)     ((ns)->ids[IPC_MSG_IDS])
 
-static void freeque(struct ipc_namespace *, struct kern_ipc_perm *);
-static int newque(struct ipc_namespace *, struct ipc_params *);
-#ifdef CONFIG_PROC_FS
-static int sysvipc_msg_proc_show(struct seq_file *s, void *it);
-#endif
-
-/*
- * Scale msgmni with the available lowmem size: the memory dedicated to msg
- * queues should occupy at most 1/MSG_MEM_SCALE of lowmem.
- * Also take into account the number of nsproxies created so far.
- * This should be done staying within the (MSGMNI , IPCMNI/nr_ipc_ns) range.
- */
-void recompute_msgmni(struct ipc_namespace *ns)
-{
-        struct sysinfo i;
-        unsigned long allowed;
-        int nb_ns;
-
-        si_meminfo(&i);
-        allowed = (((i.totalram - i.totalhigh) / MSG_MEM_SCALE) * i.mem_unit)
-                / MSGMNB;
-        nb_ns = atomic_read(&nr_ipc_ns);
-        allowed /= nb_ns;
-
-        if (allowed < MSGMNI) {
-                ns->msg_ctlmni = MSGMNI;
-                return;
-        }
-
-        if (allowed > IPCMNI / nb_ns) {
-                ns->msg_ctlmni = IPCMNI / nb_ns;
-                return;
-        }
-
-        ns->msg_ctlmni = allowed;
-}
-
-void msg_init_ns(struct ipc_namespace *ns)
-{
-        ns->msg_ctlmax = MSGMAX;
-        ns->msg_ctlmnb = MSGMNB;
-
-        recompute_msgmni(ns);
-
-        atomic_set(&ns->msg_bytes, 0);
-        atomic_set(&ns->msg_hdrs, 0);
-        ipc_init_ids(&ns->ids[IPC_MSG_IDS]);
-}
-
-#ifdef CONFIG_IPC_NS
-void msg_exit_ns(struct ipc_namespace *ns)
-{
-        free_ipcs(ns, &msg_ids(ns), freeque);
-        idr_destroy(&ns->ids[IPC_MSG_IDS].ipcs_idr);
-}
-#endif
-
-void __init msg_init(void)
-{
-        msg_init_ns(&init_ipc_ns);
-
-        printk(KERN_INFO "msgmni has been set to %d\n",
-                init_ipc_ns.msg_ctlmni);
-
-        ipc_init_proc_interface("sysvipc/msg",
-                                "       key      msqid perms      cbytes       qnum lspid lrpid   uid   gid  cuid  cgid      stime      rtime      ctime\n",
-                                IPC_MSG_IDS, sysvipc_msg_proc_show);
-}
-
 static inline struct msg_queue *msq_obtain_object(struct ipc_namespace *ns, int id)
 {
         struct kern_ipc_perm *ipcp = ipc_obtain_object(&msg_ids(ns), id);
@@ -227,7 +162,7 @@ static int newque(struct ipc_namespace *ns, struct ipc_params *params)
 static inline void ss_add(struct msg_queue *msq, struct msg_sender *mss)
 {
         mss->tsk = current;
-        current->state = TASK_INTERRUPTIBLE;
+        __set_current_state(TASK_INTERRUPTIBLE);
         list_add_tail(&mss->list, &msq->q_senders);
 }
 
@@ -306,15 +241,14 @@ static inline int msg_security(struct kern_ipc_perm *ipcp, int msgflg)
 SYSCALL_DEFINE2(msgget, key_t, key, int, msgflg)
 {
         struct ipc_namespace *ns;
-        struct ipc_ops msg_ops;
+        static const struct ipc_ops msg_ops = {
+                .getnew = newque,
+                .associate = msg_security,
+        };
         struct ipc_params msg_params;
 
         ns = current->nsproxy->ipc_ns;
 
-        msg_ops.getnew = newque;
-        msg_ops.associate = msg_security;
-        msg_ops.more_checks = NULL;
-
         msg_params.key = key;
         msg_params.flg = msgflg;
 
@@ -612,23 +546,22 @@ SYSCALL_DEFINE3(msgctl, int, msqid, int, cmd, struct msqid_ds __user *, buf)
 
 static int testmsg(struct msg_msg *msg, long type, int mode)
 {
-        switch (mode)
-        {
-                case SEARCH_ANY:
-                case SEARCH_NUMBER:
+        switch (mode) {
+        case SEARCH_ANY:
+        case SEARCH_NUMBER:
+                return 1;
+        case SEARCH_LESSEQUAL:
+                if (msg->m_type <= type)
                         return 1;
-                case SEARCH_LESSEQUAL:
-                        if (msg->m_type <= type)
-                                return 1;
-                        break;
-                case SEARCH_EQUAL:
-                        if (msg->m_type == type)
-                                return 1;
-                        break;
-                case SEARCH_NOTEQUAL:
-                        if (msg->m_type != type)
-                                return 1;
-                        break;
+                break;
+        case SEARCH_EQUAL:
+                if (msg->m_type == type)
+                        return 1;
+                break;
+        case SEARCH_NOTEQUAL:
+                if (msg->m_type != type)
+                        return 1;
+                break;
         }
         return 0;
 }
@@ -978,7 +911,7 @@ long do_msgrcv(int msqid, void __user *buf, size_t bufsz, long msgtyp, int msgfl
                 else
                         msr_d.r_maxsize = bufsz;
                 msr_d.r_msg = ERR_PTR(-EAGAIN);
-                current->state = TASK_INTERRUPTIBLE;
+                __set_current_state(TASK_INTERRUPTIBLE);
 
                 ipc_unlock_object(&msq->q_perm);
                 rcu_read_unlock();
@@ -1056,6 +989,57 @@ SYSCALL_DEFINE5(msgrcv, int, msqid, struct msgbuf __user *, msgp, size_t, msgsz,
         return do_msgrcv(msqid, msgp, msgsz, msgtyp, msgflg, do_msg_fill);
 }
 
+/*
+ * Scale msgmni with the available lowmem size: the memory dedicated to msg
+ * queues should occupy at most 1/MSG_MEM_SCALE of lowmem.
+ * Also take into account the number of nsproxies created so far.
+ * This should be done staying within the (MSGMNI , IPCMNI/nr_ipc_ns) range.
+ */
+void recompute_msgmni(struct ipc_namespace *ns)
+{
+        struct sysinfo i;
+        unsigned long allowed;
+        int nb_ns;
+
+        si_meminfo(&i);
+        allowed = (((i.totalram - i.totalhigh) / MSG_MEM_SCALE) * i.mem_unit)
+                / MSGMNB;
+        nb_ns = atomic_read(&nr_ipc_ns);
+        allowed /= nb_ns;
+
+        if (allowed < MSGMNI) {
+                ns->msg_ctlmni = MSGMNI;
+                return;
+        }
+
+        if (allowed > IPCMNI / nb_ns) {
+                ns->msg_ctlmni = IPCMNI / nb_ns;
+                return;
+        }
+
+        ns->msg_ctlmni = allowed;
+}
+
+void msg_init_ns(struct ipc_namespace *ns)
+{
+        ns->msg_ctlmax = MSGMAX;
+        ns->msg_ctlmnb = MSGMNB;
+
+        recompute_msgmni(ns);
+
+        atomic_set(&ns->msg_bytes, 0);
+        atomic_set(&ns->msg_hdrs, 0);
+        ipc_init_ids(&ns->ids[IPC_MSG_IDS]);
+}
+
+#ifdef CONFIG_IPC_NS
+void msg_exit_ns(struct ipc_namespace *ns)
+{
+        free_ipcs(ns, &msg_ids(ns), freeque);
+        idr_destroy(&ns->ids[IPC_MSG_IDS].ipcs_idr);
+}
+#endif
+
 #ifdef CONFIG_PROC_FS
 static int sysvipc_msg_proc_show(struct seq_file *s, void *it)
 {
@@ -1080,3 +1064,15 @@ static int sysvipc_msg_proc_show(struct seq_file *s, void *it)
                         msq->q_ctime);
 }
 #endif
+
+void __init msg_init(void)
+{
+        msg_init_ns(&init_ipc_ns);
+
+        printk(KERN_INFO "msgmni has been set to %d\n",
+                init_ipc_ns.msg_ctlmni);
+
+        ipc_init_proc_interface("sysvipc/msg",
+                                "       key      msqid perms      cbytes       qnum lspid lrpid   uid   gid  cuid  cgid      stime      rtime      ctime\n",
+                                IPC_MSG_IDS, sysvipc_msg_proc_show);
+}
diff --git a/ipc/sem.c b/ipc/sem.c
index bee555417312..454f6c6020a8 100644
--- a/ipc/sem.c
+++ b/ipc/sem.c
@@ -47,8 +47,7 @@
  *   Thus: Perfect SMP scaling between independent semaphore arrays.
  *         If multiple semaphores in one array are used, then cache line
  *         trashing on the semaphore array spinlock will limit the scaling.
- * - semncnt and semzcnt are calculated on demand in count_semncnt() and
- *   count_semzcnt()
+ * - semncnt and semzcnt are calculated on demand in count_semcnt()
  * - the task that performs a successful semop() scans the list of all
  *   sleeping tasks and completes any pending operations that can be fulfilled.
  *   Semaphores are actively given to waiting tasks (necessary for FIFO).
@@ -87,7 +86,7 @@
 #include <linux/nsproxy.h>
 #include <linux/ipc_namespace.h>
 
-#include <asm/uaccess.h>
+#include <linux/uaccess.h>
 #include "util.h"
 
 /* One semaphore structure for each semaphore in the system. */
@@ -110,6 +109,7 @@ struct sem_queue {
         int                     pid;     /* process id of requesting process */
         int                     status;  /* completion status of operation */
         struct sembuf           *sops;   /* array of pending operations */
+        struct sembuf           *blocking; /* the operation that blocked */
         int                     nsops;   /* number of operations */
         int                     alter;   /* does *sops alter the array? */
 };
@@ -160,7 +160,7 @@ static int sysvipc_sem_proc_show(struct seq_file *s, void *it);
  *      sem_array.pending{_alter,_cont},
  *      sem_array.sem_undo: global sem_lock() for read/write
  *      sem_undo.proc_next: only "current" is allowed to read/write that field.
- *      
+ *
  *      sem_array.sem_base[i].pending_{const,alter}:
  *              global or semaphore sem_lock() for read/write
  */
@@ -564,7 +564,11 @@ static inline int sem_more_checks(struct kern_ipc_perm *ipcp,
 SYSCALL_DEFINE3(semget, key_t, key, int, nsems, int, semflg)
 {
         struct ipc_namespace *ns;
-        struct ipc_ops sem_ops;
+        static const struct ipc_ops sem_ops = {
+                .getnew = newary,
+                .associate = sem_security,
+                .more_checks = sem_more_checks,
+        };
         struct ipc_params sem_params;
 
         ns = current->nsproxy->ipc_ns;
@@ -572,10 +576,6 @@ SYSCALL_DEFINE3(semget, key_t, key, int, nsems, int, semflg)
         if (nsems < 0 || nsems > ns->sc_semmsl)
                 return -EINVAL;
 
-        sem_ops.getnew = newary;
-        sem_ops.associate = sem_security;
-        sem_ops.more_checks = sem_more_checks;
-
         sem_params.key = key;
         sem_params.flg = semflg;
         sem_params.u.nsems = nsems;
@@ -586,21 +586,23 @@ SYSCALL_DEFINE3(semget, key_t, key, int, nsems, int, semflg)
 /**
  * perform_atomic_semop - Perform (if possible) a semaphore operation
  * @sma: semaphore array
- * @sops: array with operations that should be checked
- * @nsops: number of operations
- * @un: undo array
- * @pid: pid that did the change
+ * @q: struct sem_queue that describes the operation
  *
  * Returns 0 if the operation was possible.
  * Returns 1 if the operation is impossible, the caller must sleep.
  * Negative values are error codes.
  */
-static int perform_atomic_semop(struct sem_array *sma, struct sembuf *sops,
-                             int nsops, struct sem_undo *un, int pid)
+static int perform_atomic_semop(struct sem_array *sma, struct sem_queue *q)
 {
-        int result, sem_op;
+        int result, sem_op, nsops, pid;
         struct sembuf *sop;
         struct sem *curr;
+        struct sembuf *sops;
+        struct sem_undo *un;
+
+        sops = q->sops;
+        nsops = q->nsops;
+        un = q->undo;
 
         for (sop = sops; sop < sops + nsops; sop++) {
                 curr = sma->sem_base + sop->sem_num;
@@ -628,6 +630,7 @@ static int perform_atomic_semop(struct sem_array *sma, struct sembuf *sops,
         }
 
         sop--;
+        pid = q->pid;
         while (sop >= sops) {
                 sma->sem_base[sop->sem_num].sempid = pid;
                 sop--;
@@ -640,6 +643,8 @@ out_of_range:
         goto undo;
 
 would_block:
+        q->blocking = sop;
+
         if (sop->sem_flg & IPC_NOWAIT)
                 result = -EAGAIN;
         else
@@ -780,8 +785,7 @@ static int wake_const_ops(struct sem_array *sma, int semnum,
                 q = container_of(walk, struct sem_queue, list);
                 walk = walk->next;
 
-                error = perform_atomic_semop(sma, q->sops, q->nsops,
-                                                 q->undo, q->pid);
+                error = perform_atomic_semop(sma, q);
 
                 if (error <= 0) {
                         /* operation completed, remove from queue & wakeup */
@@ -893,8 +897,7 @@ again:
                 if (semnum != -1 && sma->sem_base[semnum].semval == 0)
                         break;
 
-                error = perform_atomic_semop(sma, q->sops, q->nsops,
-                                         q->undo, q->pid);
+                error = perform_atomic_semop(sma, q);
 
                 /* Does q->sleeper still need to sleep? */
                 if (error > 0)
@@ -989,65 +992,74 @@ static void do_smart_update(struct sem_array *sma, struct sembuf *sops, int nsop
                 set_semotime(sma, sops);
 }
 
-/* The following counts are associated to each semaphore:
- *   semncnt        number of tasks waiting on semval being nonzero
- *   semzcnt        number of tasks waiting on semval being zero
- * This model assumes that a task waits on exactly one semaphore.
- * Since semaphore operations are to be performed atomically, tasks actually
- * wait on a whole sequence of semaphores simultaneously.
- * The counts we return here are a rough approximation, but still
- * warrant that semncnt+semzcnt>0 if the task is on the pending queue.
+/*
+ * check_qop: Test if a queued operation sleeps on the semaphore semnum
  */
-static int count_semncnt(struct sem_array *sma, ushort semnum)
+static int check_qop(struct sem_array *sma, int semnum, struct sem_queue *q,
+                        bool count_zero)
 {
-        int semncnt;
-        struct sem_queue *q;
+        struct sembuf *sop = q->blocking;
 
-        semncnt = 0;
-        list_for_each_entry(q, &sma->sem_base[semnum].pending_alter, list) {
-                struct sembuf *sops = q->sops;
-                BUG_ON(sops->sem_num != semnum);
-                if ((sops->sem_op < 0) && !(sops->sem_flg & IPC_NOWAIT))
-                        semncnt++;
-        }
+        /*
+         * Linux always (since 0.99.10) reported a task as sleeping on all
+         * semaphores. This violates SUS, therefore it was changed to the
+         * standard compliant behavior.
+         * Give the administrators a chance to notice that an application
+         * might misbehave because it relies on the Linux behavior.
+         */
+        pr_info_once("semctl(GETNCNT/GETZCNT) is since 3.16 Single Unix Specification compliant.\n"
+                        "The task %s (%d) triggered the difference, watch for misbehavior.\n",
+                        current->comm, task_pid_nr(current));
 
-        list_for_each_entry(q, &sma->pending_alter, list) {
-                struct sembuf *sops = q->sops;
-                int nsops = q->nsops;
-                int i;
-                for (i = 0; i < nsops; i++)
-                        if (sops[i].sem_num == semnum
-                            && (sops[i].sem_op < 0)
-                            && !(sops[i].sem_flg & IPC_NOWAIT))
-                                semncnt++;
-        }
-        return semncnt;
+        if (sop->sem_num != semnum)
+                return 0;
+
+        if (count_zero && sop->sem_op == 0)
+                return 1;
+        if (!count_zero && sop->sem_op < 0)
+                return 1;
+
+        return 0;
 }
 
-static int count_semzcnt(struct sem_array *sma, ushort semnum)
+/* The following counts are associated to each semaphore:
+ *   semncnt        number of tasks waiting on semval being nonzero
+ *   semzcnt        number of tasks waiting on semval being zero
+ *
+ * Per definition, a task waits only on the semaphore of the first semop
+ * that cannot proceed, even if additional operation would block, too.
+ */
+static int count_semcnt(struct sem_array *sma, ushort semnum,
+                        bool count_zero)
 {
-        int semzcnt;
+        struct list_head *l;
         struct sem_queue *q;
+        int semcnt;
+
+        semcnt = 0;
+        /* First: check the simple operations. They are easy to evaluate */
+        if (count_zero)
+                l = &sma->sem_base[semnum].pending_const;
+        else
+                l = &sma->sem_base[semnum].pending_alter;
 
-        semzcnt = 0;
-        list_for_each_entry(q, &sma->sem_base[semnum].pending_const, list) {
-                struct sembuf *sops = q->sops;
-                BUG_ON(sops->sem_num != semnum);
-                if ((sops->sem_op == 0) && !(sops->sem_flg & IPC_NOWAIT))
-                        semzcnt++;
+        list_for_each_entry(q, l, list) {
+                /* all task on a per-semaphore list sleep on exactly
+                 * that semaphore
+                 */
+                semcnt++;
         }
 
-        list_for_each_entry(q, &sma->pending_const, list) {
-                struct sembuf *sops = q->sops;
-                int nsops = q->nsops;
-                int i;
-                for (i = 0; i < nsops; i++)
-                        if (sops[i].sem_num == semnum
-                            && (sops[i].sem_op == 0)
-                            && !(sops[i].sem_flg & IPC_NOWAIT))
-                                semzcnt++;
+        /* Then: check the complex operations. */
+        list_for_each_entry(q, &sma->pending_alter, list) {
+                semcnt += check_qop(sma, semnum, q, count_zero);
         }
-        return semzcnt;
+        if (count_zero) {
+                list_for_each_entry(q, &sma->pending_const, list) {
+                        semcnt += check_qop(sma, semnum, q, count_zero);
+                }
+        }
+        return semcnt;
 }
 
 /* Free a semaphore set. freeary() is called with sem_ids.rwsem locked
@@ -1161,7 +1173,7 @@ static int semctl_nolock(struct ipc_namespace *ns, int semid,
                 err = security_sem_semctl(NULL, cmd);
                 if (err)
                         return err;
-                
+
                 memset(&seminfo, 0, sizeof(seminfo));
                 seminfo.semmni = ns->sc_semmni;
                 seminfo.semmns = ns->sc_semmns;
@@ -1181,7 +1193,7 @@ static int semctl_nolock(struct ipc_namespace *ns, int semid,
                 }
                 max_id = ipc_get_maxid(&sem_ids(ns));
                 up_read(&sem_ids(ns).rwsem);
-                if (copy_to_user(p, &seminfo, sizeof(struct seminfo))) 
+                if (copy_to_user(p, &seminfo, sizeof(struct seminfo)))
                         return -EFAULT;
                 return (max_id < 0) ? 0 : max_id;
         }
@@ -1449,10 +1461,10 @@ static int semctl_main(struct ipc_namespace *ns, int semid, int semnum,
                 err = curr->sempid;
                 goto out_unlock;
         case GETNCNT:
-                err = count_semncnt(sma, semnum);
+                err = count_semcnt(sma, semnum, 0);
                 goto out_unlock;
         case GETZCNT:
-                err = count_semzcnt(sma, semnum);
+                err = count_semcnt(sma, semnum, 1);
                 goto out_unlock;
         }
 
@@ -1866,8 +1878,13 @@ SYSCALL_DEFINE4(semtimedop, int, semid, struct sembuf __user *, tsops,
         if (un && un->semid == -1)
                 goto out_unlock_free;
 
-        error = perform_atomic_semop(sma, sops, nsops, un,
-                                        task_tgid_vnr(current));
+        queue.sops = sops;
+        queue.nsops = nsops;
+        queue.undo = un;
+        queue.pid = task_tgid_vnr(current);
+        queue.alter = alter;
+
+        error = perform_atomic_semop(sma, &queue);
         if (error == 0) {
                 /* If the operation was successful, then do
                  * the required updates.
@@ -1883,12 +1900,6 @@ SYSCALL_DEFINE4(semtimedop, int, semid, struct sembuf __user *, tsops,
         /* We need to sleep on this operation, so we put the current
          * task into the pending queue and go to sleep.
          */
-                
-        queue.sops = sops;
-        queue.nsops = nsops;
-        queue.undo = un;
-        queue.pid = task_tgid_vnr(current);
-        queue.alter = alter;
 
         if (nsops == 1) {
                 struct sem *curr;
@@ -2016,7 +2027,7 @@ int copy_semundo(unsigned long clone_flags, struct task_struct *tsk)
                         return error;
                 atomic_inc(&undo_list->refcnt);
                 tsk->sysvsem.undo_list = undo_list;
-        } else 
+        } else
                 tsk->sysvsem.undo_list = NULL;
 
         return 0;
diff --git a/ipc/shm.c b/ipc/shm.c
index 76459616a7fa..89fc354156cb 100644
--- a/ipc/shm.c
+++ b/ipc/shm.c
@@ -43,7 +43,7 @@
 #include <linux/mount.h>
 #include <linux/ipc_namespace.h>
 
-#include <asm/uaccess.h>
+#include <linux/uaccess.h>
 
 #include "util.h"
 
@@ -493,7 +493,11 @@ static int newseg(struct ipc_namespace *ns, struct ipc_params *params)
         if (size < SHMMIN || size > ns->shm_ctlmax)
                 return -EINVAL;
 
-        if (ns->shm_tot + numpages > ns->shm_ctlall)
+        if (numpages << PAGE_SHIFT < size)
+                return -ENOSPC;
+
+        if (ns->shm_tot + numpages < ns->shm_tot ||
+                        ns->shm_tot + numpages > ns->shm_ctlall)
                 return -ENOSPC;
 
         shp = ipc_rcu_alloc(sizeof(*shp));
@@ -609,15 +613,15 @@ static inline int shm_more_checks(struct kern_ipc_perm *ipcp,
 SYSCALL_DEFINE3(shmget, key_t, key, size_t, size, int, shmflg)
 {
         struct ipc_namespace *ns;
-        struct ipc_ops shm_ops;
+        static const struct ipc_ops shm_ops = {
+                .getnew = newseg,
+                .associate = shm_security,
+                .more_checks = shm_more_checks,
+        };
         struct ipc_params shm_params;
 
         ns = current->nsproxy->ipc_ns;
 
-        shm_ops.getnew = newseg;
-        shm_ops.associate = shm_security;
-        shm_ops.more_checks = shm_more_checks;
-
         shm_params.key = key;
         shm_params.flg = shmflg;
         shm_params.u.size = size;
@@ -694,7 +698,7 @@ static inline unsigned long copy_shminfo_to_user(void __user *buf, struct shminf
                 out.shmmin      = in->shmmin;
                 out.shmmni      = in->shmmni;
                 out.shmseg      = in->shmseg;
-                out.shmall      = in->shmall; 
+                out.shmall      = in->shmall;
 
                 return copy_to_user(buf, &out, sizeof(out));
             }
@@ -1160,6 +1164,9 @@ long do_shmat(int shmid, char __user *shmaddr, int shmflg, ulong *raddr,
         down_write(&current->mm->mmap_sem);
         if (addr && !(shmflg & SHM_REMAP)) {
                 err = -EINVAL;
+                if (addr + size < addr)
+                        goto invalid;
+
                 if (find_vma_intersection(current->mm, addr, addr + size))
                         goto invalid;
                 /*
diff --git a/ipc/util.c b/ipc/util.c
index 2eb0d1eaa312..27d74e69fd57 100644
--- a/ipc/util.c
+++ b/ipc/util.c
@@ -183,7 +183,7 @@ void __init ipc_init_proc_interface(const char *path, const char *header,
  * ipc_findkey  - find a key in an ipc identifier set
  * @ids: ipc identifier set
  * @key: key to find
- *      
+ *
  * Returns the locked pointer to the ipc structure if found or NULL
  * otherwise. If key is found ipc points to the owning ipc structure
  *
@@ -317,7 +317,7 @@ int ipc_addid(struct ipc_ids *ids, struct kern_ipc_perm *new, int size)
  * when the key is IPC_PRIVATE.
  */
 static int ipcget_new(struct ipc_namespace *ns, struct ipc_ids *ids,
-                struct ipc_ops *ops, struct ipc_params *params)
+                const struct ipc_ops *ops, struct ipc_params *params)
 {
         int err;
 
@@ -344,7 +344,7 @@ static int ipcget_new(struct ipc_namespace *ns, struct ipc_ids *ids,
  */
 static int ipc_check_perms(struct ipc_namespace *ns,
                            struct kern_ipc_perm *ipcp,
-                           struct ipc_ops *ops,
+                           const struct ipc_ops *ops,
                            struct ipc_params *params)
 {
         int err;
@@ -375,7 +375,7 @@ static int ipc_check_perms(struct ipc_namespace *ns,
  * On success, the ipc id is returned.
  */
 static int ipcget_public(struct ipc_namespace *ns, struct ipc_ids *ids,
-                struct ipc_ops *ops, struct ipc_params *params)
+                const struct ipc_ops *ops, struct ipc_params *params)
 {
         struct kern_ipc_perm *ipcp;
         int flg = params->flg;
@@ -538,7 +538,7 @@ int ipcperms(struct ipc_namespace *ns, struct kern_ipc_perm *ipcp, short flag)
         else if (in_group_p(ipcp->cgid) || in_group_p(ipcp->gid))
                 granted_mode >>= 3;
         /* is there some bit set in requested_mode but not in granted_mode? */
-        if ((requested_mode & ~granted_mode & 0007) && 
+        if ((requested_mode & ~granted_mode & 0007) &&
             !ns_capable(ns->user_ns, CAP_IPC_OWNER))
                 return -1;
 
@@ -678,7 +678,7 @@ out:
  * Common routine called by sys_msgget(), sys_semget() and sys_shmget().
  */
 int ipcget(struct ipc_namespace *ns, struct ipc_ids *ids,
-                        struct ipc_ops *ops, struct ipc_params *params)
+                        const struct ipc_ops *ops, struct ipc_params *params)
 {
         if (params->key == IPC_PRIVATE)
                 return ipcget_new(ns, ids, ops, params);
diff --git a/ipc/util.h b/ipc/util.h
index 9c47d6f6c7b4..1a5a0fcd099c 100644
--- a/ipc/util.h
+++ b/ipc/util.h
@@ -78,9 +78,9 @@ struct ipc_params {
  *      . routine to call for an extra check if needed
  */
 struct ipc_ops {
-        int (*getnew) (struct ipc_namespace *, struct ipc_params *);
-        int (*associate) (struct kern_ipc_perm *, int);
-        int (*more_checks) (struct kern_ipc_perm *, struct ipc_params *);
+        int (*getnew)(struct ipc_namespace *, struct ipc_params *);
+        int (*associate)(struct kern_ipc_perm *, int);
+        int (*more_checks)(struct kern_ipc_perm *, struct ipc_params *);
 };
 
 struct seq_file;
@@ -142,7 +142,7 @@ struct kern_ipc_perm *ipcctl_pre_down_nolock(struct ipc_namespace *ns,
                                              struct ipc64_perm *perm, int extra_perm);
 
 #ifndef CONFIG_ARCH_WANT_IPC_PARSE_VERSION
-  /* On IA-64, we always use the "64-bit version" of the IPC structures.  */ 
+/* On IA-64, we always use the "64-bit version" of the IPC structures.  */
 # define ipc_parse_version(cmd) IPC_64
 #else
 int ipc_parse_version(int *cmd);
@@ -201,7 +201,7 @@ static inline bool ipc_valid_object(struct kern_ipc_perm *perm)
 
 struct kern_ipc_perm *ipc_obtain_object_check(struct ipc_ids *ids, int id);
 int ipcget(struct ipc_namespace *ns, struct ipc_ids *ids,
-                        struct ipc_ops *ops, struct ipc_params *params);
+                        const struct ipc_ops *ops, struct ipc_params *params);
 void free_ipcs(struct ipc_namespace *ns, struct ipc_ids *ids,
                 void (*free)(struct ipc_namespace *, struct kern_ipc_perm *));
 #endif
diff --git a/kernel/acct.c b/kernel/acct.c
index 8d6e145138bb..808a86ff229d 100644
--- a/kernel/acct.c
+++ b/kernel/acct.c
@@ -55,7 +55,7 @@
 #include <linux/times.h>
 #include <linux/syscalls.h>
 #include <linux/mount.h>
-#include <asm/uaccess.h>
+#include <linux/uaccess.h>
 #include <asm/div64.h>
 #include <linux/blkdev.h> /* sector_div */
 #include <linux/pid_namespace.h>
@@ -134,7 +134,7 @@ static int check_free_space(struct bsd_acct_struct *acct, struct file *file)
         spin_lock(&acct_lock);
         if (file != acct->file) {
                 if (act)
-                        res = act>0;
+                        res = act > 0;
                 goto out;
         }
 
@@ -262,7 +262,7 @@ SYSCALL_DEFINE1(acct, const char __user *, name)
         if (name) {
                 struct filename *tmp = getname(name);
                 if (IS_ERR(tmp))
-                        return (PTR_ERR(tmp));
+                        return PTR_ERR(tmp);
                 error = acct_on(tmp);
                 putname(tmp);
         } else {
diff --git a/kernel/audit.c b/kernel/audit.c
index 47845c57eb19..f30106459a32 100644
--- a/kernel/audit.c
+++ b/kernel/audit.c
@@ -44,7 +44,7 @@
 #define pr_fmt(fmt) KBUILD_MODNAME ": " fmt
 
 #include <linux/init.h>
-#include <asm/types.h>
+#include <linux/types.h>
 #include <linux/atomic.h>
 #include <linux/mm.h>
 #include <linux/export.h>
diff --git a/kernel/exit.c b/kernel/exit.c
index 750c2e594617..e5c4668f1799 100644
--- a/kernel/exit.c
+++ b/kernel/exit.c
@@ -313,45 +313,6 @@ kill_orphaned_pgrp(struct task_struct *tsk, struct task_struct *parent)
         }
 }
 
-/*
- * Let kernel threads use this to say that they allow a certain signal.
- * Must not be used if kthread was cloned with CLONE_SIGHAND.
- */
-int allow_signal(int sig)
-{
-        if (!valid_signal(sig) || sig < 1)
-                return -EINVAL;
-
-        spin_lock_irq(&current->sighand->siglock);
-        /* This is only needed for daemonize()'ed kthreads */
-        sigdelset(&current->blocked, sig);
-        /*
-         * Kernel threads handle their own signals. Let the signal code
-         * know it'll be handled, so that they don't get converted to
-         * SIGKILL or just silently dropped.
-         */
-        current->sighand->action[(sig)-1].sa.sa_handler = (void __user *)2;
-        recalc_sigpending();
-        spin_unlock_irq(&current->sighand->siglock);
-        return 0;
-}
-
-EXPORT_SYMBOL(allow_signal);
-
-int disallow_signal(int sig)
-{
-        if (!valid_signal(sig) || sig < 1)
-                return -EINVAL;
-
-        spin_lock_irq(&current->sighand->siglock);
-        current->sighand->action[(sig)-1].sa.sa_handler = SIG_IGN;
-        recalc_sigpending();
-        spin_unlock_irq(&current->sighand->siglock);
-        return 0;
-}
-
-EXPORT_SYMBOL(disallow_signal);
-
 #ifdef CONFIG_MEMCG
 /*
  * A task is exiting.   If it owned this mm, find a new owner for the mm.
diff --git a/kernel/fork.c b/kernel/fork.c
index 0d53eb0dfb6f..d2799d1fc952 100644
--- a/kernel/fork.c
+++ b/kernel/fork.c
@@ -1606,10 +1606,12 @@ long do_fork(unsigned long clone_flags,
          */
         if (!IS_ERR(p)) {
                 struct completion vfork;
+                struct pid *pid;
 
                 trace_sched_process_fork(current, p);
 
-                nr = task_pid_vnr(p);
+                pid = get_task_pid(p, PIDTYPE_PID);
+                nr = pid_vnr(pid);
 
                 if (clone_flags & CLONE_PARENT_SETTID)
                         put_user(nr, parent_tidptr);
@@ -1624,12 +1626,14 @@ long do_fork(unsigned long clone_flags,
 
                 /* forking complete and child started to run, tell ptracer */
                 if (unlikely(trace))
-                        ptrace_event(trace, nr);
+                        ptrace_event_pid(trace, pid);
 
                 if (clone_flags & CLONE_VFORK) {
                         if (!wait_for_vfork_done(p, &vfork))
-                                ptrace_event(PTRACE_EVENT_VFORK_DONE, nr);
+                                ptrace_event_pid(PTRACE_EVENT_VFORK_DONE, pid);
                 }
+
+                put_pid(pid);
         } else {
                 nr = PTR_ERR(p);
         }
diff --git a/kernel/kexec.c b/kernel/kexec.c
index 28c57069ef68..6748688813d0 100644
--- a/kernel/kexec.c
+++ b/kernel/kexec.c
@@ -125,8 +125,8 @@ static struct page *kimage_alloc_page(struct kimage *image,
                                        unsigned long dest);
 
 static int do_kimage_alloc(struct kimage **rimage, unsigned long entry,
-                            unsigned long nr_segments,
-                            struct kexec_segment __user *segments)
+                           unsigned long nr_segments,
+                           struct kexec_segment __user *segments)
 {
         size_t segment_bytes;
         struct kimage *image;
@@ -257,13 +257,13 @@ static int kimage_normal_alloc(struct kimage **rimage, unsigned long entry,
         image->control_code_page = kimage_alloc_control_pages(image,
                                            get_order(KEXEC_CONTROL_PAGE_SIZE));
         if (!image->control_code_page) {
-                printk(KERN_ERR "Could not allocate control_code_buffer\n");
+                pr_err("Could not allocate control_code_buffer\n");
                 goto out_free;
         }
 
         image->swap_page = kimage_alloc_control_pages(image, 0);
         if (!image->swap_page) {
-                printk(KERN_ERR "Could not allocate swap buffer\n");
+                pr_err("Could not allocate swap buffer\n");
                 goto out_free;
         }
 
@@ -332,7 +332,7 @@ static int kimage_crash_alloc(struct kimage **rimage, unsigned long entry,
         image->control_code_page = kimage_alloc_control_pages(image,
                                            get_order(KEXEC_CONTROL_PAGE_SIZE));
         if (!image->control_code_page) {
-                printk(KERN_ERR "Could not allocate control_code_buffer\n");
+                pr_err("Could not allocate control_code_buffer\n");
                 goto out_free;
         }
 
@@ -621,8 +621,8 @@ static void kimage_terminate(struct kimage *image)
 
 #define for_each_kimage_entry(image, ptr, entry) \
         for (ptr = &image->head; (entry = *ptr) && !(entry & IND_DONE); \
-                ptr = (entry & IND_INDIRECTION)? \
-                        phys_to_virt((entry & PAGE_MASK)): ptr +1)
+                ptr = (entry & IND_INDIRECTION) ? \
+                        phys_to_virt((entry & PAGE_MASK)) : ptr + 1)
 
 static void kimage_free_entry(kimage_entry_t entry)
 {
@@ -650,8 +650,7 @@ static void kimage_free(struct kimage *image)
                          * done with it.
                          */
                         ind = entry;
-                }
-                else if (entry & IND_SOURCE)
+                } else if (entry & IND_SOURCE)
                         kimage_free_entry(entry);
         }
         /* Free the final indirection page */
@@ -774,8 +773,7 @@ static struct page *kimage_alloc_page(struct kimage *image,
                         addr = old_addr;
                         page = old_page;
                         break;
-                }
-                else {
+                } else {
                         /* Place the page on the destination list I
                          * will use it later.
                          */
@@ -1059,7 +1057,7 @@ COMPAT_SYSCALL_DEFINE4(kexec_load, compat_ulong_t, entry,
                 return -EINVAL;
 
         ksegments = compat_alloc_user_space(nr_segments * sizeof(out));
-        for (i=0; i < nr_segments; i++) {
+        for (i = 0; i < nr_segments; i++) {
                 result = copy_from_user(&in, &segments[i], sizeof(in));
                 if (result)
                         return -EFAULT;
@@ -1214,14 +1212,14 @@ void crash_save_cpu(struct pt_regs *regs, int cpu)
          * squirrelled away.  ELF notes happen to provide
          * all of that, so there is no need to invent something new.
          */
-        buf = (u32*)per_cpu_ptr(crash_notes, cpu);
+        buf = (u32 *)per_cpu_ptr(crash_notes, cpu);
         if (!buf)
                 return;
         memset(&prstatus, 0, sizeof(prstatus));
         prstatus.pr_pid = current->pid;
         elf_core_copy_kernel_regs(&prstatus.pr_reg, regs);
         buf = append_elf_note(buf, KEXEC_CORE_NOTE_NAME, NT_PRSTATUS,
-                              &prstatus, sizeof(prstatus));
+                              &prstatus, sizeof(prstatus));
         final_note(buf);
 }
 
@@ -1230,8 +1228,7 @@ static int __init crash_notes_memory_init(void)
         /* Allocate memory for saving cpu registers. */
         crash_notes = alloc_percpu(note_buf_t);
         if (!crash_notes) {
-                printk("Kexec: Memory allocation for saving cpu register"
-                " states failed\n");
+                pr_warn("Kexec: Memory allocation for saving cpu register states failed\n");
                 return -ENOMEM;
         }
         return 0;
@@ -1253,10 +1250,10 @@ subsys_initcall(crash_notes_memory_init);
  *
  * The function returns 0 on success and -EINVAL on failure.
  */
-static int __init parse_crashkernel_mem(char                    *cmdline,
-                                        unsigned long long      system_ram,
-                                        unsigned long long      *crash_size,
-                                        unsigned long long      *crash_base)
+static int __init parse_crashkernel_mem(char *cmdline,
+                                        unsigned long long system_ram,
+                                        unsigned long long *crash_size,
+                                        unsigned long long *crash_base)
 {
         char *cur = cmdline, *tmp;
 
@@ -1267,12 +1264,12 @@ static int __init parse_crashkernel_mem(char 			*cmdline,
                 /* get the start of the range */
                 start = memparse(cur, &tmp);
                 if (cur == tmp) {
-                        pr_warning("crashkernel: Memory value expected\n");
+                        pr_warn("crashkernel: Memory value expected\n");
                         return -EINVAL;
                 }
                 cur = tmp;
                 if (*cur != '-') {
-                        pr_warning("crashkernel: '-' expected\n");
+                        pr_warn("crashkernel: '-' expected\n");
                         return -EINVAL;
                 }
                 cur++;
@@ -1281,31 +1278,30 @@ static int __init parse_crashkernel_mem(char 			*cmdline,
                 if (*cur != ':') {
                         end = memparse(cur, &tmp);
                         if (cur == tmp) {
-                                pr_warning("crashkernel: Memory "
-                                                "value expected\n");
+                                pr_warn("crashkernel: Memory value expected\n");
                                 return -EINVAL;
                         }
                         cur = tmp;
                         if (end <= start) {
-                                pr_warning("crashkernel: end <= start\n");
+                                pr_warn("crashkernel: end <= start\n");
                                 return -EINVAL;
                         }
                 }
 
                 if (*cur != ':') {
-                        pr_warning("crashkernel: ':' expected\n");
+                        pr_warn("crashkernel: ':' expected\n");
                         return -EINVAL;
                 }
                 cur++;
 
                 size = memparse(cur, &tmp);
                 if (cur == tmp) {
-                        pr_warning("Memory value expected\n");
+                        pr_warn("Memory value expected\n");
                         return -EINVAL;
                 }
                 cur = tmp;
                 if (size >= system_ram) {
-                        pr_warning("crashkernel: invalid size\n");
+                        pr_warn("crashkernel: invalid size\n");
                         return -EINVAL;
                 }
 
@@ -1323,8 +1319,7 @@ static int __init parse_crashkernel_mem(char 			*cmdline,
                         cur++;
                         *crash_base = memparse(cur, &tmp);
                         if (cur == tmp) {
-                                pr_warning("Memory value expected "
-                                                "after '@'\n");
+                                pr_warn("Memory value expected after '@'\n");
                                 return -EINVAL;
                         }
                 }
@@ -1336,26 +1331,26 @@ static int __init parse_crashkernel_mem(char 			*cmdline,
 /*
  * That function parses "simple" (old) crashkernel command lines like
  *
- *      crashkernel=size[@offset]
+ *      crashkernel=size[@offset]
  *
  * It returns 0 on success and -EINVAL on failure.
  */
-static int __init parse_crashkernel_simple(char                 *cmdline,
-                                           unsigned long long   *crash_size,
-                                           unsigned long long   *crash_base)
+static int __init parse_crashkernel_simple(char *cmdline,
+                                           unsigned long long *crash_size,
+                                           unsigned long long *crash_base)
 {
         char *cur = cmdline;
 
         *crash_size = memparse(cmdline, &cur);
         if (cmdline == cur) {
-                pr_warning("crashkernel: memory value expected\n");
+                pr_warn("crashkernel: memory value expected\n");
                 return -EINVAL;
         }
 
         if (*cur == '@')
                 *crash_base = memparse(cur+1, &cur);
         else if (*cur != ' ' && *cur != '\0') {
-                pr_warning("crashkernel: unrecognized char\n");
+                pr_warn("crashkernel: unrecognized char\n");
                 return -EINVAL;
         }
 
@@ -1691,7 +1686,7 @@ int kernel_kexec(void)
                  * CPU hotplug again; so re-enable it here.
                  */
                 cpu_hotplug_enable();
-                printk(KERN_EMERG "Starting new kernel\n");
+                pr_emerg("Starting new kernel\n");
                 machine_shutdown();
         }
 
diff --git a/kernel/kmod.c b/kernel/kmod.c
index 0ac67a5861c5..8637e041a247 100644
--- a/kernel/kmod.c
+++ b/kernel/kmod.c
@@ -285,10 +285,7 @@ static int wait_for_helper(void *data)
         pid_t pid;
 
         /* If SIGCLD is ignored sys_wait4 won't populate the status. */
-        spin_lock_irq(&current->sighand->siglock);
-        current->sighand->action[SIGCHLD-1].sa.sa_handler = SIG_DFL;
-        spin_unlock_irq(&current->sighand->siglock);
-
+        kernel_sigaction(SIGCHLD, SIG_DFL);
         pid = kernel_thread(____call_usermodehelper, sub_info, SIGCHLD);
         if (pid < 0) {
                 sub_info->retval = pid;
diff --git a/kernel/panic.c b/kernel/panic.c
index d02fa9fef46a..62e16cef9cc2 100644
--- a/kernel/panic.c
+++ b/kernel/panic.c
@@ -32,6 +32,7 @@ static unsigned long tainted_mask;
 static int pause_on_oops;
 static int pause_on_oops_flag;
 static DEFINE_SPINLOCK(pause_on_oops_lock);
+static bool crash_kexec_post_notifiers;
 
 int panic_timeout = CONFIG_PANIC_TIMEOUT;
 EXPORT_SYMBOL_GPL(panic_timeout);
@@ -112,9 +113,11 @@ void panic(const char *fmt, ...)
         /*
          * If we have crashed and we have a crash kernel loaded let it handle
          * everything else.
-         * Do we want to call this before we try to display a message?
+         * If we want to run this after calling panic_notifiers, pass
+         * the "crash_kexec_post_notifiers" option to the kernel.
          */
-        crash_kexec(NULL);
+        if (!crash_kexec_post_notifiers)
+                crash_kexec(NULL);
 
         /*
          * Note smp_send_stop is the usual smp shutdown function, which
@@ -131,6 +134,15 @@ void panic(const char *fmt, ...)
 
         kmsg_dump(KMSG_DUMP_PANIC);
 
+        /*
+         * If you doubt kdump always works fine in any situation,
+         * "crash_kexec_post_notifiers" offers you a chance to run
+         * panic_notifiers and dumping kmsg before kdump.
+         * Note: since some panic_notifiers can make crashed kernel
+         * more unstable, it can increase risks of the kdump failure too.
+         */
+        crash_kexec(NULL);
+
         bust_spinlocks(0);
 
         if (!panic_blink)
@@ -472,6 +484,13 @@ EXPORT_SYMBOL(__stack_chk_fail);
 core_param(panic, panic_timeout, int, 0644);
 core_param(pause_on_oops, pause_on_oops, int, 0644);
 
+static int __init setup_crash_kexec_post_notifiers(char *s)
+{
+        crash_kexec_post_notifiers = true;
+        return 0;
+}
+early_param("crash_kexec_post_notifiers", setup_crash_kexec_post_notifiers);
+
 static int __init oops_setup(char *s)
 {
         if (!s)
diff --git a/kernel/profile.c b/kernel/profile.c
index cb980f0c731b..54bf5ba26420 100644
--- a/kernel/profile.c
+++ b/kernel/profile.c
@@ -52,9 +52,9 @@ static DEFINE_MUTEX(profile_flip_mutex);
 
 int profile_setup(char *str)
 {
-        static char schedstr[] = "schedule";
-        static char sleepstr[] = "sleep";
-        static char kvmstr[] = "kvm";
+        static const char schedstr[] = "schedule";
+        static const char sleepstr[] = "sleep";
+        static const char kvmstr[] = "kvm";
         int par;
 
         if (!strncmp(str, sleepstr, strlen(sleepstr))) {
@@ -64,12 +64,10 @@ int profile_setup(char *str)
                         str += strlen(sleepstr) + 1;
                 if (get_option(&str, &par))
                         prof_shift = par;
-                printk(KERN_INFO
-                        "kernel sleep profiling enabled (shift: %ld)\n",
+                pr_info("kernel sleep profiling enabled (shift: %ld)\n",
                         prof_shift);
 #else
-                printk(KERN_WARNING
-                        "kernel sleep profiling requires CONFIG_SCHEDSTATS\n");
+                pr_warn("kernel sleep profiling requires CONFIG_SCHEDSTATS\n");
 #endif /* CONFIG_SCHEDSTATS */
         } else if (!strncmp(str, schedstr, strlen(schedstr))) {
                 prof_on = SCHED_PROFILING;
@@ -77,8 +75,7 @@ int profile_setup(char *str)
                         str += strlen(schedstr) + 1;
                 if (get_option(&str, &par))
                         prof_shift = par;
-                printk(KERN_INFO
-                        "kernel schedule profiling enabled (shift: %ld)\n",
+                pr_info("kernel schedule profiling enabled (shift: %ld)\n",
                         prof_shift);
         } else if (!strncmp(str, kvmstr, strlen(kvmstr))) {
                 prof_on = KVM_PROFILING;
@@ -86,13 +83,12 @@ int profile_setup(char *str)
                         str += strlen(kvmstr) + 1;
                 if (get_option(&str, &par))
                         prof_shift = par;
-                printk(KERN_INFO
-                        "kernel KVM profiling enabled (shift: %ld)\n",
+                pr_info("kernel KVM profiling enabled (shift: %ld)\n",
                         prof_shift);
         } else if (get_option(&str, &par)) {
                 prof_shift = par;
                 prof_on = CPU_PROFILING;
-                printk(KERN_INFO "kernel profiling enabled (shift: %ld)\n",
+                pr_info("kernel profiling enabled (shift: %ld)\n",
                         prof_shift);
         }
         return 1;
diff --git a/kernel/seccomp.c b/kernel/seccomp.c
index b35c21503a36..f6d76bebe69f 100644
--- a/kernel/seccomp.c
+++ b/kernel/seccomp.c
@@ -39,7 +39,7 @@
  *         is only needed for handling filters shared across tasks.
  * @prev: points to a previously installed, or inherited, filter
  * @len: the number of instructions in the program
- * @insns: the BPF program instructions to evaluate
+ * @insnsi: the BPF program instructions to evaluate
  *
  * seccomp_filter objects are organized in a tree linked via the @prev
  * pointer.  For any task, it appears to be a singly-linked list starting
@@ -220,7 +220,7 @@ static long seccomp_attach_filter(struct sock_fprog *fprog)
                 return -ENOMEM;
 
         /*
-         * Installing a seccomp filter requires that the task have
+         * Installing a seccomp filter requires that the task has
          * CAP_SYS_ADMIN in its namespace or be running with no_new_privs.
          * This avoids scenarios where unprivileged tasks can affect the
          * behavior of privileged children.
diff --git a/kernel/signal.c b/kernel/signal.c
index 6e600aaa2af4..a4077e90f19f 100644
--- a/kernel/signal.c
+++ b/kernel/signal.c
@@ -277,6 +277,7 @@ void task_clear_jobctl_trapping(struct task_struct *task)
 {
         if (unlikely(task->jobctl & JOBCTL_TRAPPING)) {
                 task->jobctl &= ~JOBCTL_TRAPPING;
+                smp_mb();       /* advised by wake_up_bit() */
                 wake_up_bit(&task->jobctl, JOBCTL_TRAPPING_BIT);
         }
 }
@@ -705,11 +706,8 @@ void signal_wake_up_state(struct task_struct *t, unsigned int state)
  * Returns 1 if any signals were found.
  *
  * All callers must be holding the siglock.
- *
- * This version takes a sigset mask and looks at all signals,
- * not just those in the first mask word.
  */
-static int rm_from_queue_full(sigset_t *mask, struct sigpending *s)
+static int flush_sigqueue_mask(sigset_t *mask, struct sigpending *s)
 {
         struct sigqueue *q, *n;
         sigset_t m;
@@ -727,29 +725,6 @@ static int rm_from_queue_full(sigset_t *mask, struct sigpending *s)
         }
         return 1;
 }
-/*
- * Remove signals in mask from the pending set and queue.
- * Returns 1 if any signals were found.
- *
- * All callers must be holding the siglock.
- */
-static int rm_from_queue(unsigned long mask, struct sigpending *s)
-{
-        struct sigqueue *q, *n;
-
-        if (!sigtestsetmask(&s->signal, mask))
-                return 0;
-
-        sigdelsetmask(&s->signal, mask);
-        list_for_each_entry_safe(q, n, &s->list, list) {
-                if (q->info.si_signo < SIGRTMIN &&
-                    (mask & sigmask(q->info.si_signo))) {
-                        list_del_init(&q->list);
-                        __sigqueue_free(q);
-                }
-        }
-        return 1;
-}
 
 static inline int is_si_special(const struct siginfo *info)
 {
@@ -861,6 +836,7 @@ static bool prepare_signal(int sig, struct task_struct *p, bool force)
 {
         struct signal_struct *signal = p->signal;
         struct task_struct *t;
+        sigset_t flush;
 
         if (signal->flags & (SIGNAL_GROUP_EXIT | SIGNAL_GROUP_COREDUMP)) {
                 if (signal->flags & SIGNAL_GROUP_COREDUMP)
@@ -872,26 +848,25 @@ static bool prepare_signal(int sig, struct task_struct *p, bool force)
                 /*
                  * This is a stop signal.  Remove SIGCONT from all queues.
                  */
-                rm_from_queue(sigmask(SIGCONT), &signal->shared_pending);
-                t = p;
-                do {
-                        rm_from_queue(sigmask(SIGCONT), &t->pending);
-                } while_each_thread(p, t);
+                siginitset(&flush, sigmask(SIGCONT));
+                flush_sigqueue_mask(&flush, &signal->shared_pending);
+                for_each_thread(p, t)
+                        flush_sigqueue_mask(&flush, &t->pending);
         } else if (sig == SIGCONT) {
                 unsigned int why;
                 /*
                  * Remove all stop signals from all queues, wake all threads.
                  */
-                rm_from_queue(SIG_KERNEL_STOP_MASK, &signal->shared_pending);
-                t = p;
-                do {
+                siginitset(&flush, SIG_KERNEL_STOP_MASK);
+                flush_sigqueue_mask(&flush, &signal->shared_pending);
+                for_each_thread(p, t) {
+                        flush_sigqueue_mask(&flush, &t->pending);
                         task_clear_jobctl_pending(t, JOBCTL_STOP_PENDING);
-                        rm_from_queue(SIG_KERNEL_STOP_MASK, &t->pending);
                         if (likely(!(t->ptrace & PT_SEIZED)))
                                 wake_up_state(t, __TASK_STOPPED);
                         else
                                 ptrace_trap_notify(t);
-                } while_each_thread(p, t);
+                }
 
                 /*
                  * Notify the parent with CLD_CONTINUED if we were stopped.
@@ -2854,7 +2829,7 @@ int do_sigtimedwait(const sigset_t *which, siginfo_t *info,
 
                 spin_lock_irq(&tsk->sighand->siglock);
                 __set_task_blocked(tsk, &tsk->real_blocked);
-                siginitset(&tsk->real_blocked, 0);
+                sigemptyset(&tsk->real_blocked);
                 sig = dequeue_signal(tsk, &mask, info);
         }
         spin_unlock_irq(&tsk->sighand->siglock);
@@ -3091,18 +3066,39 @@ COMPAT_SYSCALL_DEFINE4(rt_tgsigqueueinfo,
 }
 #endif
 
+/*
+ * For kthreads only, must not be used if cloned with CLONE_SIGHAND
+ */
+void kernel_sigaction(int sig, __sighandler_t action)
+{
+        spin_lock_irq(&current->sighand->siglock);
+        current->sighand->action[sig - 1].sa.sa_handler = action;
+        if (action == SIG_IGN) {
+                sigset_t mask;
+
+                sigemptyset(&mask);
+                sigaddset(&mask, sig);
+
+                flush_sigqueue_mask(&mask, &current->signal->shared_pending);
+                flush_sigqueue_mask(&mask, &current->pending);
+                recalc_sigpending();
+        }
+        spin_unlock_irq(&current->sighand->siglock);
+}
+EXPORT_SYMBOL(kernel_sigaction);
+
 int do_sigaction(int sig, struct k_sigaction *act, struct k_sigaction *oact)
 {
-        struct task_struct *t = current;
+        struct task_struct *p = current, *t;
         struct k_sigaction *k;
         sigset_t mask;
 
         if (!valid_signal(sig) || sig < 1 || (act && sig_kernel_only(sig)))
                 return -EINVAL;
 
-        k = &t->sighand->action[sig-1];
+        k = &p->sighand->action[sig-1];
 
-        spin_lock_irq(&current->sighand->siglock);
+        spin_lock_irq(&p->sighand->siglock);
         if (oact)
                 *oact = *k;
 
@@ -3121,21 +3117,20 @@ int do_sigaction(int sig, struct k_sigaction *act, struct k_sigaction *oact)
                  *   (for example, SIGCHLD), shall cause the pending signal to
                  *   be discarded, whether or not it is blocked"
                  */
-                if (sig_handler_ignored(sig_handler(t, sig), sig)) {
+                if (sig_handler_ignored(sig_handler(p, sig), sig)) {
                         sigemptyset(&mask);
                         sigaddset(&mask, sig);
-                        rm_from_queue_full(&mask, &t->signal->shared_pending);
-                        do {
-                                rm_from_queue_full(&mask, &t->pending);
-                        } while_each_thread(current, t);
+                        flush_sigqueue_mask(&mask, &p->signal->shared_pending);
+                        for_each_thread(p, t)
+                                flush_sigqueue_mask(&mask, &t->pending);
                 }
         }
 
-        spin_unlock_irq(&current->sighand->siglock);
+        spin_unlock_irq(&p->sighand->siglock);
         return 0;
 }
 
-static int 
+static int
 do_sigaltstack (const stack_t __user *uss, stack_t __user *uoss, unsigned long sp)
 {
         stack_t oss;
diff --git a/kernel/smp.c b/kernel/smp.c
index 06d574e42c72..306f8180b0d5 100644
--- a/kernel/smp.c
+++ b/kernel/smp.c
@@ -185,14 +185,26 @@ void generic_smp_call_function_single_interrupt(void)
 {
         struct llist_node *entry;
         struct call_single_data *csd, *csd_next;
+        static bool warned;
+
+        entry = llist_del_all(&__get_cpu_var(call_single_queue));
+        entry = llist_reverse_order(entry);
 
         /*
          * Shouldn't receive this interrupt on a cpu that is not yet online.
          */
-        WARN_ON_ONCE(!cpu_online(smp_processor_id()));
+        if (unlikely(!cpu_online(smp_processor_id()) && !warned)) {
+                warned = true;
+                WARN(1, "IPI on offline CPU %d\n", smp_processor_id());
 
-        entry = llist_del_all(&__get_cpu_var(call_single_queue));
-        entry = llist_reverse_order(entry);
+                /*
+                 * We don't have to use the _safe() variant here
+                 * because we are not invoking the IPI handlers yet.
+                 */
+                llist_for_each_entry(csd, entry, llist)
+                        pr_warn("IPI callback %pS sent to offline CPU\n",
+                                csd->func);
+        }
 
         llist_for_each_entry_safe(csd, csd_next, entry, llist) {
                 csd->func(csd->info);
diff --git a/kernel/sysctl.c b/kernel/sysctl.c
index 40ce2d983b12..db19e3e2aa4b 100644
--- a/kernel/sysctl.c
+++ b/kernel/sysctl.c
@@ -173,6 +173,13 @@ extern int no_unaligned_warning;
 #endif
 
 #ifdef CONFIG_PROC_SYSCTL
+
+#define SYSCTL_WRITES_LEGACY    -1
+#define SYSCTL_WRITES_WARN       0
+#define SYSCTL_WRITES_STRICT     1
+
+static int sysctl_writes_strict = SYSCTL_WRITES_WARN;
+
 static int proc_do_cad_pid(struct ctl_table *table, int write,
                   void __user *buffer, size_t *lenp, loff_t *ppos);
 static int proc_taint(struct ctl_table *table, int write,
@@ -195,7 +202,7 @@ static int proc_dostring_coredump(struct ctl_table *table, int write,
 /* Note: sysrq code uses it's own private copy */
 static int __sysrq_enabled = CONFIG_MAGIC_SYSRQ_DEFAULT_ENABLE;
 
-static int sysrq_sysctl_handler(ctl_table *table, int write,
+static int sysrq_sysctl_handler(struct ctl_table *table, int write,
                                 void __user *buffer, size_t *lenp,
                                 loff_t *ppos)
 {
@@ -495,6 +502,15 @@ static struct ctl_table kern_table[] = {
                 .mode           = 0644,
                 .proc_handler   = proc_taint,
         },
+        {
+                .procname       = "sysctl_writes_strict",
+                .data           = &sysctl_writes_strict,
+                .maxlen         = sizeof(int),
+                .mode           = 0644,
+                .proc_handler   = proc_dointvec_minmax,
+                .extra1         = &neg_one,
+                .extra2         = &one,
+        },
 #endif
 #ifdef CONFIG_LATENCYTOP
         {
@@ -1703,8 +1719,8 @@ int __init sysctl_init(void)
 
 #ifdef CONFIG_PROC_SYSCTL
 
-static int _proc_do_string(void* data, int maxlen, int write,
-                           void __user *buffer,
+static int _proc_do_string(char *data, int maxlen, int write,
+                           char __user *buffer,
                            size_t *lenp, loff_t *ppos)
 {
         size_t len;
@@ -1717,21 +1733,30 @@ static int _proc_do_string(void* data, int maxlen, int write,
         }
 
         if (write) {
-                len = 0;
+                if (sysctl_writes_strict == SYSCTL_WRITES_STRICT) {
+                        /* Only continue writes not past the end of buffer. */
+                        len = strlen(data);
+                        if (len > maxlen - 1)
+                                len = maxlen - 1;
+
+                        if (*ppos > len)
+                                return 0;
+                        len = *ppos;
+                } else {
+                        /* Start writing from beginning of buffer. */
+                        len = 0;
+                }
+
+                *ppos += *lenp;
                 p = buffer;
-                while (len < *lenp) {
+                while ((p - buffer) < *lenp && len < maxlen - 1) {
                         if (get_user(c, p++))
                                 return -EFAULT;
                         if (c == 0 || c == '\n')
                                 break;
-                        len++;
+                        data[len++] = c;
                 }
-                if (len >= maxlen)
-                        len = maxlen-1;
-                if(copy_from_user(data, buffer, len))
-                        return -EFAULT;
-                ((char *) data)[len] = 0;
-                *ppos += *lenp;
+                data[len] = 0;
         } else {
                 len = strlen(data);
                 if (len > maxlen)
@@ -1748,10 +1773,10 @@ static int _proc_do_string(void* data, int maxlen, int write,
                 if (len > *lenp)
                         len = *lenp;
                 if (len)
-                        if(copy_to_user(buffer, data, len))
+                        if (copy_to_user(buffer, data, len))
                                 return -EFAULT;
                 if (len < *lenp) {
-                        if(put_user('\n', ((char __user *) buffer) + len))
+                        if (put_user('\n', buffer + len))
                                 return -EFAULT;
                         len++;
                 }
@@ -1761,6 +1786,14 @@ static int _proc_do_string(void* data, int maxlen, int write,
         return 0;
 }
 
+static void warn_sysctl_write(struct ctl_table *table)
+{
+        pr_warn_once("%s wrote to %s when file position was not 0!\n"
+                "This will not be supported in the future. To silence this\n"
+                "warning, set kernel.sysctl_writes_strict = -1\n",
+                current->comm, table->procname);
+}
+
 /**
  * proc_dostring - read a string sysctl
  * @table: the sysctl table
@@ -1781,8 +1814,11 @@ static int _proc_do_string(void* data, int maxlen, int write,
 int proc_dostring(struct ctl_table *table, int write,
                   void __user *buffer, size_t *lenp, loff_t *ppos)
 {
-        return _proc_do_string(table->data, table->maxlen, write,
-                               buffer, lenp, ppos);
+        if (write && *ppos && sysctl_writes_strict == SYSCTL_WRITES_WARN)
+                warn_sysctl_write(table);
+
+        return _proc_do_string((char *)(table->data), table->maxlen, write,
+                               (char __user *)buffer, lenp, ppos);
 }
 
 static size_t proc_skip_spaces(char **buf)
@@ -1956,6 +1992,18 @@ static int __do_proc_dointvec(void *tbl_data, struct ctl_table *table,
                 conv = do_proc_dointvec_conv;
 
         if (write) {
+                if (*ppos) {
+                        switch (sysctl_writes_strict) {
+                        case SYSCTL_WRITES_STRICT:
+                                goto out;
+                        case SYSCTL_WRITES_WARN:
+                                warn_sysctl_write(table);
+                                break;
+                        default:
+                                break;
+                        }
+                }
+
                 if (left > PAGE_SIZE - 1)
                         left = PAGE_SIZE - 1;
                 page = __get_free_page(GFP_TEMPORARY);
@@ -2013,6 +2061,7 @@ free:
                         return err ? : -EINVAL;
         }
         *lenp -= left;
+out:
         *ppos += *lenp;
         return err;
 }
@@ -2205,6 +2254,18 @@ static int __do_proc_doulongvec_minmax(void *data, struct ctl_table *table, int
         left = *lenp;
 
         if (write) {
+                if (*ppos) {
+                        switch (sysctl_writes_strict) {
+                        case SYSCTL_WRITES_STRICT:
+                                goto out;
+                        case SYSCTL_WRITES_WARN:
+                                warn_sysctl_write(table);
+                                break;
+                        default:
+                                break;
+                        }
+                }
+
                 if (left > PAGE_SIZE - 1)
                         left = PAGE_SIZE - 1;
                 page = __get_free_page(GFP_TEMPORARY);
@@ -2260,6 +2321,7 @@ free:
                         return err ? : -EINVAL;
         }
         *lenp -= left;
+out:
         *ppos += *lenp;
         return err;
 }
diff --git a/kernel/user_namespace.c b/kernel/user_namespace.c
index bf71b4b2d632..fcc02560fd6b 100644
--- a/kernel/user_namespace.c
+++ b/kernel/user_namespace.c
@@ -286,7 +286,7 @@ EXPORT_SYMBOL(from_kuid_munged);
 /**
  *      make_kgid - Map a user-namespace gid pair into a kgid.
  *      @ns:  User namespace that the gid is in
- *      @uid: group identifier
+ *      @gid: group identifier
  *
  *      Maps a user-namespace gid pair into a kernel internal kgid,
  *      and returns that kgid.
@@ -482,7 +482,8 @@ static int projid_m_show(struct seq_file *seq, void *v)
         return 0;
 }
 
-static void *m_start(struct seq_file *seq, loff_t *ppos, struct uid_gid_map *map)
+static void *m_start(struct seq_file *seq, loff_t *ppos,
+                     struct uid_gid_map *map)
 {
         struct uid_gid_extent *extent = NULL;
         loff_t pos = *ppos;
@@ -546,7 +547,8 @@ struct seq_operations proc_projid_seq_operations = {
         .show = projid_m_show,
 };
 
-static bool mappings_overlap(struct uid_gid_map *new_map, struct uid_gid_extent *extent)
+static bool mappings_overlap(struct uid_gid_map *new_map,
+                             struct uid_gid_extent *extent)
 {
         u32 upper_first, lower_first, upper_last, lower_last;
         unsigned idx;
@@ -653,7 +655,7 @@ static ssize_t map_write(struct file *file, const char __user *buf,
         ret = -EINVAL;
         pos = kbuf;
         new_map.nr_extents = 0;
-        for (;pos; pos = next_line) {
+        for (; pos; pos = next_line) {
                 extent = &new_map.extent[new_map.nr_extents];
 
                 /* Find the end of line and ensure I don't look past it */
@@ -687,13 +689,16 @@ static ssize_t map_write(struct file *file, const char __user *buf,
 
                 /* Verify we have been given valid starting values */
                 if ((extent->first == (u32) -1) ||
-                    (extent->lower_first == (u32) -1 ))
+                    (extent->lower_first == (u32) -1))
                         goto out;
 
-                /* Verify count is not zero and does not cause the extent to wrap */
+                /* Verify count is not zero and does not cause the
+                 * extent to wrap
+                 */
                 if ((extent->first + extent->count) <= extent->first)
                         goto out;
-                if ((extent->lower_first + extent->count) <= extent->lower_first)
+                if ((extent->lower_first + extent->count) <=
+                     extent->lower_first)
                         goto out;
 
                 /* Do the ranges in extent overlap any previous extents? */
@@ -751,7 +756,8 @@ out:
         return ret;
 }
 
-ssize_t proc_uid_map_write(struct file *file, const char __user *buf, size_t size, loff_t *ppos)
+ssize_t proc_uid_map_write(struct file *file, const char __user *buf,
+                           size_t size, loff_t *ppos)
 {
         struct seq_file *seq = file->private_data;
         struct user_namespace *ns = seq->private;
@@ -767,7 +773,8 @@ ssize_t proc_uid_map_write(struct file *file, const char __user *buf, size_t siz
                          &ns->uid_map, &ns->parent->uid_map);
 }
 
-ssize_t proc_gid_map_write(struct file *file, const char __user *buf, size_t size, loff_t *ppos)
+ssize_t proc_gid_map_write(struct file *file, const char __user *buf,
+                           size_t size, loff_t *ppos)
 {
         struct seq_file *seq = file->private_data;
         struct user_namespace *ns = seq->private;
@@ -783,7 +790,8 @@ ssize_t proc_gid_map_write(struct file *file, const char __user *buf, size_t siz
                          &ns->gid_map, &ns->parent->gid_map);
 }
 
-ssize_t proc_projid_map_write(struct file *file, const char __user *buf, size_t size, loff_t *ppos)
+ssize_t proc_projid_map_write(struct file *file, const char __user *buf,
+                              size_t size, loff_t *ppos)
 {
         struct seq_file *seq = file->private_data;
         struct user_namespace *ns = seq->private;
@@ -800,7 +808,7 @@ ssize_t proc_projid_map_write(struct file *file, const char __user *buf, size_t
                          &ns->projid_map, &ns->parent->projid_map);
 }
 
-static bool new_idmap_permitted(const struct file *file, 
+static bool new_idmap_permitted(const struct file *file,
                                 struct user_namespace *ns, int cap_setid,
                                 struct uid_gid_map *new_map)
 {
@@ -811,8 +819,7 @@ static bool new_idmap_permitted(const struct file *file,
                         kuid_t uid = make_kuid(ns->parent, id);
                         if (uid_eq(uid, file->f_cred->fsuid))
                                 return true;
-                }
-                else if (cap_setid == CAP_SETGID) {
+                } else if (cap_setid == CAP_SETGID) {
                         kgid_t gid = make_kgid(ns->parent, id);
                         if (gid_eq(gid, file->f_cred->fsgid))
                                 return true;
diff --git a/kernel/utsname_sysctl.c b/kernel/utsname_sysctl.c
index 6fbe811c7ad1..c8eac43267e9 100644
--- a/kernel/utsname_sysctl.c
+++ b/kernel/utsname_sysctl.c
@@ -17,7 +17,7 @@
 
 #ifdef CONFIG_PROC_SYSCTL
 
-static void *get_uts(ctl_table *table, int write)
+static void *get_uts(struct ctl_table *table, int write)
 {
         char *which = table->data;
         struct uts_namespace *uts_ns;
@@ -32,7 +32,7 @@ static void *get_uts(ctl_table *table, int write)
         return which;
 }
 
-static void put_uts(ctl_table *table, int write, void *which)
+static void put_uts(struct ctl_table *table, int write, void *which)
 {
         if (!write)
                 up_read(&uts_sem);
@@ -44,7 +44,7 @@ static void put_uts(ctl_table *table, int write, void *which)
  *      Special case of dostring for the UTS structure. This has locks
  *      to observe. Should this be in kernel/sys.c ????
  */
-static int proc_do_uts_string(ctl_table *table, int write,
+static int proc_do_uts_string(struct ctl_table *table, int write,
                   void __user *buffer, size_t *lenp, loff_t *ppos)
 {
         struct ctl_table uts_table;
diff --git a/lib/idr.c b/lib/idr.c
index 2642fa8e424d..39158abebad1 100644
--- a/lib/idr.c
+++ b/lib/idr.c
@@ -18,12 +18,6 @@
  * pointer or what ever, we treat it as a (void *).  You can pass this
  * id to a user for him to pass back at a later time.  You then pass
  * that id to this code and it returns your pointer.
-
- * You can release ids at any time. When all ids are released, most of
- * the memory is returned (we keep MAX_IDR_FREE) in a local pool so we
- * don't need to go to the memory "store" during an id allocate, just
- * so you don't need to be too concerned about locking and conflicts
- * with the slab allocator.
  */
 
 #ifndef TEST                        // to test in user space...
@@ -151,7 +145,7 @@ static void idr_layer_rcu_free(struct rcu_head *head)
 
 static inline void free_layer(struct idr *idr, struct idr_layer *p)
 {
-        if (idr->hint && idr->hint == p)
+        if (idr->hint == p)
                 RCU_INIT_POINTER(idr->hint, NULL);
         call_rcu(&p->rcu_head, idr_layer_rcu_free);
 }
@@ -249,7 +243,7 @@ static int sub_alloc(struct idr *idp, int *starting_id, struct idr_layer **pa,
                         id = (id | ((1 << (IDR_BITS * l)) - 1)) + 1;
 
                         /* if already at the top layer, we need to grow */
-                        if (id >= 1 << (idp->layers * IDR_BITS)) {
+                        if (id > idr_max(idp->layers)) {
                                 *starting_id = id;
                                 return -EAGAIN;
                         }
@@ -562,6 +556,11 @@ void idr_remove(struct idr *idp, int id)
         if (id < 0)
                 return;
 
+        if (id > idr_max(idp->layers)) {
+                idr_remove_warning(id);
+                return;
+        }
+
         sub_remove(idp, (idp->layers - 1) * IDR_BITS, id);
         if (idp->top && idp->top->count == 1 && (idp->layers > 1) &&
             idp->top->ary[0]) {
@@ -579,16 +578,6 @@ void idr_remove(struct idr *idp, int id)
                 bitmap_clear(to_free->bitmap, 0, IDR_SIZE);
                 free_layer(idp, to_free);
         }
-        while (idp->id_free_cnt >= MAX_IDR_FREE) {
-                p = get_from_free_list(idp);
-                /*
-                 * Note: we don't call the rcu callback here, since the only
-                 * layers that fall into the freelist are those that have been
-                 * preallocated.
-                 */
-                kmem_cache_free(idr_layer_cache, p);
-        }
-        return;
 }
 EXPORT_SYMBOL(idr_remove);
 
@@ -809,14 +798,12 @@ void *idr_replace(struct idr *idp, void *ptr, int id)
 
         p = idp->top;
         if (!p)
-                return ERR_PTR(-EINVAL);
-
-        n = (p->layer+1) * IDR_BITS;
+                return ERR_PTR(-ENOENT);
 
-        if (id >= (1 << n))
-                return ERR_PTR(-EINVAL);
+        if (id > idr_max(p->layer + 1))
+                return ERR_PTR(-ENOENT);
 
-        n -= IDR_BITS;
+        n = p->layer * IDR_BITS;
         while ((n > 0) && p) {
                 p = p->ary[(id >> n) & IDR_MASK];
                 n -= IDR_BITS;
@@ -1027,6 +1014,9 @@ void ida_remove(struct ida *ida, int id)
         int n;
         struct ida_bitmap *bitmap;
 
+        if (idr_id > idr_max(ida->idr.layers))
+                goto err;
+
         /* clear full bits while looking up the leaf idr_layer */
         while ((shift > 0) && p) {
                 n = (idr_id >> shift) & IDR_MASK;
@@ -1042,7 +1032,7 @@ void ida_remove(struct ida *ida, int id)
         __clear_bit(n, p->bitmap);
 
         bitmap = (void *)p->ary[n];
-        if (!test_bit(offset, bitmap->bitmap))
+        if (!bitmap || !test_bit(offset, bitmap->bitmap))
                 goto err;
 
         /* update bitmap and remove it if empty */
diff --git a/lib/radix-tree.c b/lib/radix-tree.c
index d64815651e90..3291a8e37490 100644
--- a/lib/radix-tree.c
+++ b/lib/radix-tree.c
@@ -27,6 +27,7 @@
 #include <linux/radix-tree.h>
 #include <linux/percpu.h>
 #include <linux/slab.h>
+#include <linux/kmemleak.h>
 #include <linux/notifier.h>
 #include <linux/cpu.h>
 #include <linux/string.h>
@@ -200,6 +201,11 @@ radix_tree_node_alloc(struct radix_tree_root *root)
                         rtp->nodes[rtp->nr - 1] = NULL;
                         rtp->nr--;
                 }
+                /*
+                 * Update the allocation stack trace as this is more useful
+                 * for debugging.
+                 */
+                kmemleak_update_trace(ret);
         }
         if (ret == NULL)
                 ret = kmem_cache_alloc(radix_tree_node_cachep, gfp_mask);
diff --git a/mm/fremap.c b/mm/fremap.c
index 2c5646f11f41..72b8fa361433 100644
--- a/mm/fremap.c
+++ b/mm/fremap.c
@@ -149,6 +149,10 @@ SYSCALL_DEFINE5(remap_file_pages, unsigned long, start, unsigned long, size,
         int has_write_lock = 0;
         vm_flags_t vm_flags = 0;
 
+        pr_warn_once("%s (%d) uses deprecated remap_file_pages() syscall. "
+                        "See Documentation/vm/remap_file_pages.txt.\n",
+                        current->comm, current->pid);
+
         if (prot)
                 return err;
         /*
diff --git a/mm/kmemleak-test.c b/mm/kmemleak-test.c
index ff0d9779cec8..dcdcadb69533 100644
--- a/mm/kmemleak-test.c
+++ b/mm/kmemleak-test.c
@@ -18,6 +18,8 @@
  * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
  */
 
+#define pr_fmt(fmt) "kmemleak: " fmt
+
 #include <linux/init.h>
 #include <linux/kernel.h>
 #include <linux/module.h>
@@ -50,25 +52,25 @@ static int __init kmemleak_test_init(void)
         printk(KERN_INFO "Kmemleak testing\n");
 
         /* make some orphan objects */
-        pr_info("kmemleak: kmalloc(32) = %p\n", kmalloc(32, GFP_KERNEL));
-        pr_info("kmemleak: kmalloc(32) = %p\n", kmalloc(32, GFP_KERNEL));
-        pr_info("kmemleak: kmalloc(1024) = %p\n", kmalloc(1024, GFP_KERNEL));
-        pr_info("kmemleak: kmalloc(1024) = %p\n", kmalloc(1024, GFP_KERNEL));
-        pr_info("kmemleak: kmalloc(2048) = %p\n", kmalloc(2048, GFP_KERNEL));
-        pr_info("kmemleak: kmalloc(2048) = %p\n", kmalloc(2048, GFP_KERNEL));
-        pr_info("kmemleak: kmalloc(4096) = %p\n", kmalloc(4096, GFP_KERNEL));
-        pr_info("kmemleak: kmalloc(4096) = %p\n", kmalloc(4096, GFP_KERNEL));
+        pr_info("kmalloc(32) = %p\n", kmalloc(32, GFP_KERNEL));
+        pr_info("kmalloc(32) = %p\n", kmalloc(32, GFP_KERNEL));
+        pr_info("kmalloc(1024) = %p\n", kmalloc(1024, GFP_KERNEL));
+        pr_info("kmalloc(1024) = %p\n", kmalloc(1024, GFP_KERNEL));
+        pr_info("kmalloc(2048) = %p\n", kmalloc(2048, GFP_KERNEL));
+        pr_info("kmalloc(2048) = %p\n", kmalloc(2048, GFP_KERNEL));
+        pr_info("kmalloc(4096) = %p\n", kmalloc(4096, GFP_KERNEL));
+        pr_info("kmalloc(4096) = %p\n", kmalloc(4096, GFP_KERNEL));
 #ifndef CONFIG_MODULES
-        pr_info("kmemleak: kmem_cache_alloc(files_cachep) = %p\n",
+        pr_info("kmem_cache_alloc(files_cachep) = %p\n",
                 kmem_cache_alloc(files_cachep, GFP_KERNEL));
-        pr_info("kmemleak: kmem_cache_alloc(files_cachep) = %p\n",
+        pr_info("kmem_cache_alloc(files_cachep) = %p\n",
                 kmem_cache_alloc(files_cachep, GFP_KERNEL));
 #endif
-        pr_info("kmemleak: vmalloc(64) = %p\n", vmalloc(64));
-        pr_info("kmemleak: vmalloc(64) = %p\n", vmalloc(64));
-        pr_info("kmemleak: vmalloc(64) = %p\n", vmalloc(64));
-        pr_info("kmemleak: vmalloc(64) = %p\n", vmalloc(64));
-        pr_info("kmemleak: vmalloc(64) = %p\n", vmalloc(64));
+        pr_info("vmalloc(64) = %p\n", vmalloc(64));
+        pr_info("vmalloc(64) = %p\n", vmalloc(64));
+        pr_info("vmalloc(64) = %p\n", vmalloc(64));
+        pr_info("vmalloc(64) = %p\n", vmalloc(64));
+        pr_info("vmalloc(64) = %p\n", vmalloc(64));
 
         /*
          * Add elements to a list. They should only appear as orphan
@@ -76,7 +78,7 @@ static int __init kmemleak_test_init(void)
          */
         for (i = 0; i < 10; i++) {
                 elem = kzalloc(sizeof(*elem), GFP_KERNEL);
-                pr_info("kmemleak: kzalloc(sizeof(*elem)) = %p\n", elem);
+                pr_info("kzalloc(sizeof(*elem)) = %p\n", elem);
                 if (!elem)
                         return -ENOMEM;
                 INIT_LIST_HEAD(&elem->list);
@@ -85,7 +87,7 @@ static int __init kmemleak_test_init(void)
 
         for_each_possible_cpu(i) {
                 per_cpu(kmemleak_test_pointer, i) = kmalloc(129, GFP_KERNEL);
-                pr_info("kmemleak: kmalloc(129) = %p\n",
+                pr_info("kmalloc(129) = %p\n",
                         per_cpu(kmemleak_test_pointer, i));
         }
 
diff --git a/mm/kmemleak.c b/mm/kmemleak.c
index 736ade31d1dc..3cda50c1e394 100644
--- a/mm/kmemleak.c
+++ b/mm/kmemleak.c
@@ -387,7 +387,7 @@ static void dump_object_info(struct kmemleak_object *object)
         pr_notice("  min_count = %d\n", object->min_count);
         pr_notice("  count = %d\n", object->count);
         pr_notice("  flags = 0x%lx\n", object->flags);
-        pr_notice("  checksum = %d\n", object->checksum);
+        pr_notice("  checksum = %u\n", object->checksum);
         pr_notice("  backtrace:\n");
         print_stack_trace(&trace, 4);
 }
@@ -990,6 +990,40 @@ void __ref kmemleak_free_percpu(const void __percpu *ptr)
 EXPORT_SYMBOL_GPL(kmemleak_free_percpu);
 
 /**
+ * kmemleak_update_trace - update object allocation stack trace
+ * @ptr:        pointer to beginning of the object
+ *
+ * Override the object allocation stack trace for cases where the actual
+ * allocation place is not always useful.
+ */
+void __ref kmemleak_update_trace(const void *ptr)
+{
+        struct kmemleak_object *object;
+        unsigned long flags;
+
+        pr_debug("%s(0x%p)\n", __func__, ptr);
+
+        if (!kmemleak_enabled || IS_ERR_OR_NULL(ptr))
+                return;
+
+        object = find_and_get_object((unsigned long)ptr, 1);
+        if (!object) {
+#ifdef DEBUG
+                kmemleak_warn("Updating stack trace for unknown object at %p\n",
+                              ptr);
+#endif
+                return;
+        }
+
+        spin_lock_irqsave(&object->lock, flags);
+        object->trace_len = __save_stack_trace(object->trace);
+        spin_unlock_irqrestore(&object->lock, flags);
+
+        put_object(object);
+}
+EXPORT_SYMBOL(kmemleak_update_trace);
+
+/**
  * kmemleak_not_leak - mark an allocated object as false positive
  * @ptr:        pointer to beginning of the object
  *
diff --git a/mm/memblock.c b/mm/memblock.c
index 0aa0d2b07624..6d2f219a48b0 100644
--- a/mm/memblock.c
+++ b/mm/memblock.c
@@ -691,6 +691,7 @@ int __init_memblock memblock_free(phys_addr_t base, phys_addr_t size)
                      (unsigned long long)base + size - 1,
                      (void *)_RET_IP_);
 
+        kmemleak_free_part(__va(base), size);
         return memblock_remove_range(&memblock.reserved, base, size);
 }
 
@@ -1043,9 +1044,14 @@ static phys_addr_t __init memblock_alloc_range_nid(phys_addr_t size,
                 align = SMP_CACHE_BYTES;
 
         found = memblock_find_in_range_node(size, align, start, end, nid);
-        if (found && !memblock_reserve(found, size))
+        if (found && !memblock_reserve(found, size)) {
+                /*
+                 * The min_count is set to 0 so that memblock allocations are
+                 * never reported as leaks.
+                 */
+                kmemleak_alloc(__va(found), size, 0, 0);
                 return found;
-
+        }
         return 0;
 }
 
diff --git a/mm/memcontrol.c b/mm/memcontrol.c
index a500cb0594c4..a9559b91603c 100644
--- a/mm/memcontrol.c
+++ b/mm/memcontrol.c
@@ -676,9 +676,11 @@ static void disarm_static_keys(struct mem_cgroup *memcg)
 static void drain_all_stock_async(struct mem_cgroup *memcg);
 
 static struct mem_cgroup_per_zone *
-mem_cgroup_zoneinfo(struct mem_cgroup *memcg, int nid, int zid)
+mem_cgroup_zone_zoneinfo(struct mem_cgroup *memcg, struct zone *zone)
 {
-        VM_BUG_ON((unsigned)nid >= nr_node_ids);
+        int nid = zone_to_nid(zone);
+        int zid = zone_idx(zone);
+
         return &memcg->nodeinfo[nid]->zoneinfo[zid];
 }
 
@@ -688,12 +690,12 @@ struct cgroup_subsys_state *mem_cgroup_css(struct mem_cgroup *memcg)
 }
 
 static struct mem_cgroup_per_zone *
-page_cgroup_zoneinfo(struct mem_cgroup *memcg, struct page *page)
+mem_cgroup_page_zoneinfo(struct mem_cgroup *memcg, struct page *page)
 {
         int nid = page_to_nid(page);
         int zid = page_zonenum(page);
 
-        return mem_cgroup_zoneinfo(memcg, nid, zid);
+        return &memcg->nodeinfo[nid]->zoneinfo[zid];
 }
 
 static struct mem_cgroup_tree_per_zone *
@@ -711,11 +713,9 @@ soft_limit_tree_from_page(struct page *page)
         return &soft_limit_tree.rb_tree_per_node[nid]->rb_tree_per_zone[zid];
 }
 
-static void
-__mem_cgroup_insert_exceeded(struct mem_cgroup *memcg,
-                                struct mem_cgroup_per_zone *mz,
-                                struct mem_cgroup_tree_per_zone *mctz,
-                                unsigned long long new_usage_in_excess)
+static void __mem_cgroup_insert_exceeded(struct mem_cgroup_per_zone *mz,
+                                         struct mem_cgroup_tree_per_zone *mctz,
+                                         unsigned long long new_usage_in_excess)
 {
         struct rb_node **p = &mctz->rb_root.rb_node;
         struct rb_node *parent = NULL;
@@ -745,10 +745,8 @@ __mem_cgroup_insert_exceeded(struct mem_cgroup *memcg,
         mz->on_tree = true;
 }
 
-static void
-__mem_cgroup_remove_exceeded(struct mem_cgroup *memcg,
-                                struct mem_cgroup_per_zone *mz,
-                                struct mem_cgroup_tree_per_zone *mctz)
+static void __mem_cgroup_remove_exceeded(struct mem_cgroup_per_zone *mz,
+                                         struct mem_cgroup_tree_per_zone *mctz)
 {
         if (!mz->on_tree)
                 return;
@@ -756,13 +754,11 @@ __mem_cgroup_remove_exceeded(struct mem_cgroup *memcg,
         mz->on_tree = false;
 }
 
-static void
-mem_cgroup_remove_exceeded(struct mem_cgroup *memcg,
-                                struct mem_cgroup_per_zone *mz,
-                                struct mem_cgroup_tree_per_zone *mctz)
+static void mem_cgroup_remove_exceeded(struct mem_cgroup_per_zone *mz,
+                                       struct mem_cgroup_tree_per_zone *mctz)
 {
         spin_lock(&mctz->lock);
-        __mem_cgroup_remove_exceeded(memcg, mz, mctz);
+        __mem_cgroup_remove_exceeded(mz, mctz);
         spin_unlock(&mctz->lock);
 }
 
@@ -772,16 +768,14 @@ static void mem_cgroup_update_tree(struct mem_cgroup *memcg, struct page *page)
         unsigned long long excess;
         struct mem_cgroup_per_zone *mz;
         struct mem_cgroup_tree_per_zone *mctz;
-        int nid = page_to_nid(page);
-        int zid = page_zonenum(page);
-        mctz = soft_limit_tree_from_page(page);
 
+        mctz = soft_limit_tree_from_page(page);
         /*
          * Necessary to update all ancestors when hierarchy is used.
          * because their event counter is not touched.
          */
         for (; memcg; memcg = parent_mem_cgroup(memcg)) {
-                mz = mem_cgroup_zoneinfo(memcg, nid, zid);
+                mz = mem_cgroup_page_zoneinfo(memcg, page);
                 excess = res_counter_soft_limit_excess(&memcg->res);
                 /*
                  * We have to update the tree if mz is on RB-tree or
@@ -791,12 +785,12 @@ static void mem_cgroup_update_tree(struct mem_cgroup *memcg, struct page *page)
                         spin_lock(&mctz->lock);
                         /* if on-tree, remove it */
                         if (mz->on_tree)
-                                __mem_cgroup_remove_exceeded(memcg, mz, mctz);
+                                __mem_cgroup_remove_exceeded(mz, mctz);
                         /*
                          * Insert again. mz->usage_in_excess will be updated.
                          * If excess is 0, no tree ops.
                          */
-                        __mem_cgroup_insert_exceeded(memcg, mz, mctz, excess);
+                        __mem_cgroup_insert_exceeded(mz, mctz, excess);
                         spin_unlock(&mctz->lock);
                 }
         }
@@ -804,15 +798,15 @@ static void mem_cgroup_update_tree(struct mem_cgroup *memcg, struct page *page)
 
 static void mem_cgroup_remove_from_trees(struct mem_cgroup *memcg)
 {
-        int node, zone;
-        struct mem_cgroup_per_zone *mz;
         struct mem_cgroup_tree_per_zone *mctz;
+        struct mem_cgroup_per_zone *mz;
+        int nid, zid;
 
-        for_each_node(node) {
-                for (zone = 0; zone < MAX_NR_ZONES; zone++) {
-                        mz = mem_cgroup_zoneinfo(memcg, node, zone);
-                        mctz = soft_limit_tree_node_zone(node, zone);
-                        mem_cgroup_remove_exceeded(memcg, mz, mctz);
+        for_each_node(nid) {
+                for (zid = 0; zid < MAX_NR_ZONES; zid++) {
+                        mz = &memcg->nodeinfo[nid]->zoneinfo[zid];
+                        mctz = soft_limit_tree_node_zone(nid, zid);
+                        mem_cgroup_remove_exceeded(mz, mctz);
                 }
         }
 }
@@ -835,7 +829,7 @@ retry:
          * we will to add it back at the end of reclaim to its correct
          * position in the tree.
          */
-        __mem_cgroup_remove_exceeded(mz->memcg, mz, mctz);
+        __mem_cgroup_remove_exceeded(mz, mctz);
         if (!res_counter_soft_limit_excess(&mz->memcg->res) ||
                 !css_tryget(&mz->memcg->css))
                 goto retry;
@@ -946,8 +940,7 @@ static void mem_cgroup_charge_statistics(struct mem_cgroup *memcg,
         __this_cpu_add(memcg->stat->nr_page_events, nr_pages);
 }
 
-unsigned long
-mem_cgroup_get_lru_size(struct lruvec *lruvec, enum lru_list lru)
+unsigned long mem_cgroup_get_lru_size(struct lruvec *lruvec, enum lru_list lru)
 {
         struct mem_cgroup_per_zone *mz;
 
@@ -955,46 +948,38 @@ mem_cgroup_get_lru_size(struct lruvec *lruvec, enum lru_list lru)
         return mz->lru_size[lru];
 }
 
-static unsigned long
-mem_cgroup_zone_nr_lru_pages(struct mem_cgroup *memcg, int nid, int zid,
-                        unsigned int lru_mask)
+static unsigned long mem_cgroup_node_nr_lru_pages(struct mem_cgroup *memcg,
+                                                  int nid,
+                                                  unsigned int lru_mask)
 {
-        struct mem_cgroup_per_zone *mz;
-        enum lru_list lru;
-        unsigned long ret = 0;
-
-        mz = mem_cgroup_zoneinfo(memcg, nid, zid);
-
-        for_each_lru(lru) {
-                if (BIT(lru) & lru_mask)
-                        ret += mz->lru_size[lru];
-        }
-        return ret;
-}
-
-static unsigned long
-mem_cgroup_node_nr_lru_pages(struct mem_cgroup *memcg,
-                        int nid, unsigned int lru_mask)
-{
-        u64 total = 0;
+        unsigned long nr = 0;
         int zid;
 
-        for (zid = 0; zid < MAX_NR_ZONES; zid++)
-                total += mem_cgroup_zone_nr_lru_pages(memcg,
-                                                nid, zid, lru_mask);
+        VM_BUG_ON((unsigned)nid >= nr_node_ids);
 
-        return total;
+        for (zid = 0; zid < MAX_NR_ZONES; zid++) {
+                struct mem_cgroup_per_zone *mz;
+                enum lru_list lru;
+
+                for_each_lru(lru) {
+                        if (!(BIT(lru) & lru_mask))
+                                continue;
+                        mz = &memcg->nodeinfo[nid]->zoneinfo[zid];
+                        nr += mz->lru_size[lru];
+                }
+        }
+        return nr;
 }
 
 static unsigned long mem_cgroup_nr_lru_pages(struct mem_cgroup *memcg,
                         unsigned int lru_mask)
 {
+        unsigned long nr = 0;
         int nid;
-        u64 total = 0;
 
         for_each_node_state(nid, N_MEMORY)
-                total += mem_cgroup_node_nr_lru_pages(memcg, nid, lru_mask);
-        return total;
+                nr += mem_cgroup_node_nr_lru_pages(memcg, nid, lru_mask);
+        return nr;
 }
 
 static bool mem_cgroup_event_ratelimit(struct mem_cgroup *memcg,
@@ -1242,11 +1227,9 @@ struct mem_cgroup *mem_cgroup_iter(struct mem_cgroup *root,
                 int uninitialized_var(seq);
 
                 if (reclaim) {
-                        int nid = zone_to_nid(reclaim->zone);
-                        int zid = zone_idx(reclaim->zone);
                         struct mem_cgroup_per_zone *mz;
 
-                        mz = mem_cgroup_zoneinfo(root, nid, zid);
+                        mz = mem_cgroup_zone_zoneinfo(root, reclaim->zone);
                         iter = &mz->reclaim_iter[reclaim->priority];
                         if (prev && reclaim->generation != iter->generation) {
                                 iter->last_visited = NULL;
@@ -1353,7 +1336,7 @@ struct lruvec *mem_cgroup_zone_lruvec(struct zone *zone,
                 goto out;
         }
 
-        mz = mem_cgroup_zoneinfo(memcg, zone_to_nid(zone), zone_idx(zone));
+        mz = mem_cgroup_zone_zoneinfo(memcg, zone);
         lruvec = &mz->lruvec;
 out:
         /*
@@ -1412,7 +1395,7 @@ struct lruvec *mem_cgroup_page_lruvec(struct page *page, struct zone *zone)
         if (!PageLRU(page) && !PageCgroupUsed(pc) && memcg != root_mem_cgroup)
                 pc->mem_cgroup = memcg = root_mem_cgroup;
 
-        mz = page_cgroup_zoneinfo(memcg, page);
+        mz = mem_cgroup_page_zoneinfo(memcg, page);
         lruvec = &mz->lruvec;
 out:
         /*
@@ -1550,7 +1533,7 @@ static unsigned long mem_cgroup_margin(struct mem_cgroup *memcg)
 int mem_cgroup_swappiness(struct mem_cgroup *memcg)
 {
         /* root ? */
-        if (!css_parent(&memcg->css))
+        if (mem_cgroup_disabled() || !css_parent(&memcg->css))
                 return vm_swappiness;
 
         return memcg->swappiness;
@@ -4597,7 +4580,7 @@ unsigned long mem_cgroup_soft_limit_reclaim(struct zone *zone, int order,
                                         break;
                         } while (1);
                 }
-                __mem_cgroup_remove_exceeded(mz->memcg, mz, mctz);
+                __mem_cgroup_remove_exceeded(mz, mctz);
                 excess = res_counter_soft_limit_excess(&mz->memcg->res);
                 /*
                  * One school of thought says that we should not add
@@ -4608,7 +4591,7 @@ unsigned long mem_cgroup_soft_limit_reclaim(struct zone *zone, int order,
                  * term TODO.
                  */
                 /* If excess == 0, no tree ops */
-                __mem_cgroup_insert_exceeded(mz->memcg, mz, mctz, excess);
+                __mem_cgroup_insert_exceeded(mz, mctz, excess);
                 spin_unlock(&mctz->lock);
                 css_put(&mz->memcg->css);
                 loop++;
@@ -5305,7 +5288,7 @@ static int memcg_stat_show(struct seq_file *m, void *v)
 
                 for_each_online_node(nid)
                         for (zid = 0; zid < MAX_NR_ZONES; zid++) {
-                                mz = mem_cgroup_zoneinfo(memcg, nid, zid);
+                                mz = &memcg->nodeinfo[nid]->zoneinfo[zid];
                                 rstat = &mz->lruvec.reclaim_stat;
 
                                 recent_rotated[0] += rstat->recent_rotated[0];
diff --git a/mm/mempolicy.c b/mm/mempolicy.c
index 16bc9fa42998..1c16c228f35a 100644
--- a/mm/mempolicy.c
+++ b/mm/mempolicy.c
@@ -65,6 +65,8 @@
    kernel is not always grateful with that.
 */
 
+#define pr_fmt(fmt) KBUILD_MODNAME ": " fmt
+
 #include <linux/mempolicy.h>
 #include <linux/mm.h>
 #include <linux/highmem.h>
@@ -91,6 +93,7 @@
 #include <linux/ctype.h>
 #include <linux/mm_inline.h>
 #include <linux/mmu_notifier.h>
+#include <linux/printk.h>
 
 #include <asm/tlbflush.h>
 #include <asm/uaccess.h>
@@ -2645,7 +2648,7 @@ void __init numa_policy_init(void)
                 node_set(prefer, interleave_nodes);
 
         if (do_set_mempolicy(MPOL_INTERLEAVE, 0, &interleave_nodes))
-                printk("numa_policy_init: interleaving failed\n");
+                pr_err("%s: interleaving failed\n", __func__);
 
         check_numabalancing_enable();
 }
diff --git a/mm/mempool.c b/mm/mempool.c
index 455d468c3a5d..e209c98c7203 100644
--- a/mm/mempool.c
+++ b/mm/mempool.c
@@ -10,6 +10,7 @@
 
 #include <linux/mm.h>
 #include <linux/slab.h>
+#include <linux/kmemleak.h>
 #include <linux/export.h>
 #include <linux/mempool.h>
 #include <linux/blkdev.h>
@@ -222,6 +223,11 @@ repeat_alloc:
                 spin_unlock_irqrestore(&pool->lock, flags);
                 /* paired with rmb in mempool_free(), read comment there */
                 smp_wmb();
+                /*
+                 * Update the allocation stack trace as this is more useful
+                 * for debugging.
+                 */
+                kmemleak_update_trace(element);
                 return element;
         }
 
diff --git a/mm/mmap.c b/mm/mmap.c
index ced5efcdd4b6..129b847d30cc 100644
--- a/mm/mmap.c
+++ b/mm/mmap.c
@@ -6,6 +6,8 @@
  * Address space accounting code        <alan@lxorguk.ukuu.org.uk>
  */
 
+#define pr_fmt(fmt) KBUILD_MODNAME ": " fmt
+
 #include <linux/kernel.h>
 #include <linux/slab.h>
 #include <linux/backing-dev.h>
@@ -37,6 +39,7 @@
 #include <linux/sched/sysctl.h>
 #include <linux/notifier.h>
 #include <linux/memory.h>
+#include <linux/printk.h>
 
 #include <asm/uaccess.h>
 #include <asm/cacheflush.h>
@@ -361,20 +364,20 @@ static int browse_rb(struct rb_root *root)
                 struct vm_area_struct *vma;
                 vma = rb_entry(nd, struct vm_area_struct, vm_rb);
                 if (vma->vm_start < prev) {
-                        printk("vm_start %lx prev %lx\n", vma->vm_start, prev);
+                        pr_info("vm_start %lx prev %lx\n", vma->vm_start, prev);
                         bug = 1;
                 }
                 if (vma->vm_start < pend) {
-                        printk("vm_start %lx pend %lx\n", vma->vm_start, pend);
+                        pr_info("vm_start %lx pend %lx\n", vma->vm_start, pend);
                         bug = 1;
                 }
                 if (vma->vm_start > vma->vm_end) {
-                        printk("vm_end %lx < vm_start %lx\n",
+                        pr_info("vm_end %lx < vm_start %lx\n",
                                 vma->vm_end, vma->vm_start);
                         bug = 1;
                 }
                 if (vma->rb_subtree_gap != vma_compute_subtree_gap(vma)) {
-                        printk("free gap %lx, correct %lx\n",
+                        pr_info("free gap %lx, correct %lx\n",
                                vma->rb_subtree_gap,
                                vma_compute_subtree_gap(vma));
                         bug = 1;
@@ -388,7 +391,7 @@ static int browse_rb(struct rb_root *root)
         for (nd = pn; nd; nd = rb_prev(nd))
                 j++;
         if (i != j) {
-                printk("backwards %d, forwards %d\n", j, i);
+                pr_info("backwards %d, forwards %d\n", j, i);
                 bug = 1;
         }
         return bug ? -1 : i;
@@ -423,17 +426,17 @@ static void validate_mm(struct mm_struct *mm)
                 i++;
         }
         if (i != mm->map_count) {
-                printk("map_count %d vm_next %d\n", mm->map_count, i);
+                pr_info("map_count %d vm_next %d\n", mm->map_count, i);
                 bug = 1;
         }
         if (highest_address != mm->highest_vm_end) {
-                printk("mm->highest_vm_end %lx, found %lx\n",
+                pr_info("mm->highest_vm_end %lx, found %lx\n",
                        mm->highest_vm_end, highest_address);
                 bug = 1;
         }
         i = browse_rb(&mm->mm_rb);
         if (i != mm->map_count) {
-                printk("map_count %d rb %d\n", mm->map_count, i);
+                pr_info("map_count %d rb %d\n", mm->map_count, i);
                 bug = 1;
         }
         BUG_ON(bug);
@@ -3280,7 +3283,7 @@ static struct notifier_block reserve_mem_nb = {
 static int __meminit init_reserve_notifier(void)
 {
         if (register_hotmemory_notifier(&reserve_mem_nb))
-                printk("Failed registering memory add/remove notifier for admin reserve");
+                pr_err("Failed registering memory add/remove notifier for admin reserve\n");
 
         return 0;
 }
diff --git a/mm/nobootmem.c b/mm/nobootmem.c
index 04a9d94333a5..7ed58602e71b 100644
--- a/mm/nobootmem.c
+++ b/mm/nobootmem.c
@@ -197,7 +197,6 @@ unsigned long __init free_all_bootmem(void)
 void __init free_bootmem_node(pg_data_t *pgdat, unsigned long physaddr,
                               unsigned long size)
 {
-        kmemleak_free_part(__va(physaddr), size);
         memblock_free(physaddr, size);
 }
 
@@ -212,7 +211,6 @@ void __init free_bootmem_node(pg_data_t *pgdat, unsigned long physaddr,
  */
 void __init free_bootmem(unsigned long addr, unsigned long size)
 {
-        kmemleak_free_part(__va(addr), size);
         memblock_free(addr, size);
 }
 
diff --git a/mm/nommu.c b/mm/nommu.c
index 85f8d6698d48..b78e3a8f5ee7 100644
--- a/mm/nommu.c
+++ b/mm/nommu.c
@@ -13,6 +13,8 @@
  *  Copyright (c) 2007-2010 Paul Mundt <lethal@linux-sh.org>
  */
 
+#define pr_fmt(fmt) KBUILD_MODNAME ": " fmt
+
 #include <linux/export.h>
 #include <linux/mm.h>
 #include <linux/vmacache.h>
@@ -32,6 +34,7 @@
 #include <linux/syscalls.h>
 #include <linux/audit.h>
 #include <linux/sched/sysctl.h>
+#include <linux/printk.h>
 
 #include <asm/uaccess.h>
 #include <asm/tlb.h>
@@ -1246,7 +1249,7 @@ error_free:
         return ret;
 
 enomem:
-        printk("Allocation of length %lu from process %d (%s) failed\n",
+        pr_err("Allocation of length %lu from process %d (%s) failed\n",
                len, current->pid, current->comm);
         show_free_areas(0);
         return -ENOMEM;
diff --git a/mm/page-writeback.c b/mm/page-writeback.c
index 533fa60c9ac1..7d9a4ef0a078 100644
--- a/mm/page-writeback.c
+++ b/mm/page-writeback.c
@@ -1664,7 +1664,7 @@ void throttle_vm_writeout(gfp_t gfp_mask)
 /*
  * sysctl handler for /proc/sys/vm/dirty_writeback_centisecs
  */
-int dirty_writeback_centisecs_handler(ctl_table *table, int write,
+int dirty_writeback_centisecs_handler(struct ctl_table *table, int write,
         void __user *buffer, size_t *length, loff_t *ppos)
 {
         proc_dointvec(table, write, buffer, length, ppos);
diff --git a/mm/page_alloc.c b/mm/page_alloc.c
index a59bdb653958..4f59fa29eda8 100644
--- a/mm/page_alloc.c
+++ b/mm/page_alloc.c
@@ -3389,7 +3389,7 @@ early_param("numa_zonelist_order", setup_numa_zonelist_order);
 /*
  * sysctl handler for numa_zonelist_order
  */
-int numa_zonelist_order_handler(ctl_table *table, int write,
+int numa_zonelist_order_handler(struct ctl_table *table, int write,
                 void __user *buffer, size_t *length,
                 loff_t *ppos)
 {
@@ -5805,7 +5805,7 @@ module_init(init_per_zone_wmark_min)
  *      that we can call two helper functions whenever min_free_kbytes
  *      changes.
  */
-int min_free_kbytes_sysctl_handler(ctl_table *table, int write,
+int min_free_kbytes_sysctl_handler(struct ctl_table *table, int write,
         void __user *buffer, size_t *length, loff_t *ppos)
 {
         int rc;
@@ -5822,7 +5822,7 @@ int min_free_kbytes_sysctl_handler(ctl_table *table, int write,
 }
 
 #ifdef CONFIG_NUMA
-int sysctl_min_unmapped_ratio_sysctl_handler(ctl_table *table, int write,
+int sysctl_min_unmapped_ratio_sysctl_handler(struct ctl_table *table, int write,
         void __user *buffer, size_t *length, loff_t *ppos)
 {
         struct zone *zone;
@@ -5838,7 +5838,7 @@ int sysctl_min_unmapped_ratio_sysctl_handler(ctl_table *table, int write,
         return 0;
 }
 
-int sysctl_min_slab_ratio_sysctl_handler(ctl_table *table, int write,
+int sysctl_min_slab_ratio_sysctl_handler(struct ctl_table *table, int write,
         void __user *buffer, size_t *length, loff_t *ppos)
 {
         struct zone *zone;
@@ -5864,7 +5864,7 @@ int sysctl_min_slab_ratio_sysctl_handler(ctl_table *table, int write,
  * minimum watermarks. The lowmem reserve ratio can only make sense
  * if in function of the boot time zone sizes.
  */
-int lowmem_reserve_ratio_sysctl_handler(ctl_table *table, int write,
+int lowmem_reserve_ratio_sysctl_handler(struct ctl_table *table, int write,
         void __user *buffer, size_t *length, loff_t *ppos)
 {
         proc_dointvec_minmax(table, write, buffer, length, ppos);
@@ -5877,7 +5877,7 @@ int lowmem_reserve_ratio_sysctl_handler(ctl_table *table, int write,
  * cpu.  It is the fraction of total pages in each zone that a hot per cpu
  * pagelist can have before it gets flushed back to buddy allocator.
  */
-int percpu_pagelist_fraction_sysctl_handler(ctl_table *table, int write,
+int percpu_pagelist_fraction_sysctl_handler(struct ctl_table *table, int write,
         void __user *buffer, size_t *length, loff_t *ppos)
 {
         struct zone *zone;
diff --git a/mm/slub.c b/mm/slub.c
index fdf0fe4da9a9..b2b047327d76 100644
--- a/mm/slub.c
+++ b/mm/slub.c
@@ -1726,7 +1726,7 @@ static void *get_partial(struct kmem_cache *s, gfp_t flags, int node,
                 struct kmem_cache_cpu *c)
 {
         void *object;
-        int searchnode = (node == NUMA_NO_NODE) ? numa_node_id() : node;
+        int searchnode = (node == NUMA_NO_NODE) ? numa_mem_id() : node;
 
         object = get_partial_node(s, get_node(s, searchnode), c, flags);
         if (object || node != NUMA_NO_NODE)
diff --git a/mm/vmscan.c b/mm/vmscan.c
index 9149444f947d..71f23c0c1090 100644
--- a/mm/vmscan.c
+++ b/mm/vmscan.c
@@ -11,6 +11,8 @@
  *  Multiqueue VM started 5.8.00, Rik van Riel.
  */
 
+#define pr_fmt(fmt) KBUILD_MODNAME ": " fmt
+
 #include <linux/mm.h>
 #include <linux/module.h>
 #include <linux/gfp.h>
@@ -43,6 +45,7 @@
 #include <linux/sysctl.h>
 #include <linux/oom.h>
 #include <linux/prefetch.h>
+#include <linux/printk.h>
 
 #include <asm/tlbflush.h>
 #include <asm/div64.h>
@@ -83,6 +86,9 @@ struct scan_control {
         /* Scan (total_size >> priority) pages at once */
         int priority;
 
+        /* anon vs. file LRUs scanning "ratio" */
+        int swappiness;
+
         /*
          * The memory cgroup that hit its limit and as a result is the
          * primary target of this reclaim invocation.
@@ -477,7 +483,7 @@ static pageout_t pageout(struct page *page, struct address_space *mapping,
                 if (page_has_private(page)) {
                         if (try_to_free_buffers(page)) {
                                 ClearPageDirty(page);
-                                printk("%s: orphaned page\n", __func__);
+                                pr_info("%s: orphaned page\n", __func__);
                                 return PAGE_CLEAN;
                         }
                 }
@@ -1845,13 +1851,6 @@ static unsigned long shrink_list(enum lru_list lru, unsigned long nr_to_scan,
         return shrink_inactive_list(nr_to_scan, lruvec, sc, lru);
 }
 
-static int vmscan_swappiness(struct scan_control *sc)
-{
-        if (global_reclaim(sc))
-                return vm_swappiness;
-        return mem_cgroup_swappiness(sc->target_mem_cgroup);
-}
-
 enum scan_balance {
         SCAN_EQUAL,
         SCAN_FRACT,
@@ -1912,7 +1911,7 @@ static void get_scan_count(struct lruvec *lruvec, struct scan_control *sc,
          * using the memory controller's swap limit feature would be
          * too expensive.
          */
-        if (!global_reclaim(sc) && !vmscan_swappiness(sc)) {
+        if (!global_reclaim(sc) && !sc->swappiness) {
                 scan_balance = SCAN_FILE;
                 goto out;
         }
@@ -1922,7 +1921,7 @@ static void get_scan_count(struct lruvec *lruvec, struct scan_control *sc,
          * system is close to OOM, scan both anon and file equally
          * (unless the swappiness setting disagrees with swapping).
          */
-        if (!sc->priority && vmscan_swappiness(sc)) {
+        if (!sc->priority && sc->swappiness) {
                 scan_balance = SCAN_EQUAL;
                 goto out;
         }
@@ -1965,7 +1964,7 @@ static void get_scan_count(struct lruvec *lruvec, struct scan_control *sc,
          * With swappiness at 100, anonymous and file have the same priority.
          * This scanning priority is essentially the inverse of IO cost.
          */
-        anon_prio = vmscan_swappiness(sc);
+        anon_prio = sc->swappiness;
         file_prio = 200 - anon_prio;
 
         /*
@@ -2265,6 +2264,7 @@ static void shrink_zone(struct zone *zone, struct scan_control *sc)
 
                         lruvec = mem_cgroup_zone_lruvec(zone, memcg);
 
+                        sc->swappiness = mem_cgroup_swappiness(memcg);
                         shrink_lruvec(lruvec, sc);
 
                         /*
@@ -2731,6 +2731,7 @@ unsigned long mem_cgroup_shrink_node_zone(struct mem_cgroup *memcg,
                 .may_swap = !noswap,
                 .order = 0,
                 .priority = 0,
+                .swappiness = mem_cgroup_swappiness(memcg),
                 .target_mem_cgroup = memcg,
         };
         struct lruvec *lruvec = mem_cgroup_zone_lruvec(zone, memcg);
@@ -3372,7 +3373,10 @@ static int kswapd(void *p)
                 }
         }
 
+        tsk->flags &= ~(PF_MEMALLOC | PF_SWAPWRITE | PF_KSWAPD);
         current->reclaim_state = NULL;
+        lockdep_clear_current_reclaim_state();
+
         return 0;
 }
 
diff --git a/tools/testing/selftests/Makefile b/tools/testing/selftests/Makefile
index 32487ed18354..e66e710cc595 100644
--- a/tools/testing/selftests/Makefile
+++ b/tools/testing/selftests/Makefile
@@ -10,6 +10,7 @@ TARGETS += timers
 TARGETS += vm
 TARGETS += powerpc
 TARGETS += user
+TARGETS += sysctl
 
 all:
         for TARGET in $(TARGETS); do \
diff --git a/tools/testing/selftests/sysctl/Makefile b/tools/testing/selftests/sysctl/Makefile
new file mode 100644
index 000000000000..0a92adaf0865
--- /dev/null
+++ b/tools/testing/selftests/sysctl/Makefile
@@ -0,0 +1,19 @@
+# Makefile for sysctl selftests.
+# Expects kernel.sysctl_writes_strict=1.
+
+# No binaries, but make sure arg-less "make" doesn't trigger "run_tests".
+all:
+
+# Allow specific tests to be selected.
+test_num:
+        @/bin/sh ./run_numerictests
+
+test_string:
+        @/bin/sh ./run_stringtests
+
+run_tests: all test_num test_string
+
+# Nothing to clean up.
+clean:
+
+.PHONY: all run_tests clean test_num test_string
diff --git a/tools/testing/selftests/sysctl/common_tests b/tools/testing/selftests/sysctl/common_tests
new file mode 100644
index 000000000000..17d534b1b7b4
--- /dev/null
+++ b/tools/testing/selftests/sysctl/common_tests
@@ -0,0 +1,109 @@
+#!/bin/sh
+
+TEST_FILE=$(mktemp)
+
+echo "== Testing sysctl behavior against ${TARGET} =="
+
+set_orig()
+{
+        echo "${ORIG}" > "${TARGET}"
+}
+
+set_test()
+{
+        echo "${TEST_STR}" > "${TARGET}"
+}
+
+verify()
+{
+        local seen
+        seen=$(cat "$1")
+        if [ "${seen}" != "${TEST_STR}" ]; then
+                return 1
+        fi
+        return 0
+}
+
+trap 'set_orig; rm -f "${TEST_FILE}"' EXIT
+
+rc=0
+
+echo -n "Writing test file ... "
+echo "${TEST_STR}" > "${TEST_FILE}"
+if ! verify "${TEST_FILE}"; then
+        echo "FAIL" >&2
+        exit 1
+else
+        echo "ok"
+fi
+
+echo -n "Checking sysctl is not set to test value ... "
+if verify "${TARGET}"; then
+        echo "FAIL" >&2
+        exit 1
+else
+        echo "ok"
+fi
+
+echo -n "Writing sysctl from shell ... "
+set_test
+if ! verify "${TARGET}"; then
+        echo "FAIL" >&2
+        exit 1
+else
+        echo "ok"
+fi
+
+echo -n "Resetting sysctl to original value ... "
+set_orig
+if verify "${TARGET}"; then
+        echo "FAIL" >&2
+        exit 1
+else
+        echo "ok"
+fi
+
+# Now that we've validated the sanity of "set_test" and "set_orig",
+# we can use those functions to set starting states before running
+# specific behavioral tests.
+
+echo -n "Writing entire sysctl in single write ... "
+set_orig
+dd if="${TEST_FILE}" of="${TARGET}" bs=4096 2>/dev/null
+if ! verify "${TARGET}"; then
+        echo "FAIL" >&2
+        rc=1
+else
+        echo "ok"
+fi
+
+echo -n "Writing middle of sysctl after synchronized seek ... "
+set_test
+dd if="${TEST_FILE}" of="${TARGET}" bs=1 seek=1 skip=1 2>/dev/null
+if ! verify "${TARGET}"; then
+        echo "FAIL" >&2
+        rc=1
+else
+        echo "ok"
+fi
+
+echo -n "Writing beyond end of sysctl ... "
+set_orig
+dd if="${TEST_FILE}" of="${TARGET}" bs=20 seek=2 2>/dev/null
+if verify "${TARGET}"; then
+        echo "FAIL" >&2
+        rc=1
+else
+        echo "ok"
+fi
+
+echo -n "Writing sysctl with multiple long writes ... "
+set_orig
+(perl -e 'print "A" x 50;'; echo "${TEST_STR}") | \
+        dd of="${TARGET}" bs=50 2>/dev/null
+if verify "${TARGET}"; then
+        echo "FAIL" >&2
+        rc=1
+else
+        echo "ok"
+fi
diff --git a/tools/testing/selftests/sysctl/run_numerictests b/tools/testing/selftests/sysctl/run_numerictests
new file mode 100644
index 000000000000..8510f93f2d14
--- /dev/null
+++ b/tools/testing/selftests/sysctl/run_numerictests
@@ -0,0 +1,10 @@
+#!/bin/sh
+
+SYSCTL="/proc/sys"
+TARGET="${SYSCTL}/vm/swappiness"
+ORIG=$(cat "${TARGET}")
+TEST_STR=$(( $ORIG + 1 ))
+
+. ./common_tests
+
+exit $rc
diff --git a/tools/testing/selftests/sysctl/run_stringtests b/tools/testing/selftests/sysctl/run_stringtests
new file mode 100644
index 000000000000..90a9293d520c
--- /dev/null
+++ b/tools/testing/selftests/sysctl/run_stringtests
@@ -0,0 +1,77 @@
+#!/bin/sh
+
+SYSCTL="/proc/sys"
+TARGET="${SYSCTL}/kernel/domainname"
+ORIG=$(cat "${TARGET}")
+TEST_STR="Testing sysctl"
+
+. ./common_tests
+
+# Only string sysctls support seeking/appending.
+MAXLEN=65
+
+echo -n "Writing entire sysctl in short writes ... "
+set_orig
+dd if="${TEST_FILE}" of="${TARGET}" bs=1 2>/dev/null
+if ! verify "${TARGET}"; then
+        echo "FAIL" >&2
+        rc=1
+else
+        echo "ok"
+fi
+
+echo -n "Writing middle of sysctl after unsynchronized seek ... "
+set_test
+dd if="${TEST_FILE}" of="${TARGET}" bs=1 seek=1 2>/dev/null
+if verify "${TARGET}"; then
+        echo "FAIL" >&2
+        rc=1
+else
+        echo "ok"
+fi
+
+echo -n "Checking sysctl maxlen is at least $MAXLEN ... "
+set_orig
+perl -e 'print "A" x ('"${MAXLEN}"'-2), "B";' | \
+        dd of="${TARGET}" bs="${MAXLEN}" 2>/dev/null
+if ! grep -q B "${TARGET}"; then
+        echo "FAIL" >&2
+        rc=1
+else
+        echo "ok"
+fi
+
+echo -n "Checking sysctl keeps original string on overflow append ... "
+set_orig
+perl -e 'print "A" x ('"${MAXLEN}"'-1), "B";' | \
+        dd of="${TARGET}" bs=$(( MAXLEN - 1 )) 2>/dev/null
+if grep -q B "${TARGET}"; then
+        echo "FAIL" >&2
+        rc=1
+else
+        echo "ok"
+fi
+
+echo -n "Checking sysctl stays NULL terminated on write ... "
+set_orig
+perl -e 'print "A" x ('"${MAXLEN}"'-1), "B";' | \
+        dd of="${TARGET}" bs="${MAXLEN}" 2>/dev/null
+if grep -q B "${TARGET}"; then
+        echo "FAIL" >&2
+        rc=1
+else
+        echo "ok"
+fi
+
+echo -n "Checking sysctl stays NULL terminated on overwrite ... "
+set_orig
+perl -e 'print "A" x ('"${MAXLEN}"'-1), "BB";' | \
+        dd of="${TARGET}" bs=$(( $MAXLEN + 1 )) 2>/dev/null
+if grep -q B "${TARGET}"; then
+        echo "FAIL" >&2
+        rc=1
+else
+        echo "ok"
+fi
+
+exit $rc
diff --git a/usr/Kconfig b/usr/Kconfig
index 642f503d3e9f..2d4c77eecf2e 100644
--- a/usr/Kconfig
+++ b/usr/Kconfig
@@ -98,80 +98,3 @@ config RD_LZ4
         help
           Support loading of a LZ4 encoded initial ramdisk or cpio buffer
           If unsure, say N.
-
-choice
-        prompt "Built-in initramfs compression mode" if INITRAMFS_SOURCE!=""
-        help
-          This option decides by which algorithm the builtin initramfs
-          will be compressed.  Several compression algorithms are
-          available, which differ in efficiency, compression and
-          decompression speed.  Compression speed is only relevant
-          when building a kernel.  Decompression speed is relevant at
-          each boot.
-
-          If you have any problems with bzip2 or LZMA compressed
-          initramfs, mail me (Alain Knaff) <alain@knaff.lu>.
-
-          High compression options are mostly useful for users who are
-          low on RAM, since it reduces the memory consumption during
-          boot.
-
-          If in doubt, select 'gzip'
-
-config INITRAMFS_COMPRESSION_NONE
-        bool "None"
-        help
-          Do not compress the built-in initramfs at all. This may
-          sound wasteful in space, but, you should be aware that the
-          built-in initramfs will be compressed at a later stage
-          anyways along with the rest of the kernel, on those
-          architectures that support this.
-          However, not compressing the initramfs may lead to slightly
-          higher memory consumption during a short time at boot, while
-          both the cpio image and the unpacked filesystem image will
-          be present in memory simultaneously
-
-config INITRAMFS_COMPRESSION_GZIP
-        bool "Gzip"
-        depends on RD_GZIP
-        help
-          The old and tried gzip compression. It provides a good balance
-          between compression ratio and decompression speed.
-
-config INITRAMFS_COMPRESSION_BZIP2
-        bool "Bzip2"
-        depends on RD_BZIP2
-        help
-          Its compression ratio and speed is intermediate.
-          Decompression speed is slowest among the choices.  The initramfs
-          size is about 10% smaller with bzip2, in comparison to gzip.
-          Bzip2 uses a large amount of memory. For modern kernels you
-          will need at least 8MB RAM or more for booting.
-
-config INITRAMFS_COMPRESSION_LZMA
-        bool "LZMA"
-        depends on RD_LZMA
-        help
-          This algorithm's compression ratio is best.
-          Decompression speed is between the other choices.
-          Compression is slowest. The initramfs size is about 33%
-          smaller with LZMA in comparison to gzip.
-
-config INITRAMFS_COMPRESSION_XZ
-        bool "XZ"
-        depends on RD_XZ
-        help
-          XZ uses the LZMA2 algorithm. The initramfs size is about 30%
-          smaller with XZ in comparison to gzip. Decompression speed
-          is better than that of bzip2 but worse than gzip and LZO.
-          Compression is slow.
-
-config INITRAMFS_COMPRESSION_LZO
-        bool "LZO"
-        depends on RD_LZO
-        help
-          Its compression ratio is the poorest among the choices. The kernel
-          size is about 10% bigger than gzip; however its speed
-          (both compression and decompression) is the fastest.
-
-endchoice