105 files changed, 1350 insertions, 1457 deletions

diff --git a/Documentation/DocBook/kernel-api.tmpl b/Documentation/DocBook/kernel-api.tmpl
index f31601e8bd89..dc0f30c3e571 100644
--- a/Documentation/DocBook/kernel-api.tmpl
+++ b/Documentation/DocBook/kernel-api.tmpl
@@ -361,12 +361,14 @@ X!Edrivers/pnp/system.c
   <chapter id="blkdev">
      <title>Block Devices</title>
 !Eblock/blk-core.c
+!Iblock/blk-core.c
 !Eblock/blk-map.c
 !Iblock/blk-sysfs.c
 !Eblock/blk-settings.c
 !Eblock/blk-exec.c
 !Eblock/blk-barrier.c
 !Eblock/blk-tag.c
+!Iblock/blk-tag.c
   </chapter>
 
   <chapter id="chrdev">
diff --git a/arch/arm/mm/pgd.c b/arch/arm/mm/pgd.c
index 500c9610ab30..e0f19ab91163 100644
--- a/arch/arm/mm/pgd.c
+++ b/arch/arm/mm/pgd.c
@@ -75,7 +75,7 @@ no_pgd:
 void free_pgd_slow(struct mm_struct *mm, pgd_t *pgd)
 {
         pmd_t *pmd;
-        struct page *pte;
+        pgtable_t pte;
 
         if (!pgd)
                 return;
@@ -90,10 +90,8 @@ void free_pgd_slow(struct mm_struct *mm, pgd_t *pgd)
                 goto free;
         }
 
-        pte = pmd_page(*pmd);
+        pte = pmd_pgtable(*pmd);
         pmd_clear(pmd);
-        dec_zone_page_state(virt_to_page((unsigned long *)pgd), NR_PAGETABLE);
-        pte_lock_deinit(pte);
         pte_free(mm, pte);
         pmd_free(mm, pmd);
 free:
diff --git a/arch/m68k/kernel/entry.S b/arch/m68k/kernel/entry.S
index 6dfa3b3c0e2a..18a9c5f4b00d 100644
--- a/arch/m68k/kernel/entry.S
+++ b/arch/m68k/kernel/entry.S
@@ -742,7 +742,9 @@ sys_call_table:
         .long sys_epoll_pwait           /* 315 */
         .long sys_utimensat
         .long sys_signalfd
-        .long sys_ni_syscall
+        .long sys_timerfd_create
         .long sys_eventfd
         .long sys_fallocate             /* 320 */
+        .long sys_timerfd_settime
+        .long sys_timerfd_gettime
 
diff --git a/arch/m68knommu/defconfig b/arch/m68knommu/defconfig
index 648113075f97..670b0a99cfa0 100644
--- a/arch/m68knommu/defconfig
+++ b/arch/m68knommu/defconfig
@@ -1,7 +1,7 @@
 #
 # Automatically generated make config: don't edit
-# Linux kernel version: 2.6.23
-# Thu Oct 18 13:17:38 2007
+# Linux kernel version: 2.6.25-rc3
+# Mon Feb 25 15:03:00 2008
 #
 CONFIG_M68K=y
 # CONFIG_MMU is not set
@@ -15,8 +15,10 @@ CONFIG_GENERIC_FIND_NEXT_BIT=y
 CONFIG_GENERIC_HWEIGHT=y
 CONFIG_GENERIC_HARDIRQS=y
 CONFIG_GENERIC_CALIBRATE_DELAY=y
+CONFIG_GENERIC_TIME=y
 CONFIG_TIME_LOW_RES=y
 CONFIG_NO_IOPORT=y
+CONFIG_ARCH_SUPPORTS_AOUT=y
 CONFIG_DEFCONFIG_LIST="/lib/modules/$UNAME_RELEASE/.config"
 
 #
@@ -31,12 +33,14 @@ CONFIG_LOCALVERSION_AUTO=y
 # CONFIG_POSIX_MQUEUE is not set
 # CONFIG_BSD_PROCESS_ACCT is not set
 # CONFIG_TASKSTATS is not set
-# CONFIG_USER_NS is not set
 # CONFIG_AUDIT is not set
 # CONFIG_IKCONFIG is not set
 CONFIG_LOG_BUF_SHIFT=14
+# CONFIG_CGROUPS is not set
+# CONFIG_GROUP_SCHED is not set
 # CONFIG_SYSFS_DEPRECATED is not set
 # CONFIG_RELAY is not set
+# CONFIG_NAMESPACES is not set
 # CONFIG_BLK_DEV_INITRD is not set
 # CONFIG_CC_OPTIMIZE_FOR_SIZE is not set
 CONFIG_SYSCTL=y
@@ -48,15 +52,22 @@ CONFIG_SYSCTL_SYSCALL=y
 CONFIG_PRINTK=y
 CONFIG_BUG=y
 CONFIG_ELF_CORE=y
+CONFIG_COMPAT_BRK=y
 CONFIG_BASE_FULL=y
 # CONFIG_FUTEX is not set
 # CONFIG_EPOLL is not set
 # CONFIG_SIGNALFD is not set
+# CONFIG_TIMERFD is not set
 # CONFIG_EVENTFD is not set
 # CONFIG_VM_EVENT_COUNTERS is not set
 CONFIG_SLAB=y
 # CONFIG_SLUB is not set
 # CONFIG_SLOB is not set
+# CONFIG_PROFILING is not set
+# CONFIG_MARKERS is not set
+# CONFIG_HAVE_OPROFILE is not set
+# CONFIG_HAVE_KPROBES is not set
+CONFIG_SLABINFO=y
 CONFIG_TINY_SHMEM=y
 CONFIG_BASE_SMALL=0
 CONFIG_MODULES=y
@@ -83,6 +94,8 @@ CONFIG_IOSCHED_NOOP=y
 # CONFIG_DEFAULT_CFQ is not set
 CONFIG_DEFAULT_NOOP=y
 CONFIG_DEFAULT_IOSCHED="noop"
+CONFIG_CLASSIC_RCU=y
+# CONFIG_PREEMPT_RCU is not set
 
 #
 # Processor type and features
@@ -121,6 +134,7 @@ CONFIG_M5272C3=y
 # CONFIG_MOD5272 is not set
 CONFIG_FREESCALE=y
 CONFIG_4KSTACKS=y
+CONFIG_HZ=100
 
 #
 # RAM configuration
@@ -147,6 +161,7 @@ CONFIG_FLATMEM_MANUAL=y
 CONFIG_FLATMEM=y
 CONFIG_FLAT_NODE_MEM_MAP=y
 # CONFIG_SPARSEMEM_STATIC is not set
+# CONFIG_SPARSEMEM_VMEMMAP_ENABLE is not set
 CONFIG_SPLIT_PTLOCK_CPUS=4
 # CONFIG_RESOURCES_64BIT is not set
 CONFIG_ZONE_DMA_FLAG=1
@@ -159,10 +174,6 @@ CONFIG_VIRT_TO_BUS=y
 # CONFIG_ARCH_SUPPORTS_MSI is not set
 
 #
-# PCCARD (PCMCIA/CardBus) support
-#
-
-#
 # Executable file formats
 #
 CONFIG_BINFMT_FLAT=y
@@ -205,6 +216,7 @@ CONFIG_IP_FIB_HASH=y
 # CONFIG_INET_XFRM_MODE_TRANSPORT is not set
 # CONFIG_INET_XFRM_MODE_TUNNEL is not set
 # CONFIG_INET_XFRM_MODE_BEET is not set
+# CONFIG_INET_LRO is not set
 # CONFIG_INET_DIAG is not set
 # CONFIG_TCP_CONG_ADVANCED is not set
 CONFIG_TCP_CONG_CUBIC=y
@@ -229,10 +241,6 @@ CONFIG_DEFAULT_TCP_CONG="cubic"
 # CONFIG_LAPB is not set
 # CONFIG_ECONET is not set
 # CONFIG_WAN_ROUTER is not set
-
-#
-# QoS and/or fair queueing
-#
 # CONFIG_NET_SCHED is not set
 
 #
@@ -240,6 +248,7 @@ CONFIG_DEFAULT_TCP_CONG="cubic"
 #
 # CONFIG_NET_PKTGEN is not set
 # CONFIG_HAMRADIO is not set
+# CONFIG_CAN is not set
 # CONFIG_IRDA is not set
 # CONFIG_BT is not set
 # CONFIG_AF_RXRPC is not set
@@ -283,6 +292,7 @@ CONFIG_MTD_BLOCK=y
 # CONFIG_INFTL is not set
 # CONFIG_RFD_FTL is not set
 # CONFIG_SSFDC is not set
+# CONFIG_MTD_OOPS is not set
 
 #
 # RAM/ROM/Flash chip drivers
@@ -339,10 +349,11 @@ CONFIG_BLK_DEV=y
 CONFIG_BLK_DEV_RAM=y
 CONFIG_BLK_DEV_RAM_COUNT=16
 CONFIG_BLK_DEV_RAM_SIZE=4096
-CONFIG_BLK_DEV_RAM_BLOCKSIZE=1024
+# CONFIG_BLK_DEV_XIP is not set
 # CONFIG_CDROM_PKTCDVD is not set
 # CONFIG_ATA_OVER_ETH is not set
 # CONFIG_MISC_DEVICES is not set
+CONFIG_HAVE_IDE=y
 # CONFIG_IDE is not set
 
 #
@@ -360,9 +371,15 @@ CONFIG_NETDEVICES=y
 # CONFIG_MACVLAN is not set
 # CONFIG_EQUALIZER is not set
 # CONFIG_TUN is not set
+# CONFIG_VETH is not set
 # CONFIG_PHYLIB is not set
 CONFIG_NET_ETHERNET=y
 # CONFIG_MII is not set
+# CONFIG_IBM_NEW_EMAC_ZMII is not set
+# CONFIG_IBM_NEW_EMAC_RGMII is not set
+# CONFIG_IBM_NEW_EMAC_TAH is not set
+# CONFIG_IBM_NEW_EMAC_EMAC4 is not set
+# CONFIG_B44 is not set
 CONFIG_FEC=y
 # CONFIG_FEC2 is not set
 # CONFIG_NETDEV_1000 is not set
@@ -377,7 +394,7 @@ CONFIG_FEC=y
 CONFIG_PPP=y
 # CONFIG_PPP_MULTILINK is not set
 # CONFIG_PPP_FILTER is not set
-# CONFIG_PPP_ASYNC is not set
+CONFIG_PPP_ASYNC=y
 # CONFIG_PPP_SYNC_TTY is not set
 # CONFIG_PPP_DEFLATE is not set
 # CONFIG_PPP_BSDCOMP is not set
@@ -386,7 +403,6 @@ CONFIG_PPP=y
 # CONFIG_PPPOL2TP is not set
 # CONFIG_SLIP is not set
 CONFIG_SLHC=y
-# CONFIG_SHAPER is not set
 # CONFIG_NETCONSOLE is not set
 # CONFIG_NETPOLL is not set
 # CONFIG_NET_POLL_CONTROLLER is not set
@@ -418,12 +434,16 @@ CONFIG_SLHC=y
 #
 # Non-8250 serial port support
 #
-CONFIG_SERIAL_COLDFIRE=y
+CONFIG_SERIAL_CORE=y
+CONFIG_SERIAL_CORE_CONSOLE=y
+# CONFIG_SERIAL_COLDFIRE is not set
+CONFIG_SERIAL_MCF=y
+CONFIG_SERIAL_MCF_BAUDRATE=19200
+CONFIG_SERIAL_MCF_CONSOLE=y
 # CONFIG_UNIX98_PTYS is not set
 CONFIG_LEGACY_PTYS=y
 CONFIG_LEGACY_PTY_COUNT=256
 # CONFIG_IPMI_HANDLER is not set
-# CONFIG_WATCHDOG is not set
 # CONFIG_HW_RANDOM is not set
 # CONFIG_GEN_RTC is not set
 # CONFIG_R3964 is not set
@@ -439,6 +459,14 @@ CONFIG_LEGACY_PTY_COUNT=256
 # CONFIG_W1 is not set
 # CONFIG_POWER_SUPPLY is not set
 # CONFIG_HWMON is not set
+# CONFIG_THERMAL is not set
+# CONFIG_WATCHDOG is not set
+
+#
+# Sonics Silicon Backplane
+#
+CONFIG_SSB_POSSIBLE=y
+# CONFIG_SSB is not set
 
 #
 # Multifunction device drivers
@@ -450,20 +478,20 @@ CONFIG_LEGACY_PTY_COUNT=256
 #
 # CONFIG_VIDEO_DEV is not set
 # CONFIG_DVB_CORE is not set
-CONFIG_DAB=y
+# CONFIG_DAB is not set
 
 #
 # Graphics support
 #
+# CONFIG_VGASTATE is not set
+# CONFIG_VIDEO_OUTPUT_CONTROL is not set
+# CONFIG_FB is not set
 # CONFIG_BACKLIGHT_LCD_SUPPORT is not set
 
 #
 # Display device support
 #
 # CONFIG_DISPLAY_SUPPORT is not set
-# CONFIG_VGASTATE is not set
-CONFIG_VIDEO_OUTPUT_CONTROL=y
-# CONFIG_FB is not set
 
 #
 # Sound
@@ -471,23 +499,11 @@ CONFIG_VIDEO_OUTPUT_CONTROL=y
 # CONFIG_SOUND is not set
 # CONFIG_USB_SUPPORT is not set
 # CONFIG_MMC is not set
+# CONFIG_MEMSTICK is not set
 # CONFIG_NEW_LEDS is not set
 # CONFIG_RTC_CLASS is not set
 
 #
-# DMA Engine support
-#
-# CONFIG_DMA_ENGINE is not set
-
-#
-# DMA Clients
-#
-
-#
-# DMA Devices
-#
-
-#
 # Userspace I/O
 #
 # CONFIG_UIO is not set
@@ -505,11 +521,9 @@ CONFIG_EXT2_FS=y
 # CONFIG_XFS_FS is not set
 # CONFIG_GFS2_FS is not set
 # CONFIG_OCFS2_FS is not set
-# CONFIG_MINIX_FS is not set
-CONFIG_ROMFS_FS=y
+# CONFIG_DNOTIFY is not set
 # CONFIG_INOTIFY is not set
 # CONFIG_QUOTA is not set
-# CONFIG_DNOTIFY is not set
 # CONFIG_AUTOFS_FS is not set
 # CONFIG_AUTOFS4_FS is not set
 # CONFIG_FUSE_FS is not set
@@ -535,7 +549,6 @@ CONFIG_PROC_SYSCTL=y
 CONFIG_SYSFS=y
 # CONFIG_TMPFS is not set
 # CONFIG_HUGETLB_PAGE is not set
-CONFIG_RAMFS=y
 # CONFIG_CONFIGFS_FS is not set
 
 #
@@ -551,42 +564,27 @@ CONFIG_RAMFS=y
 # CONFIG_JFFS2_FS is not set
 # CONFIG_CRAMFS is not set
 # CONFIG_VXFS_FS is not set
+# CONFIG_MINIX_FS is not set
 # CONFIG_HPFS_FS is not set
 # CONFIG_QNX4FS_FS is not set
+CONFIG_ROMFS_FS=y
 # CONFIG_SYSV_FS is not set
 # CONFIG_UFS_FS is not set
-
-#
-# Network File Systems
-#
-# CONFIG_NFS_FS is not set
-# CONFIG_NFSD is not set
-# CONFIG_SMB_FS is not set
-# CONFIG_CIFS is not set
-# CONFIG_NCP_FS is not set
-# CONFIG_CODA_FS is not set
-# CONFIG_AFS_FS is not set
+# CONFIG_NETWORK_FILESYSTEMS is not set
 
 #
 # Partition Types
 #
 # CONFIG_PARTITION_ADVANCED is not set
 CONFIG_MSDOS_PARTITION=y
-
-#
-# Native Language Support
-#
 # CONFIG_NLS is not set
-
-#
-# Distributed Lock Manager
-#
 # CONFIG_DLM is not set
 
 #
 # Kernel hacking
 #
 # CONFIG_PRINTK_TIME is not set
+CONFIG_ENABLE_WARN_DEPRECATED=y
 # CONFIG_ENABLE_MUST_CHECK is not set
 # CONFIG_MAGIC_SYSRQ is not set
 # CONFIG_UNUSED_SYMBOLS is not set
@@ -594,6 +592,7 @@ CONFIG_MSDOS_PARTITION=y
 # CONFIG_HEADERS_CHECK is not set
 # CONFIG_DEBUG_KERNEL is not set
 # CONFIG_DEBUG_BUGVERBOSE is not set
+# CONFIG_SAMPLES is not set
 # CONFIG_FULLDEBUG is not set
 # CONFIG_HIGHPROFILE is not set
 # CONFIG_BOOTPARAM is not set
@@ -605,6 +604,7 @@ CONFIG_MSDOS_PARTITION=y
 #
 # CONFIG_KEYS is not set
 # CONFIG_SECURITY is not set
+# CONFIG_SECURITY_FILE_CAPABILITIES is not set
 # CONFIG_CRYPTO is not set
 
 #
diff --git a/arch/m68knommu/kernel/syscalltable.S b/arch/m68knommu/kernel/syscalltable.S
index 1b02b8820068..fca2e49917a3 100644
--- a/arch/m68knommu/kernel/syscalltable.S
+++ b/arch/m68knommu/kernel/syscalltable.S
@@ -336,9 +336,11 @@ ENTRY(sys_call_table)
         .long sys_epoll_pwait           /* 315 */
         .long sys_utimensat
         .long sys_signalfd
-        .long sys_ni_syscall
+        .long sys_timerfd_create
         .long sys_eventfd
         .long sys_fallocate             /* 320 */
+        .long sys_timerfd_settime
+        .long sys_timerfd_gettime
 
         .rept NR_syscalls-(.-sys_call_table)/4
                 .long sys_ni_syscall
diff --git a/arch/m68knommu/platform/68328/timers.c b/arch/m68knommu/platform/68328/timers.c
index 9159fd05c9ac..6bafefa546e5 100644
--- a/arch/m68knommu/platform/68328/timers.c
+++ b/arch/m68knommu/platform/68328/timers.c
@@ -67,16 +67,6 @@ static irqreturn_t hw_tick(int irq, void *dummy)
 
 /***************************************************************************/
 
-static irqreturn_t hw_tick(int irq, void *dummy)
-{
-        /* Reset Timer1 */
-        TSTAT &= 0;
-
-        return arch_timer_interrupt(irq, dummy);
-}
-
-/***************************************************************************/
-
 static struct irqaction m68328_timer_irq = {
         .name    = "timer",
         .flags   = IRQF_DISABLED | IRQF_TIMER,
diff --git a/arch/powerpc/boot/cuboot-bamboo.c b/arch/powerpc/boot/cuboot-bamboo.c
index 900c7ff2b7e9..b5c30f766c40 100644
--- a/arch/powerpc/boot/cuboot-bamboo.c
+++ b/arch/powerpc/boot/cuboot-bamboo.c
@@ -17,6 +17,7 @@
 #include "44x.h"
 #include "cuboot.h"
 
+#define TARGET_4xx
 #define TARGET_44x
 #include "ppcboot.h"
 
diff --git a/arch/powerpc/boot/cuboot-ebony.c b/arch/powerpc/boot/cuboot-ebony.c
index c5f37ce172ea..56564ba37f62 100644
--- a/arch/powerpc/boot/cuboot-ebony.c
+++ b/arch/powerpc/boot/cuboot-ebony.c
@@ -17,6 +17,7 @@
 #include "44x.h"
 #include "cuboot.h"
 
+#define TARGET_4xx
 #define TARGET_44x
 #include "ppcboot.h"
 
diff --git a/arch/powerpc/boot/cuboot-katmai.c b/arch/powerpc/boot/cuboot-katmai.c
index c021167f9381..5434d70b5660 100644
--- a/arch/powerpc/boot/cuboot-katmai.c
+++ b/arch/powerpc/boot/cuboot-katmai.c
@@ -22,6 +22,7 @@
 #include "44x.h"
 #include "cuboot.h"
 
+#define TARGET_4xx
 #define TARGET_44x
 #include "ppcboot.h"
 
diff --git a/arch/powerpc/boot/cuboot-taishan.c b/arch/powerpc/boot/cuboot-taishan.c
index f66455a45ab1..b55b80467eed 100644
--- a/arch/powerpc/boot/cuboot-taishan.c
+++ b/arch/powerpc/boot/cuboot-taishan.c
@@ -21,7 +21,9 @@
 #include "dcr.h"
 #include "4xx.h"
 
+#define TARGET_4xx
 #define TARGET_44x
+#define TARGET_440GX
 #include "ppcboot.h"
 
 static bd_t bd;
diff --git a/arch/powerpc/boot/cuboot-warp.c b/arch/powerpc/boot/cuboot-warp.c
index bdedebe1bc14..3db93e85e9ea 100644
--- a/arch/powerpc/boot/cuboot-warp.c
+++ b/arch/powerpc/boot/cuboot-warp.c
@@ -11,6 +11,7 @@
 #include "4xx.h"
 #include "cuboot.h"
 
+#define TARGET_4xx
 #define TARGET_44x
 #include "ppcboot.h"
 
diff --git a/arch/powerpc/boot/dts/haleakala.dts b/arch/powerpc/boot/dts/haleakala.dts
index 5dd3d15f0feb..ae68fefc01b6 100644
--- a/arch/powerpc/boot/dts/haleakala.dts
+++ b/arch/powerpc/boot/dts/haleakala.dts
@@ -235,7 +235,7 @@
                         #interrupt-cells = <1>;
                         #size-cells = <2>;
                         #address-cells = <3>;
-                        compatible = "ibm,plb-pciex-405exr", "ibm,plb-pciex";
+                        compatible = "ibm,plb-pciex-405ex", "ibm,plb-pciex";
                         primary;
                         port = <0>; /* port number */
                         reg = <a0000000 20000000        /* Config space access */
diff --git a/arch/powerpc/boot/dts/katmai.dts b/arch/powerpc/boot/dts/katmai.dts
index bc32ac7250ec..fc86e5a3afc4 100644
--- a/arch/powerpc/boot/dts/katmai.dts
+++ b/arch/powerpc/boot/dts/katmai.dts
@@ -38,8 +38,8 @@
                         timebase-frequency = <0>; /* Filled in by zImage */
                         i-cache-line-size = <20>;
                         d-cache-line-size = <20>;
-                        i-cache-size = <20000>;
-                        d-cache-size = <20000>;
+                        i-cache-size = <8000>;
+                        d-cache-size = <8000>;
                         dcr-controller;
                         dcr-access-method = "native";
                 };
@@ -136,11 +136,11 @@
                 };
 
                 POB0: opb {
-                        compatible = "ibm,opb-440spe", "ibm,opb-440gp", "ibm,opb";
+                        compatible = "ibm,opb-440spe", "ibm,opb-440gp", "ibm,opb";
                         #address-cells = <1>;
                         #size-cells = <1>;
-                        ranges = <00000000 4 e0000000 20000000>;
-                        clock-frequency = <0>; /* Filled in by zImage */
+                        ranges = <00000000 4 e0000000 20000000>;
+                        clock-frequency = <0>; /* Filled in by zImage */
 
                         EBC0: ebc {
                                 compatible = "ibm,ebc-440spe", "ibm,ebc-440gp", "ibm,ebc";
@@ -153,38 +153,38 @@
                         };
 
                         UART0: serial@10000200 {
-                                device_type = "serial";
-                                compatible = "ns16550";
-                                reg = <10000200 8>;
+                                device_type = "serial";
+                                compatible = "ns16550";
+                                reg = <10000200 8>;
                                 virtual-reg = <a0000200>;
-                                clock-frequency = <0>; /* Filled in by zImage */
-                                current-speed = <1c200>;
-                                interrupt-parent = <&UIC0>;
-                                interrupts = <0 4>;
-                        };
+                                clock-frequency = <0>; /* Filled in by zImage */
+                                current-speed = <1c200>;
+                                interrupt-parent = <&UIC0>;
+                                interrupts = <0 4>;
+                        };
 
                         UART1: serial@10000300 {
-                                device_type = "serial";
-                                compatible = "ns16550";
-                                reg = <10000300 8>;
+                                device_type = "serial";
+                                compatible = "ns16550";
+                                reg = <10000300 8>;
                                 virtual-reg = <a0000300>;
-                                clock-frequency = <0>;
-                                current-speed = <0>;
-                                interrupt-parent = <&UIC0>;
-                                interrupts = <1 4>;
-                        };
+                                clock-frequency = <0>;
+                                current-speed = <0>;
+                                interrupt-parent = <&UIC0>;
+                                interrupts = <1 4>;
+                        };
 
 
                         UART2: serial@10000600 {
-                                device_type = "serial";
-                                compatible = "ns16550";
-                                reg = <10000600 8>;
+                                device_type = "serial";
+                                compatible = "ns16550";
+                                reg = <10000600 8>;
                                 virtual-reg = <a0000600>;
-                                clock-frequency = <0>;
-                                current-speed = <0>;
-                                interrupt-parent = <&UIC1>;
-                                interrupts = <5 4>;
-                        };
+                                clock-frequency = <0>;
+                                current-speed = <0>;
+                                interrupt-parent = <&UIC1>;
+                                interrupts = <5 4>;
+                        };
 
                         IIC0: i2c@10000400 {
                                 compatible = "ibm,iic-440spe", "ibm,iic-440gp", "ibm,iic";
diff --git a/arch/powerpc/oprofile/op_model_cell.c b/arch/powerpc/oprofile/op_model_cell.c
index 13929771bee7..9eed1f68fcab 100644
--- a/arch/powerpc/oprofile/op_model_cell.c
+++ b/arch/powerpc/oprofile/op_model_cell.c
@@ -1151,7 +1151,7 @@ static void cell_handle_interrupt(struct pt_regs *regs,
                 for (i = 0; i < num_counters; ++i) {
                         if ((interrupt_mask & CBE_PM_CTR_OVERFLOW_INTR(i))
                             && ctr[i].enabled) {
-                                oprofile_add_pc(pc, is_kernel, i);
+                                oprofile_add_ext_sample(pc, regs, i, is_kernel);
                                 cbe_write_ctr(cpu, i, reset_value[i]);
                         }
                 }
diff --git a/arch/powerpc/platforms/52xx/mpc52xx_common.c b/arch/powerpc/platforms/52xx/mpc52xx_common.c
index 9aa4425d80b2..4d5fd1dbd400 100644
--- a/arch/powerpc/platforms/52xx/mpc52xx_common.c
+++ b/arch/powerpc/platforms/52xx/mpc52xx_common.c
@@ -199,6 +199,7 @@ int mpc52xx_set_psc_clkdiv(int psc_id, int clkdiv)
 
         return 0;
 }
+EXPORT_SYMBOL(mpc52xx_set_psc_clkdiv);
 
 /**
  * mpc52xx_restart: ppc_md->restart hook for mpc5200 using the watchdog timer
diff --git a/arch/powerpc/platforms/cell/iommu.c b/arch/powerpc/platforms/cell/iommu.c
index edab631a8dcb..20ea0e118f24 100644
--- a/arch/powerpc/platforms/cell/iommu.c
+++ b/arch/powerpc/platforms/cell/iommu.c
@@ -113,7 +113,7 @@
 
 /* IOMMU sizing */
 #define IO_SEGMENT_SHIFT        28
-#define IO_PAGENO_BITS          (IO_SEGMENT_SHIFT - IOMMU_PAGE_SHIFT)
+#define IO_PAGENO_BITS(shift)   (IO_SEGMENT_SHIFT - (shift))
 
 /* The high bit needs to be set on every DMA address */
 #define SPIDER_DMA_OFFSET       0x80000000ul
@@ -123,7 +123,6 @@ struct iommu_window {
         struct cbe_iommu *iommu;
         unsigned long offset;
         unsigned long size;
-        unsigned long pte_offset;
         unsigned int ioid;
         struct iommu_table table;
 };
@@ -200,7 +199,7 @@ static void tce_build_cell(struct iommu_table *tbl, long index, long npages,
                 (window->ioid & IOPTE_IOID_Mask);
 #endif
 
-        io_pte = (unsigned long *)tbl->it_base + (index - window->pte_offset);
+        io_pte = (unsigned long *)tbl->it_base + (index - tbl->it_offset);
 
         for (i = 0; i < npages; i++, uaddr += IOMMU_PAGE_SIZE)
                 io_pte[i] = base_pte | (__pa(uaddr) & IOPTE_RPN_Mask);
@@ -232,7 +231,7 @@ static void tce_free_cell(struct iommu_table *tbl, long index, long npages)
                 | (window->ioid & IOPTE_IOID_Mask);
 #endif
 
-        io_pte = (unsigned long *)tbl->it_base + (index - window->pte_offset);
+        io_pte = (unsigned long *)tbl->it_base + (index - tbl->it_offset);
 
         for (i = 0; i < npages; i++)
                 io_pte[i] = pte;
@@ -307,76 +306,84 @@ static int cell_iommu_find_ioc(int nid, unsigned long *base)
         return -ENODEV;
 }
 
-static void cell_iommu_setup_page_tables(struct cbe_iommu *iommu,
+static void cell_iommu_setup_stab(struct cbe_iommu *iommu,
                                 unsigned long dbase, unsigned long dsize,
                                 unsigned long fbase, unsigned long fsize)
 {
         struct page *page;
-        int i;
-        unsigned long reg, segments, pages_per_segment, ptab_size, stab_size,
-                      n_pte_pages, base;
-
-        base = dbase;
-        if (fsize != 0)
-                base = min(fbase, dbase);
+        unsigned long segments, stab_size;
 
         segments = max(dbase + dsize, fbase + fsize) >> IO_SEGMENT_SHIFT;
-        pages_per_segment = 1ull << IO_PAGENO_BITS;
 
-        pr_debug("%s: iommu[%d]: segments: %lu, pages per segment: %lu\n",
-                        __FUNCTION__, iommu->nid, segments, pages_per_segment);
+        pr_debug("%s: iommu[%d]: segments: %lu\n",
+                        __FUNCTION__, iommu->nid, segments);
 
         /* set up the segment table */
         stab_size = segments * sizeof(unsigned long);
         page = alloc_pages_node(iommu->nid, GFP_KERNEL, get_order(stab_size));
         BUG_ON(!page);
         iommu->stab = page_address(page);
-        clear_page(iommu->stab);
+        memset(iommu->stab, 0, stab_size);
+}
+
+static unsigned long *cell_iommu_alloc_ptab(struct cbe_iommu *iommu,
+                unsigned long base, unsigned long size, unsigned long gap_base,
+                unsigned long gap_size, unsigned long page_shift)
+{
+        struct page *page;
+        int i;
+        unsigned long reg, segments, pages_per_segment, ptab_size,
+                      n_pte_pages, start_seg, *ptab;
+
+        start_seg = base >> IO_SEGMENT_SHIFT;
+        segments  = size >> IO_SEGMENT_SHIFT;
+        pages_per_segment = 1ull << IO_PAGENO_BITS(page_shift);
+        /* PTEs for each segment must start on a 4K bounday */
+        pages_per_segment = max(pages_per_segment,
+                                (1 << 12) / sizeof(unsigned long));
 
-        /* ... and the page tables. Since these are contiguous, we can treat
-         * the page tables as one array of ptes, like pSeries does.
-         */
         ptab_size = segments * pages_per_segment * sizeof(unsigned long);
         pr_debug("%s: iommu[%d]: ptab_size: %lu, order: %d\n", __FUNCTION__,
                         iommu->nid, ptab_size, get_order(ptab_size));
         page = alloc_pages_node(iommu->nid, GFP_KERNEL, get_order(ptab_size));
         BUG_ON(!page);
 
-        iommu->ptab = page_address(page);
-        memset(iommu->ptab, 0, ptab_size);
+        ptab = page_address(page);
+        memset(ptab, 0, ptab_size);
 
-        /* allocate a bogus page for the end of each mapping */
-        page = alloc_pages_node(iommu->nid, GFP_KERNEL, 0);
-        BUG_ON(!page);
-        iommu->pad_page = page_address(page);
-        clear_page(iommu->pad_page);
-
-        /* number of pages needed for a page table */
-        n_pte_pages = (pages_per_segment *
-                       sizeof(unsigned long)) >> IOMMU_PAGE_SHIFT;
+        /* number of 4K pages needed for a page table */
+        n_pte_pages = (pages_per_segment * sizeof(unsigned long)) >> 12;
 
         pr_debug("%s: iommu[%d]: stab at %p, ptab at %p, n_pte_pages: %lu\n",
-                        __FUNCTION__, iommu->nid, iommu->stab, iommu->ptab,
+                        __FUNCTION__, iommu->nid, iommu->stab, ptab,
                         n_pte_pages);
 
         /* initialise the STEs */
         reg = IOSTE_V | ((n_pte_pages - 1) << 5);
 
-        if (IOMMU_PAGE_SIZE == 0x1000)
-                reg |= IOSTE_PS_4K;
-        else if (IOMMU_PAGE_SIZE == 0x10000)
-                reg |= IOSTE_PS_64K;
-        else {
-                extern void __unknown_page_size_error(void);
-                __unknown_page_size_error();
+        switch (page_shift) {
+        case 12: reg |= IOSTE_PS_4K;  break;
+        case 16: reg |= IOSTE_PS_64K; break;
+        case 20: reg |= IOSTE_PS_1M;  break;
+        case 24: reg |= IOSTE_PS_16M; break;
+        default: BUG();
         }
 
+        gap_base = gap_base >> IO_SEGMENT_SHIFT;
+        gap_size = gap_size >> IO_SEGMENT_SHIFT;
+
         pr_debug("Setting up IOMMU stab:\n");
-        for (i = base >> IO_SEGMENT_SHIFT; i < segments; i++) {
-                iommu->stab[i] = reg |
-                        (__pa(iommu->ptab) + n_pte_pages * IOMMU_PAGE_SIZE * i);
+        for (i = start_seg; i < (start_seg + segments); i++) {
+                if (i >= gap_base && i < (gap_base + gap_size)) {
+                        pr_debug("\toverlap at %d, skipping\n", i);
+                        continue;
+                }
+                iommu->stab[i] = reg | (__pa(ptab) + (n_pte_pages << 12) *
+                                        (i - start_seg));
                 pr_debug("\t[%d] 0x%016lx\n", i, iommu->stab[i]);
         }
+
+        return ptab;
 }
 
 static void cell_iommu_enable_hardware(struct cbe_iommu *iommu)
@@ -423,7 +430,9 @@ static void cell_iommu_enable_hardware(struct cbe_iommu *iommu)
 static void cell_iommu_setup_hardware(struct cbe_iommu *iommu,
         unsigned long base, unsigned long size)
 {
-        cell_iommu_setup_page_tables(iommu, base, size, 0, 0);
+        cell_iommu_setup_stab(iommu, base, size, 0, 0);
+        iommu->ptab = cell_iommu_alloc_ptab(iommu, base, size, 0, 0,
+                                            IOMMU_PAGE_SHIFT);
         cell_iommu_enable_hardware(iommu);
 }
 
@@ -464,6 +473,7 @@ cell_iommu_setup_window(struct cbe_iommu *iommu, struct device_node *np,
                         unsigned long pte_offset)
 {
         struct iommu_window *window;
+        struct page *page;
         u32 ioid;
 
         ioid = cell_iommu_get_ioid(np);
@@ -475,13 +485,11 @@ cell_iommu_setup_window(struct cbe_iommu *iommu, struct device_node *np,
         window->size = size;
         window->ioid = ioid;
         window->iommu = iommu;
-        window->pte_offset = pte_offset;
 
         window->table.it_blocksize = 16;
         window->table.it_base = (unsigned long)iommu->ptab;
         window->table.it_index = iommu->nid;
-        window->table.it_offset = (offset >> IOMMU_PAGE_SHIFT) +
-                window->pte_offset;
+        window->table.it_offset = (offset >> IOMMU_PAGE_SHIFT) + pte_offset;
         window->table.it_size = size >> IOMMU_PAGE_SHIFT;
 
         iommu_init_table(&window->table, iommu->nid);
@@ -504,6 +512,11 @@ cell_iommu_setup_window(struct cbe_iommu *iommu, struct device_node *np,
          * This code also assumes that we have a window that starts at 0,
          * which is the case on all spider based blades.
          */
+        page = alloc_pages_node(iommu->nid, GFP_KERNEL, 0);
+        BUG_ON(!page);
+        iommu->pad_page = page_address(page);
+        clear_page(iommu->pad_page);
+
         __set_bit(0, window->table.it_map);
         tce_build_cell(&window->table, window->table.it_offset, 1,
                        (unsigned long)iommu->pad_page, DMA_TO_DEVICE);
@@ -549,7 +562,7 @@ static void cell_dma_dev_setup_iommu(struct device *dev)
         archdata->dma_data = &window->table;
 }
 
-static void cell_dma_dev_setup_static(struct device *dev);
+static void cell_dma_dev_setup_fixed(struct device *dev);
 
 static void cell_dma_dev_setup(struct device *dev)
 {
@@ -557,7 +570,7 @@ static void cell_dma_dev_setup(struct device *dev)
 
         /* Order is important here, these are not mutually exclusive */
         if (get_dma_ops(dev) == &dma_iommu_fixed_ops)
-                cell_dma_dev_setup_static(dev);
+                cell_dma_dev_setup_fixed(dev);
         else if (get_pci_dma_ops() == &dma_iommu_ops)
                 cell_dma_dev_setup_iommu(dev);
         else if (get_pci_dma_ops() == &dma_direct_ops)
@@ -858,7 +871,7 @@ static int dma_set_mask_and_switch(struct device *dev, u64 dma_mask)
         return 0;
 }
 
-static void cell_dma_dev_setup_static(struct device *dev)
+static void cell_dma_dev_setup_fixed(struct device *dev)
 {
         struct dev_archdata *archdata = &dev->archdata;
         u64 addr;
@@ -869,35 +882,45 @@ static void cell_dma_dev_setup_static(struct device *dev)
         dev_dbg(dev, "iommu: fixed addr = %lx\n", addr);
 }
 
+static void insert_16M_pte(unsigned long addr, unsigned long *ptab,
+                           unsigned long base_pte)
+{
+        unsigned long segment, offset;
+
+        segment = addr >> IO_SEGMENT_SHIFT;
+        offset = (addr >> 24) - (segment << IO_PAGENO_BITS(24));
+        ptab = ptab + (segment * (1 << 12) / sizeof(unsigned long));
+
+        pr_debug("iommu: addr %lx ptab %p segment %lx offset %lx\n",
+                  addr, ptab, segment, offset);
+
+        ptab[offset] = base_pte | (__pa(addr) & IOPTE_RPN_Mask);
+}
+
 static void cell_iommu_setup_fixed_ptab(struct cbe_iommu *iommu,
         struct device_node *np, unsigned long dbase, unsigned long dsize,
         unsigned long fbase, unsigned long fsize)
 {
-        unsigned long base_pte, uaddr, *io_pte;
-        int i;
+        unsigned long base_pte, uaddr, ioaddr, *ptab;
 
-        dma_iommu_fixed_base = fbase;
+        ptab = cell_iommu_alloc_ptab(iommu, fbase, fsize, dbase, dsize, 24);
 
-        /* convert from bytes into page table indices */
-        dbase = dbase >> IOMMU_PAGE_SHIFT;
-        dsize = dsize >> IOMMU_PAGE_SHIFT;
-        fbase = fbase >> IOMMU_PAGE_SHIFT;
-        fsize = fsize >> IOMMU_PAGE_SHIFT;
+        dma_iommu_fixed_base = fbase;
 
         pr_debug("iommu: mapping 0x%lx pages from 0x%lx\n", fsize, fbase);
 
-        io_pte = iommu->ptab;
         base_pte = IOPTE_PP_W | IOPTE_PP_R | IOPTE_M | IOPTE_SO_RW
                     | (cell_iommu_get_ioid(np) & IOPTE_IOID_Mask);
 
-        uaddr = 0;
-        for (i = fbase; i < fbase + fsize; i++, uaddr += IOMMU_PAGE_SIZE) {
+        for (uaddr = 0; uaddr < fsize; uaddr += (1 << 24)) {
                 /* Don't touch the dynamic region */
-                if (i >= dbase && i < (dbase + dsize)) {
-                        pr_debug("iommu: static/dynamic overlap, skipping\n");
+                ioaddr = uaddr + fbase;
+                if (ioaddr >= dbase && ioaddr < (dbase + dsize)) {
+                        pr_debug("iommu: fixed/dynamic overlap, skipping\n");
                         continue;
                 }
-                io_pte[i] = base_pte | (__pa(uaddr) & IOPTE_RPN_Mask);
+
+                insert_16M_pte(uaddr, ptab, base_pte);
         }
 
         mb();
@@ -995,7 +1018,9 @@ static int __init cell_iommu_fixed_mapping_init(void)
                         "fixed window 0x%lx-0x%lx\n", iommu->nid, dbase,
                          dbase + dsize, fbase, fbase + fsize);
 
-                cell_iommu_setup_page_tables(iommu, dbase, dsize, fbase, fsize);
+                cell_iommu_setup_stab(iommu, dbase, dsize, fbase, fsize);
+                iommu->ptab = cell_iommu_alloc_ptab(iommu, dbase, dsize, 0, 0,
+                                                    IOMMU_PAGE_SHIFT);
                 cell_iommu_setup_fixed_ptab(iommu, np, dbase, dsize,
                                              fbase, fsize);
                 cell_iommu_enable_hardware(iommu);
diff --git a/arch/powerpc/platforms/cell/setup.c b/arch/powerpc/platforms/cell/setup.c
index a7f609b3b876..dda34650cb07 100644
--- a/arch/powerpc/platforms/cell/setup.c
+++ b/arch/powerpc/platforms/cell/setup.c
@@ -149,6 +149,11 @@ static void __init cell_init_irq(void)
         mpic_init_IRQ();
 }
 
+static void __init cell_set_dabrx(void)
+{
+        mtspr(SPRN_DABRX, DABRX_KERNEL | DABRX_USER);
+}
+
 static void __init cell_setup_arch(void)
 {
 #ifdef CONFIG_SPU_BASE
@@ -158,6 +163,8 @@ static void __init cell_setup_arch(void)
 
         cbe_regs_init();
 
+        cell_set_dabrx();
+
 #ifdef CONFIG_CBE_RAS
         cbe_ras_init();
 #endif
diff --git a/arch/powerpc/platforms/cell/spu_base.c b/arch/powerpc/platforms/cell/spu_base.c
index 87eb07f94c5f..712001f6b7da 100644
--- a/arch/powerpc/platforms/cell/spu_base.c
+++ b/arch/powerpc/platforms/cell/spu_base.c
@@ -81,9 +81,12 @@ struct spu_slb {
 void spu_invalidate_slbs(struct spu *spu)
 {
         struct spu_priv2 __iomem *priv2 = spu->priv2;
+        unsigned long flags;
 
+        spin_lock_irqsave(&spu->register_lock, flags);
         if (spu_mfc_sr1_get(spu) & MFC_STATE1_RELOCATE_MASK)
                 out_be64(&priv2->slb_invalidate_all_W, 0UL);
+        spin_unlock_irqrestore(&spu->register_lock, flags);
 }
 EXPORT_SYMBOL_GPL(spu_invalidate_slbs);
 
@@ -148,7 +151,11 @@ static inline void spu_load_slb(struct spu *spu, int slbe, struct spu_slb *slb)
                         __func__, slbe, slb->vsid, slb->esid);
 
         out_be64(&priv2->slb_index_W, slbe);
+        /* set invalid before writing vsid */
+        out_be64(&priv2->slb_esid_RW, 0);
+        /* now it's safe to write the vsid */
         out_be64(&priv2->slb_vsid_RW, slb->vsid);
+        /* setting the new esid makes the entry valid again */
         out_be64(&priv2->slb_esid_RW, slb->esid);
 }
 
@@ -290,9 +297,11 @@ void spu_setup_kernel_slbs(struct spu *spu, struct spu_lscsa *lscsa,
                 nr_slbs++;
         }
 
+        spin_lock_irq(&spu->register_lock);
         /* Add the set of SLBs */
         for (i = 0; i < nr_slbs; i++)
                 spu_load_slb(spu, i, &slbs[i]);
+        spin_unlock_irq(&spu->register_lock);
 }
 EXPORT_SYMBOL_GPL(spu_setup_kernel_slbs);
 
@@ -337,13 +346,14 @@ spu_irq_class_1(int irq, void *data)
         if (stat & CLASS1_STORAGE_FAULT_INTR)
                 spu_mfc_dsisr_set(spu, 0ul);
         spu_int_stat_clear(spu, 1, stat);
-        spin_unlock(&spu->register_lock);
-        pr_debug("%s: %lx %lx %lx %lx\n", __FUNCTION__, mask, stat,
-                        dar, dsisr);
 
         if (stat & CLASS1_SEGMENT_FAULT_INTR)
                 __spu_trap_data_seg(spu, dar);
 
+        spin_unlock(&spu->register_lock);
+        pr_debug("%s: %lx %lx %lx %lx\n", __FUNCTION__, mask, stat,
+                        dar, dsisr);
+
         if (stat & CLASS1_STORAGE_FAULT_INTR)
                 __spu_trap_data_map(spu, dar, dsisr);
 
diff --git a/arch/powerpc/platforms/cell/spufs/context.c b/arch/powerpc/platforms/cell/spufs/context.c
index 133995ed5cc7..cf6c2c89211d 100644
--- a/arch/powerpc/platforms/cell/spufs/context.c
+++ b/arch/powerpc/platforms/cell/spufs/context.c
@@ -109,13 +109,12 @@ void spu_forget(struct spu_context *ctx)
 
         /*
          * This is basically an open-coded spu_acquire_saved, except that
-         * we don't acquire the state mutex interruptible.
+         * we don't acquire the state mutex interruptible, and we don't
+         * want this context to be rescheduled on release.
          */
         mutex_lock(&ctx->state_mutex);
-        if (ctx->state != SPU_STATE_SAVED) {
-                set_bit(SPU_SCHED_WAS_ACTIVE, &ctx->sched_flags);
+        if (ctx->state != SPU_STATE_SAVED)
                 spu_deactivate(ctx);
-        }
 
         mm = ctx->owner;
         ctx->owner = NULL;
diff --git a/arch/powerpc/platforms/cell/spufs/file.c b/arch/powerpc/platforms/cell/spufs/file.c
index c66c3756970d..f7a7e8635fb6 100644
--- a/arch/powerpc/platforms/cell/spufs/file.c
+++ b/arch/powerpc/platforms/cell/spufs/file.c
@@ -367,6 +367,13 @@ static unsigned long spufs_ps_nopfn(struct vm_area_struct *vma,
                 return NOPFN_SIGBUS;
 
         /*
+         * Because we release the mmap_sem, the context may be destroyed while
+         * we're in spu_wait. Grab an extra reference so it isn't destroyed
+         * in the meantime.
+         */
+        get_spu_context(ctx);
+
+        /*
          * We have to wait for context to be loaded before we have
          * pages to hand out to the user, but we don't want to wait
          * with the mmap_sem held.
@@ -375,7 +382,7 @@ static unsigned long spufs_ps_nopfn(struct vm_area_struct *vma,
          * hanged.
          */
         if (spu_acquire(ctx))
-                return NOPFN_REFAULT;
+                goto refault;
 
         if (ctx->state == SPU_STATE_SAVED) {
                 up_read(&current->mm->mmap_sem);
@@ -391,6 +398,9 @@ static unsigned long spufs_ps_nopfn(struct vm_area_struct *vma,
 
         if (!ret)
                 spu_release(ctx);
+
+refault:
+        put_spu_context(ctx);
         return NOPFN_REFAULT;
 }
 
diff --git a/arch/powerpc/platforms/cell/spufs/sched.c b/arch/powerpc/platforms/cell/spufs/sched.c
index 3a5972117de7..5d5f680cd0b8 100644
--- a/arch/powerpc/platforms/cell/spufs/sched.c
+++ b/arch/powerpc/platforms/cell/spufs/sched.c
@@ -246,7 +246,7 @@ static void spu_bind_context(struct spu *spu, struct spu_context *ctx)
         spu_switch_notify(spu, ctx);
         ctx->state = SPU_STATE_RUNNABLE;
 
-        spuctx_switch_state(ctx, SPU_UTIL_IDLE_LOADED);
+        spuctx_switch_state(ctx, SPU_UTIL_USER);
 }
 
 /*
diff --git a/arch/powerpc/platforms/cell/spufs/sputrace.c b/arch/powerpc/platforms/cell/spufs/sputrace.c
index 01974f7776e1..79aa773f3c99 100644
--- a/arch/powerpc/platforms/cell/spufs/sputrace.c
+++ b/arch/powerpc/platforms/cell/spufs/sputrace.c
@@ -58,12 +58,12 @@ static int sputrace_sprint(char *tbuf, int n)
                 ktime_to_timespec(ktime_sub(t->tstamp, sputrace_start));
 
         return snprintf(tbuf, n,
-                "[%lu.%09lu] %d: %s (thread = %d, spu = %d)\n",
+                "[%lu.%09lu] %d: %s (ctxthread = %d, spu = %d)\n",
                 (unsigned long) tv.tv_sec,
                 (unsigned long) tv.tv_nsec,
-                t->owner_tid,
-                t->name,
                 t->curr_tid,
+                t->name,
+                t->owner_tid,
                 t->number);
 }
 
@@ -188,6 +188,7 @@ struct spu_probe spu_probes[] = {
         { "spufs_ps_nopfn__insert", "%p %p", spu_context_event },
         { "spu_acquire_saved__enter", "%p", spu_context_nospu_event },
         { "destroy_spu_context__enter", "%p", spu_context_nospu_event },
+        { "spufs_stop_callback__enter", "%p %p", spu_context_event },
 };
 
 static int __init sputrace_init(void)
diff --git a/arch/powerpc/platforms/cell/spufs/switch.c b/arch/powerpc/platforms/cell/spufs/switch.c
index 6f5886c7b1f9..e9dc7a55d1b9 100644
--- a/arch/powerpc/platforms/cell/spufs/switch.c
+++ b/arch/powerpc/platforms/cell/spufs/switch.c
@@ -34,6 +34,7 @@
 
 #include <linux/module.h>
 #include <linux/errno.h>
+#include <linux/hardirq.h>
 #include <linux/sched.h>
 #include <linux/kernel.h>
 #include <linux/mm.h>
@@ -117,6 +118,8 @@ static inline void disable_interrupts(struct spu_state *csa, struct spu *spu)
          *     Write INT_MASK_class1 with value of 0.
          *     Save INT_Mask_class2 in CSA.
          *     Write INT_MASK_class2 with value of 0.
+         *     Synchronize all three interrupts to be sure
+         *     we no longer execute a handler on another CPU.
          */
         spin_lock_irq(&spu->register_lock);
         if (csa) {
@@ -129,6 +132,9 @@ static inline void disable_interrupts(struct spu_state *csa, struct spu *spu)
         spu_int_mask_set(spu, 2, 0ul);
         eieio();
         spin_unlock_irq(&spu->register_lock);
+        synchronize_irq(spu->irqs[0]);
+        synchronize_irq(spu->irqs[1]);
+        synchronize_irq(spu->irqs[2]);
 }
 
 static inline void set_watchdog_timer(struct spu_state *csa, struct spu *spu)
diff --git a/arch/powerpc/platforms/celleb/beat.h b/arch/powerpc/platforms/celleb/beat.h
index b2e292df13ca..ac82ac35b991 100644
--- a/arch/powerpc/platforms/celleb/beat.h
+++ b/arch/powerpc/platforms/celleb/beat.h
@@ -21,9 +21,6 @@
 #ifndef _CELLEB_BEAT_H
 #define _CELLEB_BEAT_H
 
-#define DABRX_KERNEL            (1UL<<1)
-#define DABRX_USER              (1UL<<0)
-
 int64_t beat_get_term_char(uint64_t,uint64_t*,uint64_t*,uint64_t*);
 int64_t beat_put_term_char(uint64_t,uint64_t,uint64_t,uint64_t);
 int64_t beat_repository_encode(int, const char *, uint64_t[4]);
diff --git a/arch/x86/mm/pageattr.c b/arch/x86/mm/pageattr.c
index 7049294fb469..14e48b5a94ba 100644
--- a/arch/x86/mm/pageattr.c
+++ b/arch/x86/mm/pageattr.c
@@ -26,7 +26,6 @@ struct cpa_data {
         pgprot_t        mask_set;
         pgprot_t        mask_clr;
         int             numpages;
-        int             processed;
         int             flushtlb;
         unsigned long   pfn;
 };
@@ -291,8 +290,8 @@ try_preserve_large_page(pte_t *kpte, unsigned long address,
          */
         nextpage_addr = (address + psize) & pmask;
         numpages = (nextpage_addr - address) >> PAGE_SHIFT;
-        if (numpages < cpa->processed)
-                cpa->processed = numpages;
+        if (numpages < cpa->numpages)
+                cpa->numpages = numpages;
 
         /*
          * We are safe now. Check whether the new pgprot is the same:
@@ -319,7 +318,7 @@ try_preserve_large_page(pte_t *kpte, unsigned long address,
          */
         addr = address + PAGE_SIZE;
         pfn++;
-        for (i = 1; i < cpa->processed; i++, addr += PAGE_SIZE, pfn++) {
+        for (i = 1; i < cpa->numpages; i++, addr += PAGE_SIZE, pfn++) {
                 pgprot_t chk_prot = static_protections(new_prot, addr, pfn);
 
                 if (pgprot_val(chk_prot) != pgprot_val(new_prot))
@@ -343,7 +342,7 @@ try_preserve_large_page(pte_t *kpte, unsigned long address,
          * that we limited the number of possible pages already to
          * the number of pages in the large page.
          */
-        if (address == (nextpage_addr - psize) && cpa->processed == numpages) {
+        if (address == (nextpage_addr - psize) && cpa->numpages == numpages) {
                 /*
                  * The address is aligned and the number of pages
                  * covers the full page.
@@ -573,7 +572,7 @@ repeat:
                         set_pte_atomic(kpte, new_pte);
                         cpa->flushtlb = 1;
                 }
-                cpa->processed = 1;
+                cpa->numpages = 1;
                 return 0;
         }
 
@@ -584,7 +583,7 @@ repeat:
         do_split = try_preserve_large_page(kpte, address, cpa);
         /*
          * When the range fits into the existing large page,
-         * return. cp->processed and cpa->tlbflush have been updated in
+         * return. cp->numpages and cpa->tlbflush have been updated in
          * try_large_page:
          */
         if (do_split <= 0)
@@ -663,7 +662,7 @@ static int __change_page_attr_set_clr(struct cpa_data *cpa, int checkalias)
                  * Store the remaining nr of pages for the large page
                  * preservation check.
                  */
-                cpa->numpages = cpa->processed = numpages;
+                cpa->numpages = numpages;
 
                 ret = __change_page_attr(cpa, checkalias);
                 if (ret)
@@ -680,9 +679,9 @@ static int __change_page_attr_set_clr(struct cpa_data *cpa, int checkalias)
                  * CPA operation. Either a large page has been
                  * preserved or a single page update happened.
                  */
-                BUG_ON(cpa->processed > numpages);
-                numpages -= cpa->processed;
-                cpa->vaddr += cpa->processed * PAGE_SIZE;
+                BUG_ON(cpa->numpages > numpages);
+                numpages -= cpa->numpages;
+                cpa->vaddr += cpa->numpages * PAGE_SIZE;
         }
         return 0;
 }
diff --git a/block/blk-barrier.c b/block/blk-barrier.c
index 6901eedeffce..55c5f1fc4f1f 100644
--- a/block/blk-barrier.c
+++ b/block/blk-barrier.c
@@ -259,8 +259,11 @@ int blk_do_ordered(struct request_queue *q, struct request **rqp)
 
 static void bio_end_empty_barrier(struct bio *bio, int err)
 {
-        if (err)
+        if (err) {
+                if (err == -EOPNOTSUPP)
+                        set_bit(BIO_EOPNOTSUPP, &bio->bi_flags);
                 clear_bit(BIO_UPTODATE, &bio->bi_flags);
+        }
 
         complete(bio->bi_private);
 }
@@ -309,7 +312,9 @@ int blkdev_issue_flush(struct block_device *bdev, sector_t *error_sector)
                 *error_sector = bio->bi_sector;
 
         ret = 0;
-        if (!bio_flagged(bio, BIO_UPTODATE))
+        if (bio_flagged(bio, BIO_EOPNOTSUPP))
+                ret = -EOPNOTSUPP;
+        else if (!bio_flagged(bio, BIO_UPTODATE))
                 ret = -EIO;
 
         bio_put(bio);
diff --git a/block/blk-core.c b/block/blk-core.c
index 775c8516abf5..2a438a93f723 100644
--- a/block/blk-core.c
+++ b/block/blk-core.c
@@ -127,7 +127,6 @@ void rq_init(struct request_queue *q, struct request *rq)
         rq->nr_hw_segments = 0;
         rq->ioprio = 0;
         rq->special = NULL;
-        rq->raw_data_len = 0;
         rq->buffer = NULL;
         rq->tag = -1;
         rq->errors = 0;
@@ -135,6 +134,7 @@ void rq_init(struct request_queue *q, struct request *rq)
         rq->cmd_len = 0;
         memset(rq->cmd, 0, sizeof(rq->cmd));
         rq->data_len = 0;
+        rq->extra_len = 0;
         rq->sense_len = 0;
         rq->data = NULL;
         rq->sense = NULL;
@@ -424,7 +424,6 @@ void blk_put_queue(struct request_queue *q)
 {
         kobject_put(&q->kobj);
 }
-EXPORT_SYMBOL(blk_put_queue);
 
 void blk_cleanup_queue(struct request_queue *q)
 {
@@ -592,7 +591,6 @@ int blk_get_queue(struct request_queue *q)
 
         return 1;
 }
-EXPORT_SYMBOL(blk_get_queue);
 
 static inline void blk_free_request(struct request_queue *q, struct request *rq)
 {
@@ -1768,6 +1766,7 @@ static inline void __end_request(struct request *rq, int uptodate,
 
 /**
  * blk_rq_bytes - Returns bytes left to complete in the entire request
+ * @rq: the request being processed
  **/
 unsigned int blk_rq_bytes(struct request *rq)
 {
@@ -1780,6 +1779,7 @@ EXPORT_SYMBOL_GPL(blk_rq_bytes);
 
 /**
  * blk_rq_cur_bytes - Returns bytes left to complete in the current segment
+ * @rq: the request being processed
  **/
 unsigned int blk_rq_cur_bytes(struct request *rq)
 {
@@ -2016,7 +2016,6 @@ void blk_rq_bio_prep(struct request_queue *q, struct request *rq,
         rq->hard_cur_sectors = rq->current_nr_sectors;
         rq->hard_nr_sectors = rq->nr_sectors = bio_sectors(bio);
         rq->buffer = bio_data(bio);
-        rq->raw_data_len = bio->bi_size;
         rq->data_len = bio->bi_size;
 
         rq->bio = rq->biotail = bio;
diff --git a/block/blk-map.c b/block/blk-map.c
index 09f7fd0bcb73..c07d9c8317f4 100644
--- a/block/blk-map.c
+++ b/block/blk-map.c
@@ -19,7 +19,6 @@ int blk_rq_append_bio(struct request_queue *q, struct request *rq,
                 rq->biotail->bi_next = bio;
                 rq->biotail = bio;
 
-                rq->raw_data_len += bio->bi_size;
                 rq->data_len += bio->bi_size;
         }
         return 0;
@@ -44,6 +43,7 @@ static int __blk_rq_map_user(struct request_queue *q, struct request *rq,
                              void __user *ubuf, unsigned int len)
 {
         unsigned long uaddr;
+        unsigned int alignment;
         struct bio *bio, *orig_bio;
         int reading, ret;
 
@@ -54,8 +54,8 @@ static int __blk_rq_map_user(struct request_queue *q, struct request *rq,
          * direct dma. else, set up kernel bounce buffers
          */
         uaddr = (unsigned long) ubuf;
-        if (!(uaddr & queue_dma_alignment(q)) &&
-            !(len & queue_dma_alignment(q)))
+        alignment = queue_dma_alignment(q) | q->dma_pad_mask;
+        if (!(uaddr & alignment) && !(len & alignment))
                 bio = bio_map_user(q, NULL, uaddr, len, reading);
         else
                 bio = bio_copy_user(q, uaddr, len, reading);
@@ -142,20 +142,22 @@ int blk_rq_map_user(struct request_queue *q, struct request *rq,
 
         /*
          * __blk_rq_map_user() copies the buffers if starting address
-         * or length isn't aligned.  As the copied buffer is always
-         * page aligned, we know that there's enough room for padding.
-         * Extend the last bio and update rq->data_len accordingly.
+         * or length isn't aligned to dma_pad_mask.  As the copied
+         * buffer is always page aligned, we know that there's enough
+         * room for padding.  Extend the last bio and update
+         * rq->data_len accordingly.
          *
          * On unmap, bio_uncopy_user() will use unmodified
          * bio_map_data pointed to by bio->bi_private.
          */
-        if (len & queue_dma_alignment(q)) {
-                unsigned int pad_len = (queue_dma_alignment(q) & ~len) + 1;
-                struct bio *bio = rq->biotail;
+        if (len & q->dma_pad_mask) {
+                unsigned int pad_len = (q->dma_pad_mask & ~len) + 1;
+                struct bio *tail = rq->biotail;
 
-                bio->bi_io_vec[bio->bi_vcnt - 1].bv_len += pad_len;
-                bio->bi_size += pad_len;
-                rq->data_len += pad_len;
+                tail->bi_io_vec[tail->bi_vcnt - 1].bv_len += pad_len;
+                tail->bi_size += pad_len;
+
+                rq->extra_len += pad_len;
         }
 
         rq->buffer = rq->data = NULL;
@@ -215,7 +217,6 @@ int blk_rq_map_user_iov(struct request_queue *q, struct request *rq,
         rq->buffer = rq->data = NULL;
         return 0;
 }
-EXPORT_SYMBOL(blk_rq_map_user_iov);
 
 /**
  * blk_rq_unmap_user - unmap a request with user data
diff --git a/block/blk-merge.c b/block/blk-merge.c
index 7506c4fe0264..0f58616bcd7f 100644
--- a/block/blk-merge.c
+++ b/block/blk-merge.c
@@ -231,7 +231,7 @@ new_segment:
                             ((unsigned long)q->dma_drain_buffer) &
                             (PAGE_SIZE - 1));
                 nsegs++;
-                rq->data_len += q->dma_drain_size;
+                rq->extra_len += q->dma_drain_size;
         }
 
         if (sg)
diff --git a/block/blk-settings.c b/block/blk-settings.c
index 9a8ffdd0ce3d..1344a0ea5cc6 100644
--- a/block/blk-settings.c
+++ b/block/blk-settings.c
@@ -140,7 +140,7 @@ void blk_queue_bounce_limit(struct request_queue *q, u64 dma_addr)
         /* Assume anything <= 4GB can be handled by IOMMU.
            Actually some IOMMUs can handle everything, but I don't
            know of a way to test this here. */
-        if (b_pfn < (min_t(u64, 0xffffffff, BLK_BOUNCE_HIGH) >> PAGE_SHIFT))
+        if (b_pfn <= (min_t(u64, 0xffffffff, BLK_BOUNCE_HIGH) >> PAGE_SHIFT))
                 dma = 1;
         q->bounce_pfn = max_low_pfn;
 #else
@@ -293,8 +293,24 @@ void blk_queue_stack_limits(struct request_queue *t, struct request_queue *b)
 EXPORT_SYMBOL(blk_queue_stack_limits);
 
 /**
- * blk_queue_dma_drain - Set up a drain buffer for excess dma.
+ * blk_queue_dma_pad - set pad mask
+ * @q:     the request queue for the device
+ * @mask:  pad mask
+ *
+ * Set pad mask.  Direct IO requests are padded to the mask specified.
  *
+ * Appending pad buffer to a request modifies ->data_len such that it
+ * includes the pad buffer.  The original requested data length can be
+ * obtained using blk_rq_raw_data_len().
+ **/
+void blk_queue_dma_pad(struct request_queue *q, unsigned int mask)
+{
+        q->dma_pad_mask = mask;
+}
+EXPORT_SYMBOL(blk_queue_dma_pad);
+
+/**
+ * blk_queue_dma_drain - Set up a drain buffer for excess dma.
  * @q:  the request queue for the device
  * @dma_drain_needed: fn which returns non-zero if drain is necessary
  * @buf:        physically contiguous buffer
@@ -316,7 +332,7 @@ EXPORT_SYMBOL(blk_queue_stack_limits);
  * device can support otherwise there won't be room for the drain
  * buffer.
  */
-extern int blk_queue_dma_drain(struct request_queue *q,
+int blk_queue_dma_drain(struct request_queue *q,
                                dma_drain_needed_fn *dma_drain_needed,
                                void *buf, unsigned int size)
 {
diff --git a/block/blk-tag.c b/block/blk-tag.c
index a8c37d4bbb32..4780a46ce234 100644
--- a/block/blk-tag.c
+++ b/block/blk-tag.c
@@ -6,6 +6,8 @@
 #include <linux/bio.h>
 #include <linux/blkdev.h>
 
+#include "blk.h"
+
 /**
  * blk_queue_find_tag - find a request by its tag and queue
  * @q:   The request queue for the device
diff --git a/block/blk.h b/block/blk.h
index ec898dd0c65c..ec9120fb789a 100644
--- a/block/blk.h
+++ b/block/blk.h
@@ -32,6 +32,8 @@ void blk_recalc_rq_sectors(struct request *rq, int nsect);
 
 void blk_queue_congestion_threshold(struct request_queue *q);
 
+int blk_dev_init(void);
+
 /*
  * Return the threshold (number of used requests) at which the queue is
  * considered to be congested.  It include a little hysteresis to keep the
diff --git a/block/bsg.c b/block/bsg.c
index 7f3c09549e4b..8917c5174dc2 100644
--- a/block/bsg.c
+++ b/block/bsg.c
@@ -437,14 +437,14 @@ static int blk_complete_sgv4_hdr_rq(struct request *rq, struct sg_io_v4 *hdr,
         }
 
         if (rq->next_rq) {
-                hdr->dout_resid = rq->raw_data_len;
-                hdr->din_resid = rq->next_rq->raw_data_len;
+                hdr->dout_resid = rq->data_len;
+                hdr->din_resid = rq->next_rq->data_len;
                 blk_rq_unmap_user(bidi_bio);
                 blk_put_request(rq->next_rq);
         } else if (rq_data_dir(rq) == READ)
-                hdr->din_resid = rq->raw_data_len;
+                hdr->din_resid = rq->data_len;
         else
-                hdr->dout_resid = rq->raw_data_len;
+                hdr->dout_resid = rq->data_len;
 
         /*
          * If the request generated a negative error number, return it
diff --git a/block/genhd.c b/block/genhd.c
index 53f2238e69c8..c44527d16c52 100644
--- a/block/genhd.c
+++ b/block/genhd.c
@@ -17,11 +17,15 @@
 #include <linux/buffer_head.h>
 #include <linux/mutex.h>
 
+#include "blk.h"
+
 static DEFINE_MUTEX(block_class_lock);
 #ifndef CONFIG_SYSFS_DEPRECATED
 struct kobject *block_depr;
 #endif
 
+static struct device_type disk_type;
+
 /*
  * Can be deleted altogether. Later.
  *
@@ -346,8 +350,6 @@ const struct seq_operations partitions_op = {
 #endif
 
 
-extern int blk_dev_init(void);
-
 static struct kobject *base_probe(dev_t devt, int *part, void *data)
 {
         if (request_module("block-major-%d-%d", MAJOR(devt), MINOR(devt)) > 0)
@@ -502,7 +504,7 @@ struct class block_class = {
         .name           = "block",
 };
 
-struct device_type disk_type = {
+static struct device_type disk_type = {
         .name           = "disk",
         .groups         = disk_attr_groups,
         .release        = disk_release,
@@ -632,12 +634,14 @@ static void media_change_notify_thread(struct work_struct *work)
         put_device(gd->driverfs_dev);
 }
 
+#if 0
 void genhd_media_change_notify(struct gendisk *disk)
 {
         get_device(disk->driverfs_dev);
         schedule_work(&disk->async_notify);
 }
 EXPORT_SYMBOL_GPL(genhd_media_change_notify);
+#endif  /*  0  */
 
 dev_t blk_lookup_devt(const char *name)
 {
diff --git a/block/scsi_ioctl.c b/block/scsi_ioctl.c
index e993cac4911d..a2c3a936ebf9 100644
--- a/block/scsi_ioctl.c
+++ b/block/scsi_ioctl.c
@@ -266,7 +266,7 @@ static int blk_complete_sghdr_rq(struct request *rq, struct sg_io_hdr *hdr,
         hdr->info = 0;
         if (hdr->masked_status || hdr->host_status || hdr->driver_status)
                 hdr->info |= SG_INFO_CHECK;
-        hdr->resid = rq->raw_data_len;
+        hdr->resid = rq->data_len;
         hdr->sb_len_wr = 0;
 
         if (rq->sense_len && hdr->sbp) {
@@ -528,8 +528,8 @@ static int __blk_send_generic(struct request_queue *q, struct gendisk *bd_disk,
         rq = blk_get_request(q, WRITE, __GFP_WAIT);
         rq->cmd_type = REQ_TYPE_BLOCK_PC;
         rq->data = NULL;
-        rq->raw_data_len = 0;
         rq->data_len = 0;
+        rq->extra_len = 0;
         rq->timeout = BLK_DEFAULT_SG_TIMEOUT;
         memset(rq->cmd, 0, sizeof(rq->cmd));
         rq->cmd[0] = cmd;
diff --git a/drivers/acorn/char/defkeymap-l7200.c b/drivers/acorn/char/defkeymap-l7200.c
index 28a5fbc6aa1a..93d80a1c36f9 100644
--- a/drivers/acorn/char/defkeymap-l7200.c
+++ b/drivers/acorn/char/defkeymap-l7200.c
@@ -347,40 +347,40 @@ char *func_table[MAX_NR_FUNC] = {
 };
 
 struct kbdiacruc accent_table[MAX_DIACR] = {
-        {'`', 'A', '\300'},     {'`', 'a', '\340'},
-        {'\'', 'A', '\301'},    {'\'', 'a', '\341'},
-        {'^', 'A', '\302'},     {'^', 'a', '\342'},
-        {'~', 'A', '\303'},     {'~', 'a', '\343'},
-        {'"', 'A', '\304'},     {'"', 'a', '\344'},
-        {'O', 'A', '\305'},     {'o', 'a', '\345'},
-        {'0', 'A', '\305'},     {'0', 'a', '\345'},
-        {'A', 'A', '\305'},     {'a', 'a', '\345'},
-        {'A', 'E', '\306'},     {'a', 'e', '\346'},
-        {',', 'C', '\307'},     {',', 'c', '\347'},
-        {'`', 'E', '\310'},     {'`', 'e', '\350'},
-        {'\'', 'E', '\311'},    {'\'', 'e', '\351'},
-        {'^', 'E', '\312'},     {'^', 'e', '\352'},
-        {'"', 'E', '\313'},     {'"', 'e', '\353'},
-        {'`', 'I', '\314'},     {'`', 'i', '\354'},
-        {'\'', 'I', '\315'},    {'\'', 'i', '\355'},
-        {'^', 'I', '\316'},     {'^', 'i', '\356'},
-        {'"', 'I', '\317'},     {'"', 'i', '\357'},
-        {'-', 'D', '\320'},     {'-', 'd', '\360'},
-        {'~', 'N', '\321'},     {'~', 'n', '\361'},
-        {'`', 'O', '\322'},     {'`', 'o', '\362'},
-        {'\'', 'O', '\323'},    {'\'', 'o', '\363'},
-        {'^', 'O', '\324'},     {'^', 'o', '\364'},
-        {'~', 'O', '\325'},     {'~', 'o', '\365'},
-        {'"', 'O', '\326'},     {'"', 'o', '\366'},
-        {'/', 'O', '\330'},     {'/', 'o', '\370'},
-        {'`', 'U', '\331'},     {'`', 'u', '\371'},
-        {'\'', 'U', '\332'},    {'\'', 'u', '\372'},
-        {'^', 'U', '\333'},     {'^', 'u', '\373'},
-        {'"', 'U', '\334'},     {'"', 'u', '\374'},
-        {'\'', 'Y', '\335'},    {'\'', 'y', '\375'},
-        {'T', 'H', '\336'},     {'t', 'h', '\376'},
-        {'s', 's', '\337'},     {'"', 'y', '\377'},
-        {'s', 'z', '\337'},     {'i', 'j', '\377'},
+        {'`', 'A', 0300},       {'`', 'a', 0340},
+        {'\'', 'A', 0301},      {'\'', 'a', 0341},
+        {'^', 'A', 0302},       {'^', 'a', 0342},
+        {'~', 'A', 0303},       {'~', 'a', 0343},
+        {'"', 'A', 0304},       {'"', 'a', 0344},
+        {'O', 'A', 0305},       {'o', 'a', 0345},
+        {'0', 'A', 0305},       {'0', 'a', 0345},
+        {'A', 'A', 0305},       {'a', 'a', 0345},
+        {'A', 'E', 0306},       {'a', 'e', 0346},
+        {',', 'C', 0307},       {',', 'c', 0347},
+        {'`', 'E', 0310},       {'`', 'e', 0350},
+        {'\'', 'E', 0311},      {'\'', 'e', 0351},
+        {'^', 'E', 0312},       {'^', 'e', 0352},
+        {'"', 'E', 0313},       {'"', 'e', 0353},
+        {'`', 'I', 0314},       {'`', 'i', 0354},
+        {'\'', 'I', 0315},      {'\'', 'i', 0355},
+        {'^', 'I', 0316},       {'^', 'i', 0356},
+        {'"', 'I', 0317},       {'"', 'i', 0357},
+        {'-', 'D', 0320},       {'-', 'd', 0360},
+        {'~', 'N', 0321},       {'~', 'n', 0361},
+        {'`', 'O', 0322},       {'`', 'o', 0362},
+        {'\'', 'O', 0323},      {'\'', 'o', 0363},
+        {'^', 'O', 0324},       {'^', 'o', 0364},
+        {'~', 'O', 0325},       {'~', 'o', 0365},
+        {'"', 'O', 0326},       {'"', 'o', 0366},
+        {'/', 'O', 0330},       {'/', 'o', 0370},
+        {'`', 'U', 0331},       {'`', 'u', 0371},
+        {'\'', 'U', 0332},      {'\'', 'u', 0372},
+        {'^', 'U', 0333},       {'^', 'u', 0373},
+        {'"', 'U', 0334},       {'"', 'u', 0374},
+        {'\'', 'Y', 0335},      {'\'', 'y', 0375},
+        {'T', 'H', 0336},       {'t', 'h', 0376},
+        {'s', 's', 0337},       {'"', 'y', 0377},
+        {'s', 'z', 0337},       {'i', 'j', 0377},
 };
 
 unsigned int accent_table_size = 68;
diff --git a/drivers/ata/libata-scsi.c b/drivers/ata/libata-scsi.c
index 7b1f1ee8131d..8f0e8f2bc628 100644
--- a/drivers/ata/libata-scsi.c
+++ b/drivers/ata/libata-scsi.c
@@ -862,9 +862,10 @@ static int ata_scsi_dev_config(struct scsi_device *sdev,
                 struct request_queue *q = sdev->request_queue;
                 void *buf;
 
-                /* set the min alignment */
+                /* set the min alignment and padding */
                 blk_queue_update_dma_alignment(sdev->request_queue,
                                                ATA_DMA_PAD_SZ - 1);
+                blk_queue_dma_pad(sdev->request_queue, ATA_DMA_PAD_SZ - 1);
 
                 /* configure draining */
                 buf = kmalloc(ATAPI_MAX_DRAIN, q->bounce_gfp | GFP_KERNEL);
@@ -2538,7 +2539,7 @@ static unsigned int atapi_xlat(struct ata_queued_cmd *qc)
         }
 
         qc->tf.command = ATA_CMD_PACKET;
-        qc->nbytes = scsi_bufflen(scmd);
+        qc->nbytes = scsi_bufflen(scmd) + scmd->request->extra_len;
 
         /* check whether ATAPI DMA is safe */
         if (!using_pio && ata_check_atapi_dma(qc))
@@ -2549,7 +2550,7 @@ static unsigned int atapi_xlat(struct ata_queued_cmd *qc)
          * want to set it properly, and for DMA where it is
          * effectively meaningless.
          */
-        nbytes = min(scmd->request->raw_data_len, (unsigned int)63 * 1024);
+        nbytes = min(scmd->request->data_len, (unsigned int)63 * 1024);
 
         /* Most ATAPI devices which honor transfer chunk size don't
          * behave according to the spec when odd chunk size which
@@ -2875,7 +2876,7 @@ static unsigned int ata_scsi_pass_thru(struct ata_queued_cmd *qc)
          * TODO: find out if we need to do more here to
          *       cover scatter/gather case.
          */
-        qc->nbytes = scsi_bufflen(scmd);
+        qc->nbytes = scsi_bufflen(scmd) + scmd->request->extra_len;
 
         /* request result TF and be quiet about device error */
         qc->flags |= ATA_QCFLAG_RESULT_TF | ATA_QCFLAG_QUIET;
diff --git a/drivers/base/transport_class.c b/drivers/base/transport_class.c
index f25e7c6b2d27..40bca48abc12 100644
--- a/drivers/base/transport_class.c
+++ b/drivers/base/transport_class.c
@@ -126,9 +126,7 @@ static int transport_setup_classdev(struct attribute_container *cont,
 }
 
 /**
- * transport_setup_device - declare a new dev for transport class association
- *                          but don't make it visible yet.
- *
+ * transport_setup_device - declare a new dev for transport class association but don't make it visible yet.
  * @dev: the generic device representing the entity being added
  *
  * Usually, dev represents some component in the HBA system (either
diff --git a/drivers/block/cciss.c b/drivers/block/cciss.c
index 9715be3f2487..55bd35c0f082 100644
--- a/drivers/block/cciss.c
+++ b/drivers/block/cciss.c
@@ -33,6 +33,7 @@
 #include <linux/blkpg.h>
 #include <linux/timer.h>
 #include <linux/proc_fs.h>
+#include <linux/seq_file.h>
 #include <linux/init.h>
 #include <linux/hdreg.h>
 #include <linux/spinlock.h>
@@ -131,7 +132,6 @@ static struct board_type products[] = {
 /*define how many times we will try a command because of bus resets */
 #define MAX_CMD_RETRIES 3
 
-#define READ_AHEAD       1024
 #define MAX_CTLR        32
 
 /* Originally cciss driver only supports 8 major numbers */
@@ -174,8 +174,6 @@ static int sendcmd_withirq(__u8 cmd, int ctlr, void *buff, size_t size,
 static void fail_all_cmds(unsigned long ctlr);
 
 #ifdef CONFIG_PROC_FS
-static int cciss_proc_get_info(char *buffer, char **start, off_t offset,
-                               int length, int *eof, void *data);
 static void cciss_procinit(int i);
 #else
 static void cciss_procinit(int i)
@@ -240,24 +238,46 @@ static inline CommandList_struct *removeQ(CommandList_struct **Qptr,
  */
 #define ENG_GIG 1000000000
 #define ENG_GIG_FACTOR (ENG_GIG/512)
+#define ENGAGE_SCSI     "engage scsi"
 static const char *raid_label[] = { "0", "4", "1(1+0)", "5", "5+1", "ADG",
         "UNKNOWN"
 };
 
 static struct proc_dir_entry *proc_cciss;
 
-static int cciss_proc_get_info(char *buffer, char **start, off_t offset,
-                               int length, int *eof, void *data)
+static void cciss_seq_show_header(struct seq_file *seq)
 {
-        off_t pos = 0;
-        off_t len = 0;
-        int size, i, ctlr;
-        ctlr_info_t *h = (ctlr_info_t *) data;
-        drive_info_struct *drv;
-        unsigned long flags;
-        sector_t vol_sz, vol_sz_frac;
+        ctlr_info_t *h = seq->private;
+
+        seq_printf(seq, "%s: HP %s Controller\n"
+                "Board ID: 0x%08lx\n"
+                "Firmware Version: %c%c%c%c\n"
+                "IRQ: %d\n"
+                "Logical drives: %d\n"
+                "Current Q depth: %d\n"
+                "Current # commands on controller: %d\n"
+                "Max Q depth since init: %d\n"
+                "Max # commands on controller since init: %d\n"
+                "Max SG entries since init: %d\n",
+                h->devname,
+                h->product_name,
+                (unsigned long)h->board_id,
+                h->firm_ver[0], h->firm_ver[1], h->firm_ver[2],
+                h->firm_ver[3], (unsigned int)h->intr[SIMPLE_MODE_INT],
+                h->num_luns,
+                h->Qdepth, h->commands_outstanding,
+                h->maxQsinceinit, h->max_outstanding, h->maxSG);
 
-        ctlr = h->ctlr;
+#ifdef CONFIG_CISS_SCSI_TAPE
+        cciss_seq_tape_report(seq, h->ctlr);
+#endif /* CONFIG_CISS_SCSI_TAPE */
+}
+
+static void *cciss_seq_start(struct seq_file *seq, loff_t *pos)
+{
+        ctlr_info_t *h = seq->private;
+        unsigned ctlr = h->ctlr;
+        unsigned long flags;
 
         /* prevent displaying bogus info during configuration
          * or deconfiguration of a logical volume
@@ -265,115 +285,155 @@ static int cciss_proc_get_info(char *buffer, char **start, off_t offset,
         spin_lock_irqsave(CCISS_LOCK(ctlr), flags);
         if (h->busy_configuring) {
                 spin_unlock_irqrestore(CCISS_LOCK(ctlr), flags);
-                return -EBUSY;
+                return ERR_PTR(-EBUSY);
         }
         h->busy_configuring = 1;
         spin_unlock_irqrestore(CCISS_LOCK(ctlr), flags);
 
-        size = sprintf(buffer, "%s: HP %s Controller\n"
-                       "Board ID: 0x%08lx\n"
-                       "Firmware Version: %c%c%c%c\n"
-                       "IRQ: %d\n"
-                       "Logical drives: %d\n"
-                       "Max sectors: %d\n"
-                       "Current Q depth: %d\n"
-                       "Current # commands on controller: %d\n"
-                       "Max Q depth since init: %d\n"
-                       "Max # commands on controller since init: %d\n"
-                       "Max SG entries since init: %d\n\n",
-                       h->devname,
-                       h->product_name,
-                       (unsigned long)h->board_id,
-                       h->firm_ver[0], h->firm_ver[1], h->firm_ver[2],
-                       h->firm_ver[3], (unsigned int)h->intr[SIMPLE_MODE_INT],
-                       h->num_luns,
-                       h->cciss_max_sectors,
-                       h->Qdepth, h->commands_outstanding,
-                       h->maxQsinceinit, h->max_outstanding, h->maxSG);
-
-        pos += size;
-        len += size;
-        cciss_proc_tape_report(ctlr, buffer, &pos, &len);
-        for (i = 0; i <= h->highest_lun; i++) {
-
-                drv = &h->drv[i];
-                if (drv->heads == 0)
-                        continue;
+        if (*pos == 0)
+                cciss_seq_show_header(seq);
 
-                vol_sz = drv->nr_blocks;
-                vol_sz_frac = sector_div(vol_sz, ENG_GIG_FACTOR);
-                vol_sz_frac *= 100;
-                sector_div(vol_sz_frac, ENG_GIG_FACTOR);
+        return pos;
+}
+
+static int cciss_seq_show(struct seq_file *seq, void *v)
+{
+        sector_t vol_sz, vol_sz_frac;
+        ctlr_info_t *h = seq->private;
+        unsigned ctlr = h->ctlr;
+        loff_t *pos = v;
+        drive_info_struct *drv = &h->drv[*pos];
+
+        if (*pos > h->highest_lun)
+                return 0;
+
+        if (drv->heads == 0)
+                return 0;
+
+        vol_sz = drv->nr_blocks;
+        vol_sz_frac = sector_div(vol_sz, ENG_GIG_FACTOR);
+        vol_sz_frac *= 100;
+        sector_div(vol_sz_frac, ENG_GIG_FACTOR);
+
+        if (drv->raid_level > 5)
+                drv->raid_level = RAID_UNKNOWN;
+        seq_printf(seq, "cciss/c%dd%d:"
+                        "\t%4u.%02uGB\tRAID %s\n",
+                        ctlr, (int) *pos, (int)vol_sz, (int)vol_sz_frac,
+                        raid_label[drv->raid_level]);
+        return 0;
+}
+
+static void *cciss_seq_next(struct seq_file *seq, void *v, loff_t *pos)
+{
+        ctlr_info_t *h = seq->private;
+
+        if (*pos > h->highest_lun)
+                return NULL;
+        *pos += 1;
+
+        return pos;
+}
+
+static void cciss_seq_stop(struct seq_file *seq, void *v)
+{
+        ctlr_info_t *h = seq->private;
+
+        /* Only reset h->busy_configuring if we succeeded in setting
+         * it during cciss_seq_start. */
+        if (v == ERR_PTR(-EBUSY))
+                return;
 
-                if (drv->raid_level > 5)
-                        drv->raid_level = RAID_UNKNOWN;
-                size = sprintf(buffer + len, "cciss/c%dd%d:"
-                               "\t%4u.%02uGB\tRAID %s\n",
-                               ctlr, i, (int)vol_sz, (int)vol_sz_frac,
-                               raid_label[drv->raid_level]);
-                pos += size;
-                len += size;
-        }
-
-        *eof = 1;
-        *start = buffer + offset;
-        len -= offset;
-        if (len > length)
-                len = length;
         h->busy_configuring = 0;
-        return len;
 }
 
-static int
-cciss_proc_write(struct file *file, const char __user *buffer,
-                 unsigned long count, void *data)
+static struct seq_operations cciss_seq_ops = {
+        .start = cciss_seq_start,
+        .show  = cciss_seq_show,
+        .next  = cciss_seq_next,
+        .stop  = cciss_seq_stop,
+};
+
+static int cciss_seq_open(struct inode *inode, struct file *file)
 {
-        unsigned char cmd[80];
-        int len;
-#ifdef CONFIG_CISS_SCSI_TAPE
-        ctlr_info_t *h = (ctlr_info_t *) data;
-        int rc;
+        int ret = seq_open(file, &cciss_seq_ops);
+        struct seq_file *seq = file->private_data;
+
+        if (!ret)
+                seq->private = PDE(inode)->data;
+
+        return ret;
+}
+
+static ssize_t
+cciss_proc_write(struct file *file, const char __user *buf,
+                 size_t length, loff_t *ppos)
+{
+        int err;
+        char *buffer;
+
+#ifndef CONFIG_CISS_SCSI_TAPE
+        return -EINVAL;
 #endif
 
-        if (count > sizeof(cmd) - 1)
+        if (!buf || length > PAGE_SIZE - 1)
                 return -EINVAL;
-        if (copy_from_user(cmd, buffer, count))
-                return -EFAULT;
-        cmd[count] = '\0';
-        len = strlen(cmd);      // above 3 lines ensure safety
-        if (len && cmd[len - 1] == '\n')
-                cmd[--len] = '\0';
-#       ifdef CONFIG_CISS_SCSI_TAPE
-        if (strcmp("engage scsi", cmd) == 0) {
+
+        buffer = (char *)__get_free_page(GFP_KERNEL);
+        if (!buffer)
+                return -ENOMEM;
+
+        err = -EFAULT;
+        if (copy_from_user(buffer, buf, length))
+                goto out;
+        buffer[length] = '\0';
+
+#ifdef CONFIG_CISS_SCSI_TAPE
+        if (strncmp(ENGAGE_SCSI, buffer, sizeof ENGAGE_SCSI - 1) == 0) {
+                struct seq_file *seq = file->private_data;
+                ctlr_info_t *h = seq->private;
+                int rc;
+
                 rc = cciss_engage_scsi(h->ctlr);
                 if (rc != 0)
-                        return -rc;
-                return count;
-        }
+                        err = -rc;
+                else
+                        err = length;
+        } else
+#endif /* CONFIG_CISS_SCSI_TAPE */
+                err = -EINVAL;
         /* might be nice to have "disengage" too, but it's not
            safely possible. (only 1 module use count, lock issues.) */
-#       endif
-        return -EINVAL;
+
+out:
+        free_page((unsigned long)buffer);
+        return err;
 }
 
-/*
- * Get us a file in /proc/cciss that says something about each controller.
- * Create /proc/cciss if it doesn't exist yet.
- */
+static struct file_operations cciss_proc_fops = {
+        .owner   = THIS_MODULE,
+        .open    = cciss_seq_open,
+        .read    = seq_read,
+        .llseek  = seq_lseek,
+        .release = seq_release,
+        .write   = cciss_proc_write,
+};
+
 static void __devinit cciss_procinit(int i)
 {
         struct proc_dir_entry *pde;
 
-        if (proc_cciss == NULL) {
+        if (proc_cciss == NULL)
                 proc_cciss = proc_mkdir("cciss", proc_root_driver);
-                if (!proc_cciss)
-                        return;
-        }
+        if (!proc_cciss)
+                return;
+        pde = proc_create(hba[i]->devname, S_IWUSR | S_IRUSR | S_IRGRP |
+                                        S_IROTH, proc_cciss,
+                                        &cciss_proc_fops);
+        if (!pde)
+                return;
 
-        pde = create_proc_read_entry(hba[i]->devname,
-                                     S_IWUSR | S_IRUSR | S_IRGRP | S_IROTH,
-                                     proc_cciss, cciss_proc_get_info, hba[i]);
-        pde->write_proc = cciss_proc_write;
+        pde->data = hba[i];
 }
 #endif                          /* CONFIG_PROC_FS */
 
@@ -1341,7 +1401,6 @@ geo_inq:
                 disk->private_data = &h->drv[drv_index];
 
                 /* Set up queue information */
-                disk->queue->backing_dev_info.ra_pages = READ_AHEAD;
                 blk_queue_bounce_limit(disk->queue, hba[ctlr]->pdev->dma_mask);
 
                 /* This is a hardware imposed limit. */
@@ -3434,7 +3493,6 @@ static int __devinit cciss_init_one(struct pci_dev *pdev,
                 }
                 drv->queue = q;
 
-                q->backing_dev_info.ra_pages = READ_AHEAD;
                 blk_queue_bounce_limit(q, hba[i]->pdev->dma_mask);
 
                 /* This is a hardware imposed limit. */
diff --git a/drivers/block/cciss_scsi.c b/drivers/block/cciss_scsi.c
index 55178e9973a0..45ac09300eb3 100644
--- a/drivers/block/cciss_scsi.c
+++ b/drivers/block/cciss_scsi.c
@@ -1404,21 +1404,18 @@ cciss_engage_scsi(int ctlr)
 }
 
 static void
-cciss_proc_tape_report(int ctlr, unsigned char *buffer, off_t *pos, off_t *len)
+cciss_seq_tape_report(struct seq_file *seq, int ctlr)
 {
         unsigned long flags;
-        int size;
-
-        *pos = *pos -1; *len = *len - 1; // cut off the last trailing newline
 
         CPQ_TAPE_LOCK(ctlr, flags);
-        size = sprintf(buffer + *len, 
+        seq_printf(seq,
                 "Sequential access devices: %d\n\n",
                         ccissscsi[ctlr].ndevices);
         CPQ_TAPE_UNLOCK(ctlr, flags);
-        *pos += size; *len += size;
 }
 
+
 /* Need at least one of these error handlers to keep ../scsi/hosts.c from 
  * complaining.  Doing a host- or bus-reset can't do anything good here. 
  * Despite what it might say in scsi_error.c, there may well be commands
@@ -1498,6 +1495,5 @@ static int  cciss_eh_abort_handler(struct scsi_cmnd *scsicmd)
 #define cciss_scsi_setup(cntl_num)
 #define cciss_unregister_scsi(ctlr)
 #define cciss_register_scsi(ctlr)
-#define cciss_proc_tape_report(ctlr, buffer, pos, len)
 
 #endif /* CONFIG_CISS_SCSI_TAPE */
diff --git a/drivers/cdrom/cdrom.c b/drivers/cdrom/cdrom.c
index db259e60289b..12f5baea439b 100644
--- a/drivers/cdrom/cdrom.c
+++ b/drivers/cdrom/cdrom.c
@@ -1152,8 +1152,8 @@ clean_up_and_return:
 /* This code is similar to that in open_for_data. The routine is called
    whenever an audio play operation is requested.
 */
-int check_for_audio_disc(struct cdrom_device_info * cdi,
-                         struct cdrom_device_ops * cdo)
+static int check_for_audio_disc(struct cdrom_device_info * cdi,
+                                struct cdrom_device_ops * cdo)
 {
         int ret;
         tracktype tracks;
diff --git a/drivers/char/defkeymap.c_shipped b/drivers/char/defkeymap.c_shipped
index 0aa419a61767..d2208dfe3f67 100644
--- a/drivers/char/defkeymap.c_shipped
+++ b/drivers/char/defkeymap.c_shipped
@@ -223,40 +223,40 @@ char *func_table[MAX_NR_FUNC] = {
 };
 
 struct kbdiacruc accent_table[MAX_DIACR] = {
-        {'`', 'A', '\300'},     {'`', 'a', '\340'},
-        {'\'', 'A', '\301'},    {'\'', 'a', '\341'},
-        {'^', 'A', '\302'},     {'^', 'a', '\342'},
-        {'~', 'A', '\303'},     {'~', 'a', '\343'},
-        {'"', 'A', '\304'},     {'"', 'a', '\344'},
-        {'O', 'A', '\305'},     {'o', 'a', '\345'},
-        {'0', 'A', '\305'},     {'0', 'a', '\345'},
-        {'A', 'A', '\305'},     {'a', 'a', '\345'},
-        {'A', 'E', '\306'},     {'a', 'e', '\346'},
-        {',', 'C', '\307'},     {',', 'c', '\347'},
-        {'`', 'E', '\310'},     {'`', 'e', '\350'},
-        {'\'', 'E', '\311'},    {'\'', 'e', '\351'},
-        {'^', 'E', '\312'},     {'^', 'e', '\352'},
-        {'"', 'E', '\313'},     {'"', 'e', '\353'},
-        {'`', 'I', '\314'},     {'`', 'i', '\354'},
-        {'\'', 'I', '\315'},    {'\'', 'i', '\355'},
-        {'^', 'I', '\316'},     {'^', 'i', '\356'},
-        {'"', 'I', '\317'},     {'"', 'i', '\357'},
-        {'-', 'D', '\320'},     {'-', 'd', '\360'},
-        {'~', 'N', '\321'},     {'~', 'n', '\361'},
-        {'`', 'O', '\322'},     {'`', 'o', '\362'},
-        {'\'', 'O', '\323'},    {'\'', 'o', '\363'},
-        {'^', 'O', '\324'},     {'^', 'o', '\364'},
-        {'~', 'O', '\325'},     {'~', 'o', '\365'},
-        {'"', 'O', '\326'},     {'"', 'o', '\366'},
-        {'/', 'O', '\330'},     {'/', 'o', '\370'},
-        {'`', 'U', '\331'},     {'`', 'u', '\371'},
-        {'\'', 'U', '\332'},    {'\'', 'u', '\372'},
-        {'^', 'U', '\333'},     {'^', 'u', '\373'},
-        {'"', 'U', '\334'},     {'"', 'u', '\374'},
-        {'\'', 'Y', '\335'},    {'\'', 'y', '\375'},
-        {'T', 'H', '\336'},     {'t', 'h', '\376'},
-        {'s', 's', '\337'},     {'"', 'y', '\377'},
-        {'s', 'z', '\337'},     {'i', 'j', '\377'},
+        {'`', 'A', 0300},       {'`', 'a', 0340},
+        {'\'', 'A', 0301},      {'\'', 'a', 0341},
+        {'^', 'A', 0302},       {'^', 'a', 0342},
+        {'~', 'A', 0303},       {'~', 'a', 0343},
+        {'"', 'A', 0304},       {'"', 'a', 0344},
+        {'O', 'A', 0305},       {'o', 'a', 0345},
+        {'0', 'A', 0305},       {'0', 'a', 0345},
+        {'A', 'A', 0305},       {'a', 'a', 0345},
+        {'A', 'E', 0306},       {'a', 'e', 0346},
+        {',', 'C', 0307},       {',', 'c', 0347},
+        {'`', 'E', 0310},       {'`', 'e', 0350},
+        {'\'', 'E', 0311},      {'\'', 'e', 0351},
+        {'^', 'E', 0312},       {'^', 'e', 0352},
+        {'"', 'E', 0313},       {'"', 'e', 0353},
+        {'`', 'I', 0314},       {'`', 'i', 0354},
+        {'\'', 'I', 0315},      {'\'', 'i', 0355},
+        {'^', 'I', 0316},       {'^', 'i', 0356},
+        {'"', 'I', 0317},       {'"', 'i', 0357},
+        {'-', 'D', 0320},       {'-', 'd', 0360},
+        {'~', 'N', 0321},       {'~', 'n', 0361},
+        {'`', 'O', 0322},       {'`', 'o', 0362},
+        {'\'', 'O', 0323},      {'\'', 'o', 0363},
+        {'^', 'O', 0324},       {'^', 'o', 0364},
+        {'~', 'O', 0325},       {'~', 'o', 0365},
+        {'"', 'O', 0326},       {'"', 'o', 0366},
+        {'/', 'O', 0330},       {'/', 'o', 0370},
+        {'`', 'U', 0331},       {'`', 'u', 0371},
+        {'\'', 'U', 0332},      {'\'', 'u', 0372},
+        {'^', 'U', 0333},       {'^', 'u', 0373},
+        {'"', 'U', 0334},       {'"', 'u', 0374},
+        {'\'', 'Y', 0335},      {'\'', 'y', 0375},
+        {'T', 'H', 0336},       {'t', 'h', 0376},
+        {'s', 's', 0337},       {'"', 'y', 0377},
+        {'s', 'z', 0337},       {'i', 'j', 0377},
 };
 
 unsigned int accent_table_size = 68;
diff --git a/drivers/char/xilinx_hwicap/buffer_icap.c b/drivers/char/xilinx_hwicap/buffer_icap.c
index dfea2bde162b..f577daedb630 100644
--- a/drivers/char/xilinx_hwicap/buffer_icap.c
+++ b/drivers/char/xilinx_hwicap/buffer_icap.c
@@ -73,8 +73,8 @@
 #define XHI_BUFFER_START 0
 
 /**
- * buffer_icap_get_status: Get the contents of the status register.
- * @parameter base_address: is the base address of the device
+ * buffer_icap_get_status - Get the contents of the status register.
+ * @base_address: is the base address of the device
  *
  * The status register contains the ICAP status and the done bit.
  *
@@ -94,9 +94,9 @@ static inline u32 buffer_icap_get_status(void __iomem *base_address)
 }
 
 /**
- * buffer_icap_get_bram: Reads data from the storage buffer bram.
- * @parameter base_address: contains the base address of the component.
- * @parameter offset: The word offset from which the data should be read.
+ * buffer_icap_get_bram - Reads data from the storage buffer bram.
+ * @base_address: contains the base address of the component.
+ * @offset: The word offset from which the data should be read.
  *
  * A bram is used as a configuration memory cache.  One frame of data can
  * be stored in this "storage buffer".
@@ -108,8 +108,8 @@ static inline u32 buffer_icap_get_bram(void __iomem *base_address,
 }
 
 /**
- * buffer_icap_busy: Return true if the icap device is busy
- * @parameter base_address: is the base address of the device
+ * buffer_icap_busy - Return true if the icap device is busy
+ * @base_address: is the base address of the device
  *
  * The queries the low order bit of the status register, which
  * indicates whether the current configuration or readback operation
@@ -121,8 +121,8 @@ static inline bool buffer_icap_busy(void __iomem *base_address)
 }
 
 /**
- * buffer_icap_busy: Return true if the icap device is not busy
- * @parameter base_address: is the base address of the device
+ * buffer_icap_busy - Return true if the icap device is not busy
+ * @base_address: is the base address of the device
  *
  * The queries the low order bit of the status register, which
  * indicates whether the current configuration or readback operation
@@ -134,9 +134,9 @@ static inline bool buffer_icap_done(void __iomem *base_address)
 }
 
 /**
- * buffer_icap_set_size: Set the size register.
- * @parameter base_address: is the base address of the device
- * @parameter data: The size in bytes.
+ * buffer_icap_set_size - Set the size register.
+ * @base_address: is the base address of the device
+ * @data: The size in bytes.
  *
  * The size register holds the number of 8 bit bytes to transfer between
  * bram and the icap (or icap to bram).
@@ -148,9 +148,9 @@ static inline void buffer_icap_set_size(void __iomem *base_address,
 }
 
 /**
- * buffer_icap_mSetoffsetReg: Set the bram offset register.
- * @parameter base_address: contains the base address of the device.
- * @parameter data: is the value to be written to the data register.
+ * buffer_icap_set_offset - Set the bram offset register.
+ * @base_address: contains the base address of the device.
+ * @data: is the value to be written to the data register.
  *
  * The bram offset register holds the starting bram address to transfer
  * data from during configuration or write data to during readback.
@@ -162,9 +162,9 @@ static inline void buffer_icap_set_offset(void __iomem *base_address,
 }
 
 /**
- * buffer_icap_set_rnc: Set the RNC (Readback not Configure) register.
- * @parameter base_address: contains the base address of the device.
- * @parameter data: is the value to be written to the data register.
+ * buffer_icap_set_rnc - Set the RNC (Readback not Configure) register.
+ * @base_address: contains the base address of the device.
+ * @data: is the value to be written to the data register.
  *
  * The RNC register determines the direction of the data transfer.  It
  * controls whether a configuration or readback take place.  Writing to
@@ -178,10 +178,10 @@ static inline void buffer_icap_set_rnc(void __iomem *base_address,
 }
 
 /**
- * buffer_icap_set_bram: Write data to the storage buffer bram.
- * @parameter base_address: contains the base address of the component.
- * @parameter offset: The word offset at which the data should be written.
- * @parameter data: The value to be written to the bram offset.
+ * buffer_icap_set_bram - Write data to the storage buffer bram.
+ * @base_address: contains the base address of the component.
+ * @offset: The word offset at which the data should be written.
+ * @data: The value to be written to the bram offset.
  *
  * A bram is used as a configuration memory cache.  One frame of data can
  * be stored in this "storage buffer".
@@ -193,10 +193,10 @@ static inline void buffer_icap_set_bram(void __iomem *base_address,
 }
 
 /**
- * buffer_icap_device_read: Transfer bytes from ICAP to the storage buffer.
- * @parameter drvdata: a pointer to the drvdata.
- * @parameter offset: The storage buffer start address.
- * @parameter count: The number of words (32 bit) to read from the
+ * buffer_icap_device_read - Transfer bytes from ICAP to the storage buffer.
+ * @drvdata: a pointer to the drvdata.
+ * @offset: The storage buffer start address.
+ * @count: The number of words (32 bit) to read from the
  *           device (ICAP).
  **/
 static int buffer_icap_device_read(struct hwicap_drvdata *drvdata,
@@ -227,10 +227,10 @@ static int buffer_icap_device_read(struct hwicap_drvdata *drvdata,
 };
 
 /**
- * buffer_icap_device_write: Transfer bytes from ICAP to the storage buffer.
- * @parameter drvdata: a pointer to the drvdata.
- * @parameter offset: The storage buffer start address.
- * @parameter count: The number of words (32 bit) to read from the
+ * buffer_icap_device_write - Transfer bytes from ICAP to the storage buffer.
+ * @drvdata: a pointer to the drvdata.
+ * @offset: The storage buffer start address.
+ * @count: The number of words (32 bit) to read from the
  *           device (ICAP).
  **/
 static int buffer_icap_device_write(struct hwicap_drvdata *drvdata,
@@ -261,8 +261,8 @@ static int buffer_icap_device_write(struct hwicap_drvdata *drvdata,
 };
 
 /**
- * buffer_icap_reset: Reset the logic of the icap device.
- * @parameter drvdata: a pointer to the drvdata.
+ * buffer_icap_reset - Reset the logic of the icap device.
+ * @drvdata: a pointer to the drvdata.
  *
  * Writing to the status register resets the ICAP logic in an internal
  * version of the core.  For the version of the core published in EDK,
@@ -274,10 +274,10 @@ void buffer_icap_reset(struct hwicap_drvdata *drvdata)
 }
 
 /**
- * buffer_icap_set_configuration: Load a partial bitstream from system memory.
- * @parameter drvdata: a pointer to the drvdata.
- * @parameter data: Kernel address of the partial bitstream.
- * @parameter size: the size of the partial bitstream in 32 bit words.
+ * buffer_icap_set_configuration - Load a partial bitstream from system memory.
+ * @drvdata: a pointer to the drvdata.
+ * @data: Kernel address of the partial bitstream.
+ * @size: the size of the partial bitstream in 32 bit words.
  **/
 int buffer_icap_set_configuration(struct hwicap_drvdata *drvdata, u32 *data,
                              u32 size)
@@ -333,10 +333,10 @@ int buffer_icap_set_configuration(struct hwicap_drvdata *drvdata, u32 *data,
 };
 
 /**
- * buffer_icap_get_configuration: Read configuration data from the device.
- * @parameter drvdata: a pointer to the drvdata.
- * @parameter data: Address of the data representing the partial bitstream
- * @parameter size: the size of the partial bitstream in 32 bit words.
+ * buffer_icap_get_configuration - Read configuration data from the device.
+ * @drvdata: a pointer to the drvdata.
+ * @data: Address of the data representing the partial bitstream
+ * @size: the size of the partial bitstream in 32 bit words.
  **/
 int buffer_icap_get_configuration(struct hwicap_drvdata *drvdata, u32 *data,
                              u32 size)
diff --git a/drivers/char/xilinx_hwicap/fifo_icap.c b/drivers/char/xilinx_hwicap/fifo_icap.c
index 0988314694a6..6f45dbd47125 100644
--- a/drivers/char/xilinx_hwicap/fifo_icap.c
+++ b/drivers/char/xilinx_hwicap/fifo_icap.c
@@ -94,9 +94,9 @@
 
 
 /**
- * fifo_icap_fifo_write: Write data to the write FIFO.
- * @parameter drvdata: a pointer to the drvdata.
- * @parameter data: the 32-bit value to be written to the FIFO.
+ * fifo_icap_fifo_write - Write data to the write FIFO.
+ * @drvdata: a pointer to the drvdata.
+ * @data: the 32-bit value to be written to the FIFO.
  *
  * This function will silently fail if the fifo is full.
  **/
@@ -108,8 +108,8 @@ static inline void fifo_icap_fifo_write(struct hwicap_drvdata *drvdata,
 }
 
 /**
- * fifo_icap_fifo_read: Read data from the Read FIFO.
- * @parameter drvdata: a pointer to the drvdata.
+ * fifo_icap_fifo_read - Read data from the Read FIFO.
+ * @drvdata: a pointer to the drvdata.
  *
  * This function will silently fail if the fifo is empty.
  **/
@@ -121,9 +121,9 @@ static inline u32 fifo_icap_fifo_read(struct hwicap_drvdata *drvdata)
 }
 
 /**
- * fifo_icap_set_read_size: Set the the size register.
- * @parameter drvdata: a pointer to the drvdata.
- * @parameter data: the size of the following read transaction, in words.
+ * fifo_icap_set_read_size - Set the the size register.
+ * @drvdata: a pointer to the drvdata.
+ * @data: the size of the following read transaction, in words.
  **/
 static inline void fifo_icap_set_read_size(struct hwicap_drvdata *drvdata,
                 u32 data)
@@ -132,8 +132,8 @@ static inline void fifo_icap_set_read_size(struct hwicap_drvdata *drvdata,
 }
 
 /**
- * fifo_icap_start_config: Initiate a configuration (write) to the device.
- * @parameter drvdata: a pointer to the drvdata.
+ * fifo_icap_start_config - Initiate a configuration (write) to the device.
+ * @drvdata: a pointer to the drvdata.
  **/
 static inline void fifo_icap_start_config(struct hwicap_drvdata *drvdata)
 {
@@ -142,8 +142,8 @@ static inline void fifo_icap_start_config(struct hwicap_drvdata *drvdata)
 }
 
 /**
- * fifo_icap_start_readback: Initiate a readback from the device.
- * @parameter drvdata: a pointer to the drvdata.
+ * fifo_icap_start_readback - Initiate a readback from the device.
+ * @drvdata: a pointer to the drvdata.
  **/
 static inline void fifo_icap_start_readback(struct hwicap_drvdata *drvdata)
 {
@@ -152,8 +152,8 @@ static inline void fifo_icap_start_readback(struct hwicap_drvdata *drvdata)
 }
 
 /**
- * fifo_icap_busy: Return true if the ICAP is still processing a transaction.
- * @parameter drvdata: a pointer to the drvdata.
+ * fifo_icap_busy - Return true if the ICAP is still processing a transaction.
+ * @drvdata: a pointer to the drvdata.
  **/
 static inline u32 fifo_icap_busy(struct hwicap_drvdata *drvdata)
 {
@@ -163,8 +163,8 @@ static inline u32 fifo_icap_busy(struct hwicap_drvdata *drvdata)
 }
 
 /**
- * fifo_icap_write_fifo_vacancy: Query the write fifo available space.
- * @parameter drvdata: a pointer to the drvdata.
+ * fifo_icap_write_fifo_vacancy - Query the write fifo available space.
+ * @drvdata: a pointer to the drvdata.
  *
  * Return the number of words that can be safely pushed into the write fifo.
  **/
@@ -175,8 +175,8 @@ static inline u32 fifo_icap_write_fifo_vacancy(
 }
 
 /**
- * fifo_icap_read_fifo_occupancy: Query the read fifo available data.
- * @parameter drvdata: a pointer to the drvdata.
+ * fifo_icap_read_fifo_occupancy - Query the read fifo available data.
+ * @drvdata: a pointer to the drvdata.
  *
  * Return the number of words that can be safely read from the read fifo.
  **/
@@ -187,11 +187,11 @@ static inline u32 fifo_icap_read_fifo_occupancy(
 }
 
 /**
- * fifo_icap_set_configuration: Send configuration data to the ICAP.
- * @parameter drvdata: a pointer to the drvdata.
- * @parameter frame_buffer: a pointer to the data to be written to the
+ * fifo_icap_set_configuration - Send configuration data to the ICAP.
+ * @drvdata: a pointer to the drvdata.
+ * @frame_buffer: a pointer to the data to be written to the
  *              ICAP device.
- * @parameter num_words: the number of words (32 bit) to write to the ICAP
+ * @num_words: the number of words (32 bit) to write to the ICAP
  *              device.
 
  * This function writes the given user data to the Write FIFO in
@@ -266,10 +266,10 @@ int fifo_icap_set_configuration(struct hwicap_drvdata *drvdata,
 }
 
 /**
- * fifo_icap_get_configuration: Read configuration data from the device.
- * @parameter drvdata: a pointer to the drvdata.
- * @parameter data: Address of the data representing the partial bitstream
- * @parameter size: the size of the partial bitstream in 32 bit words.
+ * fifo_icap_get_configuration - Read configuration data from the device.
+ * @drvdata: a pointer to the drvdata.
+ * @data: Address of the data representing the partial bitstream
+ * @size: the size of the partial bitstream in 32 bit words.
  *
  * This function reads the specified number of words from the ICAP device in
  * the polled mode.
@@ -335,8 +335,8 @@ int fifo_icap_get_configuration(struct hwicap_drvdata *drvdata,
 }
 
 /**
- * buffer_icap_reset: Reset the logic of the icap device.
- * @parameter drvdata: a pointer to the drvdata.
+ * buffer_icap_reset - Reset the logic of the icap device.
+ * @drvdata: a pointer to the drvdata.
  *
  * This function forces the software reset of the complete HWICAP device.
  * All the registers will return to the default value and the FIFO is also
@@ -360,8 +360,8 @@ void fifo_icap_reset(struct hwicap_drvdata *drvdata)
 }
 
 /**
- * fifo_icap_flush_fifo: This function flushes the FIFOs in the device.
- * @parameter drvdata: a pointer to the drvdata.
+ * fifo_icap_flush_fifo - This function flushes the FIFOs in the device.
+ * @drvdata: a pointer to the drvdata.
  */
 void fifo_icap_flush_fifo(struct hwicap_drvdata *drvdata)
 {
diff --git a/drivers/char/xilinx_hwicap/xilinx_hwicap.c b/drivers/char/xilinx_hwicap/xilinx_hwicap.c
index 24f6aef0fd3c..2284fa2a5a57 100644
--- a/drivers/char/xilinx_hwicap/xilinx_hwicap.c
+++ b/drivers/char/xilinx_hwicap/xilinx_hwicap.c
@@ -84,7 +84,7 @@
 #include <linux/init.h>
 #include <linux/poll.h>
 #include <linux/proc_fs.h>
-#include <asm/semaphore.h>
+#include <linux/mutex.h>
 #include <linux/sysctl.h>
 #include <linux/version.h>
 #include <linux/fs.h>
@@ -119,6 +119,7 @@ module_param(xhwicap_minor, int, S_IRUGO);
 
 /* An array, which is set to true when the device is registered. */
 static bool probed_devices[HWICAP_DEVICES];
+static struct mutex icap_sem;
 
 static struct class *icap_class;
 
@@ -199,14 +200,14 @@ static const struct config_registers v5_config_registers = {
 };
 
 /**
- * hwicap_command_desync: Send a DESYNC command to the ICAP port.
- * @parameter drvdata: a pointer to the drvdata.
+ * hwicap_command_desync - Send a DESYNC command to the ICAP port.
+ * @drvdata: a pointer to the drvdata.
  *
  * This command desynchronizes the ICAP After this command, a
  * bitstream containing a NULL packet, followed by a SYNCH packet is
  * required before the ICAP will recognize commands.
  */
-int hwicap_command_desync(struct hwicap_drvdata *drvdata)
+static int hwicap_command_desync(struct hwicap_drvdata *drvdata)
 {
         u32 buffer[4];
         u32 index = 0;
@@ -228,51 +229,18 @@ int hwicap_command_desync(struct hwicap_drvdata *drvdata)
 }
 
 /**
- * hwicap_command_capture: Send a CAPTURE command to the ICAP port.
- * @parameter drvdata: a pointer to the drvdata.
- *
- * This command captures all of the flip flop states so they will be
- * available during readback.  One can use this command instead of
- * enabling the CAPTURE block in the design.
- */
-int hwicap_command_capture(struct hwicap_drvdata *drvdata)
-{
-        u32 buffer[7];
-        u32 index = 0;
-
-        /*
-         * Create the data to be written to the ICAP.
-         */
-        buffer[index++] = XHI_DUMMY_PACKET;
-        buffer[index++] = XHI_SYNC_PACKET;
-        buffer[index++] = XHI_NOOP_PACKET;
-        buffer[index++] = hwicap_type_1_write(drvdata->config_regs->CMD) | 1;
-        buffer[index++] = XHI_CMD_GCAPTURE;
-        buffer[index++] = XHI_DUMMY_PACKET;
-        buffer[index++] = XHI_DUMMY_PACKET;
-
-        /*
-         * Write the data to the FIFO and intiate the transfer of data
-         * present in the FIFO to the ICAP device.
-         */
-        return drvdata->config->set_configuration(drvdata,
-                        &buffer[0], index);
-
-}
-
-/**
- * hwicap_get_configuration_register: Query a configuration register.
- * @parameter drvdata: a pointer to the drvdata.
- * @parameter reg: a constant which represents the configuration
+ * hwicap_get_configuration_register - Query a configuration register.
+ * @drvdata: a pointer to the drvdata.
+ * @reg: a constant which represents the configuration
  *              register value to be returned.
  *              Examples:  XHI_IDCODE, XHI_FLR.
- * @parameter RegData: returns the value of the register.
+ * @reg_data: returns the value of the register.
  *
  * Sends a query packet to the ICAP and then receives the response.
  * The icap is left in Synched state.
  */
-int hwicap_get_configuration_register(struct hwicap_drvdata *drvdata,
-                u32 reg, u32 *RegData)
+static int hwicap_get_configuration_register(struct hwicap_drvdata *drvdata,
+                u32 reg, u32 *reg_data)
 {
         int status;
         u32 buffer[6];
@@ -300,14 +268,14 @@ int hwicap_get_configuration_register(struct hwicap_drvdata *drvdata,
         /*
          * Read the configuration register
          */
-        status = drvdata->config->get_configuration(drvdata, RegData, 1);
+        status = drvdata->config->get_configuration(drvdata, reg_data, 1);
         if (status)
                 return status;
 
         return 0;
 }
 
-int hwicap_initialize_hwicap(struct hwicap_drvdata *drvdata)
+static int hwicap_initialize_hwicap(struct hwicap_drvdata *drvdata)
 {
         int status;
         u32 idcode;
@@ -344,7 +312,7 @@ int hwicap_initialize_hwicap(struct hwicap_drvdata *drvdata)
 }
 
 static ssize_t
-hwicap_read(struct file *file, char *buf, size_t count, loff_t *ppos)
+hwicap_read(struct file *file, char __user *buf, size_t count, loff_t *ppos)
 {
         struct hwicap_drvdata *drvdata = file->private_data;
         ssize_t bytes_to_read = 0;
@@ -353,8 +321,9 @@ hwicap_read(struct file *file, char *buf, size_t count, loff_t *ppos)
         u32 bytes_remaining;
         int status;
 
-        if (down_interruptible(&drvdata->sem))
-                return -ERESTARTSYS;
+        status = mutex_lock_interruptible(&drvdata->sem);
+        if (status)
+                return status;
 
         if (drvdata->read_buffer_in_use) {
                 /* If there are leftover bytes in the buffer, just */
@@ -370,8 +339,9 @@ hwicap_read(struct file *file, char *buf, size_t count, loff_t *ppos)
                         goto error;
                 }
                 drvdata->read_buffer_in_use -= bytes_to_read;
-                memcpy(drvdata->read_buffer + bytes_to_read,
-                                drvdata->read_buffer, 4 - bytes_to_read);
+                memmove(drvdata->read_buffer,
+                       drvdata->read_buffer + bytes_to_read,
+                       4 - bytes_to_read);
         } else {
                 /* Get new data from the ICAP, and return was was requested. */
                 kbuf = (u32 *) get_zeroed_page(GFP_KERNEL);
@@ -414,18 +384,20 @@ hwicap_read(struct file *file, char *buf, size_t count, loff_t *ppos)
                         status = -EFAULT;
                         goto error;
                 }
-                memcpy(kbuf, drvdata->read_buffer, bytes_remaining);
+                memcpy(drvdata->read_buffer,
+                       kbuf,
+                       bytes_remaining);
                 drvdata->read_buffer_in_use = bytes_remaining;
                 free_page((unsigned long)kbuf);
         }
         status = bytes_to_read;
  error:
-        up(&drvdata->sem);
+        mutex_unlock(&drvdata->sem);
         return status;
 }
 
 static ssize_t
-hwicap_write(struct file *file, const char *buf,
+hwicap_write(struct file *file, const char __user *buf,
                 size_t count, loff_t *ppos)
 {
         struct hwicap_drvdata *drvdata = file->private_data;
@@ -435,8 +407,9 @@ hwicap_write(struct file *file, const char *buf,
         ssize_t len;
         ssize_t status;
 
-        if (down_interruptible(&drvdata->sem))
-                return -ERESTARTSYS;
+        status = mutex_lock_interruptible(&drvdata->sem);
+        if (status)
+                return status;
 
         left += drvdata->write_buffer_in_use;
 
@@ -465,7 +438,7 @@ hwicap_write(struct file *file, const char *buf,
                         memcpy(kbuf, drvdata->write_buffer,
                                         drvdata->write_buffer_in_use);
                         if (copy_from_user(
-                            (((char *)kbuf) + (drvdata->write_buffer_in_use)),
+                            (((char *)kbuf) + drvdata->write_buffer_in_use),
                             buf + written,
                             len - (drvdata->write_buffer_in_use))) {
                                 free_page((unsigned long)kbuf);
@@ -508,7 +481,7 @@ hwicap_write(struct file *file, const char *buf,
         free_page((unsigned long)kbuf);
         status = written;
  error:
-        up(&drvdata->sem);
+        mutex_unlock(&drvdata->sem);
         return status;
 }
 
@@ -519,8 +492,9 @@ static int hwicap_open(struct inode *inode, struct file *file)
 
         drvdata = container_of(inode->i_cdev, struct hwicap_drvdata, cdev);
 
-        if (down_interruptible(&drvdata->sem))
-                return -ERESTARTSYS;
+        status = mutex_lock_interruptible(&drvdata->sem);
+        if (status)
+                return status;
 
         if (drvdata->is_open) {
                 status = -EBUSY;
@@ -539,7 +513,7 @@ static int hwicap_open(struct inode *inode, struct file *file)
         drvdata->is_open = 1;
 
  error:
-        up(&drvdata->sem);
+        mutex_unlock(&drvdata->sem);
         return status;
 }
 
@@ -549,8 +523,7 @@ static int hwicap_release(struct inode *inode, struct file *file)
         int i;
         int status = 0;
 
-        if (down_interruptible(&drvdata->sem))
-                return -ERESTARTSYS;
+        mutex_lock(&drvdata->sem);
 
         if (drvdata->write_buffer_in_use) {
                 /* Flush write buffer. */
@@ -569,7 +542,7 @@ static int hwicap_release(struct inode *inode, struct file *file)
 
  error:
         drvdata->is_open = 0;
-        up(&drvdata->sem);
+        mutex_unlock(&drvdata->sem);
         return status;
 }
 
@@ -592,31 +565,36 @@ static int __devinit hwicap_setup(struct device *dev, int id,
 
         dev_info(dev, "Xilinx icap port driver\n");
 
+        mutex_lock(&icap_sem);
+
         if (id < 0) {
                 for (id = 0; id < HWICAP_DEVICES; id++)
                         if (!probed_devices[id])
                                 break;
         }
         if (id < 0 || id >= HWICAP_DEVICES) {
+                mutex_unlock(&icap_sem);
                 dev_err(dev, "%s%i too large\n", DRIVER_NAME, id);
                 return -EINVAL;
         }
         if (probed_devices[id]) {
+                mutex_unlock(&icap_sem);
                 dev_err(dev, "cannot assign to %s%i; it is already in use\n",
                         DRIVER_NAME, id);
                 return -EBUSY;
         }
 
         probed_devices[id] = 1;
+        mutex_unlock(&icap_sem);
 
         devt = MKDEV(xhwicap_major, xhwicap_minor + id);
 
-        drvdata = kmalloc(sizeof(struct hwicap_drvdata), GFP_KERNEL);
+        drvdata = kzalloc(sizeof(struct hwicap_drvdata), GFP_KERNEL);
         if (!drvdata) {
                 dev_err(dev, "Couldn't allocate device private record\n");
-                return -ENOMEM;
+                retval = -ENOMEM;
+                goto failed0;
         }
-        memset((void *)drvdata, 0, sizeof(struct hwicap_drvdata));
         dev_set_drvdata(dev, (void *)drvdata);
 
         if (!regs_res) {
@@ -648,7 +626,7 @@ static int __devinit hwicap_setup(struct device *dev, int id,
         drvdata->config = config;
         drvdata->config_regs = config_regs;
 
-        init_MUTEX(&drvdata->sem);
+        mutex_init(&drvdata->sem);
         drvdata->is_open = 0;
 
         dev_info(dev, "ioremap %lx to %p with size %x\n",
@@ -663,7 +641,7 @@ static int __devinit hwicap_setup(struct device *dev, int id,
                 goto failed3;
         }
         /*  devfs_mk_cdev(devt, S_IFCHR|S_IRUGO|S_IWUGO, DRIVER_NAME); */
-        class_device_create(icap_class, NULL, devt, NULL, DRIVER_NAME);
+        device_create(icap_class, dev, devt, "%s%d", DRIVER_NAME, id);
         return 0;               /* success */
 
  failed3:
@@ -675,6 +653,11 @@ static int __devinit hwicap_setup(struct device *dev, int id,
  failed1:
         kfree(drvdata);
 
+ failed0:
+        mutex_lock(&icap_sem);
+        probed_devices[id] = 0;
+        mutex_unlock(&icap_sem);
+
         return retval;
 }
 
@@ -699,14 +682,16 @@ static int __devexit hwicap_remove(struct device *dev)
         if (!drvdata)
                 return 0;
 
-        class_device_destroy(icap_class, drvdata->devt);
+        device_destroy(icap_class, drvdata->devt);
         cdev_del(&drvdata->cdev);
         iounmap(drvdata->base_address);
         release_mem_region(drvdata->mem_start, drvdata->mem_size);
         kfree(drvdata);
         dev_set_drvdata(dev, NULL);
-        probed_devices[MINOR(dev->devt)-xhwicap_minor] = 0;
 
+        mutex_lock(&icap_sem);
+        probed_devices[MINOR(dev->devt)-xhwicap_minor] = 0;
+        mutex_unlock(&icap_sem);
         return 0;               /* success */
 }
 
@@ -821,28 +806,29 @@ static struct of_platform_driver hwicap_of_driver = {
 };
 
 /* Registration helpers to keep the number of #ifdefs to a minimum */
-static inline int __devinit hwicap_of_register(void)
+static inline int __init hwicap_of_register(void)
 {
         pr_debug("hwicap: calling of_register_platform_driver()\n");
         return of_register_platform_driver(&hwicap_of_driver);
 }
 
-static inline void __devexit hwicap_of_unregister(void)
+static inline void __exit hwicap_of_unregister(void)
 {
         of_unregister_platform_driver(&hwicap_of_driver);
 }
 #else /* CONFIG_OF */
 /* CONFIG_OF not enabled; do nothing helpers */
-static inline int __devinit hwicap_of_register(void) { return 0; }
-static inline void __devexit hwicap_of_unregister(void) { }
+static inline int __init hwicap_of_register(void) { return 0; }
+static inline void __exit hwicap_of_unregister(void) { }
 #endif /* CONFIG_OF */
 
-static int __devinit hwicap_module_init(void)
+static int __init hwicap_module_init(void)
 {
         dev_t devt;
         int retval;
 
         icap_class = class_create(THIS_MODULE, "xilinx_config");
+        mutex_init(&icap_sem);
 
         if (xhwicap_major) {
                 devt = MKDEV(xhwicap_major, xhwicap_minor);
@@ -883,7 +869,7 @@ static int __devinit hwicap_module_init(void)
         return retval;
 }
 
-static void __devexit hwicap_module_cleanup(void)
+static void __exit hwicap_module_cleanup(void)
 {
         dev_t devt = MKDEV(xhwicap_major, xhwicap_minor);
 
diff --git a/drivers/char/xilinx_hwicap/xilinx_hwicap.h b/drivers/char/xilinx_hwicap/xilinx_hwicap.h
index ae771cac1629..405fee7e189b 100644
--- a/drivers/char/xilinx_hwicap/xilinx_hwicap.h
+++ b/drivers/char/xilinx_hwicap/xilinx_hwicap.h
@@ -48,9 +48,9 @@ struct hwicap_drvdata {
         u8 write_buffer[4];
         u32 read_buffer_in_use;   /* Always in [0,3] */
         u8 read_buffer[4];
-        u32 mem_start;            /* phys. address of the control registers */
-        u32 mem_end;              /* phys. address of the control registers */
-        u32 mem_size;
+        resource_size_t mem_start;/* phys. address of the control registers */
+        resource_size_t mem_end;  /* phys. address of the control registers */
+        resource_size_t mem_size;
         void __iomem *base_address;/* virt. address of the control registers */
 
         struct device *dev;
@@ -61,7 +61,7 @@ struct hwicap_drvdata {
         const struct config_registers *config_regs;
         void *private_data;
         bool is_open;
-        struct semaphore sem;
+        struct mutex sem;
 };
 
 struct hwicap_driver_config {
@@ -164,29 +164,29 @@ struct config_registers {
 #define XHI_DISABLED_AUTO_CRC       0x0000DEFCUL
 
 /**
- * hwicap_type_1_read: Generates a Type 1 read packet header.
- * @parameter: Register is the address of the register to be read back.
+ * hwicap_type_1_read - Generates a Type 1 read packet header.
+ * @reg: is the address of the register to be read back.
  *
  * Generates a Type 1 read packet header, which is used to indirectly
  * read registers in the configuration logic.  This packet must then
  * be sent through the icap device, and a return packet received with
  * the information.
  **/
-static inline u32 hwicap_type_1_read(u32 Register)
+static inline u32 hwicap_type_1_read(u32 reg)
 {
         return (XHI_TYPE_1 << XHI_TYPE_SHIFT) |
-                (Register << XHI_REGISTER_SHIFT) |
+                (reg << XHI_REGISTER_SHIFT) |
                 (XHI_OP_READ << XHI_OP_SHIFT);
 }
 
 /**
- * hwicap_type_1_write: Generates a Type 1 write packet header
- * @parameter: Register is the address of the register to be read back.
+ * hwicap_type_1_write - Generates a Type 1 write packet header
+ * @reg: is the address of the register to be read back.
  **/
-static inline u32 hwicap_type_1_write(u32 Register)
+static inline u32 hwicap_type_1_write(u32 reg)
 {
         return (XHI_TYPE_1 << XHI_TYPE_SHIFT) |
-                (Register << XHI_REGISTER_SHIFT) |
+                (reg << XHI_REGISTER_SHIFT) |
                 (XHI_OP_WRITE << XHI_OP_SHIFT);
 }
 
diff --git a/drivers/message/fusion/mptbase.c b/drivers/message/fusion/mptbase.c
index 0c303c84b37b..6b6df8679585 100644
--- a/drivers/message/fusion/mptbase.c
+++ b/drivers/message/fusion/mptbase.c
@@ -632,8 +632,7 @@ mpt_deregister(u8 cb_idx)
 
 /*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=*/
 /**
- *      mpt_event_register - Register protocol-specific event callback
- *      handler.
+ *      mpt_event_register - Register protocol-specific event callback handler.
  *      @cb_idx: previously registered (via mpt_register) callback handle
  *      @ev_cbfunc: callback function
  *
@@ -654,8 +653,7 @@ mpt_event_register(u8 cb_idx, MPT_EVHANDLER ev_cbfunc)
 
 /*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=*/
 /**
- *      mpt_event_deregister - Deregister protocol-specific event callback
- *      handler.
+ *      mpt_event_deregister - Deregister protocol-specific event callback handler
  *      @cb_idx: previously registered callback handle
  *
  *      Each protocol-specific driver should call this routine
@@ -765,11 +763,13 @@ mpt_device_driver_deregister(u8 cb_idx)
 
 /*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=*/
 /**
- *      mpt_get_msg_frame - Obtain a MPT request frame from the pool (of 1024)
- *      allocated per MPT adapter.
+ *      mpt_get_msg_frame - Obtain an MPT request frame from the pool
  *      @cb_idx: Handle of registered MPT protocol driver
  *      @ioc: Pointer to MPT adapter structure
  *
+ *      Obtain an MPT request frame from the pool (of 1024) that are
+ *      allocated per MPT adapter.
+ *
  *      Returns pointer to a MPT request frame or %NULL if none are available
  *      or IOC is not active.
  */
@@ -834,13 +834,12 @@ mpt_get_msg_frame(u8 cb_idx, MPT_ADAPTER *ioc)
 
 /*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=*/
 /**
- *      mpt_put_msg_frame - Send a protocol specific MPT request frame
- *      to a IOC.
+ *      mpt_put_msg_frame - Send a protocol-specific MPT request frame to an IOC
  *      @cb_idx: Handle of registered MPT protocol driver
  *      @ioc: Pointer to MPT adapter structure
  *      @mf: Pointer to MPT request frame
  *
- *      This routine posts a MPT request frame to the request post FIFO of a
+ *      This routine posts an MPT request frame to the request post FIFO of a
  *      specific MPT adapter.
  */
 void
@@ -868,13 +867,15 @@ mpt_put_msg_frame(u8 cb_idx, MPT_ADAPTER *ioc, MPT_FRAME_HDR *mf)
 }
 
 /**
- *      mpt_put_msg_frame_hi_pri - Send a protocol specific MPT request frame
- *      to a IOC using hi priority request queue.
+ *      mpt_put_msg_frame_hi_pri - Send a hi-pri protocol-specific MPT request frame
  *      @cb_idx: Handle of registered MPT protocol driver
  *      @ioc: Pointer to MPT adapter structure
  *      @mf: Pointer to MPT request frame
  *
- *      This routine posts a MPT request frame to the request post FIFO of a
+ *      Send a protocol-specific MPT request frame to an IOC using
+ *      hi-priority request queue.
+ *
+ *      This routine posts an MPT request frame to the request post FIFO of a
  *      specific MPT adapter.
  **/
 void
diff --git a/drivers/message/fusion/mptscsih.c b/drivers/message/fusion/mptscsih.c
index af1de0ccee2f..0c252f60c4c1 100644
--- a/drivers/message/fusion/mptscsih.c
+++ b/drivers/message/fusion/mptscsih.c
@@ -1533,7 +1533,7 @@ mptscsih_freeChainBuffers(MPT_ADAPTER *ioc, int req_idx)
  *
  *      Remark: Currently invoked from a non-interrupt thread (_bh).
  *
- *      Remark: With old EH code, at most 1 SCSI TaskMgmt function per IOC
+ *      Note: With old EH code, at most 1 SCSI TaskMgmt function per IOC
  *      will be active.
  *
  *      Returns 0 for SUCCESS, or %FAILED.
@@ -2537,14 +2537,12 @@ mptscsih_copy_sense_data(struct scsi_cmnd *sc, MPT_SCSI_HOST *hd, MPT_FRAME_HDR
 
 /**
  * mptscsih_get_scsi_lookup
- *
- * retrieves scmd entry from ScsiLookup[] array list
- *
  * @ioc: Pointer to MPT_ADAPTER structure
  * @i: index into the array
  *
- * Returns the scsi_cmd pointer
+ * retrieves scmd entry from ScsiLookup[] array list
  *
+ * Returns the scsi_cmd pointer
  **/
 static struct scsi_cmnd *
 mptscsih_get_scsi_lookup(MPT_ADAPTER *ioc, int i)
@@ -2561,14 +2559,12 @@ mptscsih_get_scsi_lookup(MPT_ADAPTER *ioc, int i)
 
 /**
  * mptscsih_getclear_scsi_lookup
- *
- * retrieves and clears scmd entry from ScsiLookup[] array list
- *
  * @ioc: Pointer to MPT_ADAPTER structure
  * @i: index into the array
  *
- * Returns the scsi_cmd pointer
+ * retrieves and clears scmd entry from ScsiLookup[] array list
  *
+ * Returns the scsi_cmd pointer
  **/
 static struct scsi_cmnd *
 mptscsih_getclear_scsi_lookup(MPT_ADAPTER *ioc, int i)
diff --git a/drivers/net/fec.c b/drivers/net/fec.c
index 0fbf1bbbaee9..d7a3ea88eddb 100644
--- a/drivers/net/fec.c
+++ b/drivers/net/fec.c
@@ -1253,7 +1253,7 @@ static void __inline__ fec_request_intrs(struct net_device *dev)
 
         /* Setup interrupt handlers. */
         for (idp = id; idp->name; idp++) {
-                if (request_irq(idp->irq, idp->handler, 0, idp->name, dev) != 0)
+                if (request_irq(idp->irq, idp->handler, IRQF_DISABLED, idp->name, dev) != 0)
                         printk("FEC: Could not allocate %s IRQ(%d)!\n", idp->name, idp->irq);
         }
 
@@ -1382,7 +1382,7 @@ static void __inline__ fec_request_intrs(struct net_device *dev)
 
         /* Setup interrupt handlers. */
         for (idp = id; idp->name; idp++) {
-                if (request_irq(b+idp->irq, fec_enet_interrupt, 0, idp->name, dev) != 0)
+                if (request_irq(b+idp->irq, fec_enet_interrupt, IRQF_DISABLED, idp->name, dev) != 0)
                         printk("FEC: Could not allocate %s IRQ(%d)!\n", idp->name, b+idp->irq);
         }
 
@@ -1553,7 +1553,7 @@ static void __inline__ fec_request_intrs(struct net_device *dev)
 
         /* Setup interrupt handlers. */
         for (idp = id; idp->name; idp++) {
-                if (request_irq(b+idp->irq,fec_enet_interrupt,0,idp->name,dev)!=0)
+                if (request_irq(b+idp->irq, fec_enet_interrupt, IRQF_DISABLED, idp->name,dev) != 0)
                         printk("FEC: Could not allocate %s IRQ(%d)!\n", idp->name, b+idp->irq);
         }
 
@@ -1680,7 +1680,7 @@ static void __inline__ fec_request_intrs(struct net_device *dev)
 
         /* Setup interrupt handlers. */
         for (idp = id; idp->name; idp++) {
-                if (request_irq(b+idp->irq,fec_enet_interrupt,0,idp->name,dev)!=0)
+                if (request_irq(b+idp->irq, fec_enet_interrupt, IRQF_DISABLED, idp->name,dev) != 0)
                         printk("FEC: Could not allocate %s IRQ(%d)!\n",
                                 idp->name, b+idp->irq);
         }
diff --git a/drivers/pci/rom.c b/drivers/pci/rom.c
index a98b2470b9ea..bd5c0e031398 100644
--- a/drivers/pci/rom.c
+++ b/drivers/pci/rom.c
@@ -242,8 +242,7 @@ void pci_remove_rom(struct pci_dev *pdev)
 #endif  /*  0  */
 
 /**
- * pci_cleanup_rom - internal routine for freeing the ROM copy created
- * by pci_map_rom_copy called from remove.c
+ * pci_cleanup_rom - free the ROM copy created by pci_map_rom_copy
  * @pdev: pointer to pci device struct
  *
  * Free the copied ROM if we allocated one.
diff --git a/drivers/rapidio/rio-driver.c b/drivers/rapidio/rio-driver.c
index 5480119ff9d3..3ce9f3defc12 100644
--- a/drivers/rapidio/rio-driver.c
+++ b/drivers/rapidio/rio-driver.c
@@ -78,8 +78,7 @@ void rio_dev_put(struct rio_dev *rdev)
 }
 
 /**
- *  rio_device_probe - Tell if a RIO device structure has a matching RIO
- *                     device id structure
+ *  rio_device_probe - Tell if a RIO device structure has a matching RIO device id structure
  *  @id: the RIO device id structure to match against
  *  @dev: the RIO device structure to match against
  *
@@ -137,7 +136,7 @@ static int rio_device_remove(struct device *dev)
  *  rio_register_driver - register a new RIO driver
  *  @rdrv: the RIO driver structure to register
  *
- *  Adds a &struct rio_driver to the list of registered drivers
+ *  Adds a &struct rio_driver to the list of registered drivers.
  *  Returns a negative value on error, otherwise 0. If no error
  *  occurred, the driver remains registered even if no device
  *  was claimed during registration.
@@ -167,8 +166,7 @@ void rio_unregister_driver(struct rio_driver *rdrv)
 }
 
 /**
- *  rio_match_bus - Tell if a RIO device structure has a matching RIO
- *                  driver device id structure
+ *  rio_match_bus - Tell if a RIO device structure has a matching RIO driver device id structure
  *  @dev: the standard device structure to match against
  *  @drv: the standard driver structure containing the ids to match against
  *
diff --git a/drivers/s390/char/defkeymap.c b/drivers/s390/char/defkeymap.c
index 389346cda6c8..07c7f31081bc 100644
--- a/drivers/s390/char/defkeymap.c
+++ b/drivers/s390/char/defkeymap.c
@@ -151,8 +151,8 @@ char *func_table[MAX_NR_FUNC] = {
 };
 
 struct kbdiacruc accent_table[MAX_DIACR] = {
-        {'^', 'c', '\003'},     {'^', 'd', '\004'},
-        {'^', 'z', '\032'},     {'^', '\012', '\000'},
+        {'^', 'c', 0003},       {'^', 'd', 0004},
+        {'^', 'z', 0032},       {'^', 0012, 0000},
 };
 
 unsigned int accent_table_size = 4;
diff --git a/drivers/scsi/scsi_scan.c b/drivers/scsi/scsi_scan.c
index 1dc165ad17fb..e67c14e31bab 100644
--- a/drivers/scsi/scsi_scan.c
+++ b/drivers/scsi/scsi_scan.c
@@ -1577,8 +1577,7 @@ static void __scsi_scan_target(struct device *parent, unsigned int channel,
 }
 
 /**
- * scsi_scan_target - scan a target id, possibly including all LUNs on the
- *     target.
+ * scsi_scan_target - scan a target id, possibly including all LUNs on the target.
  * @parent:     host to scan
  * @channel:    channel to scan
  * @id:         target id to scan
diff --git a/drivers/usb/core/usb.c b/drivers/usb/core/usb.c
index 4e984060c984..f6f19908f5f0 100644
--- a/drivers/usb/core/usb.c
+++ b/drivers/usb/core/usb.c
@@ -99,8 +99,7 @@ struct usb_interface *usb_ifnum_to_if(const struct usb_device *dev,
 EXPORT_SYMBOL_GPL(usb_ifnum_to_if);
 
 /**
- * usb_altnum_to_altsetting - get the altsetting structure with a given
- *      alternate setting number.
+ * usb_altnum_to_altsetting - get the altsetting structure with a given alternate setting number.
  * @intf: the interface containing the altsetting in question
  * @altnum: the desired alternate setting number
  *
@@ -442,8 +441,7 @@ EXPORT_SYMBOL_GPL(usb_put_intf);
  */
 
 /**
- * usb_lock_device_for_reset - cautiously acquire the lock for a
- *      usb device structure
+ * usb_lock_device_for_reset - cautiously acquire the lock for a usb device structure
  * @udev: device that's being locked
  * @iface: interface bound to the driver making the request (optional)
  *
diff --git a/fs/buffer.c b/fs/buffer.c
index 3ebccf4aa7e3..897cd7477b34 100644
--- a/fs/buffer.c
+++ b/fs/buffer.c
@@ -627,8 +627,7 @@ repeat:
 }
 
 /**
- * sync_mapping_buffers - write out and wait upon a mapping's "associated"
- *                        buffers
+ * sync_mapping_buffers - write out & wait upon a mapping's "associated" buffers
  * @mapping: the mapping which wants those buffers written
  *
  * Starts I/O against the buffers at mapping->private_list, and waits upon
diff --git a/fs/cifs/CHANGES b/fs/cifs/CHANGES
index edd248367b36..dbd91461853c 100644
--- a/fs/cifs/CHANGES
+++ b/fs/cifs/CHANGES
@@ -6,7 +6,9 @@ and sync so that events like out of disk space get reported properly on
 cached files. Fix setxattr failure to certain Samba versions. Fix mount
 of second share to disconnected server session (autoreconnect on this).
 Add ability to modify cifs acls for handling chmod (when mounted with
-cifsacl flag).
+cifsacl flag). Fix prefixpath path separator so we can handle mounts
+with prefixpaths longer than one directory (one path component) when
+mounted to Windows servers.
 
 Version 1.51
 ------------
diff --git a/fs/cifs/README b/fs/cifs/README
index c623e2f9c5db..50306229b0f9 100644
--- a/fs/cifs/README
+++ b/fs/cifs/README
@@ -461,7 +461,7 @@ A partial list of the supported mount options follows:
  cifsacl        Report mode bits (e.g. on stat) based on the Windows ACL for
                 the file. (EXPERIMENTAL)
  servern        Specify the server 's netbios name (RFC1001 name) to use
-                when attempting to setup a session to the server.  This is
+                when attempting to setup a session to the server. 
                 This is needed for mounting to some older servers (such
                 as OS/2 or Windows 98 and Windows ME) since they do not
                 support a default server name.  A server name can be up
diff --git a/fs/cifs/cifs_debug.c b/fs/cifs/cifs_debug.c
index 73c4c419663c..0228ed06069e 100644
--- a/fs/cifs/cifs_debug.c
+++ b/fs/cifs/cifs_debug.c
@@ -98,8 +98,7 @@ void cifs_dump_mids(struct TCP_Server_Info *server)
                         if (mid_entry->resp_buf) {
                                 cifs_dump_detail(mid_entry->resp_buf);
                                 cifs_dump_mem("existing buf: ",
-                                        mid_entry->resp_buf,
-                                        62 /* fixme */);
+                                        mid_entry->resp_buf, 62);
                         }
                 }
         }
@@ -439,7 +438,7 @@ cifs_stats_read(char *buf, char **beginBuffer, off_t offset,
 
         return length;
 }
-#endif
+#endif /* STATS */
 
 static struct proc_dir_entry *proc_fs_cifs;
 read_proc_t cifs_txanchor_read;
@@ -482,7 +481,7 @@ cifs_proc_init(void)
                                 cifs_stats_read, NULL);
         if (pde)
                 pde->write_proc = cifs_stats_write;
-#endif
+#endif /* STATS */
         pde = create_proc_read_entry("cifsFYI", 0, proc_fs_cifs,
                                 cifsFYI_read, NULL);
         if (pde)
@@ -918,4 +917,12 @@ security_flags_write(struct file *file, const char __user *buffer,
         /* BB should we turn on MAY flags for other MUST options? */
         return count;
 }
-#endif
+#else
+inline void cifs_proc_init(void)
+{
+}
+
+inline void cifs_proc_clean(void)
+{
+}
+#endif /* PROC_FS */
diff --git a/fs/cifs/cifs_debug.h b/fs/cifs/cifs_debug.h
index c26cd0d2c6d5..5eb3b83bbfa7 100644
--- a/fs/cifs/cifs_debug.h
+++ b/fs/cifs/cifs_debug.h
@@ -25,8 +25,11 @@
 
 void cifs_dump_mem(char *label, void *data, int length);
 #ifdef CONFIG_CIFS_DEBUG2
+#define DBG2 2
 void cifs_dump_detail(struct smb_hdr *);
 void cifs_dump_mids(struct TCP_Server_Info *);
+#else
+#define DBG2 0
 #endif
 extern int traceSMB;            /* flag which enables the function below */
 void dump_smb(struct smb_hdr *, int);
@@ -64,10 +67,10 @@ extern int cifsERROR;
  *      ---------
  */
 #else           /* _CIFS_DEBUG */
-#define cERROR(button,prspec)
-#define cEVENT(format,arg...)
+#define cERROR(button, prspec)
+#define cEVENT(format, arg...)
 #define cFYI(button, prspec)
-#define cifserror(format,arg...)
+#define cifserror(format, arg...)
 #endif          /* _CIFS_DEBUG */
 
 #endif                          /* _H_CIFS_DEBUG */
diff --git a/fs/cifs/cifs_dfs_ref.c b/fs/cifs/cifs_dfs_ref.c
index 6ad447529961..7f8838253410 100644
--- a/fs/cifs/cifs_dfs_ref.c
+++ b/fs/cifs/cifs_dfs_ref.c
@@ -286,7 +286,7 @@ static void dump_referral(const struct dfs_info3_param *ref)
         cFYI(1, ("DFS: node path: %s", ref->node_name));
         cFYI(1, ("DFS: fl: %hd, srv_type: %hd", ref->flags, ref->server_type));
         cFYI(1, ("DFS: ref_flags: %hd, path_consumed: %hd", ref->ref_flag,
-                                ref->PathConsumed));
+                                ref->path_consumed));
 }
 
 
diff --git a/fs/cifs/cifs_spnego.c b/fs/cifs/cifs_spnego.c
index d543accc10dd..6653e29637a7 100644
--- a/fs/cifs/cifs_spnego.c
+++ b/fs/cifs/cifs_spnego.c
@@ -125,7 +125,7 @@ cifs_get_spnego_key(struct cifsSesInfo *sesInfo)
 #ifdef CONFIG_CIFS_DEBUG2
         if (cifsFYI && !IS_ERR(spnego_key)) {
                 struct cifs_spnego_msg *msg = spnego_key->payload.data;
-                cifs_dump_mem("SPNEGO reply blob:", msg->data, min(1024,
+                cifs_dump_mem("SPNEGO reply blob:", msg->data, min(1024U,
                                 msg->secblob_len + msg->sesskey_len));
         }
 #endif /* CONFIG_CIFS_DEBUG2 */
diff --git a/fs/cifs/cifs_unicode.c b/fs/cifs/cifs_unicode.c
index b5903b89250d..7d75272a6b3f 100644
--- a/fs/cifs/cifs_unicode.c
+++ b/fs/cifs/cifs_unicode.c
@@ -32,7 +32,7 @@
  *
  */
 int
-cifs_strfromUCS_le(char *to, const __le16 * from,
+cifs_strfromUCS_le(char *to, const __le16 *from,
                    int len, const struct nls_table *codepage)
 {
         int i;
@@ -61,7 +61,7 @@ cifs_strfromUCS_le(char *to, const __le16 * from,
  *
  */
 int
-cifs_strtoUCS(__le16 * to, const char *from, int len,
+cifs_strtoUCS(__le16 *to, const char *from, int len,
               const struct nls_table *codepage)
 {
         int charlen;
diff --git a/fs/cifs/cifs_unicode.h b/fs/cifs/cifs_unicode.h
index 614c11fcdcb6..14eb9a2395d3 100644
--- a/fs/cifs/cifs_unicode.h
+++ b/fs/cifs/cifs_unicode.h
@@ -254,7 +254,8 @@ UniStrstr(const wchar_t *ucs1, const wchar_t *ucs2)
         const wchar_t *anchor2 = ucs2;
 
         while (*ucs1) {
-                if (*ucs1 == *ucs2) {   /* Partial match found */
+                if (*ucs1 == *ucs2) {
+                        /* Partial match found */
                         ucs1++;
                         ucs2++;
                 } else {
@@ -279,7 +280,8 @@ UniToupper(register wchar_t uc)
 {
         register const struct UniCaseRange *rp;
 
-        if (uc < sizeof (CifsUniUpperTable)) {  /* Latin characters */
+        if (uc < sizeof(CifsUniUpperTable)) {
+                /* Latin characters */
                 return uc + CifsUniUpperTable[uc];      /* Use base tables */
         } else {
                 rp = CifsUniUpperRange; /* Use range tables */
@@ -320,7 +322,8 @@ UniTolower(wchar_t uc)
 {
         register struct UniCaseRange *rp;
 
-        if (uc < sizeof (UniLowerTable)) {      /* Latin characters */
+        if (uc < sizeof(UniLowerTable)) {
+                /* Latin characters */
                 return uc + UniLowerTable[uc];  /* Use base tables */
         } else {
                 rp = UniLowerRange;     /* Use range tables */
diff --git a/fs/cifs/cifsacl.c b/fs/cifs/cifsacl.c
index a7035bd18e4e..f93932c21772 100644
--- a/fs/cifs/cifsacl.c
+++ b/fs/cifs/cifsacl.c
@@ -46,8 +46,7 @@ static struct cifs_wksid wksidarr[NUM_WK_SIDS] = {
 static const struct cifs_sid sid_everyone = {
         1, 1, {0, 0, 0, 0, 0, 1}, {0} };
 /* group users */
-static const struct cifs_sid sid_user =
-                {1, 2 , {0, 0, 0, 0, 0, 5}, {} };
+static const struct cifs_sid sid_user = {1, 2 , {0, 0, 0, 0, 0, 5}, {} };
 
 
 int match_sid(struct cifs_sid *ctsid)
@@ -195,9 +194,9 @@ static void access_flags_to_mode(__le32 ace_flags, int type, umode_t *pmode,
         /* For deny ACEs we change the mask so that subsequent allow access
            control entries do not turn on the bits we are denying */
         if (type == ACCESS_DENIED) {
-                if (flags & GENERIC_ALL) {
+                if (flags & GENERIC_ALL)
                         *pbits_to_set &= ~S_IRWXUGO;
-                }
+
                 if ((flags & GENERIC_WRITE) ||
                         ((flags & FILE_WRITE_RIGHTS) == FILE_WRITE_RIGHTS))
                         *pbits_to_set &= ~S_IWUGO;
@@ -216,9 +215,7 @@ static void access_flags_to_mode(__le32 ace_flags, int type, umode_t *pmode,
 
         if (flags & GENERIC_ALL) {
                 *pmode |= (S_IRWXUGO & (*pbits_to_set));
-#ifdef CONFIG_CIFS_DEBUG2
-                cFYI(1, ("all perms"));
-#endif
+                cFYI(DBG2, ("all perms"));
                 return;
         }
         if ((flags & GENERIC_WRITE) ||
@@ -231,9 +228,7 @@ static void access_flags_to_mode(__le32 ace_flags, int type, umode_t *pmode,
                         ((flags & FILE_EXEC_RIGHTS) == FILE_EXEC_RIGHTS))
                 *pmode |= (S_IXUGO & (*pbits_to_set));
 
-#ifdef CONFIG_CIFS_DEBUG2
-        cFYI(1, ("access flags 0x%x mode now 0x%x", flags, *pmode));
-#endif
+        cFYI(DBG2, ("access flags 0x%x mode now 0x%x", flags, *pmode));
         return;
 }
 
@@ -262,9 +257,7 @@ static void mode_to_access_flags(umode_t mode, umode_t bits_to_use,
         if (mode & S_IXUGO)
                 *pace_flags |= SET_FILE_EXEC_RIGHTS;
 
-#ifdef CONFIG_CIFS_DEBUG2
-        cFYI(1, ("mode: 0x%x, access flags now 0x%x", mode, *pace_flags));
-#endif
+        cFYI(DBG2, ("mode: 0x%x, access flags now 0x%x", mode, *pace_flags));
         return;
 }
 
@@ -358,11 +351,9 @@ static void parse_dacl(struct cifs_acl *pdacl, char *end_of_acl,
                 return;
         }
 
-#ifdef CONFIG_CIFS_DEBUG2
-        cFYI(1, ("DACL revision %d size %d num aces %d",
+        cFYI(DBG2, ("DACL revision %d size %d num aces %d",
                 le16_to_cpu(pdacl->revision), le16_to_cpu(pdacl->size),
                 le32_to_cpu(pdacl->num_aces)));
-#endif
 
         /* reset rwx permissions for user/group/other.
            Also, if num_aces is 0 i.e. DACL has no ACEs,
@@ -381,10 +372,6 @@ static void parse_dacl(struct cifs_acl *pdacl, char *end_of_acl,
                 ppace = kmalloc(num_aces * sizeof(struct cifs_ace *),
                                 GFP_KERNEL);
 
-/*              cifscred->cecount = pdacl->num_aces;
-                cifscred->aces = kmalloc(num_aces *
-                        sizeof(struct cifs_ace *), GFP_KERNEL);*/
-
                 for (i = 0; i < num_aces; ++i) {
                         ppace[i] = (struct cifs_ace *) (acl_base + acl_size);
 #ifdef CONFIG_CIFS_DEBUG2
@@ -437,7 +424,7 @@ static int set_chmod_dacl(struct cifs_acl *pndacl, struct cifs_sid *pownersid,
                                          &sid_everyone, nmode, S_IRWXO);
 
         pndacl->size = cpu_to_le16(size + sizeof(struct cifs_acl));
-        pndacl->num_aces = 3;
+        pndacl->num_aces = cpu_to_le32(3);
 
         return (0);
 }
@@ -495,13 +482,11 @@ static int parse_sec_desc(struct cifs_ntsd *pntsd, int acl_len,
                                 le32_to_cpu(pntsd->gsidoffset));
         dacloffset = le32_to_cpu(pntsd->dacloffset);
         dacl_ptr = (struct cifs_acl *)((char *)pntsd + dacloffset);
-#ifdef CONFIG_CIFS_DEBUG2
-        cFYI(1, ("revision %d type 0x%x ooffset 0x%x goffset 0x%x "
+        cFYI(DBG2, ("revision %d type 0x%x ooffset 0x%x goffset 0x%x "
                  "sacloffset 0x%x dacloffset 0x%x",
                  pntsd->revision, pntsd->type, le32_to_cpu(pntsd->osidoffset),
                  le32_to_cpu(pntsd->gsidoffset),
                  le32_to_cpu(pntsd->sacloffset), dacloffset));
-#endif
 /*      cifs_dump_mem("owner_sid: ", owner_sid_ptr, 64); */
         rc = parse_sid(owner_sid_ptr, end_of_acl);
         if (rc)
@@ -636,9 +621,7 @@ static int set_cifs_acl(struct cifs_ntsd *pnntsd, __u32 acllen,
         struct super_block *sb;
         struct cifs_sb_info *cifs_sb;
 
-#ifdef CONFIG_CIFS_DEBUG2
-        cFYI(1, ("set ACL for %s from mode 0x%x", path, inode->i_mode));
-#endif
+        cFYI(DBG2, ("set ACL for %s from mode 0x%x", path, inode->i_mode));
 
         if (!inode)
                 return (rc);
@@ -669,9 +652,7 @@ static int set_cifs_acl(struct cifs_ntsd *pnntsd, __u32 acllen,
         }
 
         rc = CIFSSMBSetCIFSACL(xid, cifs_sb->tcon, fid, pnntsd, acllen);
-#ifdef CONFIG_CIFS_DEBUG2
-        cFYI(1, ("SetCIFSACL rc = %d", rc));
-#endif
+        cFYI(DBG2, ("SetCIFSACL rc = %d", rc));
         if (unlock_file == TRUE)
                 atomic_dec(&open_file->wrtPending);
         else
@@ -689,9 +670,7 @@ void acl_to_uid_mode(struct inode *inode, const char *path)
         u32 acllen = 0;
         int rc = 0;
 
-#ifdef CONFIG_CIFS_DEBUG2
-        cFYI(1, ("converting ACL to mode for %s", path));
-#endif
+        cFYI(DBG2, ("converting ACL to mode for %s", path));
         pntsd = get_cifs_acl(&acllen, inode, path);
 
         /* if we can retrieve the ACL, now parse Access Control Entries, ACEs */
@@ -712,9 +691,7 @@ int mode_to_acl(struct inode *inode, const char *path, __u64 nmode)
         struct cifs_ntsd *pntsd = NULL; /* acl obtained from server */
         struct cifs_ntsd *pnntsd = NULL; /* modified acl to be sent to server */
 
-#ifdef CONFIG_CIFS_DEBUG2
-        cFYI(1, ("set ACL from mode for %s", path));
-#endif
+        cFYI(DBG2, ("set ACL from mode for %s", path));
 
         /* Get the security descriptor */
         pntsd = get_cifs_acl(&acllen, inode, path);
@@ -736,16 +713,12 @@ int mode_to_acl(struct inode *inode, const char *path, __u64 nmode)
 
                 rc = build_sec_desc(pntsd, pnntsd, acllen, inode, nmode);
 
-#ifdef CONFIG_CIFS_DEBUG2
-                cFYI(1, ("build_sec_desc rc: %d", rc));
-#endif
+                cFYI(DBG2, ("build_sec_desc rc: %d", rc));
 
                 if (!rc) {
                         /* Set the security descriptor */
                         rc = set_cifs_acl(pnntsd, acllen, inode, path);
-#ifdef CONFIG_CIFS_DEBUG2
-                        cFYI(1, ("set_cifs_acl rc: %d", rc));
-#endif
+                        cFYI(DBG2, ("set_cifs_acl rc: %d", rc));
                 }
 
                 kfree(pnntsd);
diff --git a/fs/cifs/cifsfs.c b/fs/cifs/cifsfs.c
index fcc434227691..a04b17e5a9d0 100644
--- a/fs/cifs/cifsfs.c
+++ b/fs/cifs/cifsfs.c
@@ -204,9 +204,8 @@ cifs_put_super(struct super_block *sb)
                 return;
         }
         rc = cifs_umount(sb, cifs_sb);
-        if (rc) {
+        if (rc)
                 cERROR(1, ("cifs_umount failed with return code %d", rc));
-        }
 #ifdef CONFIG_CIFS_DFS_UPCALL
         if (cifs_sb->mountdata) {
                 kfree(cifs_sb->mountdata);
@@ -461,7 +460,7 @@ int cifs_xstate_get(struct super_block *sb, struct fs_quota_stat *qstats)
 
 static struct quotactl_ops cifs_quotactl_ops = {
         .set_xquota     = cifs_xquota_set,
-        .get_xquota     = cifs_xquota_set,
+        .get_xquota     = cifs_xquota_get,
         .set_xstate     = cifs_xstate_set,
         .get_xstate     = cifs_xstate_get,
 };
@@ -472,9 +471,7 @@ static void cifs_umount_begin(struct vfsmount *vfsmnt, int flags)
         struct cifs_sb_info *cifs_sb;
         struct cifsTconInfo *tcon;
 
-#ifdef CONFIG_CIFS_DFS_UPCALL
         dfs_shrink_umount_helper(vfsmnt);
-#endif /* CONFIG CIFS_DFS_UPCALL */
 
         if (!(flags & MNT_FORCE))
                 return;
@@ -992,9 +989,7 @@ static int __init
 init_cifs(void)
 {
         int rc = 0;
-#ifdef CONFIG_PROC_FS
         cifs_proc_init();
-#endif
 /*      INIT_LIST_HEAD(&GlobalServerList);*/    /* BB not implemented yet */
         INIT_LIST_HEAD(&GlobalSMBSessionList);
         INIT_LIST_HEAD(&GlobalTreeConnectionList);
@@ -1095,19 +1090,15 @@ init_cifs(void)
  out_destroy_inodecache:
         cifs_destroy_inodecache();
  out_clean_proc:
-#ifdef CONFIG_PROC_FS
         cifs_proc_clean();
-#endif
         return rc;
 }
 
 static void __exit
 exit_cifs(void)
 {
-        cFYI(0, ("exit_cifs"));
-#ifdef CONFIG_PROC_FS
+        cFYI(DBG2, ("exit_cifs"));
         cifs_proc_clean();
-#endif
 #ifdef CONFIG_CIFS_DFS_UPCALL
         unregister_key_type(&key_type_dns_resolver);
 #endif
diff --git a/fs/cifs/cifsglob.h b/fs/cifs/cifsglob.h
index 5d32d8ddc82e..69a2e1942542 100644
--- a/fs/cifs/cifsglob.h
+++ b/fs/cifs/cifsglob.h
@@ -454,7 +454,7 @@ struct dir_notify_req {
 
 struct dfs_info3_param {
         int flags; /* DFSREF_REFERRAL_SERVER, DFSREF_STORAGE_SERVER*/
-        int PathConsumed;
+        int path_consumed;
         int server_type;
         int ref_flag;
         char *path_name;
diff --git a/fs/cifs/cifsproto.h b/fs/cifs/cifsproto.h
index 2f09f565a3d9..0af63e6b426b 100644
--- a/fs/cifs/cifsproto.h
+++ b/fs/cifs/cifsproto.h
@@ -53,11 +53,11 @@ extern int SendReceiveNoRsp(const unsigned int xid, struct cifsSesInfo *ses,
 extern int SendReceive2(const unsigned int /* xid */ , struct cifsSesInfo *,
                         struct kvec *, int /* nvec to send */,
                         int * /* type of buf returned */ , const int flags);
-extern int SendReceiveBlockingLock(const unsigned int /* xid */ ,
-                                        struct cifsTconInfo *,
-                                struct smb_hdr * /* input */ ,
-                                struct smb_hdr * /* out */ ,
-                                int * /* bytes returned */);
+extern int SendReceiveBlockingLock(const unsigned int xid,
+                        struct cifsTconInfo *ptcon,
+                        struct smb_hdr *in_buf ,
+                        struct smb_hdr *out_buf,
+                        int *bytes_returned);
 extern int checkSMB(struct smb_hdr *smb, __u16 mid, unsigned int length);
 extern int is_valid_oplock_break(struct smb_hdr *smb, struct TCP_Server_Info *);
 extern int is_size_safe_to_change(struct cifsInodeInfo *, __u64 eof);
@@ -84,7 +84,7 @@ extern __u16 GetNextMid(struct TCP_Server_Info *server);
 extern struct oplock_q_entry *AllocOplockQEntry(struct inode *, u16,
                                                  struct cifsTconInfo *);
 extern void DeleteOplockQEntry(struct oplock_q_entry *);
-extern struct timespec cifs_NTtimeToUnix(u64 /* utc nanoseconds since 1601 */ );
+extern struct timespec cifs_NTtimeToUnix(u64 utc_nanoseconds_since_1601);
 extern u64 cifs_UnixTimeToNT(struct timespec);
 extern __le64 cnvrtDosCifsTm(__u16 date, __u16 time);
 extern struct timespec cnvrtDosUnixTm(__u16 date, __u16 time);
@@ -104,7 +104,11 @@ extern int cifs_mount(struct super_block *, struct cifs_sb_info *, char *,
 extern int cifs_umount(struct super_block *, struct cifs_sb_info *);
 #ifdef CONFIG_CIFS_DFS_UPCALL
 extern void dfs_shrink_umount_helper(struct vfsmount *vfsmnt);
-#endif
+#else
+static inline void dfs_shrink_umount_helper(struct vfsmount *vfsmnt)
+{
+}
+#endif /* DFS_UPCALL */
 void cifs_proc_init(void);
 void cifs_proc_clean(void);
 
@@ -175,11 +179,11 @@ extern int CIFSSMBQFSPosixInfo(const int xid, struct cifsTconInfo *tcon,
                         struct kstatfs *FSData);
 
 extern int CIFSSMBSetTimes(const int xid, struct cifsTconInfo *tcon,
-                        const char *fileName, const FILE_BASIC_INFO * data,
+                        const char *fileName, const FILE_BASIC_INFO *data,
                         const struct nls_table *nls_codepage,
                         int remap_special_chars);
 extern int CIFSSMBSetFileTimes(const int xid, struct cifsTconInfo *tcon,
-                        const FILE_BASIC_INFO * data, __u16 fid);
+                        const FILE_BASIC_INFO *data, __u16 fid);
 #if 0
 extern int CIFSSMBSetAttrLegacy(int xid, struct cifsTconInfo *tcon,
                         char *fileName, __u16 dos_attributes,
diff --git a/fs/cifs/cifssmb.c b/fs/cifs/cifssmb.c
index 9409524e4bf8..30bbe448e260 100644
--- a/fs/cifs/cifssmb.c
+++ b/fs/cifs/cifssmb.c
@@ -1,7 +1,7 @@
 /*
  *   fs/cifs/cifssmb.c
  *
- *   Copyright (C) International Business Machines  Corp., 2002,2007
+ *   Copyright (C) International Business Machines  Corp., 2002,2008
  *   Author(s): Steve French (sfrench@us.ibm.com)
  *
  *   Contains the routines for constructing the SMB PDUs themselves
@@ -102,10 +102,12 @@ static void mark_open_files_invalid(struct cifsTconInfo *pTcon)
            to this tcon */
 }
 
-/* If the return code is zero, this function must fill in request_buf pointer */
+/* Allocate and return pointer to an SMB request buffer, and set basic
+   SMB information in the SMB header.  If the return code is zero, this
+   function must have filled in request_buf pointer */
 static int
 small_smb_init(int smb_command, int wct, struct cifsTconInfo *tcon,
-         void **request_buf /* returned */)
+                void **request_buf)
 {
         int rc = 0;
 
@@ -363,7 +365,7 @@ smb_init(int smb_command, int wct, struct cifsTconInfo *tcon,
                 *response_buf = *request_buf;
 
         header_assemble((struct smb_hdr *) *request_buf, smb_command, tcon,
-                        wct /*wct */ );
+                        wct);
 
         if (tcon != NULL)
                 cifs_stats_inc(&tcon->num_smbs_sent);
@@ -523,7 +525,7 @@ CIFSSMBNegotiate(unsigned int xid, struct cifsSesInfo *ses)
                         if (remain >= (MIN_TZ_ADJ / 2))
                                 result += MIN_TZ_ADJ;
                         if (val < 0)
-                                result = - result;
+                                result = -result;
                         server->timeAdj = result;
                 } else {
                         server->timeAdj = (int)tmp;
@@ -600,7 +602,7 @@ CIFSSMBNegotiate(unsigned int xid, struct cifsSesInfo *ses)
         server->maxBuf = min(le32_to_cpu(pSMBr->MaxBufferSize),
                         (__u32) CIFSMaxBufSize + MAX_CIFS_HDR_SIZE);
         server->maxRw = le32_to_cpu(pSMBr->MaxRawSize);
-        cFYI(0, ("Max buf = %d", ses->server->maxBuf));
+        cFYI(DBG2, ("Max buf = %d", ses->server->maxBuf));
         GETU32(ses->server->sessid) = le32_to_cpu(pSMBr->SessionKey);
         server->capabilities = le32_to_cpu(pSMBr->Capabilities);
         server->timeAdj = (int)(__s16)le16_to_cpu(pSMBr->ServerTimeZone);
@@ -868,9 +870,8 @@ PsxDelete:
         pSMB->ByteCount = cpu_to_le16(byte_count);
         rc = SendReceive(xid, tcon->ses, (struct smb_hdr *) pSMB,
                          (struct smb_hdr *) pSMBr, &bytes_returned, 0);
-        if (rc) {
+        if (rc)
                 cFYI(1, ("Posix delete returned %d", rc));
-        }
         cifs_buf_release(pSMB);
 
         cifs_stats_inc(&tcon->num_deletes);
@@ -916,9 +917,8 @@ DelFileRetry:
         rc = SendReceive(xid, tcon->ses, (struct smb_hdr *) pSMB,
                          (struct smb_hdr *) pSMBr, &bytes_returned, 0);
         cifs_stats_inc(&tcon->num_deletes);
-        if (rc) {
+        if (rc)
                 cFYI(1, ("Error in RMFile = %d", rc));
-        }
 
         cifs_buf_release(pSMB);
         if (rc == -EAGAIN)
@@ -961,9 +961,8 @@ RmDirRetry:
         rc = SendReceive(xid, tcon->ses, (struct smb_hdr *) pSMB,
                          (struct smb_hdr *) pSMBr, &bytes_returned, 0);
         cifs_stats_inc(&tcon->num_rmdirs);
-        if (rc) {
+        if (rc)
                 cFYI(1, ("Error in RMDir = %d", rc));
-        }
 
         cifs_buf_release(pSMB);
         if (rc == -EAGAIN)
@@ -1005,9 +1004,8 @@ MkDirRetry:
         rc = SendReceive(xid, tcon->ses, (struct smb_hdr *) pSMB,
                          (struct smb_hdr *) pSMBr, &bytes_returned, 0);
         cifs_stats_inc(&tcon->num_mkdirs);
-        if (rc) {
+        if (rc)
                 cFYI(1, ("Error in Mkdir = %d", rc));
-        }
 
         cifs_buf_release(pSMB);
         if (rc == -EAGAIN)
@@ -1017,7 +1015,7 @@ MkDirRetry:
 
 int
 CIFSPOSIXCreate(const int xid, struct cifsTconInfo *tcon, __u32 posix_flags,
-                __u64 mode, __u16 * netfid, FILE_UNIX_BASIC_INFO *pRetData,
+                __u64 mode, __u16 *netfid, FILE_UNIX_BASIC_INFO *pRetData,
                 __u32 *pOplock, const char *name,
                 const struct nls_table *nls_codepage, int remap)
 {
@@ -1027,8 +1025,8 @@ CIFSPOSIXCreate(const int xid, struct cifsTconInfo *tcon, __u32 posix_flags,
         int rc = 0;
         int bytes_returned = 0;
         __u16 params, param_offset, offset, byte_count, count;
-        OPEN_PSX_REQ * pdata;
-        OPEN_PSX_RSP * psx_rsp;
+        OPEN_PSX_REQ *pdata;
+        OPEN_PSX_RSP *psx_rsp;
 
         cFYI(1, ("In POSIX Create"));
 PsxCreat:
@@ -1110,9 +1108,7 @@ PsxCreat:
         /* check to make sure response data is there */
         if (psx_rsp->ReturnedLevel != cpu_to_le16(SMB_QUERY_FILE_UNIX_BASIC)) {
                 pRetData->Type = cpu_to_le32(-1); /* unknown */
-#ifdef CONFIG_CIFS_DEBUG2
-                cFYI(1, ("unknown type"));
-#endif
+                cFYI(DBG2, ("unknown type"));
         } else {
                 if (pSMBr->ByteCount < sizeof(OPEN_PSX_RSP)
                                         + sizeof(FILE_UNIX_BASIC_INFO)) {
@@ -1169,8 +1165,8 @@ static __u16 convert_disposition(int disposition)
 int
 SMBLegacyOpen(const int xid, struct cifsTconInfo *tcon,
             const char *fileName, const int openDisposition,
-            const int access_flags, const int create_options, __u16 * netfid,
-            int *pOplock, FILE_ALL_INFO * pfile_info,
+            const int access_flags, const int create_options, __u16 *netfid,
+            int *pOplock, FILE_ALL_INFO *pfile_info,
             const struct nls_table *nls_codepage, int remap)
 {
         int rc = -EACCES;
@@ -1221,8 +1217,8 @@ OldOpenRetry:
 
         if (create_options & CREATE_OPTION_SPECIAL)
                 pSMB->FileAttributes = cpu_to_le16(ATTR_SYSTEM);
-        else
-                pSMB->FileAttributes = cpu_to_le16(0/*ATTR_NORMAL*/); /* BB FIXME */
+        else /* BB FIXME BB */
+                pSMB->FileAttributes = cpu_to_le16(0/*ATTR_NORMAL*/);
 
         /* if ((omode & S_IWUGO) == 0)
                 pSMB->FileAttributes |= cpu_to_le32(ATTR_READONLY);*/
@@ -1284,8 +1280,8 @@ OldOpenRetry:
 int
 CIFSSMBOpen(const int xid, struct cifsTconInfo *tcon,
             const char *fileName, const int openDisposition,
-            const int access_flags, const int create_options, __u16 * netfid,
-            int *pOplock, FILE_ALL_INFO * pfile_info,
+            const int access_flags, const int create_options, __u16 *netfid,
+            int *pOplock, FILE_ALL_INFO *pfile_info,
             const struct nls_table *nls_codepage, int remap)
 {
         int rc = -EACCES;
@@ -1556,9 +1552,9 @@ CIFSSMBWrite(const int xid, struct cifsTconInfo *tcon,
         } /* else setting file size with write of zero bytes */
         if (wct == 14)
                 byte_count = bytes_sent + 1; /* pad */
-        else /* wct == 12 */ {
+        else /* wct == 12 */
                 byte_count = bytes_sent + 5; /* bigger pad, smaller smb hdr */
-        }
+
         pSMB->DataLengthLow = cpu_to_le16(bytes_sent & 0xFFFF);
         pSMB->DataLengthHigh = cpu_to_le16(bytes_sent >> 16);
         pSMB->hdr.smb_buf_length += byte_count;
@@ -1663,7 +1659,7 @@ CIFSSMBWrite2(const int xid, struct cifsTconInfo *tcon,
                 rc = -EIO;
                 *nbytes = 0;
         } else {
-                WRITE_RSP * pSMBr = (WRITE_RSP *)iov[0].iov_base;
+                WRITE_RSP *pSMBr = (WRITE_RSP *)iov[0].iov_base;
                 *nbytes = le16_to_cpu(pSMBr->CountHigh);
                 *nbytes = (*nbytes) << 16;
                 *nbytes += le16_to_cpu(pSMBr->Count);
@@ -1744,9 +1740,8 @@ CIFSSMBLock(const int xid, struct cifsTconInfo *tcon,
                 /* SMB buffer freed by function above */
         }
         cifs_stats_inc(&tcon->num_locks);
-        if (rc) {
+        if (rc)
                 cFYI(1, ("Send error in Lock = %d", rc));
-        }
 
         /* Note: On -EAGAIN error only caller can retry on handle based calls
         since file handle passed in no longer valid */
@@ -1791,7 +1786,7 @@ CIFSSMBPosixLock(const int xid, struct cifsTconInfo *tcon,
 
         count = sizeof(struct cifs_posix_lock);
         pSMB->MaxParameterCount = cpu_to_le16(2);
-        pSMB->MaxDataCount = cpu_to_le16(1000); /* BB find max SMB PDU from sess */
+        pSMB->MaxDataCount = cpu_to_le16(1000); /* BB find max SMB from sess */
         pSMB->SetupCount = 1;
         pSMB->Reserved3 = 0;
         if (get_flag)
@@ -1972,9 +1967,8 @@ renameRetry:
         rc = SendReceive(xid, tcon->ses, (struct smb_hdr *) pSMB,
                          (struct smb_hdr *) pSMBr, &bytes_returned, 0);
         cifs_stats_inc(&tcon->num_renames);
-        if (rc) {
+        if (rc)
                 cFYI(1, ("Send error in rename = %d", rc));
-        }
 
         cifs_buf_release(pSMB);
 
@@ -2016,7 +2010,7 @@ int CIFSSMBRenameOpenFile(const int xid, struct cifsTconInfo *pTcon,
         data_offset = (char *) (&pSMB->hdr.Protocol) + offset;
         rename_info = (struct set_file_rename *) data_offset;
         pSMB->MaxParameterCount = cpu_to_le16(2);
-        pSMB->MaxDataCount = cpu_to_le16(1000); /* BB find max SMB PDU from sess */
+        pSMB->MaxDataCount = cpu_to_le16(1000); /* BB find max SMB from sess */
         pSMB->SetupCount = 1;
         pSMB->Reserved3 = 0;
         pSMB->SubCommand = cpu_to_le16(TRANS2_SET_FILE_INFORMATION);
@@ -2052,9 +2046,8 @@ int CIFSSMBRenameOpenFile(const int xid, struct cifsTconInfo *pTcon,
         rc = SendReceive(xid, pTcon->ses, (struct smb_hdr *) pSMB,
                          (struct smb_hdr *) pSMBr, &bytes_returned, 0);
         cifs_stats_inc(&pTcon->num_t2renames);
-        if (rc) {
+        if (rc)
                 cFYI(1, ("Send error in Rename (by file handle) = %d", rc));
-        }
 
         cifs_buf_release(pSMB);
 
@@ -2211,9 +2204,8 @@ createSymLinkRetry:
         rc = SendReceive(xid, tcon->ses, (struct smb_hdr *) pSMB,
                          (struct smb_hdr *) pSMBr, &bytes_returned, 0);
         cifs_stats_inc(&tcon->num_symlinks);
-        if (rc) {
+        if (rc)
                 cFYI(1, ("Send error in SetPathInfo create symlink = %d", rc));
-        }
 
         if (pSMB)
                 cifs_buf_release(pSMB);
@@ -2299,9 +2291,8 @@ createHardLinkRetry:
         rc = SendReceive(xid, tcon->ses, (struct smb_hdr *) pSMB,
                          (struct smb_hdr *) pSMBr, &bytes_returned, 0);
         cifs_stats_inc(&tcon->num_hardlinks);
-        if (rc) {
+        if (rc)
                 cFYI(1, ("Send error in SetPathInfo (hard link) = %d", rc));
-        }
 
         cifs_buf_release(pSMB);
         if (rc == -EAGAIN)
@@ -2370,9 +2361,9 @@ winCreateHardLinkRetry:
         rc = SendReceive(xid, tcon->ses, (struct smb_hdr *) pSMB,
                          (struct smb_hdr *) pSMBr, &bytes_returned, 0);
         cifs_stats_inc(&tcon->num_hardlinks);
-        if (rc) {
+        if (rc)
                 cFYI(1, ("Send error in hard link (NT rename) = %d", rc));
-        }
+
         cifs_buf_release(pSMB);
         if (rc == -EAGAIN)
                 goto winCreateHardLinkRetry;
@@ -2968,9 +2959,8 @@ setAclRetry:
         pSMB->ByteCount = cpu_to_le16(byte_count);
         rc = SendReceive(xid, tcon->ses, (struct smb_hdr *) pSMB,
                          (struct smb_hdr *) pSMBr, &bytes_returned, 0);
-        if (rc) {
+        if (rc)
                 cFYI(1, ("Set POSIX ACL returned %d", rc));
-        }
 
 setACLerrorExit:
         cifs_buf_release(pSMB);
@@ -2982,7 +2972,7 @@ setACLerrorExit:
 /* BB fix tabs in this function FIXME BB */
 int
 CIFSGetExtAttr(const int xid, struct cifsTconInfo *tcon,
-               const int netfid, __u64 * pExtAttrBits, __u64 *pMask)
+               const int netfid, __u64 *pExtAttrBits, __u64 *pMask)
 {
         int rc = 0;
         struct smb_t2_qfi_req *pSMB = NULL;
@@ -3000,7 +2990,7 @@ GetExtAttrRetry:
         if (rc)
                 return rc;
 
-        params = 2 /* level */ +2 /* fid */;
+        params = 2 /* level */ + 2 /* fid */;
         pSMB->t2.TotalDataCount = 0;
         pSMB->t2.MaxParameterCount = cpu_to_le16(4);
         /* BB find exact max data count below from sess structure BB */
@@ -3071,7 +3061,7 @@ CIFSSMBGetCIFSACL(const int xid, struct cifsTconInfo *tcon, __u16 fid,
 {
         int rc = 0;
         int buf_type = 0;
-        QUERY_SEC_DESC_REQ * pSMB;
+        QUERY_SEC_DESC_REQ *pSMB;
         struct kvec iov[1];
 
         cFYI(1, ("GetCifsACL"));
@@ -3101,7 +3091,7 @@ CIFSSMBGetCIFSACL(const int xid, struct cifsTconInfo *tcon, __u16 fid,
         if (rc) {
                 cFYI(1, ("Send error in QuerySecDesc = %d", rc));
         } else {                /* decode response */
-                __le32 * parm;
+                __le32 *parm;
                 __u32 parm_len;
                 __u32 acl_len;
                 struct smb_com_ntransact_rsp *pSMBr;
@@ -3230,8 +3220,8 @@ int SMBQueryInformation(const int xid, struct cifsTconInfo *tcon,
                         FILE_ALL_INFO *pFinfo,
                         const struct nls_table *nls_codepage, int remap)
 {
-        QUERY_INFORMATION_REQ * pSMB;
-        QUERY_INFORMATION_RSP * pSMBr;
+        QUERY_INFORMATION_REQ *pSMB;
+        QUERY_INFORMATION_RSP *pSMBr;
         int rc = 0;
         int bytes_returned;
         int name_len;
@@ -3263,9 +3253,11 @@ QInfRetry:
                          (struct smb_hdr *) pSMBr, &bytes_returned, 0);
         if (rc) {
                 cFYI(1, ("Send error in QueryInfo = %d", rc));
-        } else if (pFinfo) {            /* decode response */
+        } else if (pFinfo) {
                 struct timespec ts;
                 __u32 time = le32_to_cpu(pSMBr->last_write_time);
+
+                /* decode response */
                 /* BB FIXME - add time zone adjustment BB */
                 memset(pFinfo, 0, sizeof(FILE_ALL_INFO));
                 ts.tv_nsec = 0;
@@ -3296,7 +3288,7 @@ QInfRetry:
 int
 CIFSSMBQPathInfo(const int xid, struct cifsTconInfo *tcon,
                  const unsigned char *searchName,
-                 FILE_ALL_INFO * pFindData,
+                 FILE_ALL_INFO *pFindData,
                  int legacy /* old style infolevel */,
                  const struct nls_table *nls_codepage, int remap)
 {
@@ -3371,10 +3363,12 @@ QPathInfoRetry:
                 else if (pFindData) {
                         int size;
                         __u16 data_offset = le16_to_cpu(pSMBr->t2.DataOffset);
-                        if (legacy) /* we do not read the last field, EAsize,
-                                       fortunately since it varies by subdialect
-                                       and on Set vs. Get, is two bytes or 4
-                                       bytes depending but we don't care here */
+
+                        /* On legacy responses we do not read the last field,
+                        EAsize, fortunately since it varies by subdialect and
+                        also note it differs on Set vs. Get, ie two bytes or 4
+                        bytes depending but we don't care here */
+                        if (legacy)
                                 size = sizeof(FILE_INFO_STANDARD);
                         else
                                 size = sizeof(FILE_ALL_INFO);
@@ -3476,85 +3470,6 @@ UnixQPathInfoRetry:
         return rc;
 }
 
-#if 0  /* function unused at present */
-int CIFSFindSingle(const int xid, struct cifsTconInfo *tcon,
-               const char *searchName, FILE_ALL_INFO * findData,
-               const struct nls_table *nls_codepage)
-{
-/* level 257 SMB_ */
-        TRANSACTION2_FFIRST_REQ *pSMB = NULL;
-        TRANSACTION2_FFIRST_RSP *pSMBr = NULL;
-        int rc = 0;
-        int bytes_returned;
-        int name_len;
-        __u16 params, byte_count;
-
-        cFYI(1, ("In FindUnique"));
-findUniqueRetry:
-        rc = smb_init(SMB_COM_TRANSACTION2, 15, tcon, (void **) &pSMB,
-                      (void **) &pSMBr);
-        if (rc)
-                return rc;
-
-        if (pSMB->hdr.Flags2 & SMBFLG2_UNICODE) {
-                name_len =
-                    cifsConvertToUCS((__le16 *) pSMB->FileName, searchName,
-                                     PATH_MAX, nls_codepage);
-                name_len++;     /* trailing null */
-                name_len *= 2;
-        } else {        /* BB improve the check for buffer overruns BB */
-                name_len = strnlen(searchName, PATH_MAX);
-                name_len++;     /* trailing null */
-                strncpy(pSMB->FileName, searchName, name_len);
-        }
-
-        params = 12 + name_len /* includes null */ ;
-        pSMB->TotalDataCount = 0;       /* no EAs */
-        pSMB->MaxParameterCount = cpu_to_le16(2);
-        pSMB->MaxDataCount = cpu_to_le16(4000); /* BB find exact max SMB PDU from sess structure BB */
-        pSMB->MaxSetupCount = 0;
-        pSMB->Reserved = 0;
-        pSMB->Flags = 0;
-        pSMB->Timeout = 0;
-        pSMB->Reserved2 = 0;
-        pSMB->ParameterOffset = cpu_to_le16(
-         offsetof(struct smb_com_transaction2_ffirst_req, InformationLevel)-4);
-        pSMB->DataCount = 0;
-        pSMB->DataOffset = 0;
-        pSMB->SetupCount = 1;   /* one byte, no need to le convert */
-        pSMB->Reserved3 = 0;
-        pSMB->SubCommand = cpu_to_le16(TRANS2_FIND_FIRST);
-        byte_count = params + 1 /* pad */ ;
-        pSMB->TotalParameterCount = cpu_to_le16(params);
-        pSMB->ParameterCount = pSMB->TotalParameterCount;
-        pSMB->SearchAttributes =
-            cpu_to_le16(ATTR_READONLY | ATTR_HIDDEN | ATTR_SYSTEM |
-                        ATTR_DIRECTORY);
-        pSMB->SearchCount = cpu_to_le16(16);    /* BB increase */
-        pSMB->SearchFlags = cpu_to_le16(1);
-        pSMB->InformationLevel = cpu_to_le16(SMB_FIND_FILE_DIRECTORY_INFO);
-        pSMB->SearchStorageType = 0;    /* BB what should we set this to? BB */
-        pSMB->hdr.smb_buf_length += byte_count;
-        pSMB->ByteCount = cpu_to_le16(byte_count);
-
-        rc = SendReceive(xid, tcon->ses, (struct smb_hdr *) pSMB,
-                         (struct smb_hdr *) pSMBr, &bytes_returned, 0);
-
-        if (rc) {
-                cFYI(1, ("Send error in FindFileDirInfo = %d", rc));
-        } else {                /* decode response */
-                cifs_stats_inc(&tcon->num_ffirst);
-                /* BB fill in */
-        }
-
-        cifs_buf_release(pSMB);
-        if (rc == -EAGAIN)
-                goto findUniqueRetry;
-
-        return rc;
-}
-#endif /* end unused (temporarily) function */
-
 /* xid, tcon, searchName and codepage are input parms, rest are returned */
 int
 CIFSFindFirst(const int xid, struct cifsTconInfo *tcon,
@@ -3566,7 +3481,7 @@ CIFSFindFirst(const int xid, struct cifsTconInfo *tcon,
 /* level 257 SMB_ */
         TRANSACTION2_FFIRST_REQ *pSMB = NULL;
         TRANSACTION2_FFIRST_RSP *pSMBr = NULL;
-        T2_FFIRST_RSP_PARMS * parms;
+        T2_FFIRST_RSP_PARMS *parms;
         int rc = 0;
         int bytes_returned = 0;
         int name_len;
@@ -3697,7 +3612,7 @@ int CIFSFindNext(const int xid, struct cifsTconInfo *tcon,
 {
         TRANSACTION2_FNEXT_REQ *pSMB = NULL;
         TRANSACTION2_FNEXT_RSP *pSMBr = NULL;
-        T2_FNEXT_RSP_PARMS * parms;
+        T2_FNEXT_RSP_PARMS *parms;
         char *response_data;
         int rc = 0;
         int bytes_returned, name_len;
@@ -3836,9 +3751,9 @@ CIFSFindClose(const int xid, struct cifsTconInfo *tcon,
         pSMB->FileID = searchHandle;
         pSMB->ByteCount = 0;
         rc = SendReceiveNoRsp(xid, tcon->ses, (struct smb_hdr *) pSMB, 0);
-        if (rc) {
+        if (rc)
                 cERROR(1, ("Send error in FindClose = %d", rc));
-        }
+
         cifs_stats_inc(&tcon->num_fclose);
 
         /* Since session is dead, search handle closed on server already */
@@ -3851,7 +3766,7 @@ CIFSFindClose(const int xid, struct cifsTconInfo *tcon,
 int
 CIFSGetSrvInodeNumber(const int xid, struct cifsTconInfo *tcon,
                       const unsigned char *searchName,
-                      __u64 * inode_number,
+                      __u64 *inode_number,
                       const struct nls_table *nls_codepage, int remap)
 {
         int rc = 0;
@@ -4560,9 +4475,8 @@ SETFSUnixRetry:
                 cERROR(1, ("Send error in SETFSUnixInfo = %d", rc));
         } else {                /* decode response */
                 rc = validate_t2((struct smb_t2_rsp *)pSMBr);
-                if (rc) {
+                if (rc)
                         rc = -EIO;      /* bad smb */
-                }
         }
         cifs_buf_release(pSMB);
 
@@ -4744,9 +4658,8 @@ SetEOFRetry:
         pSMB->ByteCount = cpu_to_le16(byte_count);
         rc = SendReceive(xid, tcon->ses, (struct smb_hdr *) pSMB,
                          (struct smb_hdr *) pSMBr, &bytes_returned, 0);
-        if (rc) {
+        if (rc)
                 cFYI(1, ("SetPathInfo (file size) returned %d", rc));
-        }
 
         cifs_buf_release(pSMB);
 
@@ -4897,9 +4810,8 @@ CIFSSMBSetFileTimes(const int xid, struct cifsTconInfo *tcon,
         pSMB->ByteCount = cpu_to_le16(byte_count);
         memcpy(data_offset, data, sizeof(FILE_BASIC_INFO));
         rc = SendReceiveNoRsp(xid, tcon->ses, (struct smb_hdr *) pSMB, 0);
-        if (rc) {
+        if (rc)
                 cFYI(1, ("Send error in Set Time (SetFileInfo) = %d", rc));
-        }
 
         /* Note: On -EAGAIN error only caller can retry on handle based calls
                 since file handle passed in no longer valid */
@@ -4975,9 +4887,8 @@ SetTimesRetry:
         pSMB->ByteCount = cpu_to_le16(byte_count);
         rc = SendReceive(xid, tcon->ses, (struct smb_hdr *) pSMB,
                          (struct smb_hdr *) pSMBr, &bytes_returned, 0);
-        if (rc) {
+        if (rc)
                 cFYI(1, ("SetPathInfo (times) returned %d", rc));
-        }
 
         cifs_buf_release(pSMB);
 
@@ -5027,9 +4938,8 @@ SetAttrLgcyRetry:
         pSMB->ByteCount = cpu_to_le16(name_len + 1);
         rc = SendReceive(xid, tcon->ses, (struct smb_hdr *) pSMB,
                          (struct smb_hdr *) pSMBr, &bytes_returned, 0);
-        if (rc) {
+        if (rc)
                 cFYI(1, ("Error in LegacySetAttr = %d", rc));
-        }
 
         cifs_buf_release(pSMB);
 
@@ -5138,9 +5048,8 @@ setPermsRetry:
         pSMB->ByteCount = cpu_to_le16(byte_count);
         rc = SendReceive(xid, tcon->ses, (struct smb_hdr *) pSMB,
                          (struct smb_hdr *) pSMBr, &bytes_returned, 0);
-        if (rc) {
+        if (rc)
                 cFYI(1, ("SetPathInfo (perms) returned %d", rc));
-        }
 
         if (pSMB)
                 cifs_buf_release(pSMB);
@@ -5615,9 +5524,8 @@ SetEARetry:
         pSMB->ByteCount = cpu_to_le16(byte_count);
         rc = SendReceive(xid, tcon->ses, (struct smb_hdr *) pSMB,
                          (struct smb_hdr *) pSMBr, &bytes_returned, 0);
-        if (rc) {
+        if (rc)
                 cFYI(1, ("SetPathInfo (EA) returned %d", rc));
-        }
 
         cifs_buf_release(pSMB);
 
diff --git a/fs/cifs/connect.c b/fs/cifs/connect.c
index 65d0ba72e78f..8dbfa97cd18c 100644
--- a/fs/cifs/connect.c
+++ b/fs/cifs/connect.c
@@ -1722,8 +1722,15 @@ void reset_cifs_unix_caps(int xid, struct cifsTconInfo *tcon,
                            originally at mount time */
                         if ((saved_cap & CIFS_UNIX_POSIX_ACL_CAP) == 0)
                                 cap &= ~CIFS_UNIX_POSIX_ACL_CAP;
-                        if ((saved_cap & CIFS_UNIX_POSIX_PATHNAMES_CAP) == 0)
+                        if ((saved_cap & CIFS_UNIX_POSIX_PATHNAMES_CAP) == 0) {
+                                if (cap & CIFS_UNIX_POSIX_PATHNAMES_CAP)
+                                        cERROR(1, ("POSIXPATH support change"));
                                 cap &= ~CIFS_UNIX_POSIX_PATHNAMES_CAP;
+                        } else if ((cap & CIFS_UNIX_POSIX_PATHNAMES_CAP) == 0) {
+                                cERROR(1, ("possible reconnect error"));
+                                cERROR(1,
+                                        ("server disabled POSIX path support"));
+                        }
                 }
 
                 cap &= CIFS_UNIX_CAP_MASK;
@@ -1753,9 +1760,8 @@ void reset_cifs_unix_caps(int xid, struct cifsTconInfo *tcon,
                 if (sb && (CIFS_SB(sb)->rsize > 127 * 1024)) {
                         if ((cap & CIFS_UNIX_LARGE_READ_CAP) == 0) {
                                 CIFS_SB(sb)->rsize = 127 * 1024;
-#ifdef CONFIG_CIFS_DEBUG2
-                                cFYI(1, ("larger reads not supported by srv"));
-#endif
+                                cFYI(DBG2,
+                                        ("larger reads not supported by srv"));
                         }
                 }
 
@@ -1792,6 +1798,26 @@ void reset_cifs_unix_caps(int xid, struct cifsTconInfo *tcon,
         }
 }
 
+static void
+convert_delimiter(char *path, char delim)
+{
+        int i;
+        char old_delim;
+
+        if (path == NULL)
+                return;
+
+        if (delim == '/') 
+                old_delim = '\\';
+        else
+                old_delim = '/';
+
+        for (i = 0; path[i] != '\0'; i++) {
+                if (path[i] == old_delim)
+                        path[i] = delim;
+        }
+}
+
 int
 cifs_mount(struct super_block *sb, struct cifs_sb_info *cifs_sb,
            char *mount_data, const char *devname)
@@ -2057,7 +2083,11 @@ cifs_mount(struct super_block *sb, struct cifs_sb_info *cifs_sb,
                 cifs_sb->prepath = volume_info.prepath;
                 if (cifs_sb->prepath) {
                         cifs_sb->prepathlen = strlen(cifs_sb->prepath);
-                        cifs_sb->prepath[0] = CIFS_DIR_SEP(cifs_sb);
+                        /* we can not convert the / to \ in the path
+                        separators in the prefixpath yet because we do not
+                        know (until reset_cifs_unix_caps is called later)
+                        whether POSIX PATH CAP is available. We normalize
+                        the / to \ after reset_cifs_unix_caps is called */
                         volume_info.prepath = NULL;
                 } else
                         cifs_sb->prepathlen = 0;
@@ -2225,11 +2255,15 @@ cifs_mount(struct super_block *sb, struct cifs_sb_info *cifs_sb,
                 else
                         tcon->unix_ext = 0; /* server does not support them */
 
+                /* convert forward to back slashes in prepath here if needed */
+                if ((cifs_sb->mnt_cifs_flags & CIFS_MOUNT_POSIX_PATHS) == 0)
+                        convert_delimiter(cifs_sb->prepath,
+                                          CIFS_DIR_SEP(cifs_sb));
+
                 if ((tcon->unix_ext == 0) && (cifs_sb->rsize > (1024 * 127))) {
                         cifs_sb->rsize = 1024 * 127;
-#ifdef CONFIG_CIFS_DEBUG2
-                        cFYI(1, ("no very large read support, rsize now 127K"));
-#endif
+                        cFYI(DBG2,
+                                ("no very large read support, rsize now 127K"));
                 }
                 if (!(tcon->ses->capabilities & CAP_LARGE_WRITE_X))
                         cifs_sb->wsize = min(cifs_sb->wsize,
diff --git a/fs/cifs/dir.c b/fs/cifs/dir.c
index 699ec1198409..4e83b47c4b34 100644
--- a/fs/cifs/dir.c
+++ b/fs/cifs/dir.c
@@ -3,7 +3,7 @@
  *
  *   vfs operations that deal with dentries
  *
- *   Copyright (C) International Business Machines  Corp., 2002,2007
+ *   Copyright (C) International Business Machines  Corp., 2002,2008
  *   Author(s): Steve French (sfrench@us.ibm.com)
  *
  *   This library is free software; you can redistribute it and/or modify
@@ -111,16 +111,6 @@ cifs_bp_rename_retry:
         return full_path;
 }
 
-/* char * build_wildcard_path_from_dentry(struct dentry *direntry)
-{
-        if(full_path == NULL)
-                return full_path;
-
-        full_path[namelen] = '\\';
-        full_path[namelen+1] = '*';
-        full_path[namelen+2] = 0;
-BB remove above eight lines BB */
-
 /* Inode operations in similar order to how they appear in Linux file fs.h */
 
 int
@@ -171,9 +161,8 @@ cifs_create(struct inode *inode, struct dentry *direntry, int mode,
                         disposition = FILE_OVERWRITE_IF;
                 else if ((oflags & O_CREAT) == O_CREAT)
                         disposition = FILE_OPEN_IF;
-                else {
+                else
                         cFYI(1, ("Create flag not set in create function"));
-                }
         }
 
         /* BB add processing to set equivalent of mode - e.g. via CreateX with
@@ -367,7 +356,7 @@ int cifs_mknod(struct inode *inode, struct dentry *direntry, int mode,
                 if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_UNX_EMUL) {
                         int oplock = 0;
                         u16 fileHandle;
-                        FILE_ALL_INFO * buf;
+                        FILE_ALL_INFO *buf;
 
                         cFYI(1, ("sfu compat create special file"));
 
@@ -534,9 +523,8 @@ cifs_d_revalidate(struct dentry *direntry, struct nameidata *nd)
         int isValid = 1;
 
         if (direntry->d_inode) {
-                if (cifs_revalidate(direntry)) {
+                if (cifs_revalidate(direntry))
                         return 0;
-                }
         } else {
                 cFYI(1, ("neg dentry 0x%p name = %s",
                          direntry, direntry->d_name.name));
diff --git a/fs/cifs/dns_resolve.h b/fs/cifs/dns_resolve.h
index 073fdc3db419..966e9288930b 100644
--- a/fs/cifs/dns_resolve.h
+++ b/fs/cifs/dns_resolve.h
@@ -1,7 +1,7 @@
 /*
  *   fs/cifs/dns_resolve.h -- DNS Resolver upcall management for CIFS DFS
  *                            Handles host name to IP address resolution
- * 
+ *
  *   Copyright (c) International Business Machines  Corp., 2008
  *   Author(s): Steve French (sfrench@us.ibm.com)
  *
diff --git a/fs/cifs/fcntl.c b/fs/cifs/fcntl.c
index 995474c90885..7d1d5aa4c430 100644
--- a/fs/cifs/fcntl.c
+++ b/fs/cifs/fcntl.c
@@ -35,9 +35,8 @@ static __u32 convert_to_cifs_notify_flags(unsigned long fcntl_notify_flags)
 
         /* No way on Linux VFS to ask to monitor xattr
         changes (and no stream support either */
-        if (fcntl_notify_flags & DN_ACCESS) {
+        if (fcntl_notify_flags & DN_ACCESS)
                 cifs_ntfy_flags |= FILE_NOTIFY_CHANGE_LAST_ACCESS;
-        }
         if (fcntl_notify_flags & DN_MODIFY) {
                 /* What does this mean on directories? */
                 cifs_ntfy_flags |= FILE_NOTIFY_CHANGE_LAST_WRITE |
@@ -47,9 +46,8 @@ static __u32 convert_to_cifs_notify_flags(unsigned long fcntl_notify_flags)
                 cifs_ntfy_flags |= FILE_NOTIFY_CHANGE_CREATION |
                         FILE_NOTIFY_CHANGE_LAST_WRITE;
         }
-        if (fcntl_notify_flags & DN_DELETE) {
+        if (fcntl_notify_flags & DN_DELETE)
                 cifs_ntfy_flags |= FILE_NOTIFY_CHANGE_LAST_WRITE;
-        }
         if (fcntl_notify_flags & DN_RENAME) {
                 /* BB review this - checking various server behaviors */
                 cifs_ntfy_flags |= FILE_NOTIFY_CHANGE_DIR_NAME |
diff --git a/fs/cifs/file.c b/fs/cifs/file.c
index 5f7c374ae89c..fa849c91d323 100644
--- a/fs/cifs/file.c
+++ b/fs/cifs/file.c
@@ -353,9 +353,9 @@ static int cifs_reopen_file(struct file *file, int can_flush)
         int disposition = FILE_OPEN;
         __u16 netfid;
 
-        if (file->private_data) {
+        if (file->private_data)
                 pCifsFile = (struct cifsFileInfo *)file->private_data;
-        } else
+        else
                 return -EBADF;
 
         xid = GetXid();
@@ -499,9 +499,8 @@ int cifs_close(struct inode *inode, struct file *file)
                                         the struct would be in each open file,
                                         but this should give enough time to
                                         clear the socket */
-#ifdef CONFIG_CIFS_DEBUG2
-                                        cFYI(1, ("close delay, write pending"));
-#endif /* DEBUG2 */
+                                        cFYI(DBG2,
+                                                ("close delay, write pending"));
                                         msleep(timeout);
                                         timeout *= 4;
                                 }
@@ -1423,9 +1422,8 @@ static int cifs_writepage(struct page *page, struct writeback_control *wbc)
         xid = GetXid();
 /* BB add check for wbc flags */
         page_cache_get(page);
-        if (!PageUptodate(page)) {
+        if (!PageUptodate(page))
                 cFYI(1, ("ppw - page not up to date"));
-        }
 
         /*
          * Set the "writeback" flag, and clear "dirty" in the radix tree.
@@ -1460,9 +1458,9 @@ static int cifs_commit_write(struct file *file, struct page *page,
         cFYI(1, ("commit write for page %p up to position %lld for %d",
                  page, position, to));
         spin_lock(&inode->i_lock);
-        if (position > inode->i_size) {
+        if (position > inode->i_size)
                 i_size_write(inode, position);
-        }
+
         spin_unlock(&inode->i_lock);
         if (!PageUptodate(page)) {
                 position =  ((loff_t)page->index << PAGE_CACHE_SHIFT) + offset;
@@ -1596,9 +1594,9 @@ ssize_t cifs_user_read(struct file *file, char __user *read_data,
         }
         open_file = (struct cifsFileInfo *)file->private_data;
 
-        if ((file->f_flags & O_ACCMODE) == O_WRONLY) {
+        if ((file->f_flags & O_ACCMODE) == O_WRONLY)
                 cFYI(1, ("attempting read on write only file instance"));
-        }
+
         for (total_read = 0, current_offset = read_data;
              read_size > total_read;
              total_read += bytes_read, current_offset += bytes_read) {
@@ -1625,9 +1623,8 @@ ssize_t cifs_user_read(struct file *file, char __user *read_data,
                                                 smb_read_data +
                                                 4 /* RFC1001 length field */ +
                                                 le16_to_cpu(pSMBr->DataOffset),
-                                                bytes_read)) {
+                                                bytes_read))
                                         rc = -EFAULT;
-                                }
 
                                 if (buf_type == CIFS_SMALL_BUFFER)
                                         cifs_small_buf_release(smb_read_data);
@@ -1814,9 +1811,7 @@ static int cifs_readpages(struct file *file, struct address_space *mapping,
         pTcon = cifs_sb->tcon;
 
         pagevec_init(&lru_pvec, 0);
-#ifdef CONFIG_CIFS_DEBUG2
-                cFYI(1, ("rpages: num pages %d", num_pages));
-#endif
+                cFYI(DBG2, ("rpages: num pages %d", num_pages));
         for (i = 0; i < num_pages; ) {
                 unsigned contig_pages;
                 struct page *tmp_page;
@@ -1849,10 +1844,8 @@ static int cifs_readpages(struct file *file, struct address_space *mapping,
                 /* Read size needs to be in multiples of one page */
                 read_size = min_t(const unsigned int, read_size,
                                   cifs_sb->rsize & PAGE_CACHE_MASK);
-#ifdef CONFIG_CIFS_DEBUG2
-                cFYI(1, ("rpages: read size 0x%x  contiguous pages %d",
+                cFYI(DBG2, ("rpages: read size 0x%x  contiguous pages %d",
                                 read_size, contig_pages));
-#endif
                 rc = -EAGAIN;
                 while (rc == -EAGAIN) {
                         if ((open_file->invalidHandle) &&
@@ -2026,7 +2019,7 @@ int is_size_safe_to_change(struct cifsInodeInfo *cifsInode, __u64 end_of_file)
                 struct cifs_sb_info *cifs_sb;
 
                 cifs_sb = CIFS_SB(cifsInode->vfs_inode.i_sb);
-                if ( cifs_sb->mnt_cifs_flags & CIFS_MOUNT_DIRECT_IO ) {
+                if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_DIRECT_IO) {
                         /* since no page cache to corrupt on directio
                         we can change size safely */
                         return 1;
diff --git a/fs/cifs/inode.c b/fs/cifs/inode.c
index b1a4a65eaa08..24eb4d392155 100644
--- a/fs/cifs/inode.c
+++ b/fs/cifs/inode.c
@@ -29,6 +29,130 @@
 #include "cifs_debug.h"
 #include "cifs_fs_sb.h"
 
+
+static void cifs_set_ops(struct inode *inode)
+{
+        struct cifs_sb_info *cifs_sb = CIFS_SB(inode->i_sb);
+
+        switch (inode->i_mode & S_IFMT) {
+        case S_IFREG:
+                inode->i_op = &cifs_file_inode_ops;
+                if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_DIRECT_IO) {
+                        if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_NO_BRL)
+                                inode->i_fop = &cifs_file_direct_nobrl_ops;
+                        else
+                                inode->i_fop = &cifs_file_direct_ops;
+                } else if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_NO_BRL)
+                        inode->i_fop = &cifs_file_nobrl_ops;
+                else { /* not direct, send byte range locks */
+                        inode->i_fop = &cifs_file_ops;
+                }
+
+
+                /* check if server can support readpages */
+                if (cifs_sb->tcon->ses->server->maxBuf <
+                                PAGE_CACHE_SIZE + MAX_CIFS_HDR_SIZE)
+                        inode->i_data.a_ops = &cifs_addr_ops_smallbuf;
+                else
+                        inode->i_data.a_ops = &cifs_addr_ops;
+                break;
+        case S_IFDIR:
+                inode->i_op = &cifs_dir_inode_ops;
+                inode->i_fop = &cifs_dir_ops;
+                break;
+        case S_IFLNK:
+                inode->i_op = &cifs_symlink_inode_ops;
+                break;
+        default:
+                init_special_inode(inode, inode->i_mode, inode->i_rdev);
+                break;
+        }
+}
+
+static void cifs_unix_info_to_inode(struct inode *inode,
+                FILE_UNIX_BASIC_INFO *info, int force_uid_gid)
+{
+        struct cifs_sb_info *cifs_sb = CIFS_SB(inode->i_sb);
+        struct cifsInodeInfo *cifsInfo = CIFS_I(inode);
+        __u64 num_of_bytes = le64_to_cpu(info->NumOfBytes);
+        __u64 end_of_file = le64_to_cpu(info->EndOfFile);
+
+        inode->i_atime = cifs_NTtimeToUnix(le64_to_cpu(info->LastAccessTime));
+        inode->i_mtime =
+                cifs_NTtimeToUnix(le64_to_cpu(info->LastModificationTime));
+        inode->i_ctime = cifs_NTtimeToUnix(le64_to_cpu(info->LastStatusChange));
+        inode->i_mode = le64_to_cpu(info->Permissions);
+
+        /*
+         * Since we set the inode type below we need to mask off
+         * to avoid strange results if bits set above.
+         */
+        inode->i_mode &= ~S_IFMT;
+        switch (le32_to_cpu(info->Type)) {
+        case UNIX_FILE:
+                inode->i_mode |= S_IFREG;
+                break;
+        case UNIX_SYMLINK:
+                inode->i_mode |= S_IFLNK;
+                break;
+        case UNIX_DIR:
+                inode->i_mode |= S_IFDIR;
+                break;
+        case UNIX_CHARDEV:
+                inode->i_mode |= S_IFCHR;
+                inode->i_rdev = MKDEV(le64_to_cpu(info->DevMajor),
+                                      le64_to_cpu(info->DevMinor) & MINORMASK);
+                break;
+        case UNIX_BLOCKDEV:
+                inode->i_mode |= S_IFBLK;
+                inode->i_rdev = MKDEV(le64_to_cpu(info->DevMajor),
+                                      le64_to_cpu(info->DevMinor) & MINORMASK);
+                break;
+        case UNIX_FIFO:
+                inode->i_mode |= S_IFIFO;
+                break;
+        case UNIX_SOCKET:
+                inode->i_mode |= S_IFSOCK;
+                break;
+        default:
+                /* safest to call it a file if we do not know */
+                inode->i_mode |= S_IFREG;
+                cFYI(1, ("unknown type %d", le32_to_cpu(info->Type)));
+                break;
+        }
+
+        if ((cifs_sb->mnt_cifs_flags & CIFS_MOUNT_OVERR_UID) &&
+            !force_uid_gid)
+                inode->i_uid = cifs_sb->mnt_uid;
+        else
+                inode->i_uid = le64_to_cpu(info->Uid);
+
+        if ((cifs_sb->mnt_cifs_flags & CIFS_MOUNT_OVERR_GID) &&
+            !force_uid_gid)
+                inode->i_gid = cifs_sb->mnt_gid;
+        else
+                inode->i_gid = le64_to_cpu(info->Gid);
+
+        inode->i_nlink = le64_to_cpu(info->Nlinks);
+
+        spin_lock(&inode->i_lock);
+        if (is_size_safe_to_change(cifsInfo, end_of_file)) {
+                /*
+                 * We can not safely change the file size here if the client
+                 * is writing to it due to potential races.
+                 */
+                i_size_write(inode, end_of_file);
+
+                /*
+                 * i_blocks is not related to (i_size / i_blksize),
+                 * but instead 512 byte (2**9) size is required for
+                 * calculating num blocks.
+                 */
+                inode->i_blocks = (512 - 1 + num_of_bytes) >> 9;
+        }
+        spin_unlock(&inode->i_lock);
+}
+
 int cifs_get_inode_info_unix(struct inode **pinode,
         const unsigned char *search_path, struct super_block *sb, int xid)
 {
@@ -74,7 +198,6 @@ int cifs_get_inode_info_unix(struct inode **pinode,
                 }
         } else {
                 struct cifsInodeInfo *cifsInfo;
-                __u32 type = le32_to_cpu(findData.Type);
                 __u64 num_of_bytes = le64_to_cpu(findData.NumOfBytes);
                 __u64 end_of_file = le64_to_cpu(findData.EndOfFile);
 
@@ -105,112 +228,16 @@ int cifs_get_inode_info_unix(struct inode **pinode,
                 /* this is ok to set on every inode revalidate */
                 atomic_set(&cifsInfo->inUse, 1);
 
-                inode->i_atime =
-                    cifs_NTtimeToUnix(le64_to_cpu(findData.LastAccessTime));
-                inode->i_mtime =
-                    cifs_NTtimeToUnix(le64_to_cpu
-                                (findData.LastModificationTime));
-                inode->i_ctime =
-                    cifs_NTtimeToUnix(le64_to_cpu(findData.LastStatusChange));
-                inode->i_mode = le64_to_cpu(findData.Permissions);
-                /* since we set the inode type below we need to mask off
-                   to avoid strange results if bits set above */
-                inode->i_mode &= ~S_IFMT;
-                if (type == UNIX_FILE) {
-                        inode->i_mode |= S_IFREG;
-                } else if (type == UNIX_SYMLINK) {
-                        inode->i_mode |= S_IFLNK;
-                } else if (type == UNIX_DIR) {
-                        inode->i_mode |= S_IFDIR;
-                } else if (type == UNIX_CHARDEV) {
-                        inode->i_mode |= S_IFCHR;
-                        inode->i_rdev = MKDEV(le64_to_cpu(findData.DevMajor),
-                                le64_to_cpu(findData.DevMinor) & MINORMASK);
-                } else if (type == UNIX_BLOCKDEV) {
-                        inode->i_mode |= S_IFBLK;
-                        inode->i_rdev = MKDEV(le64_to_cpu(findData.DevMajor),
-                                le64_to_cpu(findData.DevMinor) & MINORMASK);
-                } else if (type == UNIX_FIFO) {
-                        inode->i_mode |= S_IFIFO;
-                } else if (type == UNIX_SOCKET) {
-                        inode->i_mode |= S_IFSOCK;
-                } else {
-                        /* safest to call it a file if we do not know */
-                        inode->i_mode |= S_IFREG;
-                        cFYI(1, ("unknown type %d", type));
-                }
+                cifs_unix_info_to_inode(inode, &findData, 0);
 
-                if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_OVERR_UID)
-                        inode->i_uid = cifs_sb->mnt_uid;
-                else
-                        inode->i_uid = le64_to_cpu(findData.Uid);
-
-                if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_OVERR_GID)
-                        inode->i_gid = cifs_sb->mnt_gid;
-                else
-                        inode->i_gid = le64_to_cpu(findData.Gid);
-
-                inode->i_nlink = le64_to_cpu(findData.Nlinks);
-
-                spin_lock(&inode->i_lock);
-                if (is_size_safe_to_change(cifsInfo, end_of_file)) {
-                /* can not safely change the file size here if the
-                   client is writing to it due to potential races */
-                        i_size_write(inode, end_of_file);
-
-                /* blksize needs to be multiple of two. So safer to default to
-                blksize and blkbits set in superblock so 2**blkbits and blksize
-                will match rather than setting to:
-                (pTcon->ses->server->maxBuf - MAX_CIFS_HDR_SIZE) & 0xFFFFFE00;*/
-
-                /* This seems incredibly stupid but it turns out that i_blocks
-                   is not related to (i_size / i_blksize), instead 512 byte size
-                   is required for calculating num blocks */
-
-                /* 512 bytes (2**9) is the fake blocksize that must be used */
-                /* for this calculation */
-                        inode->i_blocks = (512 - 1 + num_of_bytes) >> 9;
-                }
-                spin_unlock(&inode->i_lock);
 
                 if (num_of_bytes < end_of_file)
                         cFYI(1, ("allocation size less than end of file"));
                 cFYI(1, ("Size %ld and blocks %llu",
                         (unsigned long) inode->i_size,
                         (unsigned long long)inode->i_blocks));
-                if (S_ISREG(inode->i_mode)) {
-                        cFYI(1, ("File inode"));
-                        inode->i_op = &cifs_file_inode_ops;
-                        if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_DIRECT_IO) {
-                                if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_NO_BRL)
-                                        inode->i_fop =
-                                                &cifs_file_direct_nobrl_ops;
-                                else
-                                        inode->i_fop = &cifs_file_direct_ops;
-                        } else if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_NO_BRL)
-                                inode->i_fop = &cifs_file_nobrl_ops;
-                        else /* not direct, send byte range locks */
-                                inode->i_fop = &cifs_file_ops;
-
-                        /* check if server can support readpages */
-                        if (pTcon->ses->server->maxBuf <
-                            PAGE_CACHE_SIZE + MAX_CIFS_HDR_SIZE)
-                                inode->i_data.a_ops = &cifs_addr_ops_smallbuf;
-                        else
-                                inode->i_data.a_ops = &cifs_addr_ops;
-                } else if (S_ISDIR(inode->i_mode)) {
-                        cFYI(1, ("Directory inode"));
-                        inode->i_op = &cifs_dir_inode_ops;
-                        inode->i_fop = &cifs_dir_ops;
-                } else if (S_ISLNK(inode->i_mode)) {
-                        cFYI(1, ("Symbolic Link inode"));
-                        inode->i_op = &cifs_symlink_inode_ops;
-                /* tmp_inode->i_fop = */ /* do not need to set to anything */
-                } else {
-                        cFYI(1, ("Init special inode"));
-                        init_special_inode(inode, inode->i_mode,
-                                           inode->i_rdev);
-                }
+
+                cifs_set_ops(inode);
         }
         return rc;
 }
@@ -490,9 +517,9 @@ int cifs_get_inode_info(struct inode **pinode,
                         if (decode_sfu_inode(inode,
                                          le64_to_cpu(pfindData->EndOfFile),
                                          search_path,
-                                         cifs_sb, xid)) {
+                                         cifs_sb, xid))
                                 cFYI(1, ("Unrecognized sfu inode type"));
-                        }
+
                         cFYI(1, ("sfu mode 0%o", inode->i_mode));
                 } else {
                         inode->i_mode |= S_IFREG;
@@ -546,36 +573,7 @@ int cifs_get_inode_info(struct inode **pinode,
                         atomic_set(&cifsInfo->inUse, 1);
                 }
 
-                if (S_ISREG(inode->i_mode)) {
-                        cFYI(1, ("File inode"));
-                        inode->i_op = &cifs_file_inode_ops;
-                        if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_DIRECT_IO) {
-                                if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_NO_BRL)
-                                        inode->i_fop =
-                                                &cifs_file_direct_nobrl_ops;
-                                else
-                                        inode->i_fop = &cifs_file_direct_ops;
-                        } else if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_NO_BRL)
-                                inode->i_fop = &cifs_file_nobrl_ops;
-                        else /* not direct, send byte range locks */
-                                inode->i_fop = &cifs_file_ops;
-
-                        if (pTcon->ses->server->maxBuf <
-                             PAGE_CACHE_SIZE + MAX_CIFS_HDR_SIZE)
-                                inode->i_data.a_ops = &cifs_addr_ops_smallbuf;
-                        else
-                                inode->i_data.a_ops = &cifs_addr_ops;
-                } else if (S_ISDIR(inode->i_mode)) {
-                        cFYI(1, ("Directory inode"));
-                        inode->i_op = &cifs_dir_inode_ops;
-                        inode->i_fop = &cifs_dir_ops;
-                } else if (S_ISLNK(inode->i_mode)) {
-                        cFYI(1, ("Symbolic Link inode"));
-                        inode->i_op = &cifs_symlink_inode_ops;
-                } else {
-                        init_special_inode(inode, inode->i_mode,
-                                           inode->i_rdev);
-                }
+                cifs_set_ops(inode);
         }
         kfree(buf);
         return rc;
@@ -792,17 +790,12 @@ psx_del_no_retry:
 }
 
 static void posix_fill_in_inode(struct inode *tmp_inode,
-        FILE_UNIX_BASIC_INFO *pData, int *pobject_type, int isNewInode)
+        FILE_UNIX_BASIC_INFO *pData, int isNewInode)
 {
+        struct cifsInodeInfo *cifsInfo = CIFS_I(tmp_inode);
         loff_t local_size;
         struct timespec local_mtime;
 
-        struct cifsInodeInfo *cifsInfo = CIFS_I(tmp_inode);
-        struct cifs_sb_info *cifs_sb = CIFS_SB(tmp_inode->i_sb);
-
-        __u32 type = le32_to_cpu(pData->Type);
-        __u64 num_of_bytes = le64_to_cpu(pData->NumOfBytes);
-        __u64 end_of_file = le64_to_cpu(pData->EndOfFile);
         cifsInfo->time = jiffies;
         atomic_inc(&cifsInfo->inUse);
 
@@ -810,115 +803,27 @@ static void posix_fill_in_inode(struct inode *tmp_inode,
         local_mtime = tmp_inode->i_mtime;
         local_size  = tmp_inode->i_size;
 
-        tmp_inode->i_atime =
-            cifs_NTtimeToUnix(le64_to_cpu(pData->LastAccessTime));
-        tmp_inode->i_mtime =
-            cifs_NTtimeToUnix(le64_to_cpu(pData->LastModificationTime));
-        tmp_inode->i_ctime =
-            cifs_NTtimeToUnix(le64_to_cpu(pData->LastStatusChange));
-
-        tmp_inode->i_mode = le64_to_cpu(pData->Permissions);
-        /* since we set the inode type below we need to mask off type
-           to avoid strange results if bits above were corrupt */
-        tmp_inode->i_mode &= ~S_IFMT;
-        if (type == UNIX_FILE) {
-                *pobject_type = DT_REG;
-                tmp_inode->i_mode |= S_IFREG;
-        } else if (type == UNIX_SYMLINK) {
-                *pobject_type = DT_LNK;
-                tmp_inode->i_mode |= S_IFLNK;
-        } else if (type == UNIX_DIR) {
-                *pobject_type = DT_DIR;
-                tmp_inode->i_mode |= S_IFDIR;
-        } else if (type == UNIX_CHARDEV) {
-                *pobject_type = DT_CHR;
-                tmp_inode->i_mode |= S_IFCHR;
-                tmp_inode->i_rdev = MKDEV(le64_to_cpu(pData->DevMajor),
-                                le64_to_cpu(pData->DevMinor) & MINORMASK);
-        } else if (type == UNIX_BLOCKDEV) {
-                *pobject_type = DT_BLK;
-                tmp_inode->i_mode |= S_IFBLK;
-                tmp_inode->i_rdev = MKDEV(le64_to_cpu(pData->DevMajor),
-                                le64_to_cpu(pData->DevMinor) & MINORMASK);
-        } else if (type == UNIX_FIFO) {
-                *pobject_type = DT_FIFO;
-                tmp_inode->i_mode |= S_IFIFO;
-        } else if (type == UNIX_SOCKET) {
-                *pobject_type = DT_SOCK;
-                tmp_inode->i_mode |= S_IFSOCK;
-        } else {
-                /* safest to just call it a file */
-                *pobject_type = DT_REG;
-                tmp_inode->i_mode |= S_IFREG;
-                cFYI(1, ("unknown inode type %d", type));
-        }
-
-#ifdef CONFIG_CIFS_DEBUG2
-        cFYI(1, ("object type: %d", type));
-#endif
-        tmp_inode->i_uid = le64_to_cpu(pData->Uid);
-        tmp_inode->i_gid = le64_to_cpu(pData->Gid);
-        tmp_inode->i_nlink = le64_to_cpu(pData->Nlinks);
-
-        spin_lock(&tmp_inode->i_lock);
-        if (is_size_safe_to_change(cifsInfo, end_of_file)) {
-                /* can not safely change the file size here if the
-                client is writing to it due to potential races */
-                i_size_write(tmp_inode, end_of_file);
+        cifs_unix_info_to_inode(tmp_inode, pData, 1);
+        cifs_set_ops(tmp_inode);
 
-        /* 512 bytes (2**9) is the fake blocksize that must be used */
-        /* for this calculation, not the real blocksize */
-                tmp_inode->i_blocks = (512 - 1 + num_of_bytes) >> 9;
-        }
-        spin_unlock(&tmp_inode->i_lock);
-
-        if (S_ISREG(tmp_inode->i_mode)) {
-                cFYI(1, ("File inode"));
-                tmp_inode->i_op = &cifs_file_inode_ops;
-
-                if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_DIRECT_IO) {
-                        if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_NO_BRL)
-                                tmp_inode->i_fop = &cifs_file_direct_nobrl_ops;
-                        else
-                                tmp_inode->i_fop = &cifs_file_direct_ops;
+        if (!S_ISREG(tmp_inode->i_mode))
+                return;
 
-                } else if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_NO_BRL)
-                        tmp_inode->i_fop = &cifs_file_nobrl_ops;
-                else
-                        tmp_inode->i_fop = &cifs_file_ops;
-
-                if ((cifs_sb->tcon) && (cifs_sb->tcon->ses) &&
-                   (cifs_sb->tcon->ses->server->maxBuf <
-                        PAGE_CACHE_SIZE + MAX_CIFS_HDR_SIZE))
-                        tmp_inode->i_data.a_ops = &cifs_addr_ops_smallbuf;
-                else
-                        tmp_inode->i_data.a_ops = &cifs_addr_ops;
-
-                if (isNewInode)
-                        return; /* No sense invalidating pages for new inode
-                                   since we we have not started caching
-                                   readahead file data yet */
+        /*
+         * No sense invalidating pages for new inode
+         * since we we have not started caching
+         * readahead file data yet.
+         */
+        if (isNewInode)
+                return;
 
-                if (timespec_equal(&tmp_inode->i_mtime, &local_mtime) &&
-                        (local_size == tmp_inode->i_size)) {
-                        cFYI(1, ("inode exists but unchanged"));
-                } else {
-                        /* file may have changed on server */
-                        cFYI(1, ("invalidate inode, readdir detected change"));
-                        invalidate_remote_inode(tmp_inode);
-                }
-        } else if (S_ISDIR(tmp_inode->i_mode)) {
-                cFYI(1, ("Directory inode"));
-                tmp_inode->i_op = &cifs_dir_inode_ops;
-                tmp_inode->i_fop = &cifs_dir_ops;
-        } else if (S_ISLNK(tmp_inode->i_mode)) {
-                cFYI(1, ("Symbolic Link inode"));
-                tmp_inode->i_op = &cifs_symlink_inode_ops;
-/* tmp_inode->i_fop = *//* do not need to set to anything */
+        if (timespec_equal(&tmp_inode->i_mtime, &local_mtime) &&
+                (local_size == tmp_inode->i_size)) {
+                cFYI(1, ("inode exists but unchanged"));
         } else {
-                cFYI(1, ("Special inode"));
-                init_special_inode(tmp_inode, tmp_inode->i_mode,
-                                   tmp_inode->i_rdev);
+                /* file may have changed on server */
+                cFYI(1, ("invalidate inode, readdir detected change"));
+                invalidate_remote_inode(tmp_inode);
         }
 }
 
@@ -968,7 +873,6 @@ int cifs_mkdir(struct inode *inode, struct dentry *direntry, int mode)
                         cFYI(1, ("posix mkdir returned 0x%x", rc));
                         d_drop(direntry);
                 } else {
-                        int obj_type;
                         if (pInfo->Type == cpu_to_le32(-1)) {
                                 /* no return info, go query for it */
                                 kfree(pInfo);
@@ -1004,7 +908,7 @@ int cifs_mkdir(struct inode *inode, struct dentry *direntry, int mode)
                         /* we already checked in POSIXCreate whether
                            frame was long enough */
                         posix_fill_in_inode(direntry->d_inode,
-                                        pInfo, &obj_type, 1 /* NewInode */);
+                                        pInfo, 1 /* NewInode */);
 #ifdef CONFIG_CIFS_DEBUG2
                         cFYI(1, ("instantiated dentry %p %s to inode %p",
                                 direntry, direntry->d_name.name, newinode));
@@ -1214,9 +1118,8 @@ int cifs_rename(struct inode *source_inode, struct dentry *source_direntry,
                 } /* if we can not get memory just leave rc as EEXIST */
         }
 
-        if (rc) {
+        if (rc)
                 cFYI(1, ("rename rc %d", rc));
-        }
 
         if ((rc == -EIO) || (rc == -EEXIST)) {
                 int oplock = FALSE;
diff --git a/fs/cifs/ioctl.c b/fs/cifs/ioctl.c
index d24fe6880a04..5c792df13d62 100644
--- a/fs/cifs/ioctl.c
+++ b/fs/cifs/ioctl.c
@@ -30,7 +30,7 @@
 
 #define CIFS_IOC_CHECKUMOUNT _IO(0xCF, 2)
 
-int cifs_ioctl (struct inode *inode, struct file *filep,
+int cifs_ioctl(struct inode *inode, struct file *filep,
                 unsigned int command, unsigned long arg)
 {
         int rc = -ENOTTY; /* strange error - but the precedent */
diff --git a/fs/cifs/md4.c b/fs/cifs/md4.c
index a2415c1a14db..a725c2609d67 100644
--- a/fs/cifs/md4.c
+++ b/fs/cifs/md4.c
@@ -56,7 +56,7 @@ lshift(__u32 x, int s)
 
 /* this applies md4 to 64 byte chunks */
 static void
-mdfour64(__u32 * M, __u32 * A, __u32 *B, __u32 * C, __u32 *D)
+mdfour64(__u32 *M, __u32 *A, __u32 *B, __u32 *C, __u32 *D)
 {
         int j;
         __u32 AA, BB, CC, DD;
@@ -137,7 +137,7 @@ mdfour64(__u32 * M, __u32 * A, __u32 *B, __u32 * C, __u32 *D)
 }
 
 static void
-copy64(__u32 * M, unsigned char *in)
+copy64(__u32 *M, unsigned char *in)
 {
         int i;
 
diff --git a/fs/cifs/md5.c b/fs/cifs/md5.c
index f13f96d42fcf..462bbfefd4b6 100644
--- a/fs/cifs/md5.c
+++ b/fs/cifs/md5.c
@@ -161,7 +161,7 @@ MD5Final(unsigned char digest[16], struct MD5Context *ctx)
 
 /* This is the central step in the MD5 algorithm. */
 #define MD5STEP(f, w, x, y, z, data, s) \
-        ( w += f(x, y, z) + data,  w = w<<s | w>>(32-s),  w += x )
+        (w += f(x, y, z) + data,  w = w<<s | w>>(32-s),  w += x)
 
 /*
  * The core of the MD5 algorithm, this alters an existing MD5 hash to
@@ -302,9 +302,8 @@ hmac_md5_init_limK_to_64(const unsigned char *key, int key_len,
         int i;
 
         /* if key is longer than 64 bytes truncate it */
-        if (key_len > 64) {
+        if (key_len > 64)
                 key_len = 64;
-        }
 
         /* start out by storing key in pads */
         memset(ctx->k_ipad, 0, sizeof(ctx->k_ipad));
@@ -359,9 +358,9 @@ hmac_md5(unsigned char key[16], unsigned char *data, int data_len,
 {
         struct HMACMD5Context ctx;
         hmac_md5_init_limK_to_64(key, 16, &ctx);
-        if (data_len != 0) {
+        if (data_len != 0)
                 hmac_md5_update(data, data_len, &ctx);
-        }
+
         hmac_md5_final(digest, &ctx);
 }
 #endif
diff --git a/fs/cifs/misc.c b/fs/cifs/misc.c
index 15546c2354c5..2a42d9fedbb2 100644
--- a/fs/cifs/misc.c
+++ b/fs/cifs/misc.c
@@ -1,7 +1,7 @@
 /*
  *   fs/cifs/misc.c
  *
- *   Copyright (C) International Business Machines  Corp., 2002,2007
+ *   Copyright (C) International Business Machines  Corp., 2002,2008
  *   Author(s): Steve French (sfrench@us.ibm.com)
  *
  *   This library is free software; you can redistribute it and/or modify
@@ -320,9 +320,9 @@ header_assemble(struct smb_hdr *buffer, char smb_command /* command */ ,
                 if (treeCon->ses) {
                         if (treeCon->ses->capabilities & CAP_UNICODE)
                                 buffer->Flags2 |= SMBFLG2_UNICODE;
-                        if (treeCon->ses->capabilities & CAP_STATUS32) {
+                        if (treeCon->ses->capabilities & CAP_STATUS32)
                                 buffer->Flags2 |= SMBFLG2_ERR_STATUS;
-                        }
+
                         /* Uid is not converted */
                         buffer->Uid = treeCon->ses->Suid;
                         buffer->Mid = GetNextMid(treeCon->ses->server);
@@ -610,7 +610,8 @@ dump_smb(struct smb_hdr *smb_buf, int smb_buf_length)
 
         buffer = (unsigned char *) smb_buf;
         for (i = 0, j = 0; i < smb_buf_length; i++, j++) {
-                if (i % 8 == 0) {       /* have reached the beginning of line */
+                if (i % 8 == 0) {
+                        /* have reached the beginning of line */
                         printk(KERN_DEBUG "| ");
                         j = 0;
                 }
@@ -621,7 +622,8 @@ dump_smb(struct smb_hdr *smb_buf, int smb_buf_length)
                 else
                         debug_line[1 + (2 * j)] = '_';
 
-                if (i % 8 == 7) { /* reached end of line, time to print ascii */
+                if (i % 8 == 7) {
+                        /* reached end of line, time to print ascii */
                         debug_line[16] = 0;
                         printk(" | %s\n", debug_line);
                 }
@@ -631,7 +633,7 @@ dump_smb(struct smb_hdr *smb_buf, int smb_buf_length)
                 debug_line[2 * j] = ' ';
                 debug_line[1 + (2 * j)] = ' ';
         }
-        printk( " | %s\n", debug_line);
+        printk(" | %s\n", debug_line);
         return;
 }
 
diff --git a/fs/cifs/netmisc.c b/fs/cifs/netmisc.c
index 646e1f06941b..3b5a5ce882b6 100644
--- a/fs/cifs/netmisc.c
+++ b/fs/cifs/netmisc.c
@@ -1,7 +1,7 @@
 /*
  *   fs/cifs/netmisc.c
  *
- *   Copyright (c) International Business Machines  Corp., 2002
+ *   Copyright (c) International Business Machines  Corp., 2002,2008
  *   Author(s): Steve French (sfrench@us.ibm.com)
  *
  *   Error mapping routines from Samba libsmb/errormap.c
@@ -150,9 +150,7 @@ static int canonicalize_unc(char *cp)
                 if (cp[i] == '\\')
                         break;
                 if (cp[i] == '/') {
-#ifdef CONFIG_CIFS_DEBUG2
-                        cFYI(1, ("change slash to backslash in malformed UNC"));
-#endif
+                        cFYI(DBG2, ("change slash to \\ in malformed UNC"));
                         cp[i] = '\\';
                         return 1;
                 }
@@ -178,9 +176,7 @@ cifs_inet_pton(int address_family, char *cp, void *dst)
         } else if (address_family == AF_INET6) {
                 ret = in6_pton(cp, -1 /* len */, dst , '\\', NULL);
         }
-#ifdef CONFIG_CIFS_DEBUG2
-        cFYI(1, ("address conversion returned %d for %s", ret, cp));
-#endif
+        cFYI(DBG2, ("address conversion returned %d for %s", ret, cp));
         if (ret > 0)
                 ret = 1;
         return ret;
@@ -253,7 +249,8 @@ static const struct {
         ERRDOS, 87, NT_STATUS_INVALID_PARAMETER_MIX}, {
         ERRHRD, ERRgeneral, NT_STATUS_INVALID_QUOTA_LOWER}, {
         ERRHRD, ERRgeneral, NT_STATUS_DISK_CORRUPT_ERROR}, {
-        ERRDOS, ERRbadfile, NT_STATUS_OBJECT_NAME_INVALID}, {   /* mapping changed since shell does lookup on * and expects file not found */
+         /* mapping changed since shell does lookup on * expects FileNotFound */
+        ERRDOS, ERRbadfile, NT_STATUS_OBJECT_NAME_INVALID}, {
         ERRDOS, ERRbadfile, NT_STATUS_OBJECT_NAME_NOT_FOUND}, {
         ERRDOS, ERRalreadyexists, NT_STATUS_OBJECT_NAME_COLLISION}, {
         ERRHRD, ERRgeneral, NT_STATUS_HANDLE_NOT_WAITABLE}, {
@@ -820,7 +817,8 @@ map_smb_to_linux_error(struct smb_hdr *smb, int logErr)
         /* old style errors */
 
         /* DOS class smb error codes - map DOS */
-        if (smberrclass == ERRDOS) {  /* 1 byte field no need to byte reverse */
+        if (smberrclass == ERRDOS) {
+                /* 1 byte field no need to byte reverse */
                 for (i = 0;
                      i <
                      sizeof(mapping_table_ERRDOS) /
@@ -834,7 +832,8 @@ map_smb_to_linux_error(struct smb_hdr *smb, int logErr)
                         }
                         /* else try next error mapping one to see if match */
                 }
-        } else if (smberrclass == ERRSRV) {   /* server class of error codes */
+        } else if (smberrclass == ERRSRV) {
+                /* server class of error codes */
                 for (i = 0;
                      i <
                      sizeof(mapping_table_ERRSRV) /
@@ -922,8 +921,8 @@ struct timespec cnvrtDosUnixTm(__u16 date, __u16 time)
 {
         struct timespec ts;
         int sec, min, days, month, year;
-        SMB_TIME * st = (SMB_TIME *)&time;
-        SMB_DATE * sd = (SMB_DATE *)&date;
+        SMB_TIME *st = (SMB_TIME *)&time;
+        SMB_DATE *sd = (SMB_DATE *)&date;
 
         cFYI(1, ("date %d time %d", date, time));
 
diff --git a/fs/cifs/readdir.c b/fs/cifs/readdir.c
index 0f22def4bdff..32b445edc882 100644
--- a/fs/cifs/readdir.c
+++ b/fs/cifs/readdir.c
@@ -3,7 +3,7 @@
  *
  *   Directory search handling
  *
- *   Copyright (C) International Business Machines  Corp., 2004, 2007
+ *   Copyright (C) International Business Machines  Corp., 2004, 2008
  *   Author(s): Steve French (sfrench@us.ibm.com)
  *
  *   This library is free software; you can redistribute it and/or modify
@@ -42,17 +42,18 @@ static void dump_cifs_file_struct(struct file *file, char *label)
                         cFYI(1, ("empty cifs private file data"));
                         return;
                 }
-                if (cf->invalidHandle) {
+                if (cf->invalidHandle)
                         cFYI(1, ("invalid handle"));
-                }
-                if (cf->srch_inf.endOfSearch) {
+                if (cf->srch_inf.endOfSearch)
                         cFYI(1, ("end of search"));
-                }
-                if (cf->srch_inf.emptyDir) {
+                if (cf->srch_inf.emptyDir)
                         cFYI(1, ("empty dir"));
-                }
         }
 }
+#else
+static inline void dump_cifs_file_struct(struct file *file, char *label)
+{
+}
 #endif /* DEBUG2 */
 
 /* Returns one if new inode created (which therefore needs to be hashed) */
@@ -150,7 +151,7 @@ static void fill_in_inode(struct inode *tmp_inode, int new_buf_type,
                       cifs_NTtimeToUnix(le64_to_cpu(pfindData->ChangeTime));
         } else { /* legacy, OS2 and DOS style */
 /*              struct timespec ts;*/
-                FIND_FILE_STANDARD_INFO * pfindData =
+                FIND_FILE_STANDARD_INFO *pfindData =
                         (FIND_FILE_STANDARD_INFO *)buf;
 
                 tmp_inode->i_mtime = cnvrtDosUnixTm(
@@ -198,9 +199,8 @@ static void fill_in_inode(struct inode *tmp_inode, int new_buf_type,
         if (attr & ATTR_DIRECTORY) {
                 *pobject_type = DT_DIR;
                 /* override default perms since we do not lock dirs */
-                if (atomic_read(&cifsInfo->inUse) == 0) {
+                if (atomic_read(&cifsInfo->inUse) == 0)
                         tmp_inode->i_mode = cifs_sb->mnt_dir_mode;
-                }
                 tmp_inode->i_mode |= S_IFDIR;
         } else if ((cifs_sb->mnt_cifs_flags & CIFS_MOUNT_UNX_EMUL) &&
                    (attr & ATTR_SYSTEM)) {
@@ -231,9 +231,8 @@ static void fill_in_inode(struct inode *tmp_inode, int new_buf_type,
         } /* could add code here - to validate if device or weird share type? */
 
         /* can not fill in nlink here as in qpathinfo version and Unx search */
-        if (atomic_read(&cifsInfo->inUse) == 0) {
+        if (atomic_read(&cifsInfo->inUse) == 0)
                 atomic_set(&cifsInfo->inUse, 1);
-        }
 
         spin_lock(&tmp_inode->i_lock);
         if (is_size_safe_to_change(cifsInfo, end_of_file)) {
@@ -461,9 +460,8 @@ static int initiate_cifs_search(const int xid, struct file *file)
 
         full_path = build_path_from_dentry(file->f_path.dentry);
 
-        if (full_path == NULL) {
+        if (full_path == NULL)
                 return -ENOMEM;
-        }
 
         cFYI(1, ("Full path: %s start at: %lld", full_path, file->f_pos));
 
@@ -471,9 +469,9 @@ ffirst_retry:
         /* test for Unix extensions */
         /* but now check for them on the share/mount not on the SMB session */
 /*      if (pTcon->ses->capabilities & CAP_UNIX) { */
-        if (pTcon->unix_ext) {
+        if (pTcon->unix_ext)
                 cifsFile->srch_inf.info_level = SMB_FIND_FILE_UNIX;
-        } else if ((pTcon->ses->capabilities &
+        else if ((pTcon->ses->capabilities &
                         (CAP_NT_SMBS | CAP_NT_FIND)) == 0) {
                 cifsFile->srch_inf.info_level = SMB_FIND_FILE_INFO_STANDARD;
         } else if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_SERVER_INUM) {
@@ -514,10 +512,10 @@ static int cifs_unicode_bytelen(char *str)
 static char *nxt_dir_entry(char *old_entry, char *end_of_smb, int level)
 {
         char *new_entry;
-        FILE_DIRECTORY_INFO * pDirInfo = (FILE_DIRECTORY_INFO *)old_entry;
+        FILE_DIRECTORY_INFO *pDirInfo = (FILE_DIRECTORY_INFO *)old_entry;
 
         if (level == SMB_FIND_FILE_INFO_STANDARD) {
-                FIND_FILE_STANDARD_INFO * pfData;
+                FIND_FILE_STANDARD_INFO *pfData;
                 pfData = (FIND_FILE_STANDARD_INFO *)pDirInfo;
 
                 new_entry = old_entry + sizeof(FIND_FILE_STANDARD_INFO) +
@@ -553,7 +551,7 @@ static int cifs_entry_is_dot(char *current_entry, struct cifsFileInfo *cfile)
         int len = 0;
 
         if (cfile->srch_inf.info_level == SMB_FIND_FILE_UNIX) {
-                FILE_UNIX_INFO * pFindData = (FILE_UNIX_INFO *)current_entry;
+                FILE_UNIX_INFO *pFindData = (FILE_UNIX_INFO *)current_entry;
                 filename = &pFindData->FileName[0];
                 if (cfile->srch_inf.unicode) {
                         len = cifs_unicode_bytelen(filename);
@@ -562,30 +560,30 @@ static int cifs_entry_is_dot(char *current_entry, struct cifsFileInfo *cfile)
                         len = strnlen(filename, 5);
                 }
         } else if (cfile->srch_inf.info_level == SMB_FIND_FILE_DIRECTORY_INFO) {
-                FILE_DIRECTORY_INFO * pFindData =
+                FILE_DIRECTORY_INFO *pFindData =
                         (FILE_DIRECTORY_INFO *)current_entry;
                 filename = &pFindData->FileName[0];
                 len = le32_to_cpu(pFindData->FileNameLength);
         } else if (cfile->srch_inf.info_level ==
                         SMB_FIND_FILE_FULL_DIRECTORY_INFO) {
-                FILE_FULL_DIRECTORY_INFO * pFindData =
+                FILE_FULL_DIRECTORY_INFO *pFindData =
                         (FILE_FULL_DIRECTORY_INFO *)current_entry;
                 filename = &pFindData->FileName[0];
                 len = le32_to_cpu(pFindData->FileNameLength);
         } else if (cfile->srch_inf.info_level ==
                         SMB_FIND_FILE_ID_FULL_DIR_INFO) {
-                SEARCH_ID_FULL_DIR_INFO * pFindData =
+                SEARCH_ID_FULL_DIR_INFO *pFindData =
                         (SEARCH_ID_FULL_DIR_INFO *)current_entry;
                 filename = &pFindData->FileName[0];
                 len = le32_to_cpu(pFindData->FileNameLength);
         } else if (cfile->srch_inf.info_level ==
                         SMB_FIND_FILE_BOTH_DIRECTORY_INFO) {
-                FILE_BOTH_DIRECTORY_INFO * pFindData =
+                FILE_BOTH_DIRECTORY_INFO *pFindData =
                         (FILE_BOTH_DIRECTORY_INFO *)current_entry;
                 filename = &pFindData->FileName[0];
                 len = le32_to_cpu(pFindData->FileNameLength);
         } else if (cfile->srch_inf.info_level == SMB_FIND_FILE_INFO_STANDARD) {
-                FIND_FILE_STANDARD_INFO * pFindData =
+                FIND_FILE_STANDARD_INFO *pFindData =
                         (FIND_FILE_STANDARD_INFO *)current_entry;
                 filename = &pFindData->FileName[0];
                 len = pFindData->FileNameLength;
@@ -666,9 +664,7 @@ static int find_cifs_entry(const int xid, struct cifsTconInfo *pTcon,
         . and .. for the root of a drive and for those we need
         to start two entries earlier */
 
-#ifdef CONFIG_CIFS_DEBUG2
         dump_cifs_file_struct(file, "In fce ");
-#endif
         if (((index_to_find < cifsFile->srch_inf.index_of_last_entry) &&
              is_dir_changed(file)) ||
            (index_to_find < first_entry_in_buffer)) {
@@ -718,7 +714,7 @@ static int find_cifs_entry(const int xid, struct cifsTconInfo *pTcon,
                 pos_in_buf = index_to_find - first_entry_in_buffer;
                 cFYI(1, ("found entry - pos_in_buf %d", pos_in_buf));
 
-                for (i=0; (i < (pos_in_buf)) && (current_entry != NULL); i++) {
+                for (i = 0; (i < (pos_in_buf)) && (current_entry != NULL); i++) {
                         /* go entry by entry figuring out which is first */
                         current_entry = nxt_dir_entry(current_entry, end_of_smb,
                                                 cifsFile->srch_inf.info_level);
@@ -793,7 +789,7 @@ static int cifs_get_name_from_search_buf(struct qstr *pqst,
                 filename = &pFindData->FileName[0];
                 len = le32_to_cpu(pFindData->FileNameLength);
         } else if (level == SMB_FIND_FILE_INFO_STANDARD) {
-                FIND_FILE_STANDARD_INFO * pFindData =
+                FIND_FILE_STANDARD_INFO *pFindData =
                         (FIND_FILE_STANDARD_INFO *)current_entry;
                 filename = &pFindData->FileName[0];
                 /* one byte length, no name conversion */
@@ -928,7 +924,7 @@ static int cifs_save_resume_key(const char *current_entry,
         level = cifsFile->srch_inf.info_level;
 
         if (level == SMB_FIND_FILE_UNIX) {
-                FILE_UNIX_INFO * pFindData = (FILE_UNIX_INFO *)current_entry;
+                FILE_UNIX_INFO *pFindData = (FILE_UNIX_INFO *)current_entry;
 
                 filename = &pFindData->FileName[0];
                 if (cifsFile->srch_inf.unicode) {
diff --git a/fs/cifs/sess.c b/fs/cifs/sess.c
index d2153abcba6d..ed150efbe27c 100644
--- a/fs/cifs/sess.c
+++ b/fs/cifs/sess.c
@@ -417,10 +417,6 @@ CIFS_SessSetup(unsigned int xid, struct cifsSesInfo *ses, int first_time,
 
                 calc_lanman_hash(ses, lnm_session_key);
                 ses->flags |= CIFS_SES_LANMAN;
-/* #ifdef CONFIG_CIFS_DEBUG2
-                cifs_dump_mem("cryptkey: ",ses->server->cryptKey,
-                        CIFS_SESS_KEY_SIZE);
-#endif */
                 memcpy(bcc_ptr, (char *)lnm_session_key, CIFS_SESS_KEY_SIZE);
                 bcc_ptr += CIFS_SESS_KEY_SIZE;
 
diff --git a/fs/cifs/smbdes.c b/fs/cifs/smbdes.c
index cfa6d21fb4e8..04943c976f98 100644
--- a/fs/cifs/smbdes.c
+++ b/fs/cifs/smbdes.c
@@ -114,42 +114,42 @@ static uchar sbox[8][4][16] = {
         {{14, 4, 13, 1, 2, 15, 11, 8, 3, 10, 6, 12, 5, 9, 0, 7},
          {0, 15, 7, 4, 14, 2, 13, 1, 10, 6, 12, 11, 9, 5, 3, 8},
          {4, 1, 14, 8, 13, 6, 2, 11, 15, 12, 9, 7, 3, 10, 5, 0},
-         {15, 12, 8, 2, 4, 9, 1, 7, 5, 11, 3, 14, 10, 0, 6, 13}},
+         {15, 12, 8, 2, 4, 9, 1, 7, 5, 11, 3, 14, 10, 0, 6, 13} },
 
         {{15, 1, 8, 14, 6, 11, 3, 4, 9, 7, 2, 13, 12, 0, 5, 10},
          {3, 13, 4, 7, 15, 2, 8, 14, 12, 0, 1, 10, 6, 9, 11, 5},
          {0, 14, 7, 11, 10, 4, 13, 1, 5, 8, 12, 6, 9, 3, 2, 15},
-         {13, 8, 10, 1, 3, 15, 4, 2, 11, 6, 7, 12, 0, 5, 14, 9}},
+         {13, 8, 10, 1, 3, 15, 4, 2, 11, 6, 7, 12, 0, 5, 14, 9} },
 
         {{10, 0, 9, 14, 6, 3, 15, 5, 1, 13, 12, 7, 11, 4, 2, 8},
          {13, 7, 0, 9, 3, 4, 6, 10, 2, 8, 5, 14, 12, 11, 15, 1},
          {13, 6, 4, 9, 8, 15, 3, 0, 11, 1, 2, 12, 5, 10, 14, 7},
-         {1, 10, 13, 0, 6, 9, 8, 7, 4, 15, 14, 3, 11, 5, 2, 12}},
+         {1, 10, 13, 0, 6, 9, 8, 7, 4, 15, 14, 3, 11, 5, 2, 12} },
 
         {{7, 13, 14, 3, 0, 6, 9, 10, 1, 2, 8, 5, 11, 12, 4, 15},
          {13, 8, 11, 5, 6, 15, 0, 3, 4, 7, 2, 12, 1, 10, 14, 9},
          {10, 6, 9, 0, 12, 11, 7, 13, 15, 1, 3, 14, 5, 2, 8, 4},
-         {3, 15, 0, 6, 10, 1, 13, 8, 9, 4, 5, 11, 12, 7, 2, 14}},
+         {3, 15, 0, 6, 10, 1, 13, 8, 9, 4, 5, 11, 12, 7, 2, 14} },
 
         {{2, 12, 4, 1, 7, 10, 11, 6, 8, 5, 3, 15, 13, 0, 14, 9},
          {14, 11, 2, 12, 4, 7, 13, 1, 5, 0, 15, 10, 3, 9, 8, 6},
          {4, 2, 1, 11, 10, 13, 7, 8, 15, 9, 12, 5, 6, 3, 0, 14},
-         {11, 8, 12, 7, 1, 14, 2, 13, 6, 15, 0, 9, 10, 4, 5, 3}},
+         {11, 8, 12, 7, 1, 14, 2, 13, 6, 15, 0, 9, 10, 4, 5, 3} },
 
         {{12, 1, 10, 15, 9, 2, 6, 8, 0, 13, 3, 4, 14, 7, 5, 11},
          {10, 15, 4, 2, 7, 12, 9, 5, 6, 1, 13, 14, 0, 11, 3, 8},
          {9, 14, 15, 5, 2, 8, 12, 3, 7, 0, 4, 10, 1, 13, 11, 6},
-         {4, 3, 2, 12, 9, 5, 15, 10, 11, 14, 1, 7, 6, 0, 8, 13}},
+         {4, 3, 2, 12, 9, 5, 15, 10, 11, 14, 1, 7, 6, 0, 8, 13} },
 
         {{4, 11, 2, 14, 15, 0, 8, 13, 3, 12, 9, 7, 5, 10, 6, 1},
          {13, 0, 11, 7, 4, 9, 1, 10, 14, 3, 5, 12, 2, 15, 8, 6},
          {1, 4, 11, 13, 12, 3, 7, 14, 10, 15, 6, 8, 0, 5, 9, 2},
-         {6, 11, 13, 8, 1, 4, 10, 7, 9, 5, 0, 15, 14, 2, 3, 12}},
+         {6, 11, 13, 8, 1, 4, 10, 7, 9, 5, 0, 15, 14, 2, 3, 12} },
 
         {{13, 2, 8, 4, 6, 15, 11, 1, 10, 9, 3, 14, 5, 0, 12, 7},
          {1, 15, 13, 8, 10, 3, 7, 4, 12, 5, 6, 11, 0, 14, 9, 2},
          {7, 11, 4, 1, 9, 12, 14, 2, 0, 6, 10, 13, 15, 3, 5, 8},
-         {2, 1, 14, 7, 4, 10, 8, 13, 15, 12, 9, 0, 3, 5, 6, 11}}
+         {2, 1, 14, 7, 4, 10, 8, 13, 15, 12, 9, 0, 3, 5, 6, 11} }
 };
 
 static void
@@ -313,9 +313,8 @@ str_to_key(unsigned char *str, unsigned char *key)
         key[5] = ((str[4] & 0x1F) << 2) | (str[5] >> 6);
         key[6] = ((str[5] & 0x3F) << 1) | (str[6] >> 7);
         key[7] = str[6] & 0x7F;
-        for (i = 0; i < 8; i++) {
+        for (i = 0; i < 8; i++)
                 key[i] = (key[i] << 1);
-        }
 }
 
 static void
@@ -344,9 +343,8 @@ smbhash(unsigned char *out, unsigned char *in, unsigned char *key, int forw)
 
         dohash(outb, inb, keyb, forw);
 
-        for (i = 0; i < 8; i++) {
+        for (i = 0; i < 8; i++)
                 out[i] = 0;
-        }
 
         for (i = 0; i < 64; i++) {
                 if (outb[i])
diff --git a/fs/cifs/transport.c b/fs/cifs/transport.c
index 50b623ad9320..3612d6c0a0bb 100644
--- a/fs/cifs/transport.c
+++ b/fs/cifs/transport.c
@@ -1,7 +1,7 @@
 /*
  *   fs/cifs/transport.c
  *
- *   Copyright (C) International Business Machines  Corp., 2002,2007
+ *   Copyright (C) International Business Machines  Corp., 2002,2008
  *   Author(s): Steve French (sfrench@us.ibm.com)
  *   Jeremy Allison (jra@samba.org) 2006.
  *
@@ -358,9 +358,9 @@ static int allocate_mid(struct cifsSesInfo *ses, struct smb_hdr *in_buf,
         } else if (ses->status != CifsGood) {
                 /* check if SMB session is bad because we are setting it up */
                 if ((in_buf->Command != SMB_COM_SESSION_SETUP_ANDX) &&
-                        (in_buf->Command != SMB_COM_NEGOTIATE)) {
+                        (in_buf->Command != SMB_COM_NEGOTIATE))
                         return -EAGAIN;
-                } /* else ok - we are setting up session */
+                /* else ok - we are setting up session */
         }
         *ppmidQ = AllocMidQEntry(in_buf, ses);
         if (*ppmidQ == NULL)
@@ -437,9 +437,8 @@ SendReceiveNoRsp(const unsigned int xid, struct cifsSesInfo *ses,
         iov[0].iov_len = in_buf->smb_buf_length + 4;
         flags |= CIFS_NO_RESP;
         rc = SendReceive2(xid, ses, iov, 1, &resp_buf_type, flags);
-#ifdef CONFIG_CIFS_DEBUG2
-        cFYI(1, ("SendRcvNoR flags %d rc %d", flags, rc));
-#endif
+        cFYI(DBG2, ("SendRcvNoRsp flags %d rc %d", flags, rc));
+
         return rc;
 }
 
diff --git a/fs/cifs/xattr.c b/fs/cifs/xattr.c
index 54e8ef96cb79..8cd6a445b017 100644
--- a/fs/cifs/xattr.c
+++ b/fs/cifs/xattr.c
@@ -139,9 +139,9 @@ int cifs_setxattr(struct dentry *direntry, const char *ea_name,
         } else if (strncmp(ea_name, CIFS_XATTR_USER_PREFIX, 5) == 0) {
                 if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_NO_XATTR)
                         goto set_ea_exit;
-                if (strncmp(ea_name, CIFS_XATTR_DOS_ATTRIB, 14) == 0) {
+                if (strncmp(ea_name, CIFS_XATTR_DOS_ATTRIB, 14) == 0)
                         cFYI(1, ("attempt to set cifs inode metadata"));
-                }
+
                 ea_name += 5; /* skip past user. prefix */
                 rc = CIFSSMBSetEA(xid, pTcon, full_path, ea_name, ea_value,
                         (__u16)value_size, cifs_sb->local_nls,
@@ -262,7 +262,7 @@ ssize_t cifs_getxattr(struct dentry *direntry, const char *ea_name,
                                 cifs_sb->mnt_cifs_flags &
                                         CIFS_MOUNT_MAP_SPECIAL_CHR);
 #ifdef CONFIG_CIFS_EXPERIMENTAL
-                else if(cifs_sb->mnt_cifs_flags & CIFS_MOUNT_CIFS_ACL) {
+                else if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_CIFS_ACL) {
                         __u16 fid;
                         int oplock = FALSE;
                         struct cifs_ntsd *pacl = NULL;
@@ -303,11 +303,10 @@ ssize_t cifs_getxattr(struct dentry *direntry, const char *ea_name,
         } else if (strncmp(ea_name,
                   CIFS_XATTR_SECURITY_PREFIX, XATTR_SECURITY_PREFIX_LEN) == 0) {
                 cFYI(1, ("Security xattr namespace not supported yet"));
-        } else {
+        } else
                 cFYI(1,
                     ("illegal xattr request %s (only user namespace supported)",
                         ea_name));
-        }
 
         /* We could add an additional check for streams ie
             if proc/fs/cifs/streamstoxattr is set then
diff --git a/fs/exec.c b/fs/exec.c
index a44b142fb460..54a0a557b678 100644
--- a/fs/exec.c
+++ b/fs/exec.c
@@ -173,8 +173,15 @@ static struct page *get_arg_page(struct linux_binprm *bprm, unsigned long pos,
                 return NULL;
 
         if (write) {
-                struct rlimit *rlim = current->signal->rlim;
                 unsigned long size = bprm->vma->vm_end - bprm->vma->vm_start;
+                struct rlimit *rlim;
+
+                /*
+                 * We've historically supported up to 32 pages (ARG_MAX)
+                 * of argument strings even with small stacks
+                 */
+                if (size <= ARG_MAX)
+                        return page;
 
                 /*
                  * Limit to 1/4-th the stack size for the argv+env strings.
@@ -183,6 +190,7 @@ static struct page *get_arg_page(struct linux_binprm *bprm, unsigned long pos,
                  *  - the program will have a reasonable amount of stack left
                  *    to work from.
                  */
+                rlim = current->signal->rlim;
                 if (size > rlim[RLIMIT_STACK].rlim_cur / 4) {
                         put_page(page);
                         return NULL;
diff --git a/fs/jbd/transaction.c b/fs/jbd/transaction.c
index 038ed7436199..c6cbb6cd59b2 100644
--- a/fs/jbd/transaction.c
+++ b/fs/jbd/transaction.c
@@ -369,7 +369,7 @@ out:
 
 
 /**
- * int journal_restart() - restart a handle .
+ * int journal_restart() - restart a handle.
  * @handle:  handle to restart
  * @nblocks: nr credits requested
  *
@@ -844,8 +844,7 @@ out:
 }
 
 /**
- * int journal_get_undo_access() -  Notify intent to modify metadata with
- *     non-rewindable consequences
+ * int journal_get_undo_access() - Notify intent to modify metadata with non-rewindable consequences
  * @handle: transaction
  * @bh: buffer to undo
  * @credits: store the number of taken credits here (if not NULL)
@@ -921,12 +920,14 @@ out:
 }
 
 /**
- * int journal_dirty_data() -  mark a buffer as containing dirty data which
- *                             needs to be flushed before we can commit the
- *                             current transaction.
+ * int journal_dirty_data() - mark a buffer as containing dirty data to be flushed
  * @handle: transaction
  * @bh: bufferhead to mark
  *
+ * Description:
+ * Mark a buffer as containing dirty data which needs to be flushed before
+ * we can commit the current transaction.
+ *
  * The buffer is placed on the transaction's data list and is marked as
  * belonging to the transaction.
  *
@@ -1098,11 +1099,11 @@ no_journal:
 }
 
 /**
- * int journal_dirty_metadata() -  mark a buffer as containing dirty metadata
+ * int journal_dirty_metadata() - mark a buffer as containing dirty metadata
  * @handle: transaction to add buffer to.
  * @bh: buffer to mark
  *
- * mark dirty metadata which needs to be journaled as part of the current
+ * Mark dirty metadata which needs to be journaled as part of the current
  * transaction.
  *
  * The buffer is placed on the transaction's metadata list and is marked
diff --git a/fs/mpage.c b/fs/mpage.c
index 5df564366f36..235e4d3873a8 100644
--- a/fs/mpage.c
+++ b/fs/mpage.c
@@ -325,16 +325,12 @@ confused:
 }
 
 /**
- * mpage_readpages - populate an address space with some pages, and
- *                       start reads against them.
- *
+ * mpage_readpages - populate an address space with some pages & start reads against them
  * @mapping: the address_space
  * @pages: The address of a list_head which contains the target pages.  These
  *   pages have their ->index populated and are otherwise uninitialised.
- *
  *   The page at @pages->prev has the lowest file offset, and reads should be
  *   issued in @pages->prev to @pages->next order.
- *
  * @nr_pages: The number of pages at *@pages
  * @get_block: The filesystem's block mapper function.
  *
@@ -360,6 +356,7 @@ confused:
  * So an mpage read of the first 16 blocks of an ext2 file will cause I/O to be
  * submitted in the following order:
  *      12 0 1 2 3 4 5 6 7 8 9 10 11 13 14 15 16
+ *
  * because the indirect block has to be read to get the mappings of blocks
  * 13,14,15,16.  Obviously, this impacts performance.
  *
@@ -656,9 +653,7 @@ out:
 }
 
 /**
- * mpage_writepages - walk the list of dirty pages of the given
- * address space and writepage() all of them.
- * 
+ * mpage_writepages - walk the list of dirty pages of the given address space & writepage() all of them
  * @mapping: address space structure to write
  * @wbc: subtract the number of written pages from *@wbc->nr_to_write
  * @get_block: the filesystem's block mapper function.
diff --git a/fs/proc/proc_misc.c b/fs/proc/proc_misc.c
index 468805d40e2b..2d563979cb02 100644
--- a/fs/proc/proc_misc.c
+++ b/fs/proc/proc_misc.c
@@ -32,6 +32,7 @@
 #include <linux/interrupt.h>
 #include <linux/swap.h>
 #include <linux/slab.h>
+#include <linux/genhd.h>
 #include <linux/smp.h>
 #include <linux/signal.h>
 #include <linux/module.h>
@@ -377,7 +378,6 @@ static int stram_read_proc(char *page, char **start, off_t off,
 #endif
 
 #ifdef CONFIG_BLOCK
-extern const struct seq_operations partitions_op;
 static int partitions_open(struct inode *inode, struct file *file)
 {
         return seq_open(file, &partitions_op);
@@ -389,7 +389,6 @@ static const struct file_operations proc_partitions_operations = {
         .release        = seq_release,
 };
 
-extern const struct seq_operations diskstats_op;
 static int diskstats_open(struct inode *inode, struct file *file)
 {
         return seq_open(file, &diskstats_op);
diff --git a/fs/splice.c b/fs/splice.c
index 9b559ee711a8..0670c915cd35 100644
--- a/fs/splice.c
+++ b/fs/splice.c
@@ -1669,6 +1669,13 @@ static int link_pipe(struct pipe_inode_info *ipipe,
                 i++;
         } while (len);
 
+        /*
+         * return EAGAIN if we have the potential of some data in the
+         * future, otherwise just return 0
+         */
+        if (!ret && ipipe->waiting_writers && (flags & SPLICE_F_NONBLOCK))
+                ret = -EAGAIN;
+
         inode_double_unlock(ipipe->inode, opipe->inode);
 
         /*
@@ -1709,11 +1716,8 @@ static long do_tee(struct file *in, struct file *out, size_t len,
                 ret = link_ipipe_prep(ipipe, flags);
                 if (!ret) {
                         ret = link_opipe_prep(opipe, flags);
-                        if (!ret) {
+                        if (!ret)
                                 ret = link_pipe(ipipe, opipe, len, flags);
-                                if (!ret && (flags & SPLICE_F_NONBLOCK))
-                                        ret = -EAGAIN;
-                        }
                 }
         }
 
diff --git a/include/asm-m68k/unistd.h b/include/asm-m68k/unistd.h
index 87f77b119317..e72ba563f102 100644
--- a/include/asm-m68k/unistd.h
+++ b/include/asm-m68k/unistd.h
@@ -320,13 +320,15 @@
 #define __NR_epoll_pwait        315
 #define __NR_utimensat          316
 #define __NR_signalfd           317
-#define __NR_timerfd            318
+#define __NR_timerfd_create     318
 #define __NR_eventfd            319
 #define __NR_fallocate          320
+#define __NR_timerfd_settime    321
+#define __NR_timerfd_gettime    322
 
 #ifdef __KERNEL__
 
-#define NR_syscalls             321
+#define NR_syscalls             323
 
 #define __ARCH_WANT_IPC_PARSE_VERSION
 #define __ARCH_WANT_OLD_READDIR
diff --git a/include/asm-m68knommu/machdep.h b/include/asm-m68knommu/machdep.h
index 1cf26d240d83..de9f47a51cc2 100644
--- a/include/asm-m68knommu/machdep.h
+++ b/include/asm-m68knommu/machdep.h
@@ -21,4 +21,6 @@ extern void (*mach_power_off)( void );
 
 extern void config_BSP(char *command, int len);
 
+extern void do_IRQ(int irq, struct pt_regs *fp);
+
 #endif /* _M68KNOMMU_MACHDEP_H */
diff --git a/include/asm-m68knommu/unistd.h b/include/asm-m68knommu/unistd.h
index 27c2f9bb4dbd..4ba98b9c5d79 100644
--- a/include/asm-m68knommu/unistd.h
+++ b/include/asm-m68knommu/unistd.h
@@ -321,13 +321,15 @@
 #define __NR_epoll_pwait        315
 #define __NR_utimensat          316
 #define __NR_signalfd           317
-#define __NR_timerfd            318
+#define __NR_timerfd_create     318
 #define __NR_eventfd            319
 #define __NR_fallocate          320
+#define __NR_timerfd_settime    321
+#define __NR_timerfd_gettime    322
 
 #ifdef __KERNEL__
 
-#define NR_syscalls             321
+#define NR_syscalls             323
 
 #define __ARCH_WANT_IPC_PARSE_VERSION
 #define __ARCH_WANT_OLD_READDIR
diff --git a/include/asm-powerpc/reg.h b/include/asm-powerpc/reg.h
index 0d6238987df8..edc0cfd7f6e2 100644
--- a/include/asm-powerpc/reg.h
+++ b/include/asm-powerpc/reg.h
@@ -153,6 +153,9 @@
 #define   CTRL_RUNLATCH 0x1
 #define SPRN_DABR       0x3F5   /* Data Address Breakpoint Register */
 #define   DABR_TRANSLATION      (1UL << 2)
+#define SPRN_DABRX      0x3F7   /* Data Address Breakpoint Register Extension */
+#define   DABRX_USER    (1UL << 0)
+#define   DABRX_KERNEL  (1UL << 1)
 #define SPRN_DAR        0x013   /* Data Address Register */
 #define SPRN_DSISR      0x012   /* Data Storage Interrupt Status Register */
 #define   DSISR_NOHPTE          0x40000000      /* no translation found */
diff --git a/include/asm-x86/pgtable_32.h b/include/asm-x86/pgtable_32.h
index b478efa971e0..a842c7222b1e 100644
--- a/include/asm-x86/pgtable_32.h
+++ b/include/asm-x86/pgtable_32.h
@@ -91,9 +91,7 @@ extern unsigned long pg0[];
 /* To avoid harmful races, pmd_none(x) should check only the lower when PAE */
 #define pmd_none(x)     (!(unsigned long)pmd_val(x))
 #define pmd_present(x)  (pmd_val(x) & _PAGE_PRESENT)
-#define pmd_bad(x)      ((pmd_val(x) \
-                          & ~(PAGE_MASK | _PAGE_USER | _PAGE_PSE | _PAGE_NX)) \
-                         != _KERNPG_TABLE)
+#define pmd_bad(x)      ((pmd_val(x) & (~PAGE_MASK & ~_PAGE_USER)) != _KERNPG_TABLE)
 
 
 #define pages_to_mb(x) ((x) >> (20-PAGE_SHIFT))
diff --git a/include/asm-x86/pgtable_64.h b/include/asm-x86/pgtable_64.h
index 0a9258333cbd..0a0b77bc736a 100644
--- a/include/asm-x86/pgtable_64.h
+++ b/include/asm-x86/pgtable_64.h
@@ -153,14 +153,12 @@ static inline unsigned long pgd_bad(pgd_t pgd)
 
 static inline unsigned long pud_bad(pud_t pud)
 {
-        return pud_val(pud) &
-                ~(PTE_MASK | _KERNPG_TABLE | _PAGE_USER | _PAGE_PSE | _PAGE_NX);
+        return pud_val(pud) & ~(PTE_MASK | _KERNPG_TABLE | _PAGE_USER);
 }
 
 static inline unsigned long pmd_bad(pmd_t pmd)
 {
-        return pmd_val(pmd) &
-                ~(PTE_MASK | _KERNPG_TABLE | _PAGE_USER | _PAGE_PSE | _PAGE_NX);
+        return pmd_val(pmd) & ~(PTE_MASK | _KERNPG_TABLE | _PAGE_USER);
 }
 
 #define pte_none(x)     (!pte_val(x))
diff --git a/include/linux/blkdev.h b/include/linux/blkdev.h
index 6fe67d1939c2..6f79d40dd3c0 100644
--- a/include/linux/blkdev.h
+++ b/include/linux/blkdev.h
@@ -216,8 +216,8 @@ struct request {
         unsigned int cmd_len;
         unsigned char cmd[BLK_MAX_CDB];
 
-        unsigned int raw_data_len;
         unsigned int data_len;
+        unsigned int extra_len; /* length of alignment and padding */
         unsigned int sense_len;
         void *data;
         void *sense;
@@ -362,6 +362,7 @@ struct request_queue
         unsigned long           seg_boundary_mask;
         void                    *dma_drain_buffer;
         unsigned int            dma_drain_size;
+        unsigned int            dma_pad_mask;
         unsigned int            dma_alignment;
 
         struct blk_queue_tag    *queue_tags;
@@ -701,6 +702,7 @@ extern void blk_queue_max_hw_segments(struct request_queue *, unsigned short);
 extern void blk_queue_max_segment_size(struct request_queue *, unsigned int);
 extern void blk_queue_hardsect_size(struct request_queue *, unsigned short);
 extern void blk_queue_stack_limits(struct request_queue *t, struct request_queue *b);
+extern void blk_queue_dma_pad(struct request_queue *, unsigned int);
 extern int blk_queue_dma_drain(struct request_queue *q,
                                dma_drain_needed_fn *dma_drain_needed,
                                void *buf, unsigned int size);
diff --git a/include/linux/genhd.h b/include/linux/genhd.h
index 09a3b18918c7..32c2ac49a070 100644
--- a/include/linux/genhd.h
+++ b/include/linux/genhd.h
@@ -18,11 +18,13 @@
 #define dev_to_disk(device) container_of(device, struct gendisk, dev)
 #define dev_to_part(device) container_of(device, struct hd_struct, dev)
 
-extern struct device_type disk_type;
 extern struct device_type part_type;
 extern struct kobject *block_depr;
 extern struct class block_class;
 
+extern const struct seq_operations partitions_op;
+extern const struct seq_operations diskstats_op;
+
 enum {
 /* These three have identical behaviour; use the second one if DOS FDISK gets
    confused about extended/logical partitions starting past cylinder 1023. */
@@ -556,7 +558,6 @@ extern struct gendisk *alloc_disk_node(int minors, int node_id);
 extern struct gendisk *alloc_disk(int minors);
 extern struct kobject *get_disk(struct gendisk *disk);
 extern void put_disk(struct gendisk *disk);
-extern void genhd_media_change_notify(struct gendisk *disk);
 extern void blk_register_region(dev_t devt, unsigned long range,
                         struct module *module,
                         struct kobject *(*probe)(dev_t, int *, void *),
diff --git a/include/linux/mm_types.h b/include/linux/mm_types.h
index bfee0bd1d435..34023c65d466 100644
--- a/include/linux/mm_types.h
+++ b/include/linux/mm_types.h
@@ -64,10 +64,7 @@ struct page {
 #if NR_CPUS >= CONFIG_SPLIT_PTLOCK_CPUS
             spinlock_t ptl;
 #endif
-            struct {
-                   struct kmem_cache *slab;     /* SLUB: Pointer to slab */
-                   void *end;                   /* SLUB: end marker */
-            };
+            struct kmem_cache *slab;    /* SLUB: Pointer to slab */
             struct page *first_page;    /* Compound tail pages */
         };
         union {
diff --git a/include/linux/slub_def.h b/include/linux/slub_def.h
index 57deecc79d52..b00c1c73eb0a 100644
--- a/include/linux/slub_def.h
+++ b/include/linux/slub_def.h
@@ -61,7 +61,7 @@ struct kmem_cache {
         int size;               /* The size of an object including meta data */
         int objsize;            /* The size of an object without meta data */
         int offset;             /* Free pointer offset. */
-        int order;
+        int order;              /* Current preferred allocation order */
 
         /*
          * Avoid an extra cache line for UP, SMP and for the node local to
@@ -138,11 +138,11 @@ static __always_inline int kmalloc_index(size_t size)
         if (size <=        512) return 9;
         if (size <=       1024) return 10;
         if (size <=   2 * 1024) return 11;
+        if (size <=   4 * 1024) return 12;
 /*
  * The following is only needed to support architectures with a larger page
  * size than 4k.
  */
-        if (size <=   4 * 1024) return 12;
         if (size <=   8 * 1024) return 13;
         if (size <=  16 * 1024) return 14;
         if (size <=  32 * 1024) return 15;
diff --git a/include/linux/usb.h b/include/linux/usb.h
index 2372e2e6b527..5bd3ae8aaaf4 100644
--- a/include/linux/usb.h
+++ b/include/linux/usb.h
@@ -781,8 +781,7 @@ static inline int usb_endpoint_is_isoc_out(
         .idVendor = (vend), \
         .idProduct = (prod)
 /**
- * USB_DEVICE_VER - macro used to describe a specific usb device with a
- *              version range
+ * USB_DEVICE_VER - describe a specific usb device with a version range
  * @vend: the 16 bit USB Vendor ID
  * @prod: the 16 bit USB Product ID
  * @lo: the bcdDevice_lo value
@@ -799,8 +798,7 @@ static inline int usb_endpoint_is_isoc_out(
         .bcdDevice_hi = (hi)
 
 /**
- * USB_DEVICE_INTERFACE_PROTOCOL - macro used to describe a usb
- *              device with a specific interface protocol
+ * USB_DEVICE_INTERFACE_PROTOCOL - describe a usb device with a specific interface protocol
  * @vend: the 16 bit USB Vendor ID
  * @prod: the 16 bit USB Product ID
  * @pr: bInterfaceProtocol value
@@ -846,8 +844,7 @@ static inline int usb_endpoint_is_isoc_out(
         .bInterfaceProtocol = (pr)
 
 /**
- * USB_DEVICE_AND_INTERFACE_INFO - macro used to describe a specific usb device
- *              with a class of usb interfaces
+ * USB_DEVICE_AND_INTERFACE_INFO - describe a specific usb device with a class of usb interfaces
  * @vend: the 16 bit USB Vendor ID
  * @prod: the 16 bit USB Product ID
  * @cl: bInterfaceClass value
diff --git a/kernel/exit.c b/kernel/exit.c
index 506a957b665a..cd20bf07e9e3 100644
--- a/kernel/exit.c
+++ b/kernel/exit.c
@@ -214,20 +214,19 @@ struct pid *session_of_pgrp(struct pid *pgrp)
 static int will_become_orphaned_pgrp(struct pid *pgrp, struct task_struct *ignored_task)
 {
         struct task_struct *p;
-        int ret = 1;
 
         do_each_pid_task(pgrp, PIDTYPE_PGID, p) {
-                if (p == ignored_task
-                                || p->exit_state
-                                || is_global_init(p->real_parent))
+                if ((p == ignored_task) ||
+                    (p->exit_state && thread_group_empty(p)) ||
+                    is_global_init(p->real_parent))
                         continue;
+
                 if (task_pgrp(p->real_parent) != pgrp &&
-                    task_session(p->real_parent) == task_session(p)) {
-                        ret = 0;
-                        break;
-                }
+                    task_session(p->real_parent) == task_session(p))
+                        return 0;
         } while_each_pid_task(pgrp, PIDTYPE_PGID, p);
-        return ret;     /* (sighing) "Often!" */
+
+        return 1;
 }
 
 int is_current_pgrp_orphaned(void)
@@ -255,6 +254,37 @@ static int has_stopped_jobs(struct pid *pgrp)
         return retval;
 }
 
+/*
+ * Check to see if any process groups have become orphaned as
+ * a result of our exiting, and if they have any stopped jobs,
+ * send them a SIGHUP and then a SIGCONT. (POSIX 3.2.2.2)
+ */
+static void
+kill_orphaned_pgrp(struct task_struct *tsk, struct task_struct *parent)
+{
+        struct pid *pgrp = task_pgrp(tsk);
+        struct task_struct *ignored_task = tsk;
+
+        if (!parent)
+                 /* exit: our father is in a different pgrp than
+                  * we are and we were the only connection outside.
+                  */
+                parent = tsk->real_parent;
+        else
+                /* reparent: our child is in a different pgrp than
+                 * we are, and it was the only connection outside.
+                 */
+                ignored_task = NULL;
+
+        if (task_pgrp(parent) != pgrp &&
+            task_session(parent) == task_session(tsk) &&
+            will_become_orphaned_pgrp(pgrp, ignored_task) &&
+            has_stopped_jobs(pgrp)) {
+                __kill_pgrp_info(SIGHUP, SEND_SIG_PRIV, pgrp);
+                __kill_pgrp_info(SIGCONT, SEND_SIG_PRIV, pgrp);
+        }
+}
+
 /**
  * reparent_to_kthreadd - Reparent the calling kernel thread to kthreadd
  *
@@ -635,22 +665,7 @@ reparent_thread(struct task_struct *p, struct task_struct *father, int traced)
             p->exit_signal != -1 && thread_group_empty(p))
                 do_notify_parent(p, p->exit_signal);
 
-        /*
-         * process group orphan check
-         * Case ii: Our child is in a different pgrp
-         * than we are, and it was the only connection
-         * outside, so the child pgrp is now orphaned.
-         */
-        if ((task_pgrp(p) != task_pgrp(father)) &&
-            (task_session(p) == task_session(father))) {
-                struct pid *pgrp = task_pgrp(p);
-
-                if (will_become_orphaned_pgrp(pgrp, NULL) &&
-                    has_stopped_jobs(pgrp)) {
-                        __kill_pgrp_info(SIGHUP, SEND_SIG_PRIV, pgrp);
-                        __kill_pgrp_info(SIGCONT, SEND_SIG_PRIV, pgrp);
-                }
-        }
+        kill_orphaned_pgrp(p, father);
 }
 
 /*
@@ -735,11 +750,9 @@ static void forget_original_parent(struct task_struct *father)
  * Send signals to all our closest relatives so that they know
  * to properly mourn us..
  */
-static void exit_notify(struct task_struct *tsk)
+static void exit_notify(struct task_struct *tsk, int group_dead)
 {
         int state;
-        struct task_struct *t;
-        struct pid *pgrp;
 
         /*
          * This does two things:
@@ -753,25 +766,8 @@ static void exit_notify(struct task_struct *tsk)
         exit_task_namespaces(tsk);
 
         write_lock_irq(&tasklist_lock);
-        /*
-         * Check to see if any process groups have become orphaned
-         * as a result of our exiting, and if they have any stopped
-         * jobs, send them a SIGHUP and then a SIGCONT.  (POSIX 3.2.2.2)
-         *
-         * Case i: Our father is in a different pgrp than we are
-         * and we were the only connection outside, so our pgrp
-         * is about to become orphaned.
-         */
-        t = tsk->real_parent;
-
-        pgrp = task_pgrp(tsk);
-        if ((task_pgrp(t) != pgrp) &&
-            (task_session(t) == task_session(tsk)) &&
-            will_become_orphaned_pgrp(pgrp, tsk) &&
-            has_stopped_jobs(pgrp)) {
-                __kill_pgrp_info(SIGHUP, SEND_SIG_PRIV, pgrp);
-                __kill_pgrp_info(SIGCONT, SEND_SIG_PRIV, pgrp);
-        }
+        if (group_dead)
+                kill_orphaned_pgrp(tsk->group_leader, NULL);
 
         /* Let father know we died
          *
@@ -788,8 +784,8 @@ static void exit_notify(struct task_struct *tsk)
          * the same after a fork.
          */
         if (tsk->exit_signal != SIGCHLD && tsk->exit_signal != -1 &&
-            ( tsk->parent_exec_id != t->self_exec_id  ||
-              tsk->self_exec_id != tsk->parent_exec_id)
+            (tsk->parent_exec_id != tsk->real_parent->self_exec_id ||
+             tsk->self_exec_id != tsk->parent_exec_id)
             && !capable(CAP_KILL))
                 tsk->exit_signal = SIGCHLD;
 
@@ -986,7 +982,7 @@ NORET_TYPE void do_exit(long code)
                 module_put(tsk->binfmt->module);
 
         proc_exit_connector(tsk);
-        exit_notify(tsk);
+        exit_notify(tsk, group_dead);
 #ifdef CONFIG_NUMA
         mpol_free(tsk->mempolicy);
         tsk->mempolicy = NULL;
diff --git a/kernel/power/process.c b/kernel/power/process.c
index 7c2118f9597f..f1d0b345c9ba 100644
--- a/kernel/power/process.c
+++ b/kernel/power/process.c
@@ -75,22 +75,15 @@ void refrigerator(void)
         __set_current_state(save);
 }
 
-static void fake_signal_wake_up(struct task_struct *p, int resume)
+static void fake_signal_wake_up(struct task_struct *p)
 {
         unsigned long flags;
 
         spin_lock_irqsave(&p->sighand->siglock, flags);
-        signal_wake_up(p, resume);
+        signal_wake_up(p, 0);
         spin_unlock_irqrestore(&p->sighand->siglock, flags);
 }
 
-static void send_fake_signal(struct task_struct *p)
-{
-        if (task_is_stopped(p))
-                force_sig_specific(SIGSTOP, p);
-        fake_signal_wake_up(p, task_is_stopped(p));
-}
-
 static int has_mm(struct task_struct *p)
 {
         return (p->mm && !(p->flags & PF_BORROWED_MM));
@@ -121,7 +114,7 @@ static int freeze_task(struct task_struct *p, int with_mm_only)
         if (freezing(p)) {
                 if (has_mm(p)) {
                         if (!signal_pending(p))
-                                fake_signal_wake_up(p, 0);
+                                fake_signal_wake_up(p);
                 } else {
                         if (with_mm_only)
                                 ret = 0;
@@ -135,7 +128,7 @@ static int freeze_task(struct task_struct *p, int with_mm_only)
                 } else {
                         if (has_mm(p)) {
                                 set_freeze_flag(p);
-                                send_fake_signal(p);
+                                fake_signal_wake_up(p);
                         } else {
                                 if (with_mm_only) {
                                         ret = 0;
@@ -182,15 +175,17 @@ static int try_to_freeze_tasks(int freeze_user_space)
                         if (frozen(p) || !freezeable(p))
                                 continue;
 
-                        if (task_is_traced(p) && frozen(p->parent)) {
-                                cancel_freezing(p);
-                                continue;
-                        }
-
                         if (!freeze_task(p, freeze_user_space))
                                 continue;
 
-                        if (!freezer_should_skip(p))
+                        /*
+                         * Now that we've done set_freeze_flag, don't
+                         * perturb a task in TASK_STOPPED or TASK_TRACED.
+                         * It is "frozen enough".  If the task does wake
+                         * up, it will immediately call try_to_freeze.
+                         */
+                        if (!task_is_stopped_or_traced(p) &&
+                            !freezer_should_skip(p))
                                 todo++;
                 } while_each_thread(g, p);
                 read_unlock(&tasklist_lock);
diff --git a/kernel/signal.c b/kernel/signal.c
index 84917fe507f7..6af1210092c3 100644
--- a/kernel/signal.c
+++ b/kernel/signal.c
@@ -1623,7 +1623,6 @@ static void ptrace_stop(int exit_code, int clear_code, siginfo_t *info)
         /* Let the debugger run.  */
         __set_current_state(TASK_TRACED);
         spin_unlock_irq(&current->sighand->siglock);
-        try_to_freeze();
         read_lock(&tasklist_lock);
         if (!unlikely(killed) && may_ptrace_stop()) {
                 do_notify_parent_cldstop(current, CLD_TRAPPED);
@@ -1641,6 +1640,13 @@ static void ptrace_stop(int exit_code, int clear_code, siginfo_t *info)
         }
 
         /*
+         * While in TASK_TRACED, we were considered "frozen enough".
+         * Now that we woke up, it's crucial if we're supposed to be
+         * frozen that we freeze now before running anything substantial.
+         */
+        try_to_freeze();
+
+        /*
          * We are back.  Now reacquire the siglock before touching
          * last_siginfo, so that we are sure to have synchronized with
          * any signal-sending on another CPU that wants to examine it.
@@ -1757,9 +1763,15 @@ int get_signal_to_deliver(siginfo_t *info, struct k_sigaction *return_ka,
         sigset_t *mask = &current->blocked;
         int signr = 0;
 
+relock:
+        /*
+         * We'll jump back here after any time we were stopped in TASK_STOPPED.
+         * While in TASK_STOPPED, we were considered "frozen enough".
+         * Now that we woke up, it's crucial if we're supposed to be
+         * frozen that we freeze now before running anything substantial.
+         */
         try_to_freeze();
 
-relock:
         spin_lock_irq(&current->sighand->siglock);
         for (;;) {
                 struct k_sigaction *ka;
diff --git a/mm/slub.c b/mm/slub.c
index 74c65af0a54f..0863fd38a5ce 100644
--- a/mm/slub.c
+++ b/mm/slub.c
@@ -291,32 +291,16 @@ static inline struct kmem_cache_cpu *get_cpu_slab(struct kmem_cache *s, int cpu)
 #endif
 }
 
-/*
- * The end pointer in a slab is special. It points to the first object in the
- * slab but has bit 0 set to mark it.
- *
- * Note that SLUB relies on page_mapping returning NULL for pages with bit 0
- * in the mapping set.
- */
-static inline int is_end(void *addr)
-{
-        return (unsigned long)addr & PAGE_MAPPING_ANON;
-}
-
-static void *slab_address(struct page *page)
-{
-        return page->end - PAGE_MAPPING_ANON;
-}
-
+/* Verify that a pointer has an address that is valid within a slab page */
 static inline int check_valid_pointer(struct kmem_cache *s,
                                 struct page *page, const void *object)
 {
         void *base;
 
-        if (object == page->end)
+        if (!object)
                 return 1;
 
-        base = slab_address(page);
+        base = page_address(page);
         if (object < base || object >= base + s->objects * s->size ||
                 (object - base) % s->size) {
                 return 0;
@@ -349,8 +333,7 @@ static inline void set_freepointer(struct kmem_cache *s, void *object, void *fp)
 
 /* Scan freelist */
 #define for_each_free_object(__p, __s, __free) \
-        for (__p = (__free); (__p) != page->end; __p = get_freepointer((__s),\
-                __p))
+        for (__p = (__free); __p; __p = get_freepointer((__s), __p))
 
 /* Determine object index from a given position */
 static inline int slab_index(void *p, struct kmem_cache *s, void *addr)
@@ -502,7 +485,7 @@ static void slab_fix(struct kmem_cache *s, char *fmt, ...)
 static void print_trailer(struct kmem_cache *s, struct page *page, u8 *p)
 {
         unsigned int off;       /* Offset of last byte */
-        u8 *addr = slab_address(page);
+        u8 *addr = page_address(page);
 
         print_tracking(s, p);
 
@@ -637,7 +620,7 @@ static int check_bytes_and_report(struct kmem_cache *s, struct page *page,
  *      A. Free pointer (if we cannot overwrite object on free)
  *      B. Tracking data for SLAB_STORE_USER
  *      C. Padding to reach required alignment boundary or at mininum
- *              one word if debuggin is on to be able to detect writes
+ *              one word if debugging is on to be able to detect writes
  *              before the word boundary.
  *
  *      Padding is done using 0x5a (POISON_INUSE)
@@ -680,7 +663,7 @@ static int slab_pad_check(struct kmem_cache *s, struct page *page)
         if (!(s->flags & SLAB_POISON))
                 return 1;
 
-        start = slab_address(page);
+        start = page_address(page);
         end = start + (PAGE_SIZE << s->order);
         length = s->objects * s->size;
         remainder = end - (start + length);
@@ -748,7 +731,7 @@ static int check_object(struct kmem_cache *s, struct page *page,
                  * of the free objects in this slab. May cause
                  * another error because the object count is now wrong.
                  */
-                set_freepointer(s, p, page->end);
+                set_freepointer(s, p, NULL);
                 return 0;
         }
         return 1;
@@ -782,18 +765,18 @@ static int on_freelist(struct kmem_cache *s, struct page *page, void *search)
         void *fp = page->freelist;
         void *object = NULL;
 
-        while (fp != page->end && nr <= s->objects) {
+        while (fp && nr <= s->objects) {
                 if (fp == search)
                         return 1;
                 if (!check_valid_pointer(s, page, fp)) {
                         if (object) {
                                 object_err(s, page, object,
                                         "Freechain corrupt");
-                                set_freepointer(s, object, page->end);
+                                set_freepointer(s, object, NULL);
                                 break;
                         } else {
                                 slab_err(s, page, "Freepointer corrupt");
-                                page->freelist = page->end;
+                                page->freelist = NULL;
                                 page->inuse = s->objects;
                                 slab_fix(s, "Freelist cleared");
                                 return 0;
@@ -870,7 +853,7 @@ static int alloc_debug_processing(struct kmem_cache *s, struct page *page,
         if (!check_slab(s, page))
                 goto bad;
 
-        if (object && !on_freelist(s, page, object)) {
+        if (!on_freelist(s, page, object)) {
                 object_err(s, page, object, "Object already allocated");
                 goto bad;
         }
@@ -880,7 +863,7 @@ static int alloc_debug_processing(struct kmem_cache *s, struct page *page,
                 goto bad;
         }
 
-        if (object && !check_object(s, page, object, 0))
+        if (!check_object(s, page, object, 0))
                 goto bad;
 
         /* Success perform special debug activities for allocs */
@@ -899,7 +882,7 @@ bad:
                  */
                 slab_fix(s, "Marking all objects used");
                 page->inuse = s->objects;
-                page->freelist = page->end;
+                page->freelist = NULL;
         }
         return 0;
 }
@@ -939,7 +922,7 @@ static int free_debug_processing(struct kmem_cache *s, struct page *page,
         }
 
         /* Special debug activities for freeing objects */
-        if (!SlabFrozen(page) && page->freelist == page->end)
+        if (!SlabFrozen(page) && !page->freelist)
                 remove_full(s, page);
         if (s->flags & SLAB_STORE_USER)
                 set_track(s, object, TRACK_FREE, addr);
@@ -1015,30 +998,11 @@ static unsigned long kmem_cache_flags(unsigned long objsize,
         void (*ctor)(struct kmem_cache *, void *))
 {
         /*
-         * The page->offset field is only 16 bit wide. This is an offset
-         * in units of words from the beginning of an object. If the slab
-         * size is bigger then we cannot move the free pointer behind the
-         * object anymore.
-         *
-         * On 32 bit platforms the limit is 256k. On 64bit platforms
-         * the limit is 512k.
-         *
-         * Debugging or ctor may create a need to move the free
-         * pointer. Fail if this happens.
+         * Enable debugging if selected on the kernel commandline.
          */
-        if (objsize >= 65535 * sizeof(void *)) {
-                BUG_ON(flags & (SLAB_RED_ZONE | SLAB_POISON |
-                                SLAB_STORE_USER | SLAB_DESTROY_BY_RCU));
-                BUG_ON(ctor);
-        } else {
-                /*
-                 * Enable debugging if selected on the kernel commandline.
-                 */
-                if (slub_debug && (!slub_debug_slabs ||
-                    strncmp(slub_debug_slabs, name,
-                        strlen(slub_debug_slabs)) == 0))
-                                flags |= slub_debug;
-        }
+        if (slub_debug && (!slub_debug_slabs ||
+            strncmp(slub_debug_slabs, name, strlen(slub_debug_slabs)) == 0))
+                        flags |= slub_debug;
 
         return flags;
 }
@@ -1124,7 +1088,6 @@ static struct page *new_slab(struct kmem_cache *s, gfp_t flags, int node)
                 SetSlabDebug(page);
 
         start = page_address(page);
-        page->end = start + 1;
 
         if (unlikely(s->flags & SLAB_POISON))
                 memset(start, POISON_INUSE, PAGE_SIZE << s->order);
@@ -1136,7 +1099,7 @@ static struct page *new_slab(struct kmem_cache *s, gfp_t flags, int node)
                 last = p;
         }
         setup_object(s, page, last);
-        set_freepointer(s, last, page->end);
+        set_freepointer(s, last, NULL);
 
         page->freelist = start;
         page->inuse = 0;
@@ -1152,7 +1115,7 @@ static void __free_slab(struct kmem_cache *s, struct page *page)
                 void *p;
 
                 slab_pad_check(s, page);
-                for_each_object(p, s, slab_address(page))
+                for_each_object(p, s, page_address(page))
                         check_object(s, page, p, 0);
                 ClearSlabDebug(page);
         }
@@ -1162,7 +1125,6 @@ static void __free_slab(struct kmem_cache *s, struct page *page)
                 NR_SLAB_RECLAIMABLE : NR_SLAB_UNRECLAIMABLE,
                 -pages);
 
-        page->mapping = NULL;
         __free_pages(page, s->order);
 }
 
@@ -1307,7 +1269,7 @@ static struct page *get_any_partial(struct kmem_cache *s, gfp_t flags)
          * may return off node objects because partial slabs are obtained
          * from other nodes and filled up.
          *
-         * If /sys/slab/xx/defrag_ratio is set to 100 (which makes
+         * If /sys/kernel/slab/xx/defrag_ratio is set to 100 (which makes
          * defrag_ratio = 1000) then every (well almost) allocation will
          * first attempt to defrag slab caches on other nodes. This means
          * scanning over all nodes to look for partial slabs which may be
@@ -1366,7 +1328,7 @@ static void unfreeze_slab(struct kmem_cache *s, struct page *page, int tail)
         ClearSlabFrozen(page);
         if (page->inuse) {
 
-                if (page->freelist != page->end) {
+                if (page->freelist) {
                         add_partial(n, page, tail);
                         stat(c, tail ? DEACTIVATE_TO_TAIL : DEACTIVATE_TO_HEAD);
                 } else {
@@ -1382,9 +1344,11 @@ static void unfreeze_slab(struct kmem_cache *s, struct page *page, int tail)
                          * Adding an empty slab to the partial slabs in order
                          * to avoid page allocator overhead. This slab needs
                          * to come after the other slabs with objects in
-                         * order to fill them up. That way the size of the
-                         * partial list stays small. kmem_cache_shrink can
-                         * reclaim empty slabs from the partial list.
+                         * so that the others get filled first. That way the
+                         * size of the partial list stays small.
+                         *
+                         * kmem_cache_shrink can reclaim any empty slabs from the
+                         * partial list.
                          */
                         add_partial(n, page, 1);
                         slab_unlock(page);
@@ -1407,15 +1371,11 @@ static void deactivate_slab(struct kmem_cache *s, struct kmem_cache_cpu *c)
         if (c->freelist)
                 stat(c, DEACTIVATE_REMOTE_FREES);
         /*
-         * Merge cpu freelist into freelist. Typically we get here
+         * Merge cpu freelist into slab freelist. Typically we get here
          * because both freelists are empty. So this is unlikely
          * to occur.
-         *
-         * We need to use _is_end here because deactivate slab may
-         * be called for a debug slab. Then c->freelist may contain
-         * a dummy pointer.
          */
-        while (unlikely(!is_end(c->freelist))) {
+        while (unlikely(c->freelist)) {
                 void **object;
 
                 tail = 0;       /* Hot objects. Put the slab first */
@@ -1442,6 +1402,7 @@ static inline void flush_slab(struct kmem_cache *s, struct kmem_cache_cpu *c)
 
 /*
  * Flush cpu slab.
+ *
  * Called from IPI handler with interrupts disabled.
  */
 static inline void __flush_cpu_slab(struct kmem_cache *s, int cpu)
@@ -1500,7 +1461,8 @@ static inline int node_match(struct kmem_cache_cpu *c, int node)
  * rest of the freelist to the lockless freelist.
  *
  * And if we were unable to get a new slab from the partial slab lists then
- * we need to allocate a new slab. This is slowest path since we may sleep.
+ * we need to allocate a new slab. This is the slowest path since it involves
+ * a call to the page allocator and the setup of a new slab.
  */
 static void *__slab_alloc(struct kmem_cache *s,
                 gfp_t gfpflags, int node, void *addr, struct kmem_cache_cpu *c)
@@ -1514,18 +1476,19 @@ static void *__slab_alloc(struct kmem_cache *s,
         slab_lock(c->page);
         if (unlikely(!node_match(c, node)))
                 goto another_slab;
+
         stat(c, ALLOC_REFILL);
+
 load_freelist:
         object = c->page->freelist;
-        if (unlikely(object == c->page->end))
+        if (unlikely(!object))
                 goto another_slab;
         if (unlikely(SlabDebug(c->page)))
                 goto debug;
 
-        object = c->page->freelist;
         c->freelist = object[c->offset];
         c->page->inuse = s->objects;
-        c->page->freelist = c->page->end;
+        c->page->freelist = NULL;
         c->node = page_to_nid(c->page);
 unlock_out:
         slab_unlock(c->page);
@@ -1578,7 +1541,6 @@ new_slab:
 
         return NULL;
 debug:
-        object = c->page->freelist;
         if (!alloc_debug_processing(s, c->page, object, addr))
                 goto another_slab;
 
@@ -1607,7 +1569,7 @@ static __always_inline void *slab_alloc(struct kmem_cache *s,
 
         local_irq_save(flags);
         c = get_cpu_slab(s, smp_processor_id());
-        if (unlikely(is_end(c->freelist) || !node_match(c, node)))
+        if (unlikely(!c->freelist || !node_match(c, node)))
 
                 object = __slab_alloc(s, gfpflags, node, addr, c);
 
@@ -1659,6 +1621,7 @@ static void __slab_free(struct kmem_cache *s, struct page *page,
 
         if (unlikely(SlabDebug(page)))
                 goto debug;
+
 checks_ok:
         prior = object[offset] = page->freelist;
         page->freelist = object;
@@ -1673,11 +1636,10 @@ checks_ok:
                 goto slab_empty;
 
         /*
-         * Objects left in the slab. If it
-         * was not on the partial list before
+         * Objects left in the slab. If it was not on the partial list before
          * then add it.
          */
-        if (unlikely(prior == page->end)) {
+        if (unlikely(!prior)) {
                 add_partial(get_node(s, page_to_nid(page)), page, 1);
                 stat(c, FREE_ADD_PARTIAL);
         }
@@ -1687,7 +1649,7 @@ out_unlock:
         return;
 
 slab_empty:
-        if (prior != page->end) {
+        if (prior) {
                 /*
                  * Slab still on the partial list.
                  */
@@ -1724,8 +1686,8 @@ static __always_inline void slab_free(struct kmem_cache *s,
         unsigned long flags;
 
         local_irq_save(flags);
-        debug_check_no_locks_freed(object, s->objsize);
         c = get_cpu_slab(s, smp_processor_id());
+        debug_check_no_locks_freed(object, c->objsize);
         if (likely(page == c->page && c->node >= 0)) {
                 object[c->offset] = c->freelist;
                 c->freelist = object;
@@ -1888,13 +1850,11 @@ static unsigned long calculate_alignment(unsigned long flags,
                 unsigned long align, unsigned long size)
 {
         /*
-         * If the user wants hardware cache aligned objects then
-         * follow that suggestion if the object is sufficiently
-         * large.
+         * If the user wants hardware cache aligned objects then follow that
+         * suggestion if the object is sufficiently large.
          *
-         * The hardware cache alignment cannot override the
-         * specified alignment though. If that is greater
-         * then use it.
+         * The hardware cache alignment cannot override the specified
+         * alignment though. If that is greater then use it.
          */
         if ((flags & SLAB_HWCACHE_ALIGN) &&
                         size > cache_line_size() / 2)
@@ -1910,7 +1870,7 @@ static void init_kmem_cache_cpu(struct kmem_cache *s,
                         struct kmem_cache_cpu *c)
 {
         c->page = NULL;
-        c->freelist = (void *)PAGE_MAPPING_ANON;
+        c->freelist = NULL;
         c->node = 0;
         c->offset = s->offset / sizeof(void *);
         c->objsize = s->objsize;
@@ -2092,6 +2052,7 @@ static struct kmem_cache_node *early_kmem_cache_node_alloc(gfp_t gfpflags,
 #endif
         init_kmem_cache_node(n);
         atomic_long_inc(&n->nr_slabs);
+
         /*
          * lockdep requires consistent irq usage for each lock
          * so even though there cannot be a race this early in
@@ -2173,6 +2134,14 @@ static int calculate_sizes(struct kmem_cache *s)
         unsigned long align = s->align;
 
         /*
+         * Round up object size to the next word boundary. We can only
+         * place the free pointer at word boundaries and this determines
+         * the possible location of the free pointer.
+         */
+        size = ALIGN(size, sizeof(void *));
+
+#ifdef CONFIG_SLUB_DEBUG
+        /*
          * Determine if we can poison the object itself. If the user of
          * the slab may touch the object after free or before allocation
          * then we should never poison the object itself.
@@ -2183,14 +2152,7 @@ static int calculate_sizes(struct kmem_cache *s)
         else
                 s->flags &= ~__OBJECT_POISON;
 
-        /*
-         * Round up object size to the next word boundary. We can only
-         * place the free pointer at word boundaries and this determines
-         * the possible location of the free pointer.
-         */
-        size = ALIGN(size, sizeof(void *));
 
-#ifdef CONFIG_SLUB_DEBUG
         /*
          * If we are Redzoning then check if there is some space between the
          * end of the object and the free pointer. If not then add an
@@ -2343,7 +2305,7 @@ int kmem_ptr_validate(struct kmem_cache *s, const void *object)
         /*
          * We could also check if the object is on the slabs freelist.
          * But this would be too expensive and it seems that the main
-         * purpose of kmem_ptr_valid is to check if the object belongs
+         * purpose of kmem_ptr_valid() is to check if the object belongs
          * to a certain slab.
          */
         return 1;
@@ -2630,13 +2592,24 @@ void *__kmalloc(size_t size, gfp_t flags)
 }
 EXPORT_SYMBOL(__kmalloc);
 
+static void *kmalloc_large_node(size_t size, gfp_t flags, int node)
+{
+        struct page *page = alloc_pages_node(node, flags | __GFP_COMP,
+                                                get_order(size));
+
+        if (page)
+                return page_address(page);
+        else
+                return NULL;
+}
+
 #ifdef CONFIG_NUMA
 void *__kmalloc_node(size_t size, gfp_t flags, int node)
 {
         struct kmem_cache *s;
 
         if (unlikely(size > PAGE_SIZE))
-                return kmalloc_large(size, flags);
+                return kmalloc_large_node(size, flags, node);
 
         s = get_slab(size, flags);
 
@@ -2653,19 +2626,17 @@ size_t ksize(const void *object)
         struct page *page;
         struct kmem_cache *s;
 
-        BUG_ON(!object);
         if (unlikely(object == ZERO_SIZE_PTR))
                 return 0;
 
         page = virt_to_head_page(object);
-        BUG_ON(!page);
 
         if (unlikely(!PageSlab(page)))
                 return PAGE_SIZE << compound_order(page);
 
         s = page->slab;
-        BUG_ON(!s);
 
+#ifdef CONFIG_SLUB_DEBUG
         /*
          * Debugging requires use of the padding between object
          * and whatever may come after it.
@@ -2673,6 +2644,7 @@ size_t ksize(const void *object)
         if (s->flags & (SLAB_RED_ZONE | SLAB_POISON))
                 return s->objsize;
 
+#endif
         /*
          * If we have the need to store the freelist pointer
          * back there or track user information then we can
@@ -2680,7 +2652,6 @@ size_t ksize(const void *object)
          */
         if (s->flags & (SLAB_DESTROY_BY_RCU | SLAB_STORE_USER))
                 return s->inuse;
-
         /*
          * Else we can use all the padding etc for the allocation
          */
@@ -2957,7 +2928,7 @@ void __init kmem_cache_init(void)
         /*
          * Patch up the size_index table if we have strange large alignment
          * requirements for the kmalloc array. This is only the case for
-         * mips it seems. The standard arches will not generate any code here.
+         * MIPS it seems. The standard arches will not generate any code here.
          *
          * Largest permitted alignment is 256 bytes due to the way we
          * handle the index determination for the smaller caches.
@@ -2986,7 +2957,6 @@ void __init kmem_cache_init(void)
         kmem_size = sizeof(struct kmem_cache);
 #endif
 
-
         printk(KERN_INFO
                 "SLUB: Genslabs=%d, HWalign=%d, Order=%d-%d, MinObjects=%d,"
                 " CPUs=%d, Nodes=%d\n",
@@ -3083,12 +3053,15 @@ struct kmem_cache *kmem_cache_create(const char *name, size_t size,
                  */
                 for_each_online_cpu(cpu)
                         get_cpu_slab(s, cpu)->objsize = s->objsize;
+
                 s->inuse = max_t(int, s->inuse, ALIGN(size, sizeof(void *)));
                 up_write(&slub_lock);
+
                 if (sysfs_slab_alias(s, name))
                         goto err;
                 return s;
         }
+
         s = kmalloc(kmem_size, GFP_KERNEL);
         if (s) {
                 if (kmem_cache_open(s, GFP_KERNEL, name,
@@ -3184,7 +3157,7 @@ void *__kmalloc_node_track_caller(size_t size, gfp_t gfpflags,
         struct kmem_cache *s;
 
         if (unlikely(size > PAGE_SIZE))
-                return kmalloc_large(size, gfpflags);
+                return kmalloc_large_node(size, gfpflags, node);
 
         s = get_slab(size, gfpflags);
 
@@ -3199,7 +3172,7 @@ static int validate_slab(struct kmem_cache *s, struct page *page,
                                                 unsigned long *map)
 {
         void *p;
-        void *addr = slab_address(page);
+        void *addr = page_address(page);
 
         if (!check_slab(s, page) ||
                         !on_freelist(s, page, NULL))
@@ -3482,7 +3455,7 @@ static int add_location(struct loc_track *t, struct kmem_cache *s,
 static void process_slab(struct loc_track *t, struct kmem_cache *s,
                 struct page *page, enum track_item alloc)
 {
-        void *addr = slab_address(page);
+        void *addr = page_address(page);
         DECLARE_BITMAP(map, s->objects);
         void *p;
 
@@ -3591,8 +3564,8 @@ enum slab_stat_type {
 #define SO_CPU          (1 << SL_CPU)
 #define SO_OBJECTS      (1 << SL_OBJECTS)
 
-static unsigned long slab_objects(struct kmem_cache *s,
-                        char *buf, unsigned long flags)
+static ssize_t show_slab_objects(struct kmem_cache *s,
+                            char *buf, unsigned long flags)
 {
         unsigned long total = 0;
         int cpu;
@@ -3602,6 +3575,8 @@ static unsigned long slab_objects(struct kmem_cache *s,
         unsigned long *per_cpu;
 
         nodes = kzalloc(2 * sizeof(unsigned long) * nr_node_ids, GFP_KERNEL);
+        if (!nodes)
+                return -ENOMEM;
         per_cpu = nodes + nr_node_ids;
 
         for_each_possible_cpu(cpu) {
@@ -3754,25 +3729,25 @@ SLAB_ATTR_RO(aliases);
 
 static ssize_t slabs_show(struct kmem_cache *s, char *buf)
 {
-        return slab_objects(s, buf, SO_FULL|SO_PARTIAL|SO_CPU);
+        return show_slab_objects(s, buf, SO_FULL|SO_PARTIAL|SO_CPU);
 }
 SLAB_ATTR_RO(slabs);
 
 static ssize_t partial_show(struct kmem_cache *s, char *buf)
 {
-        return slab_objects(s, buf, SO_PARTIAL);
+        return show_slab_objects(s, buf, SO_PARTIAL);
 }
 SLAB_ATTR_RO(partial);
 
 static ssize_t cpu_slabs_show(struct kmem_cache *s, char *buf)
 {
-        return slab_objects(s, buf, SO_CPU);
+        return show_slab_objects(s, buf, SO_CPU);
 }
 SLAB_ATTR_RO(cpu_slabs);
 
 static ssize_t objects_show(struct kmem_cache *s, char *buf)
 {
-        return slab_objects(s, buf, SO_FULL|SO_PARTIAL|SO_CPU|SO_OBJECTS);
+        return show_slab_objects(s, buf, SO_FULL|SO_PARTIAL|SO_CPU|SO_OBJECTS);
 }
 SLAB_ATTR_RO(objects);
 
@@ -3971,7 +3946,6 @@ SLAB_ATTR(remote_node_defrag_ratio);
 #endif
 
 #ifdef CONFIG_SLUB_STATS
-
 static int show_stat(struct kmem_cache *s, char *buf, enum stat_item si)
 {
         unsigned long sum  = 0;
@@ -4155,8 +4129,8 @@ static struct kset *slab_kset;
 #define ID_STR_LENGTH 64
 
 /* Create a unique string id for a slab cache:
- * format
- * :[flags-]size:[memory address of kmemcache]
+ *
+ * Format       :[flags-]size
  */
 static char *create_unique_id(struct kmem_cache *s)
 {
diff --git a/mm/truncate.c b/mm/truncate.c
index c35c49e54fb6..7d20ce41ecf5 100644
--- a/mm/truncate.c
+++ b/mm/truncate.c
@@ -134,8 +134,7 @@ invalidate_complete_page(struct address_space *mapping, struct page *page)
 }
 
 /**
- * truncate_inode_pages - truncate range of pages specified by start and
- * end byte offsets
+ * truncate_inode_pages - truncate range of pages specified by start & end byte offsets
  * @mapping: mapping to truncate
  * @lstart: offset from which to truncate
  * @lend: offset to which to truncate