Merge ssh://master.kernel.org/pub/scm/linux/kernel/git/torvalds/linux-2.6

author: Mauro Carvalho Chehab <mchehab@infradead.org> 2006-01-15 17:59:29 -0500
committer: Mauro Carvalho Chehab <mchehab@infradead.org> 2006-01-15 17:59:29 -0500
commit: f1dccedc8148026d9071c6805f7cb77374a9e56f (patch)
tree: ba4a630084b8d21309930321ff53a6ed4381c0f3 /include
parent: c943aa859c392eb4cc76d911daa1f261555075b2 (diff)
parent: 0238cb4e7583c521bb3538060f98a73e65f61324 (diff)
144 files changed, 5319 insertions, 1048 deletions
diff --git a/include/asm-arm/arch-ixp2000/ixp2000-regs.h b/include/asm-arm/arch-ixp2000/ixp2000-regs.h
index 8cf70ff160af..2b57f91b4ebd 100644
--- a/include/asm-arm/arch-ixp2000/ixp2000-regs.h
+++ b/include/asm-arm/arch-ixp2000/ixp2000-regs.h
@@ -26,6 +26,8 @@
 * fc000000     da000000        16M             PCI CFG0
 * fd000000     d8000000        16M             PCI I/O
 * fe[0-7]00000                 8M              per-platform mappings
+ * fe900000     80000000        1M              SRAM #0 (first MB)
+ * fea00000     cb400000        1M              SCRATCH ring get/put
 * feb00000     c8000000        1M              MSF
 * fec00000     df000000        1M              PCI CSRs
 * fed00000     de000000        1M              PCI CREG
@@ -91,6 +93,14 @@
 #define IXP2000_MSF_VIRT_BASE           0xfeb00000
 #define IXP2000_MSF_SIZE                0x00100000
+#define IXP2000_SCRATCH_RING_PHYS_BASE  0xcb400000
+#define IXP2000_SCRATCH_RING_VIRT_BASE  0xfea00000
+#define IXP2000_SCRATCH_RING_SIZE       0x00100000
+#define IXP2000_SRAM0_PHYS_BASE         0x80000000
+#define IXP2000_SRAM0_VIRT_BASE         0xfe900000
+#define IXP2000_SRAM0_SIZE              0x00100000
 #define IXP2000_PCI_IO_PHYS_BASE        0xd8000000
 #define IXP2000_PCI_IO_VIRT_BASE        0xfd000000
 #define IXP2000_PCI_IO_SIZE             0x01000000
diff --git a/include/asm-arm/arch-versatile/entry-macro.S b/include/asm-arm/arch-versatile/entry-macro.S
index 58f0d71759f6..feff771c0a0a 100644
--- a/include/asm-arm/arch-versatile/entry-macro.S
+++ b/include/asm-arm/arch-versatile/entry-macro.S
@@ -8,6 +8,7 @@
 * warranty of any kind, whether express or implied.
 */
 #include <asm/hardware.h>
+#include <asm/hardware/vic.h>
                .macro  disable_fiq
                .endm
diff --git a/include/asm-arm/arch-versatile/platform.h b/include/asm-arm/arch-versatile/platform.h
index cbdd9fb96332..72ef874567d5 100644
--- a/include/asm-arm/arch-versatile/platform.h
+++ b/include/asm-arm/arch-versatile/platform.h
@@ -293,26 +293,7 @@
 *      VERSATILE_SYS_IC 
 * 
 */
-#define VIC_IRQ_STATUS                  0
+/* VIC definitions in include/asm-arm/hardware/vic.h */
-#define VIC_FIQ_STATUS                  0x04
-#define VIC_IRQ_RAW_STATUS              0x08
-#define VIC_INT_SELECT                  0x0C    /* 1 = FIQ, 0 = IRQ */
-#define VIC_IRQ_ENABLE                  0x10    /* 1 = enable, 0 = disable */
-#define VIC_IRQ_ENABLE_CLEAR            0x14
-#define VIC_IRQ_SOFT                    0x18
-#define VIC_IRQ_SOFT_CLEAR              0x1C
-#define VIC_PROTECT                     0x20
-#define VIC_VECT_ADDR                   0x30
-#define VIC_DEF_VECT_ADDR               0x34
-#define VIC_VECT_ADDR0                  0x100   /* 0 to 15 */
-#define VIC_VECT_CNTL0                  0x200   /* 0 to 15 */
-#define VIC_ITCR                        0x300   /* VIC test control register */
-#define VIC_FIQ_RAW_STATUS              0x08
-#define VIC_FIQ_ENABLE                  0x10    /* 1 = enable, 0 = disable */
-#define VIC_FIQ_ENABLE_CLEAR            0x14
-#define VIC_FIQ_SOFT                    0x18
-#define VIC_FIQ_SOFT_CLEAR              0x1C
 #define SIC_IRQ_STATUS                  0
 #define SIC_IRQ_RAW_STATUS              0x04
@@ -325,8 +306,6 @@
 #define SIC_INT_PIC_ENABLES             0x20    /* set interrupt pass through bits */
 #define SIC_INT_PIC_ENABLEC             0x24    /* Clear interrupt pass through bits */
-#define VICVectCntl_Enable              (1 << 5)
 /* ------------------------------------------------------------------------
 *  Interrupts - bit assignment (primary)
 * ------------------------------------------------------------------------
diff --git a/include/asm-arm/hardware/vic.h b/include/asm-arm/hardware/vic.h
new file mode 100644
index 000000000000..81825eb54c9e
--- /dev/null
+++ b/include/asm-arm/hardware/vic.h
@@ -0,0 +1,45 @@
+/*
+ *  linux/include/asm-arm/hardware/vic.h
+ *
+ *  Copyright (c) ARM Limited 2003.  All rights reserved.
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; either version 2 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
+ */
+#ifndef __ASM_ARM_HARDWARE_VIC_H
+#define __ASM_ARM_HARDWARE_VIC_H
+#define VIC_IRQ_STATUS                  0x00
+#define VIC_FIQ_STATUS                  0x04
+#define VIC_RAW_STATUS                  0x08
+#define VIC_INT_SELECT                  0x0c    /* 1 = FIQ, 0 = IRQ */
+#define VIC_INT_ENABLE                  0x10    /* 1 = enable, 0 = disable */
+#define VIC_INT_ENABLE_CLEAR            0x14
+#define VIC_INT_SOFT                    0x18
+#define VIC_INT_SOFT_CLEAR              0x1c
+#define VIC_PROTECT                     0x20
+#define VIC_VECT_ADDR                   0x30
+#define VIC_DEF_VECT_ADDR               0x34
+#define VIC_VECT_ADDR0                  0x100   /* 0 to 15 */
+#define VIC_VECT_CNTL0                  0x200   /* 0 to 15 */
+#define VIC_ITCR                        0x300   /* VIC test control register */
+#define VIC_VECT_CNTL_ENABLE            (1 << 5)
+#ifndef __ASSEMBLY__
+void vic_init(void __iomem *base, u32 vic_sources);
+#endif
+#endif
diff --git a/include/asm-arm/mach/arch.h b/include/asm-arm/mach/arch.h
index eb262e078c46..2cd57b4d64d9 100644
--- a/include/asm-arm/mach/arch.h
+++ b/include/asm-arm/mach/arch.h
@@ -10,6 +10,8 @@
 #ifndef __ASSEMBLY__
+#include <linux/compiler.h>
 struct tag;
 struct meminfo;
 struct sys_timer;
@@ -20,7 +22,7 @@ struct machine_desc {
         * by assembler code in head-armv.S
         */
        unsigned int            nr;             /* architecture number  */
-        unsigned int            phys_ram;       /* start of physical ram */
+        unsigned int __deprecated phys_ram;     /* start of physical ram */
        unsigned int            phys_io;        /* start of physical io */
        unsigned int            io_pg_offst;    /* byte offset for io 
                                                 * page tabe entry      */
diff --git a/include/asm-arm/page.h b/include/asm-arm/page.h
index 4da1d532cbeb..416320d95419 100644
--- a/include/asm-arm/page.h
+++ b/include/asm-arm/page.h
@@ -170,6 +170,13 @@ extern pmd_t *top_pmd;
 #define VM_DATA_DEFAULT_FLAGS   (VM_READ | VM_WRITE | VM_EXEC | \
                                 VM_MAYREAD | VM_MAYWRITE | VM_MAYEXEC)
+/*
+ * With EABI on ARMv5 and above we must have 64-bit aligned slab pointers.
+ */
+#if defined(CONFIG_AEABI) && (__LINUX_ARM_ARCH__ >= 5)
+#define ARCH_SLAB_MINALIGN 8
+#endif
 #endif /* __KERNEL__ */
 #include <asm-generic/page.h>
diff --git a/include/asm-arm/processor.h b/include/asm-arm/processor.h
index 31290694648b..04f4d34c6317 100644
--- a/include/asm-arm/processor.h
+++ b/include/asm-arm/processor.h
@@ -49,6 +49,12 @@ struct thread_struct {
 #define INIT_THREAD  {  }
+#ifdef CONFIG_MMU
+#define nommu_start_thread(regs) do { } while (0)
+#else
+#define nommu_start_thread(regs) regs->ARM_r10 = current->mm->start_data
+#endif
 #define start_thread(regs,pc,sp)                                        \
 ({                                                                      \
        unsigned long *stack = (unsigned long *)sp;                     \
@@ -65,6 +71,7 @@ struct thread_struct {
        regs->ARM_r2 = stack[2];        /* r2 (envp) */                 \
        regs->ARM_r1 = stack[1];        /* r1 (argv) */                 \
        regs->ARM_r0 = stack[0];        /* r0 (argc) */                 \
+        nommu_start_thread(regs);                                       \
 })
 /* Forward declaration, a strange C thing */
diff --git a/include/asm-arm/ptrace.h b/include/asm-arm/ptrace.h
index 4377e22b7e1a..77adb7fa169b 100644
--- a/include/asm-arm/ptrace.h
+++ b/include/asm-arm/ptrace.h
@@ -23,6 +23,9 @@
 #define PTRACE_OLDSETOPTIONS    21
 #define PTRACE_GET_THREAD_AREA  22
+#define PTRACE_SET_SYSCALL      23
 /*
 * PSR bits
 */
@@ -60,9 +63,11 @@
 #ifndef __ASSEMBLY__
-/* this struct defines the way the registers are stored on the
+/*
-   stack during a system call. */
+ * This struct defines the way the registers are stored on the
+ * stack during a system call.  Note that sizeof(struct pt_regs)
+ * has to be a multiple of 8.
+ */
 struct pt_regs {
        long uregs[18];
 };
diff --git a/include/asm-arm/stat.h b/include/asm-arm/stat.h
index ec4e2c2e3b47..42c0c13999d5 100644
--- a/include/asm-arm/stat.h
+++ b/include/asm-arm/stat.h
@@ -70,14 +70,7 @@ struct stat64 {
        long long       st_size;
        unsigned long   st_blksize;
+        unsigned long long st_blocks;   /* Number 512-byte blocks allocated. */
-#if defined(__ARMEB__)
-        unsigned long   __pad4;         /* Future possible st_blocks hi bits */
-        unsigned long   st_blocks;      /* Number 512-byte blocks allocated. */
-#else /* Must be little */
-        unsigned long   st_blocks;      /* Number 512-byte blocks allocated. */
-        unsigned long   __pad4;         /* Future possible st_blocks hi bits */
-#endif
        unsigned long   st_atime;
        unsigned long   st_atime_nsec;
@@ -89,6 +82,6 @@ struct stat64 {
        unsigned long   st_ctime_nsec;
        unsigned long long      st_ino;
-} __attribute__((packed));
+};
 #endif
diff --git a/include/asm-arm/statfs.h b/include/asm-arm/statfs.h
index e81f82783b87..a02e6a8c3d70 100644
--- a/include/asm-arm/statfs.h
+++ b/include/asm-arm/statfs.h
@@ -1,6 +1,42 @@
 #ifndef _ASMARM_STATFS_H
 #define _ASMARM_STATFS_H
-#include <asm-generic/statfs.h>
+#ifndef __KERNEL_STRICT_NAMES
+# include <linux/types.h>
+typedef __kernel_fsid_t fsid_t;
+#endif
+struct statfs {
+        __u32 f_type;
+        __u32 f_bsize;
+        __u32 f_blocks;
+        __u32 f_bfree;
+        __u32 f_bavail;
+        __u32 f_files;
+        __u32 f_ffree;
+        __kernel_fsid_t f_fsid;
+        __u32 f_namelen;
+        __u32 f_frsize;
+        __u32 f_spare[5];
+};
+/*
+ * With EABI there is 4 bytes of padding added to this structure.
+ * Let's pack it so the padding goes away to simplify dual ABI support.
+ * Note that user space does NOT have to pack this structure.
+ */
+struct statfs64 {
+        __u32 f_type;
+        __u32 f_bsize;
+        __u64 f_blocks;
+        __u64 f_bfree;
+        __u64 f_bavail;
+        __u64 f_files;
+        __u64 f_ffree;
+        __kernel_fsid_t f_fsid;
+        __u32 f_namelen;
+        __u32 f_frsize;
+        __u32 f_spare[5];
+} __attribute__ ((packed,aligned(4)));
 #endif
diff --git a/include/asm-arm/unistd.h b/include/asm-arm/unistd.h
index d626e70faded..77430d6178ae 100644
--- a/include/asm-arm/unistd.h
+++ b/include/asm-arm/unistd.h
@@ -15,10 +15,12 @@
 #include <linux/linkage.h>
-#if defined(__thumb__)
+#define __NR_OABI_SYSCALL_BASE  0x900000
+#if defined(__thumb__) || defined(__ARM_EABI__)
 #define __NR_SYSCALL_BASE       0
 #else
-#define __NR_SYSCALL_BASE       0x900000
+#define __NR_SYSCALL_BASE       __NR_OABI_SYSCALL_BASE
 #endif
 /*
@@ -373,13 +375,13 @@
 #define __sys1(x) __sys2(x)
 #ifndef __syscall
-#if defined(__thumb__)
+#if defined(__thumb__) || defined(__ARM_EABI__)
-#define __syscall(name)                                 \
+#define __SYS_REG(name) register long __sysreg __asm__("r7") = __NR_##name;
-        "push   {r7}\n\t"                               \
+#define __SYS_REG_LIST(regs...) "r" (__sysreg) , ##regs
-        "mov    r7, #" __sys1(__NR_##name) "\n\t"       \
+#define __syscall(name) "swi\t0"
-        "swi    0\n\t"                                  \
-        "pop    {r7}"
 #else
+#define __SYS_REG(name)
+#define __SYS_REG_LIST(regs...) regs
 #define __syscall(name) "swi\t" __sys1(__NR_##name) ""
 #endif
 #endif
@@ -395,33 +397,34 @@ do {									\
 #define _syscall0(type,name)                                            \
 type name(void) {                                                       \
+  __SYS_REG(name)                                                       \
  register long __res_r0 __asm__("r0");                                 \
  long __res;                                                           \
  __asm__ __volatile__ (                                                \
  __syscall(name)                                                       \
        : "=r" (__res_r0)                                               \
-        :                                                               \
+        : __SYS_REG_LIST() );                                           \
-        : "lr");                                                        \
  __res = __res_r0;                                                     \
  __syscall_return(type,__res);                                         \
 }
 #define _syscall1(type,name,type1,arg1)                                 \
 type name(type1 arg1) {                                                 \
+  __SYS_REG(name)                                                       \
  register long __r0 __asm__("r0") = (long)arg1;                        \
  register long __res_r0 __asm__("r0");                                 \
  long __res;                                                           \
  __asm__ __volatile__ (                                                \
  __syscall(name)                                                       \
        : "=r" (__res_r0)                                               \
-        : "r" (__r0)                                                    \
+        : __SYS_REG_LIST( "0" (__r0) ) );                               \
-        : "lr");                                                        \
  __res = __res_r0;                                                     \
  __syscall_return(type,__res);                                         \
 }
 #define _syscall2(type,name,type1,arg1,type2,arg2)                      \
 type name(type1 arg1,type2 arg2) {                                      \
+  __SYS_REG(name)                                                       \
  register long __r0 __asm__("r0") = (long)arg1;                        \
  register long __r1 __asm__("r1") = (long)arg2;                        \
  register long __res_r0 __asm__("r0");                                 \
@@ -429,8 +432,7 @@ type name(type1 arg1,type2 arg2) {					\
  __asm__ __volatile__ (                                                \
  __syscall(name)                                                       \
        : "=r" (__res_r0)                                               \
-        : "r" (__r0),"r" (__r1)                                         \
+        : __SYS_REG_LIST( "0" (__r0), "r" (__r1) ) );                   \
-        : "lr");                                                        \
  __res = __res_r0;                                                     \
  __syscall_return(type,__res);                                         \
 }
@@ -438,6 +440,7 @@ type name(type1 arg1,type2 arg2) {					\
 #define _syscall3(type,name,type1,arg1,type2,arg2,type3,arg3)           \
 type name(type1 arg1,type2 arg2,type3 arg3) {                           \
+  __SYS_REG(name)                                                       \
  register long __r0 __asm__("r0") = (long)arg1;                        \
  register long __r1 __asm__("r1") = (long)arg2;                        \
  register long __r2 __asm__("r2") = (long)arg3;                        \
@@ -446,8 +449,7 @@ type name(type1 arg1,type2 arg2,type3 arg3) {				\
  __asm__ __volatile__ (                                                \
  __syscall(name)                                                       \
        : "=r" (__res_r0)                                               \
-        : "r" (__r0),"r" (__r1),"r" (__r2)                              \
+        : __SYS_REG_LIST( "0" (__r0), "r" (__r1), "r" (__r2) ) );       \
-        : "lr");                                                        \
  __res = __res_r0;                                                     \
  __syscall_return(type,__res);                                         \
 }
@@ -455,6 +457,7 @@ type name(type1 arg1,type2 arg2,type3 arg3) {				\
 #define _syscall4(type,name,type1,arg1,type2,arg2,type3,arg3,type4,arg4)\
 type name(type1 arg1, type2 arg2, type3 arg3, type4 arg4) {             \
+  __SYS_REG(name)                                                       \
  register long __r0 __asm__("r0") = (long)arg1;                        \
  register long __r1 __asm__("r1") = (long)arg2;                        \
  register long __r2 __asm__("r2") = (long)arg3;                        \
@@ -464,8 +467,7 @@ type name(type1 arg1, type2 arg2, type3 arg3, type4 arg4) {		\
  __asm__ __volatile__ (                                                \
  __syscall(name)                                                       \
        : "=r" (__res_r0)                                               \
-        : "r" (__r0),"r" (__r1),"r" (__r2),"r" (__r3)                   \
+        : __SYS_REG_LIST( "0" (__r0), "r" (__r1), "r" (__r2), "r" (__r3) ) ); \
-        : "lr");                                                        \
  __res = __res_r0;                                                     \
  __syscall_return(type,__res);                                         \
 }
@@ -473,6 +475,7 @@ type name(type1 arg1, type2 arg2, type3 arg3, type4 arg4) {		\
 #define _syscall5(type,name,type1,arg1,type2,arg2,type3,arg3,type4,arg4,type5,arg5)     \
 type name(type1 arg1, type2 arg2, type3 arg3, type4 arg4, type5 arg5) { \
+  __SYS_REG(name)                                                       \
  register long __r0 __asm__("r0") = (long)arg1;                        \
  register long __r1 __asm__("r1") = (long)arg2;                        \
  register long __r2 __asm__("r2") = (long)arg3;                        \
@@ -483,14 +486,15 @@ type name(type1 arg1, type2 arg2, type3 arg3, type4 arg4, type5 arg5) {	\
  __asm__ __volatile__ (                                                \
  __syscall(name)                                                       \
        : "=r" (__res_r0)                                               \
-        : "r" (__r0),"r" (__r1),"r" (__r2),"r" (__r3),"r" (__r4)        \
+        : __SYS_REG_LIST( "0" (__r0), "r" (__r1), "r" (__r2),           \
-        : "lr");                                                        \
+                          "r" (__r3), "r" (__r4) ) );                   \
  __res = __res_r0;                                                     \
  __syscall_return(type,__res);                                         \
 }
 #define _syscall6(type,name,type1,arg1,type2,arg2,type3,arg3,type4,arg4,type5,arg5,type6,arg6)  \
 type name(type1 arg1, type2 arg2, type3 arg3, type4 arg4, type5 arg5, type6 arg6) {     \
+  __SYS_REG(name)                                                       \
  register long __r0 __asm__("r0") = (long)arg1;                        \
  register long __r1 __asm__("r1") = (long)arg2;                        \
  register long __r2 __asm__("r2") = (long)arg3;                        \
@@ -502,30 +506,33 @@ type name(type1 arg1, type2 arg2, type3 arg3, type4 arg4, type5 arg5, type6 arg6
  __asm__ __volatile__ (                                                \
  __syscall(name)                                                       \
        : "=r" (__res_r0)                                               \
-        : "r" (__r0),"r" (__r1),"r" (__r2),"r" (__r3), "r" (__r4),"r" (__r5)            \
+        : __SYS_REG_LIST( "0" (__r0), "r" (__r1), "r" (__r2),           \
-        : "lr");                                                        \
+                          "r" (__r3), "r" (__r4), "r" (__r5) ) );       \
  __res = __res_r0;                                                     \
  __syscall_return(type,__res);                                         \
 }
 #ifdef __KERNEL__
 #define __ARCH_WANT_IPC_PARSE_VERSION
-#define __ARCH_WANT_OLD_READDIR
 #define __ARCH_WANT_STAT64
-#define __ARCH_WANT_SYS_ALARM
 #define __ARCH_WANT_SYS_GETHOSTNAME
 #define __ARCH_WANT_SYS_PAUSE
-#define __ARCH_WANT_SYS_TIME
-#define __ARCH_WANT_SYS_UTIME
-#define __ARCH_WANT_SYS_SOCKETCALL
 #define __ARCH_WANT_SYS_GETPGRP
 #define __ARCH_WANT_SYS_LLSEEK
 #define __ARCH_WANT_SYS_NICE
-#define __ARCH_WANT_SYS_OLD_GETRLIMIT
-#define __ARCH_WANT_SYS_OLDUMOUNT
 #define __ARCH_WANT_SYS_SIGPENDING
 #define __ARCH_WANT_SYS_SIGPROCMASK
 #define __ARCH_WANT_SYS_RT_SIGACTION
+#if !defined(CONFIG_AEABI) || defined(CONFIG_OABI_COMPAT)
+#define __ARCH_WANT_SYS_TIME
+#define __ARCH_WANT_SYS_OLDUMOUNT
+#define __ARCH_WANT_SYS_ALARM
+#define __ARCH_WANT_SYS_UTIME
+#define __ARCH_WANT_SYS_OLD_GETRLIMIT
+#define __ARCH_WANT_OLD_READDIR
+#define __ARCH_WANT_SYS_SOCKETCALL
+#endif
 #endif
 #ifdef __KERNEL_SYSCALLS__
diff --git a/include/asm-generic/atomic.h b/include/asm-generic/atomic.h
index 0fada8f16dc6..42a95d9a0641 100644
--- a/include/asm-generic/atomic.h
+++ b/include/asm-generic/atomic.h
@@ -35,7 +35,7 @@ static inline void atomic_long_set(atomic_long_t *l, long i)
 {
        atomic64_t *v = (atomic64_t *)l;
-        atomic_set(v, i);
+        atomic64_set(v, i);
 }
 static inline void atomic_long_inc(atomic_long_t *l)
diff --git a/include/asm-i386/bitops.h b/include/asm-i386/bitops.h
index fe0819fe9c64..88e6ca248cd7 100644
--- a/include/asm-i386/bitops.h
+++ b/include/asm-i386/bitops.h
@@ -247,7 +247,7 @@ static inline int test_and_change_bit(int nr, volatile unsigned long* addr)
 static int test_bit(int nr, const volatile void * addr);
 #endif
-static inline int constant_test_bit(int nr, const volatile unsigned long *addr)
+static __always_inline int constant_test_bit(int nr, const volatile unsigned long *addr)
 {
        return ((1UL << (nr & 31)) & (addr[nr >> 5])) != 0;
 }
diff --git a/include/asm-i386/current.h b/include/asm-i386/current.h
index d97328951f5f..3cbbecd79016 100644
--- a/include/asm-i386/current.h
+++ b/include/asm-i386/current.h
@@ -5,7 +5,7 @@
 struct task_struct;
-static inline struct task_struct * get_current(void)
+static __always_inline struct task_struct * get_current(void)
 {
        return current_thread_info()->task;
 }
diff --git a/include/asm-i386/string.h b/include/asm-i386/string.h
index 02c8f5d22065..bb5f88a27f7a 100644
--- a/include/asm-i386/string.h
+++ b/include/asm-i386/string.h
@@ -201,7 +201,7 @@ __asm__ __volatile__(
 return __res;
 }
-static inline void * __memcpy(void * to, const void * from, size_t n)
+static __always_inline void * __memcpy(void * to, const void * from, size_t n)
 {
 int d0, d1, d2;
 __asm__ __volatile__(
@@ -223,7 +223,7 @@ return (to);
 * This looks ugly, but the compiler can optimize it totally,
 * as the count is constant.
 */
-static inline void * __constant_memcpy(void * to, const void * from, size_t n)
+static __always_inline void * __constant_memcpy(void * to, const void * from, size_t n)
 {
        long esi, edi;
        if (!n) return to;
@@ -367,7 +367,7 @@ return s;
 * things 32 bits at a time even when we don't know the size of the
 * area at compile-time..
 */
-static inline void * __constant_c_memset(void * s, unsigned long c, size_t count)
+static __always_inline void * __constant_c_memset(void * s, unsigned long c, size_t count)
 {
 int d0, d1;
 __asm__ __volatile__(
@@ -416,7 +416,7 @@ extern char *strstr(const char *cs, const char *ct);
 * This looks horribly ugly, but the compiler can optimize it totally,
 * as we by now know that both pattern and count is constant..
 */
-static inline void * __constant_c_and_count_memset(void * s, unsigned long pattern, size_t count)
+static __always_inline void * __constant_c_and_count_memset(void * s, unsigned long pattern, size_t count)
 {
        switch (count) {
                case 0:
diff --git a/include/asm-i386/uaccess.h b/include/asm-i386/uaccess.h
index 89ab7e2bc5aa..3f1337c34208 100644
--- a/include/asm-i386/uaccess.h
+++ b/include/asm-i386/uaccess.h
@@ -411,7 +411,7 @@ unsigned long __must_check __copy_from_user_ll(void *to,
 * Returns number of bytes that could not be copied.
 * On success, this will be zero.
 */
-static inline unsigned long __must_check
+static __always_inline unsigned long __must_check
 __copy_to_user_inatomic(void __user *to, const void *from, unsigned long n)
 {
        if (__builtin_constant_p(n)) {
@@ -432,7 +432,7 @@ __copy_to_user_inatomic(void __user *to, const void *from, unsigned long n)
        return __copy_to_user_ll(to, from, n);
 }
-static inline unsigned long __must_check
+static __always_inline unsigned long __must_check
 __copy_to_user(void __user *to, const void *from, unsigned long n)
 {
       might_sleep();
@@ -456,7 +456,7 @@ __copy_to_user(void __user *to, const void *from, unsigned long n)
 * If some data could not be copied, this function will pad the copied
 * data to the requested size using zero bytes.
 */
-static inline unsigned long
+static __always_inline unsigned long
 __copy_from_user_inatomic(void *to, const void __user *from, unsigned long n)
 {
        if (__builtin_constant_p(n)) {
@@ -477,7 +477,7 @@ __copy_from_user_inatomic(void *to, const void __user *from, unsigned long n)
        return __copy_from_user_ll(to, from, n);
 }
-static inline unsigned long
+static __always_inline unsigned long
 __copy_from_user(void *to, const void __user *from, unsigned long n)
 {
       might_sleep();
diff --git a/include/asm-ia64/kprobes.h b/include/asm-ia64/kprobes.h
index a74b68104559..8c0fc227f0fb 100644
--- a/include/asm-ia64/kprobes.h
+++ b/include/asm-ia64/kprobes.h
@@ -68,10 +68,14 @@ struct prev_kprobe {
        unsigned long status;
 };
+#define MAX_PARAM_RSE_SIZE      (0x60+0x60/0x3f)
 /* per-cpu kprobe control block */
 struct kprobe_ctlblk {
        unsigned long kprobe_status;
        struct pt_regs jprobe_saved_regs;
+        unsigned long jprobes_saved_stacked_regs[MAX_PARAM_RSE_SIZE];
+        unsigned long *bsp;
+        unsigned long cfm;
        struct prev_kprobe prev_kprobe;
 };
@@ -118,5 +122,7 @@ extern int kprobe_exceptions_notify(struct notifier_block *self,
 static inline void jprobe_return(void)
 {
 }
+extern void invalidate_stacked_regs(void);
+extern void flush_register_stack(void);
 #endif                          /* _ASM_KPROBES_H */
diff --git a/include/asm-ia64/sn/ioc3.h b/include/asm-ia64/sn/ioc3.h
new file mode 100644
index 000000000000..95ed6cc83cf1
--- /dev/null
+++ b/include/asm-ia64/sn/ioc3.h
@@ -0,0 +1,241 @@
+/*
+ * Copyright (C) 2005 Silicon Graphics, Inc.
+ */
+#ifndef IA64_SN_IOC3_H
+#define IA64_SN_IOC3_H
+/* serial port register map */
+struct ioc3_serialregs {
+        uint32_t sscr;
+        uint32_t stpir;
+        uint32_t stcir;
+        uint32_t srpir;
+        uint32_t srcir;
+        uint32_t srtr;
+        uint32_t shadow;
+};
+/* SUPERIO uart register map */
+struct ioc3_uartregs {
+        char iu_lcr;
+        union {
+                char iir;       /* read only */
+                char fcr;       /* write only */
+        } u3;
+        union {
+                char ier;       /* DLAB == 0 */
+                char dlm;       /* DLAB == 1 */
+        } u2;
+        union {
+                char rbr;       /* read only, DLAB == 0 */
+                char thr;       /* write only, DLAB == 0 */
+                char dll;       /* DLAB == 1 */
+        } u1;
+        char iu_scr;
+        char iu_msr;
+        char iu_lsr;
+        char iu_mcr;
+};
+#define iu_rbr u1.rbr
+#define iu_thr u1.thr
+#define iu_dll u1.dll
+#define iu_ier u2.ier
+#define iu_dlm u2.dlm
+#define iu_iir u3.iir
+#define iu_fcr u3.fcr
+struct ioc3_sioregs {
+        char fill[0x170];
+        struct ioc3_uartregs uartb;
+        struct ioc3_uartregs uarta;
+};
+/* PCI IO/mem space register map */
+struct ioc3 {
+        uint32_t pci_id;
+        uint32_t pci_scr;
+        uint32_t pci_rev;
+        uint32_t pci_lat;
+        uint32_t pci_addr;
+        uint32_t pci_err_addr_l;
+        uint32_t pci_err_addr_h;
+        uint32_t sio_ir;
+        /* these registers are read-only for general kernel code. To
+         * modify them use the functions in ioc3.c
+         */
+        uint32_t sio_ies;
+        uint32_t sio_iec;
+        uint32_t sio_cr;
+        uint32_t int_out;
+        uint32_t mcr;
+        uint32_t gpcr_s;
+        uint32_t gpcr_c;
+        uint32_t gpdr;
+        uint32_t gppr[9];
+        char fill[0x4c];
+        /* serial port registers */
+        uint32_t sbbr_h;
+        uint32_t sbbr_l;
+        struct ioc3_serialregs port_a;
+        struct ioc3_serialregs port_b;
+        char fill1[0x1ff10];
+        /* superio registers */
+        struct ioc3_sioregs sregs;
+};
+/* These don't exist on the ioc3 serial card... */
+#define eier    fill1[8]
+#define eisr    fill1[4]
+#define PCI_LAT                 0xc     /* Latency Timer */
+#define PCI_SCR_DROP_MODE_EN    0x00008000 /* drop pios on parity err */
+#define UARTA_BASE              0x178
+#define UARTB_BASE              0x170
+/* bitmasks for serial RX status byte */
+#define RXSB_OVERRUN            0x01    /* char(s) lost */
+#define RXSB_PAR_ERR            0x02    /* parity error */
+#define RXSB_FRAME_ERR          0x04    /* framing error */
+#define RXSB_BREAK              0x08    /* break character */
+#define RXSB_CTS                0x10    /* state of CTS */
+#define RXSB_DCD                0x20    /* state of DCD */
+#define RXSB_MODEM_VALID        0x40    /* DCD, CTS and OVERRUN are valid */
+#define RXSB_DATA_VALID         0x80    /* FRAME_ERR PAR_ERR & BREAK valid */
+/* bitmasks for serial TX control byte */
+#define TXCB_INT_WHEN_DONE      0x20    /* interrupt after this byte is sent */
+#define TXCB_INVALID            0x00    /* byte is invalid */
+#define TXCB_VALID              0x40    /* byte is valid */
+#define TXCB_MCR                0x80    /* data<7:0> to modem cntrl register */
+#define TXCB_DELAY              0xc0    /* delay data<7:0> mSec */
+/* bitmasks for SBBR_L */
+#define SBBR_L_SIZE             0x00000001      /* 0 1KB rings, 1 4KB rings */
+/* bitmasks for SSCR_<A:B> */
+#define SSCR_RX_THRESHOLD       0x000001ff      /* hiwater mark */
+#define SSCR_TX_TIMER_BUSY      0x00010000      /* TX timer in progress */
+#define SSCR_HFC_EN             0x00020000      /* h/w flow cntrl enabled */
+#define SSCR_RX_RING_DCD        0x00040000      /* postRX record on delta-DCD */
+#define SSCR_RX_RING_CTS        0x00080000      /* postRX record on delta-CTS */
+#define SSCR_HIGH_SPD           0x00100000      /* 4X speed */
+#define SSCR_DIAG               0x00200000      /* bypass clock divider */
+#define SSCR_RX_DRAIN           0x08000000      /* drain RX buffer to memory */
+#define SSCR_DMA_EN             0x10000000      /* enable ring buffer DMA */
+#define SSCR_DMA_PAUSE          0x20000000      /* pause DMA */
+#define SSCR_PAUSE_STATE        0x40000000      /* set when PAUSE takes effect*/
+#define SSCR_RESET              0x80000000      /* reset DMA channels */
+/* all producer/comsumer pointers are the same bitfield */
+#define PROD_CONS_PTR_4K        0x00000ff8      /* for 4K buffers */
+#define PROD_CONS_PTR_1K        0x000003f8      /* for 1K buffers */
+#define PROD_CONS_PTR_OFF       3
+/* bitmasks for SRCIR_<A:B> */
+#define SRCIR_ARM               0x80000000      /* arm RX timer */
+/* bitmasks for SHADOW_<A:B> */
+#define SHADOW_DR               0x00000001      /* data ready */
+#define SHADOW_OE               0x00000002      /* overrun error */
+#define SHADOW_PE               0x00000004      /* parity error */
+#define SHADOW_FE               0x00000008      /* framing error */
+#define SHADOW_BI               0x00000010      /* break interrupt */
+#define SHADOW_THRE             0x00000020      /* transmit holding reg empty */
+#define SHADOW_TEMT             0x00000040      /* transmit shift reg empty */
+#define SHADOW_RFCE             0x00000080      /* char in RX fifo has error */
+#define SHADOW_DCTS             0x00010000      /* delta clear to send */
+#define SHADOW_DDCD             0x00080000      /* delta data carrier detect */
+#define SHADOW_CTS              0x00100000      /* clear to send */
+#define SHADOW_DCD              0x00800000      /* data carrier detect */
+#define SHADOW_DTR              0x01000000      /* data terminal ready */
+#define SHADOW_RTS              0x02000000      /* request to send */
+#define SHADOW_OUT1             0x04000000      /* 16550 OUT1 bit */
+#define SHADOW_OUT2             0x08000000      /* 16550 OUT2 bit */
+#define SHADOW_LOOP             0x10000000      /* loopback enabled */
+/* bitmasks for SRTR_<A:B> */
+#define SRTR_CNT                0x00000fff      /* reload value for RX timer */
+#define SRTR_CNT_VAL            0x0fff0000      /* current value of RX timer */
+#define SRTR_CNT_VAL_SHIFT      16
+#define SRTR_HZ                 16000           /* SRTR clock frequency */
+/* bitmasks for SIO_IR, SIO_IEC and SIO_IES  */
+#define SIO_IR_SA_TX_MT         0x00000001      /* Serial port A TX empty */
+#define SIO_IR_SA_RX_FULL       0x00000002      /* port A RX buf full */
+#define SIO_IR_SA_RX_HIGH       0x00000004      /* port A RX hiwat */
+#define SIO_IR_SA_RX_TIMER      0x00000008      /* port A RX timeout */
+#define SIO_IR_SA_DELTA_DCD     0x00000010      /* port A delta DCD */
+#define SIO_IR_SA_DELTA_CTS     0x00000020      /* port A delta CTS */
+#define SIO_IR_SA_INT           0x00000040      /* port A pass-thru intr */
+#define SIO_IR_SA_TX_EXPLICIT   0x00000080      /* port A explicit TX thru */
+#define SIO_IR_SA_MEMERR        0x00000100      /* port A PCI error */
+#define SIO_IR_SB_TX_MT         0x00000200
+#define SIO_IR_SB_RX_FULL       0x00000400
+#define SIO_IR_SB_RX_HIGH       0x00000800
+#define SIO_IR_SB_RX_TIMER      0x00001000
+#define SIO_IR_SB_DELTA_DCD     0x00002000
+#define SIO_IR_SB_DELTA_CTS     0x00004000
+#define SIO_IR_SB_INT           0x00008000
+#define SIO_IR_SB_TX_EXPLICIT   0x00010000
+#define SIO_IR_SB_MEMERR        0x00020000
+#define SIO_IR_PP_INT           0x00040000      /* P port pass-thru intr */
+#define SIO_IR_PP_INTA          0x00080000      /* PP context A thru */
+#define SIO_IR_PP_INTB          0x00100000      /* PP context B thru */
+#define SIO_IR_PP_MEMERR        0x00200000      /* PP PCI error */
+#define SIO_IR_KBD_INT          0x00400000      /* kbd/mouse intr */
+#define SIO_IR_RT_INT           0x08000000      /* RT output pulse */
+#define SIO_IR_GEN_INT1         0x10000000      /* RT input pulse */
+#define SIO_IR_GEN_INT_SHIFT    28
+/* per device interrupt masks */
+#define SIO_IR_SA               (SIO_IR_SA_TX_MT | \
+                                 SIO_IR_SA_RX_FULL | \
+                                 SIO_IR_SA_RX_HIGH | \
+                                 SIO_IR_SA_RX_TIMER | \
+                                 SIO_IR_SA_DELTA_DCD | \
+                                 SIO_IR_SA_DELTA_CTS | \
+                                 SIO_IR_SA_INT | \
+                                 SIO_IR_SA_TX_EXPLICIT | \
+                                 SIO_IR_SA_MEMERR)
+#define SIO_IR_SB               (SIO_IR_SB_TX_MT | \
+                                 SIO_IR_SB_RX_FULL | \
+                                 SIO_IR_SB_RX_HIGH | \
+                                 SIO_IR_SB_RX_TIMER | \
+                                 SIO_IR_SB_DELTA_DCD | \
+                                 SIO_IR_SB_DELTA_CTS | \
+                                 SIO_IR_SB_INT | \
+                                 SIO_IR_SB_TX_EXPLICIT | \
+                                 SIO_IR_SB_MEMERR)
+#define SIO_IR_PP               (SIO_IR_PP_INT | SIO_IR_PP_INTA | \
+                                 SIO_IR_PP_INTB | SIO_IR_PP_MEMERR)
+#define SIO_IR_RT               (SIO_IR_RT_INT | SIO_IR_GEN_INT1)
+/* bitmasks for SIO_CR */
+#define SIO_CR_CMD_PULSE_SHIFT 15
+#define SIO_CR_SER_A_BASE_SHIFT 1
+#define SIO_CR_SER_B_BASE_SHIFT 8
+#define SIO_CR_ARB_DIAG         0x00380000      /* cur !enet PCI requet (ro) */
+#define SIO_CR_ARB_DIAG_TXA     0x00000000
+#define SIO_CR_ARB_DIAG_RXA     0x00080000
+#define SIO_CR_ARB_DIAG_TXB     0x00100000
+#define SIO_CR_ARB_DIAG_RXB     0x00180000
+#define SIO_CR_ARB_DIAG_PP      0x00200000
+#define SIO_CR_ARB_DIAG_IDLE    0x00400000      /* 0 -> active request (ro) */
+/* defs for some of the generic I/O pins */
+#define GPCR_PHY_RESET          0x20    /* pin is output to PHY reset */
+#define GPCR_UARTB_MODESEL      0x40    /* pin is output to port B mode sel */
+#define GPCR_UARTA_MODESEL      0x80    /* pin is output to port A mode sel */
+#define GPPR_PHY_RESET_PIN      5       /* GIO pin controlling phy reset */
+#define GPPR_UARTB_MODESEL_PIN  6       /* GIO pin cntrling uartb modeselect */
+#define GPPR_UARTA_MODESEL_PIN  7       /* GIO pin cntrling uarta modeselect */
+#endif /* IA64_SN_IOC3_H */
diff --git a/include/asm-ia64/sn/sn_sal.h b/include/asm-ia64/sn/sn_sal.h
index 2a8b0d92a5d6..8b9e10e7cdba 100644
--- a/include/asm-ia64/sn/sn_sal.h
+++ b/include/asm-ia64/sn/sn_sal.h
@@ -75,7 +75,8 @@
 #define  SN_SAL_IOIF_GET_HUBDEV_INFO               0x02000055
 #define  SN_SAL_IOIF_GET_PCIBUS_INFO               0x02000056
 #define  SN_SAL_IOIF_GET_PCIDEV_INFO               0x02000057
-#define  SN_SAL_IOIF_GET_WIDGET_DMAFLUSH_LIST      0x02000058
+#define  SN_SAL_IOIF_GET_WIDGET_DMAFLUSH_LIST      0x02000058   // deprecated
+#define  SN_SAL_IOIF_GET_DEVICE_DMAFLUSH_LIST      0x0200005a
 #define SN_SAL_HUB_ERROR_INTERRUPT                 0x02000060
 #define SN_SAL_BTE_RECOVER                         0x02000061
@@ -1100,7 +1101,7 @@ ia64_sn_bte_recovery(nasid_t nasid)
        struct ia64_sal_retval rv;
        rv.status = 0;
-        SAL_CALL_NOLOCK(rv, SN_SAL_BTE_RECOVER, 0, 0, 0, 0, 0, 0, 0);
+        SAL_CALL_NOLOCK(rv, SN_SAL_BTE_RECOVER, (u64)nasid, 0, 0, 0, 0, 0, 0);
        if (rv.status == SALRET_NOT_IMPLEMENTED)
                return 0;
        return (int) rv.status;
diff --git a/include/asm-ia64/sn/xp.h b/include/asm-ia64/sn/xp.h
index 49faf8f26430..203945ae034e 100644
--- a/include/asm-ia64/sn/xp.h
+++ b/include/asm-ia64/sn/xp.h
@@ -227,7 +227,9 @@ enum xpc_retval {
        xpcOpenCloseError,      /* 50: channel open/close protocol error */
-        xpcUnknownReason        /* 51: unknown reason -- must be last in list */
+        xpcDisconnected,        /* 51: channel disconnected (closed) */
+        xpcUnknownReason        /* 52: unknown reason -- must be last in list */
 };
diff --git a/include/asm-ia64/sn/xpc.h b/include/asm-ia64/sn/xpc.h
new file mode 100644
index 000000000000..87e9cd588510
--- /dev/null
+++ b/include/asm-ia64/sn/xpc.h
@@ -0,0 +1,1274 @@
+/*
+ * This file is subject to the terms and conditions of the GNU General Public
+ * License.  See the file "COPYING" in the main directory of this archive
+ * for more details.
+ *
+ * Copyright (c) 2004-2006 Silicon Graphics, Inc.  All Rights Reserved.
+ */
+/*
+ * Cross Partition Communication (XPC) structures and macros.
+ */
+#ifndef _ASM_IA64_SN_XPC_H
+#define _ASM_IA64_SN_XPC_H
+#include <linux/config.h>
+#include <linux/interrupt.h>
+#include <linux/sysctl.h>
+#include <linux/device.h>
+#include <asm/pgtable.h>
+#include <asm/processor.h>
+#include <asm/sn/bte.h>
+#include <asm/sn/clksupport.h>
+#include <asm/sn/addrs.h>
+#include <asm/sn/mspec.h>
+#include <asm/sn/shub_mmr.h>
+#include <asm/sn/xp.h>
+/*
+ * XPC Version numbers consist of a major and minor number. XPC can always
+ * talk to versions with same major #, and never talk to versions with a
+ * different major #.
+ */
+#define _XPC_VERSION(_maj, _min)        (((_maj) << 4) | ((_min) & 0xf))
+#define XPC_VERSION_MAJOR(_v)           ((_v) >> 4)
+#define XPC_VERSION_MINOR(_v)           ((_v) & 0xf)
+/*
+ * The next macros define word or bit representations for given
+ * C-brick nasid in either the SAL provided bit array representing
+ * nasids in the partition/machine or the AMO_t array used for
+ * inter-partition initiation communications.
+ *
+ * For SN2 machines, C-Bricks are alway even numbered NASIDs.  As
+ * such, some space will be saved by insisting that nasid information
+ * passed from SAL always be packed for C-Bricks and the
+ * cross-partition interrupts use the same packing scheme.
+ */
+#define XPC_NASID_W_INDEX(_n)   (((_n) / 64) / 2)
+#define XPC_NASID_B_INDEX(_n)   (((_n) / 2) & (64 - 1))
+#define XPC_NASID_IN_ARRAY(_n, _p) ((_p)[XPC_NASID_W_INDEX(_n)] & \
+                                    (1UL << XPC_NASID_B_INDEX(_n)))
+#define XPC_NASID_FROM_W_B(_w, _b) (((_w) * 64 + (_b)) * 2)
+#define XPC_HB_DEFAULT_INTERVAL         5       /* incr HB every x secs */
+#define XPC_HB_CHECK_DEFAULT_INTERVAL   20      /* check HB every x secs */
+/* define the process name of HB checker and the CPU it is pinned to */
+#define XPC_HB_CHECK_THREAD_NAME        "xpc_hb"
+#define XPC_HB_CHECK_CPU                0
+/* define the process name of the discovery thread */
+#define XPC_DISCOVERY_THREAD_NAME       "xpc_discovery"
+/*
+ * the reserved page
+ *
+ *   SAL reserves one page of memory per partition for XPC. Though a full page
+ *   in length (16384 bytes), its starting address is not page aligned, but it
+ *   is cacheline aligned. The reserved page consists of the following:
+ *
+ *   reserved page header
+ *
+ *     The first cacheline of the reserved page contains the header
+ *     (struct xpc_rsvd_page). Before SAL initialization has completed,
+ *     SAL has set up the following fields of the reserved page header:
+ *     SAL_signature, SAL_version, partid, and nasids_size. The other
+ *     fields are set up by XPC. (xpc_rsvd_page points to the local
+ *     partition's reserved page.)
+ *
+ *   part_nasids mask
+ *   mach_nasids mask
+ *
+ *     SAL also sets up two bitmaps (or masks), one that reflects the actual
+ *     nasids in this partition (part_nasids), and the other that reflects
+ *     the actual nasids in the entire machine (mach_nasids). We're only
+ *     interested in the even numbered nasids (which contain the processors
+ *     and/or memory), so we only need half as many bits to represent the
+ *     nasids. The part_nasids mask is located starting at the first cacheline
+ *     following the reserved page header. The mach_nasids mask follows right
+ *     after the part_nasids mask. The size in bytes of each mask is reflected
+ *     by the reserved page header field 'nasids_size'. (Local partition's
+ *     mask pointers are xpc_part_nasids and xpc_mach_nasids.)
+ *
+ *   vars
+ *   vars part
+ *
+ *     Immediately following the mach_nasids mask are the XPC variables
+ *     required by other partitions. First are those that are generic to all
+ *     partitions (vars), followed on the next available cacheline by those
+ *     which are partition specific (vars part). These are setup by XPC.
+ *     (Local partition's vars pointers are xpc_vars and xpc_vars_part.)
+ *
+ * Note: Until vars_pa is set, the partition XPC code has not been initialized.
+ */
+struct xpc_rsvd_page {
+        u64 SAL_signature;      /* SAL: unique signature */
+        u64 SAL_version;        /* SAL: version */
+        u8 partid;              /* SAL: partition ID */
+        u8 version;
+        u8 pad1[6];             /* align to next u64 in cacheline */
+        volatile u64 vars_pa;
+        struct timespec stamp;  /* time when reserved page was setup by XPC */
+        u64 pad2[9];            /* align to last u64 in cacheline */
+        u64 nasids_size;        /* SAL: size of each nasid mask in bytes */
+};
+#define XPC_RP_VERSION _XPC_VERSION(1,1) /* version 1.1 of the reserved page */
+#define XPC_SUPPORTS_RP_STAMP(_version) \
+                        (_version >= _XPC_VERSION(1,1))
+/*
+ * compare stamps - the return value is:
+ *
+ *      < 0,    if stamp1 < stamp2
+ *      = 0,    if stamp1 == stamp2
+ *      > 0,    if stamp1 > stamp2
+ */
+static inline int
+xpc_compare_stamps(struct timespec *stamp1, struct timespec *stamp2)
+{
+        int ret;
+        if ((ret = stamp1->tv_sec - stamp2->tv_sec) == 0) {
+                ret = stamp1->tv_nsec - stamp2->tv_nsec;
+        }
+        return ret;
+}
+/*
+ * Define the structures by which XPC variables can be exported to other
+ * partitions. (There are two: struct xpc_vars and struct xpc_vars_part)
+ */
+/*
+ * The following structure describes the partition generic variables
+ * needed by other partitions in order to properly initialize.
+ *
+ * struct xpc_vars version number also applies to struct xpc_vars_part.
+ * Changes to either structure and/or related functionality should be
+ * reflected by incrementing either the major or minor version numbers
+ * of struct xpc_vars.
+ */
+struct xpc_vars {
+        u8 version;
+        u64 heartbeat;
+        u64 heartbeating_to_mask;
+        u64 heartbeat_offline;  /* if 0, heartbeat should be changing */
+        int act_nasid;
+        int act_phys_cpuid;
+        u64 vars_part_pa;
+        u64 amos_page_pa;       /* paddr of page of AMOs from MSPEC driver */
+        AMO_t *amos_page;       /* vaddr of page of AMOs from MSPEC driver */
+};
+#define XPC_V_VERSION _XPC_VERSION(3,1) /* version 3.1 of the cross vars */
+#define XPC_SUPPORTS_DISENGAGE_REQUEST(_version) \
+                        (_version >= _XPC_VERSION(3,1))
+static inline int
+xpc_hb_allowed(partid_t partid, struct xpc_vars *vars)
+{
+        return ((vars->heartbeating_to_mask & (1UL << partid)) != 0);
+}
+static inline void
+xpc_allow_hb(partid_t partid, struct xpc_vars *vars)
+{
+        u64 old_mask, new_mask;
+        do {
+                old_mask = vars->heartbeating_to_mask;
+                new_mask = (old_mask | (1UL << partid));
+        } while (cmpxchg(&vars->heartbeating_to_mask, old_mask, new_mask) !=
+                                                        old_mask);
+}
+static inline void
+xpc_disallow_hb(partid_t partid, struct xpc_vars *vars)
+{
+        u64 old_mask, new_mask;
+        do {
+                old_mask = vars->heartbeating_to_mask;
+                new_mask = (old_mask & ~(1UL << partid));
+        } while (cmpxchg(&vars->heartbeating_to_mask, old_mask, new_mask) !=
+                                                        old_mask);
+}
+/*
+ * The AMOs page consists of a number of AMO variables which are divided into
+ * four groups, The first two groups are used to identify an IRQ's sender.
+ * These two groups consist of 64 and 128 AMO variables respectively. The last
+ * two groups, consisting of just one AMO variable each, are used to identify
+ * the remote partitions that are currently engaged (from the viewpoint of
+ * the XPC running on the remote partition).
+ */
+#define XPC_NOTIFY_IRQ_AMOS        0
+#define XPC_ACTIVATE_IRQ_AMOS      (XPC_NOTIFY_IRQ_AMOS + XP_MAX_PARTITIONS)
+#define XPC_ENGAGED_PARTITIONS_AMO (XPC_ACTIVATE_IRQ_AMOS + XP_NASID_MASK_WORDS)
+#define XPC_DISENGAGE_REQUEST_AMO  (XPC_ENGAGED_PARTITIONS_AMO + 1)
+/*
+ * The following structure describes the per partition specific variables.
+ *
+ * An array of these structures, one per partition, will be defined. As a
+ * partition becomes active XPC will copy the array entry corresponding to
+ * itself from that partition. It is desirable that the size of this
+ * structure evenly divide into a cacheline, such that none of the entries
+ * in this array crosses a cacheline boundary. As it is now, each entry
+ * occupies half a cacheline.
+ */
+struct xpc_vars_part {
+        volatile u64 magic;
+        u64 openclose_args_pa;  /* physical address of open and close args */
+        u64 GPs_pa;             /* physical address of Get/Put values */
+        u64 IPI_amo_pa;         /* physical address of IPI AMO_t structure */
+        int IPI_nasid;          /* nasid of where to send IPIs */
+        int IPI_phys_cpuid;     /* physical CPU ID of where to send IPIs */
+        u8 nchannels;           /* #of defined channels supported */
+        u8 reserved[23];        /* pad to a full 64 bytes */
+};
+/*
+ * The vars_part MAGIC numbers play a part in the first contact protocol.
+ *
+ * MAGIC1 indicates that the per partition specific variables for a remote
+ * partition have been initialized by this partition.
+ *
+ * MAGIC2 indicates that this partition has pulled the remote partititions
+ * per partition variables that pertain to this partition.
+ */
+#define XPC_VP_MAGIC1   0x0053524156435058L  /* 'XPCVARS\0'L (little endian) */
+#define XPC_VP_MAGIC2   0x0073726176435058L  /* 'XPCvars\0'L (little endian) */
+/* the reserved page sizes and offsets */
+#define XPC_RP_HEADER_SIZE      L1_CACHE_ALIGN(sizeof(struct xpc_rsvd_page))
+#define XPC_RP_VARS_SIZE        L1_CACHE_ALIGN(sizeof(struct xpc_vars))
+#define XPC_RP_PART_NASIDS(_rp) (u64 *) ((u8 *) _rp + XPC_RP_HEADER_SIZE)
+#define XPC_RP_MACH_NASIDS(_rp) (XPC_RP_PART_NASIDS(_rp) + xp_nasid_mask_words)
+#define XPC_RP_VARS(_rp)        ((struct xpc_vars *) XPC_RP_MACH_NASIDS(_rp) + xp_nasid_mask_words)
+#define XPC_RP_VARS_PART(_rp)   (struct xpc_vars_part *) ((u8 *) XPC_RP_VARS(rp) + XPC_RP_VARS_SIZE)
+/*
+ * Functions registered by add_timer() or called by kernel_thread() only
+ * allow for a single 64-bit argument. The following macros can be used to
+ * pack and unpack two (32-bit, 16-bit or 8-bit) arguments into or out from
+ * the passed argument.
+ */
+#define XPC_PACK_ARGS(_arg1, _arg2) \
+                        ((((u64) _arg1) & 0xffffffff) | \
+                        ((((u64) _arg2) & 0xffffffff) << 32))
+#define XPC_UNPACK_ARG1(_args)  (((u64) _args) & 0xffffffff)
+#define XPC_UNPACK_ARG2(_args)  ((((u64) _args) >> 32) & 0xffffffff)
+/*
+ * Define a Get/Put value pair (pointers) used with a message queue.
+ */
+struct xpc_gp {
+        volatile s64 get;       /* Get value */
+        volatile s64 put;       /* Put value */
+};
+#define XPC_GP_SIZE \
+                L1_CACHE_ALIGN(sizeof(struct xpc_gp) * XPC_NCHANNELS)
+/*
+ * Define a structure that contains arguments associated with opening and
+ * closing a channel.
+ */
+struct xpc_openclose_args {
+        u16 reason;             /* reason why channel is closing */
+        u16 msg_size;           /* sizeof each message entry */
+        u16 remote_nentries;    /* #of message entries in remote msg queue */
+        u16 local_nentries;     /* #of message entries in local msg queue */
+        u64 local_msgqueue_pa;  /* physical address of local message queue */
+};
+#define XPC_OPENCLOSE_ARGS_SIZE \
+              L1_CACHE_ALIGN(sizeof(struct xpc_openclose_args) * XPC_NCHANNELS)
+/* struct xpc_msg flags */
+#define XPC_M_DONE              0x01    /* msg has been received/consumed */
+#define XPC_M_READY             0x02    /* msg is ready to be sent */
+#define XPC_M_INTERRUPT         0x04    /* send interrupt when msg consumed */
+#define XPC_MSG_ADDRESS(_payload) \
+                ((struct xpc_msg *)((u8 *)(_payload) - XPC_MSG_PAYLOAD_OFFSET))
+/*
+ * Defines notify entry.
+ *
+ * This is used to notify a message's sender that their message was received
+ * and consumed by the intended recipient.
+ */
+struct xpc_notify {
+        struct semaphore sema;          /* notify semaphore */
+        volatile u8 type;                       /* type of notification */
+        /* the following two fields are only used if type == XPC_N_CALL */
+        xpc_notify_func func;           /* user's notify function */
+        void *key;                      /* pointer to user's key */
+};
+/* struct xpc_notify type of notification */
+#define XPC_N_CALL              0x01    /* notify function provided by user */
+/*
+ * Define the structure that manages all the stuff required by a channel. In
+ * particular, they are used to manage the messages sent across the channel.
+ *
+ * This structure is private to a partition, and is NOT shared across the
+ * partition boundary.
+ *
+ * There is an array of these structures for each remote partition. It is
+ * allocated at the time a partition becomes active. The array contains one
+ * of these structures for each potential channel connection to that partition.
+ *
+ * Each of these structures manages two message queues (circular buffers).
+ * They are allocated at the time a channel connection is made. One of
+ * these message queues (local_msgqueue) holds the locally created messages
+ * that are destined for the remote partition. The other of these message
+ * queues (remote_msgqueue) is a locally cached copy of the remote partition's
+ * own local_msgqueue.
+ *
+ * The following is a description of the Get/Put pointers used to manage these
+ * two message queues. Consider the local_msgqueue to be on one partition
+ * and the remote_msgqueue to be its cached copy on another partition. A
+ * description of what each of the lettered areas contains is included.
+ *
+ *
+ *                     local_msgqueue      remote_msgqueue
+ *
+ *                        |/////////|      |/////////|
+ *    w_remote_GP.get --> +---------+      |/////////|
+ *                        |    F    |      |/////////|
+ *     remote_GP.get  --> +---------+      +---------+ <-- local_GP->get
+ *                        |         |      |         |
+ *                        |         |      |    E    |
+ *                        |         |      |         |
+ *                        |         |      +---------+ <-- w_local_GP.get
+ *                        |    B    |      |/////////|
+ *                        |         |      |////D////|
+ *                        |         |      |/////////|
+ *                        |         |      +---------+ <-- w_remote_GP.put
+ *                        |         |      |////C////|
+ *      local_GP->put --> +---------+      +---------+ <-- remote_GP.put
+ *                        |         |      |/////////|
+ *                        |    A    |      |/////////|
+ *                        |         |      |/////////|
+ *     w_local_GP.put --> +---------+      |/////////|
+ *                        |/////////|      |/////////|
+ *
+ *
+ *          ( remote_GP.[get|put] are cached copies of the remote
+ *            partition's local_GP->[get|put], and thus their values can
+ *            lag behind their counterparts on the remote partition. )
+ *
+ *
+ *  A - Messages that have been allocated, but have not yet been sent to the
+ *      remote partition.
+ *
+ *  B - Messages that have been sent, but have not yet been acknowledged by the
+ *      remote partition as having been received.
+ *
+ *  C - Area that needs to be prepared for the copying of sent messages, by
+ *      the clearing of the message flags of any previously received messages.
+ *
+ *  D - Area into which sent messages are to be copied from the remote
+ *      partition's local_msgqueue and then delivered to their intended
+ *      recipients. [ To allow for a multi-message copy, another pointer
+ *      (next_msg_to_pull) has been added to keep track of the next message
+ *      number needing to be copied (pulled). It chases after w_remote_GP.put.
+ *      Any messages lying between w_local_GP.get and next_msg_to_pull have
+ *      been copied and are ready to be delivered. ]
+ *
+ *  E - Messages that have been copied and delivered, but have not yet been
+ *      acknowledged by the recipient as having been received.
+ *
+ *  F - Messages that have been acknowledged, but XPC has not yet notified the
+ *      sender that the message was received by its intended recipient.
+ *      This is also an area that needs to be prepared for the allocating of
+ *      new messages, by the clearing of the message flags of the acknowledged
+ *      messages.
+ */
+struct xpc_channel {
+        partid_t partid;                /* ID of remote partition connected */
+        spinlock_t lock;                /* lock for updating this structure */
+        u32 flags;                      /* general flags */
+        enum xpc_retval reason;         /* reason why channel is disconnect'g */
+        int reason_line;                /* line# disconnect initiated from */
+        u16 number;                     /* channel # */
+        u16 msg_size;                   /* sizeof each msg entry */
+        u16 local_nentries;             /* #of msg entries in local msg queue */
+        u16 remote_nentries;            /* #of msg entries in remote msg queue*/
+        void *local_msgqueue_base;      /* base address of kmalloc'd space */
+        struct xpc_msg *local_msgqueue; /* local message queue */
+        void *remote_msgqueue_base;     /* base address of kmalloc'd space */
+        struct xpc_msg *remote_msgqueue;/* cached copy of remote partition's */
+                                        /* local message queue */
+        u64 remote_msgqueue_pa;         /* phys addr of remote partition's */
+                                        /* local message queue */
+        atomic_t references;            /* #of external references to queues */
+        atomic_t n_on_msg_allocate_wq;   /* #on msg allocation wait queue */
+        wait_queue_head_t msg_allocate_wq; /* msg allocation wait queue */
+        u8 delayed_IPI_flags;           /* IPI flags received, but delayed */
+                                        /* action until channel disconnected */
+        /* queue of msg senders who want to be notified when msg received */
+        atomic_t n_to_notify;           /* #of msg senders to notify */
+        struct xpc_notify *notify_queue;/* notify queue for messages sent */
+        xpc_channel_func func;          /* user's channel function */
+        void *key;                      /* pointer to user's key */
+        struct semaphore msg_to_pull_sema; /* next msg to pull serialization */
+        struct semaphore wdisconnect_sema; /* wait for channel disconnect */
+        struct xpc_openclose_args *local_openclose_args; /* args passed on */
+                                        /* opening or closing of channel */
+        /* various flavors of local and remote Get/Put values */
+        struct xpc_gp *local_GP;        /* local Get/Put values */
+        struct xpc_gp remote_GP;        /* remote Get/Put values */
+        struct xpc_gp w_local_GP;       /* working local Get/Put values */
+        struct xpc_gp w_remote_GP;      /* working remote Get/Put values */
+        s64 next_msg_to_pull;           /* Put value of next msg to pull */
+        /* kthread management related fields */
+// >>> rethink having kthreads_assigned_limit and kthreads_idle_limit; perhaps
+// >>> allow the assigned limit be unbounded and let the idle limit be dynamic
+// >>> dependent on activity over the last interval of time
+        atomic_t kthreads_assigned;     /* #of kthreads assigned to channel */
+        u32 kthreads_assigned_limit;    /* limit on #of kthreads assigned */
+        atomic_t kthreads_idle;         /* #of kthreads idle waiting for work */
+        u32 kthreads_idle_limit;        /* limit on #of kthreads idle */
+        atomic_t kthreads_active;       /* #of kthreads actively working */
+        // >>> following field is temporary
+        u32 kthreads_created;           /* total #of kthreads created */
+        wait_queue_head_t idle_wq;      /* idle kthread wait queue */
+} ____cacheline_aligned;
+/* struct xpc_channel flags */
+#define XPC_C_WASCONNECTED      0x00000001 /* channel was connected */
+#define XPC_C_ROPENREPLY        0x00000002 /* remote open channel reply */
+#define XPC_C_OPENREPLY         0x00000004 /* local open channel reply */
+#define XPC_C_ROPENREQUEST      0x00000008 /* remote open channel request */
+#define XPC_C_OPENREQUEST       0x00000010 /* local open channel request */
+#define XPC_C_SETUP             0x00000020 /* channel's msgqueues are alloc'd */
+#define XPC_C_CONNECTCALLOUT    0x00000040 /* channel connected callout made */
+#define XPC_C_CONNECTED         0x00000080 /* local channel is connected */
+#define XPC_C_CONNECTING        0x00000100 /* channel is being connected */
+#define XPC_C_RCLOSEREPLY       0x00000200 /* remote close channel reply */
+#define XPC_C_CLOSEREPLY        0x00000400 /* local close channel reply */
+#define XPC_C_RCLOSEREQUEST     0x00000800 /* remote close channel request */
+#define XPC_C_CLOSEREQUEST      0x00001000 /* local close channel request */
+#define XPC_C_DISCONNECTED      0x00002000 /* channel is disconnected */
+#define XPC_C_DISCONNECTING     0x00004000 /* channel is being disconnected */
+#define XPC_C_DISCONNECTCALLOUT 0x00008000 /* chan disconnected callout made */
+#define XPC_C_WDISCONNECT       0x00010000 /* waiting for channel disconnect */
+/*
+ * Manages channels on a partition basis. There is one of these structures
+ * for each partition (a partition will never utilize the structure that
+ * represents itself).
+ */
+struct xpc_partition {
+        /* XPC HB infrastructure */
+        u8 remote_rp_version;           /* version# of partition's rsvd pg */
+        struct timespec remote_rp_stamp;/* time when rsvd pg was initialized */
+        u64 remote_rp_pa;               /* phys addr of partition's rsvd pg */
+        u64 remote_vars_pa;             /* phys addr of partition's vars */
+        u64 remote_vars_part_pa;        /* phys addr of partition's vars part */
+        u64 last_heartbeat;             /* HB at last read */
+        u64 remote_amos_page_pa;        /* phys addr of partition's amos page */
+        int remote_act_nasid;           /* active part's act/deact nasid */
+        int remote_act_phys_cpuid;      /* active part's act/deact phys cpuid */
+        u32 act_IRQ_rcvd;               /* IRQs since activation */
+        spinlock_t act_lock;            /* protect updating of act_state */
+        u8 act_state;                   /* from XPC HB viewpoint */
+        u8 remote_vars_version;         /* version# of partition's vars */
+        enum xpc_retval reason;         /* reason partition is deactivating */
+        int reason_line;                /* line# deactivation initiated from */
+        int reactivate_nasid;           /* nasid in partition to reactivate */
+        unsigned long disengage_request_timeout; /* timeout in jiffies */
+        struct timer_list disengage_request_timer;
+        /* XPC infrastructure referencing and teardown control */
+        volatile u8 setup_state;        /* infrastructure setup state */
+        wait_queue_head_t teardown_wq;  /* kthread waiting to teardown infra */
+        atomic_t references;            /* #of references to infrastructure */
+        /*
+         * NONE OF THE PRECEDING FIELDS OF THIS STRUCTURE WILL BE CLEARED WHEN
+         * XPC SETS UP THE NECESSARY INFRASTRUCTURE TO SUPPORT CROSS PARTITION
+         * COMMUNICATION. ALL OF THE FOLLOWING FIELDS WILL BE CLEARED. (THE
+         * 'nchannels' FIELD MUST BE THE FIRST OF THE FIELDS TO BE CLEARED.)
+         */
+        u8 nchannels;              /* #of defined channels supported */
+        atomic_t nchannels_active; /* #of channels that are not DISCONNECTED */
+        atomic_t nchannels_engaged;/* #of channels engaged with remote part */
+        struct xpc_channel *channels;/* array of channel structures */
+        void *local_GPs_base;     /* base address of kmalloc'd space */
+        struct xpc_gp *local_GPs; /* local Get/Put values */
+        void *remote_GPs_base;    /* base address of kmalloc'd space */
+        struct xpc_gp *remote_GPs;/* copy of remote partition's local Get/Put */
+                                  /* values */
+        u64 remote_GPs_pa;        /* phys address of remote partition's local */
+                                  /* Get/Put values */
+        /* fields used to pass args when opening or closing a channel */
+        void *local_openclose_args_base;  /* base address of kmalloc'd space */
+        struct xpc_openclose_args *local_openclose_args;  /* local's args */
+        void *remote_openclose_args_base; /* base address of kmalloc'd space */
+        struct xpc_openclose_args *remote_openclose_args; /* copy of remote's */
+                                          /* args */
+        u64 remote_openclose_args_pa;     /* phys addr of remote's args */
+        /* IPI sending, receiving and handling related fields */
+        int remote_IPI_nasid;       /* nasid of where to send IPIs */
+        int remote_IPI_phys_cpuid;  /* phys CPU ID of where to send IPIs */
+        AMO_t *remote_IPI_amo_va;   /* address of remote IPI AMO_t structure */
+        AMO_t *local_IPI_amo_va;    /* address of IPI AMO_t structure */
+        u64 local_IPI_amo;          /* IPI amo flags yet to be handled */
+        char IPI_owner[8];          /* IPI owner's name */
+        struct timer_list dropped_IPI_timer; /* dropped IPI timer */
+        spinlock_t IPI_lock;        /* IPI handler lock */
+        /* channel manager related fields */
+        atomic_t channel_mgr_requests;  /* #of requests to activate chan mgr */
+        wait_queue_head_t channel_mgr_wq; /* channel mgr's wait queue */
+} ____cacheline_aligned;
+/* struct xpc_partition act_state values (for XPC HB) */
+#define XPC_P_INACTIVE          0x00    /* partition is not active */
+#define XPC_P_ACTIVATION_REQ    0x01    /* created thread to activate */
+#define XPC_P_ACTIVATING        0x02    /* activation thread started */
+#define XPC_P_ACTIVE            0x03    /* xpc_partition_up() was called */
+#define XPC_P_DEACTIVATING      0x04    /* partition deactivation initiated */
+#define XPC_DEACTIVATE_PARTITION(_p, _reason) \
+                        xpc_deactivate_partition(__LINE__, (_p), (_reason))
+/* struct xpc_partition setup_state values */
+#define XPC_P_UNSET             0x00    /* infrastructure was never setup */
+#define XPC_P_SETUP             0x01    /* infrastructure is setup */
+#define XPC_P_WTEARDOWN         0x02    /* waiting to teardown infrastructure */
+#define XPC_P_TORNDOWN          0x03    /* infrastructure is torndown */
+/*
+ * struct xpc_partition IPI_timer #of seconds to wait before checking for
+ * dropped IPIs. These occur whenever an IPI amo write doesn't complete until
+ * after the IPI was received.
+ */
+#define XPC_P_DROPPED_IPI_WAIT  (0.25 * HZ)
+/* number of seconds to wait for other partitions to disengage */
+#define XPC_DISENGAGE_REQUEST_DEFAULT_TIMELIMIT 90
+/* interval in seconds to print 'waiting disengagement' messages */
+#define XPC_DISENGAGE_PRINTMSG_INTERVAL         10
+#define XPC_PARTID(_p)  ((partid_t) ((_p) - &xpc_partitions[0]))
+/* found in xp_main.c */
+extern struct xpc_registration xpc_registrations[];
+/* found in xpc_main.c */
+extern struct device *xpc_part;
+extern struct device *xpc_chan;
+extern int xpc_disengage_request_timelimit;
+extern int xpc_disengage_request_timedout;
+extern irqreturn_t xpc_notify_IRQ_handler(int, void *, struct pt_regs *);
+extern void xpc_dropped_IPI_check(struct xpc_partition *);
+extern void xpc_activate_partition(struct xpc_partition *);
+extern void xpc_activate_kthreads(struct xpc_channel *, int);
+extern void xpc_create_kthreads(struct xpc_channel *, int);
+extern void xpc_disconnect_wait(int);
+/* found in xpc_partition.c */
+extern int xpc_exiting;
+extern struct xpc_vars *xpc_vars;
+extern struct xpc_rsvd_page *xpc_rsvd_page;
+extern struct xpc_vars_part *xpc_vars_part;
+extern struct xpc_partition xpc_partitions[XP_MAX_PARTITIONS + 1];
+extern char xpc_remote_copy_buffer[];
+extern struct xpc_rsvd_page *xpc_rsvd_page_init(void);
+extern void xpc_allow_IPI_ops(void);
+extern void xpc_restrict_IPI_ops(void);
+extern int xpc_identify_act_IRQ_sender(void);
+extern int xpc_partition_disengaged(struct xpc_partition *);
+extern enum xpc_retval xpc_mark_partition_active(struct xpc_partition *);
+extern void xpc_mark_partition_inactive(struct xpc_partition *);
+extern void xpc_discovery(void);
+extern void xpc_check_remote_hb(void);
+extern void xpc_deactivate_partition(const int, struct xpc_partition *,
+                                                enum xpc_retval);
+extern enum xpc_retval xpc_initiate_partid_to_nasids(partid_t, void *);
+/* found in xpc_channel.c */
+extern void xpc_initiate_connect(int);
+extern void xpc_initiate_disconnect(int);
+extern enum xpc_retval xpc_initiate_allocate(partid_t, int, u32, void **);
+extern enum xpc_retval xpc_initiate_send(partid_t, int, void *);
+extern enum xpc_retval xpc_initiate_send_notify(partid_t, int, void *,
+                                                xpc_notify_func, void *);
+extern void xpc_initiate_received(partid_t, int, void *);
+extern enum xpc_retval xpc_setup_infrastructure(struct xpc_partition *);
+extern enum xpc_retval xpc_pull_remote_vars_part(struct xpc_partition *);
+extern void xpc_process_channel_activity(struct xpc_partition *);
+extern void xpc_connected_callout(struct xpc_channel *);
+extern void xpc_deliver_msg(struct xpc_channel *);
+extern void xpc_disconnect_channel(const int, struct xpc_channel *,
+                                        enum xpc_retval, unsigned long *);
+extern void xpc_disconnect_callout(struct xpc_channel *, enum xpc_retval);
+extern void xpc_partition_going_down(struct xpc_partition *, enum xpc_retval);
+extern void xpc_teardown_infrastructure(struct xpc_partition *);
+static inline void
+xpc_wakeup_channel_mgr(struct xpc_partition *part)
+{
+        if (atomic_inc_return(&part->channel_mgr_requests) == 1) {
+                wake_up(&part->channel_mgr_wq);
+        }
+}
+/*
+ * These next two inlines are used to keep us from tearing down a channel's
+ * msg queues while a thread may be referencing them.
+ */
+static inline void
+xpc_msgqueue_ref(struct xpc_channel *ch)
+{
+        atomic_inc(&ch->references);
+}
+static inline void
+xpc_msgqueue_deref(struct xpc_channel *ch)
+{
+        s32 refs = atomic_dec_return(&ch->references);
+        DBUG_ON(refs < 0);
+        if (refs == 0) {
+                xpc_wakeup_channel_mgr(&xpc_partitions[ch->partid]);
+        }
+}
+#define XPC_DISCONNECT_CHANNEL(_ch, _reason, _irqflgs) \
+                xpc_disconnect_channel(__LINE__, _ch, _reason, _irqflgs)
+/*
+ * These two inlines are used to keep us from tearing down a partition's
+ * setup infrastructure while a thread may be referencing it.
+ */
+static inline void
+xpc_part_deref(struct xpc_partition *part)
+{
+        s32 refs = atomic_dec_return(&part->references);
+        DBUG_ON(refs < 0);
+        if (refs == 0 && part->setup_state == XPC_P_WTEARDOWN) {
+                wake_up(&part->teardown_wq);
+        }
+}
+static inline int
+xpc_part_ref(struct xpc_partition *part)
+{
+        int setup;
+        atomic_inc(&part->references);
+        setup = (part->setup_state == XPC_P_SETUP);
+        if (!setup) {
+                xpc_part_deref(part);
+        }
+        return setup;
+}
+/*
+ * The following macro is to be used for the setting of the reason and
+ * reason_line fields in both the struct xpc_channel and struct xpc_partition
+ * structures.
+ */
+#define XPC_SET_REASON(_p, _reason, _line) \
+        { \
+                (_p)->reason = _reason; \
+                (_p)->reason_line = _line; \
+        }
+/*
+ * This next set of inlines are used to keep track of when a partition is
+ * potentially engaged in accessing memory belonging to another partition.
+ */
+static inline void
+xpc_mark_partition_engaged(struct xpc_partition *part)
+{
+        unsigned long irq_flags;
+        AMO_t *amo = (AMO_t *) __va(part->remote_amos_page_pa +
+                                (XPC_ENGAGED_PARTITIONS_AMO * sizeof(AMO_t)));
+        local_irq_save(irq_flags);
+        /* set bit corresponding to our partid in remote partition's AMO */
+        FETCHOP_STORE_OP(TO_AMO((u64) &amo->variable), FETCHOP_OR,
+                                                (1UL << sn_partition_id));
+        /*
+         * We must always use the nofault function regardless of whether we
+         * are on a Shub 1.1 system or a Shub 1.2 slice 0xc processor. If we
+         * didn't, we'd never know that the other partition is down and would
+         * keep sending IPIs and AMOs to it until the heartbeat times out.
+         */
+        (void) xp_nofault_PIOR((u64 *) GLOBAL_MMR_ADDR(NASID_GET(&amo->
+                                variable), xp_nofault_PIOR_target));
+        local_irq_restore(irq_flags);
+}
+static inline void
+xpc_mark_partition_disengaged(struct xpc_partition *part)
+{
+        unsigned long irq_flags;
+        AMO_t *amo = (AMO_t *) __va(part->remote_amos_page_pa +
+                                (XPC_ENGAGED_PARTITIONS_AMO * sizeof(AMO_t)));
+        local_irq_save(irq_flags);
+        /* clear bit corresponding to our partid in remote partition's AMO */
+        FETCHOP_STORE_OP(TO_AMO((u64) &amo->variable), FETCHOP_AND,
+                                                ~(1UL << sn_partition_id));
+        /*
+         * We must always use the nofault function regardless of whether we
+         * are on a Shub 1.1 system or a Shub 1.2 slice 0xc processor. If we
+         * didn't, we'd never know that the other partition is down and would
+         * keep sending IPIs and AMOs to it until the heartbeat times out.
+         */
+        (void) xp_nofault_PIOR((u64 *) GLOBAL_MMR_ADDR(NASID_GET(&amo->
+                                variable), xp_nofault_PIOR_target));
+        local_irq_restore(irq_flags);
+}
+static inline void
+xpc_request_partition_disengage(struct xpc_partition *part)
+{
+        unsigned long irq_flags;
+        AMO_t *amo = (AMO_t *) __va(part->remote_amos_page_pa +
+                                (XPC_DISENGAGE_REQUEST_AMO * sizeof(AMO_t)));
+        local_irq_save(irq_flags);
+        /* set bit corresponding to our partid in remote partition's AMO */
+        FETCHOP_STORE_OP(TO_AMO((u64) &amo->variable), FETCHOP_OR,
+                                                (1UL << sn_partition_id));
+        /*
+         * We must always use the nofault function regardless of whether we
+         * are on a Shub 1.1 system or a Shub 1.2 slice 0xc processor. If we
+         * didn't, we'd never know that the other partition is down and would
+         * keep sending IPIs and AMOs to it until the heartbeat times out.
+         */
+        (void) xp_nofault_PIOR((u64 *) GLOBAL_MMR_ADDR(NASID_GET(&amo->
+                                variable), xp_nofault_PIOR_target));
+        local_irq_restore(irq_flags);
+}
+static inline void
+xpc_cancel_partition_disengage_request(struct xpc_partition *part)
+{
+        unsigned long irq_flags;
+        AMO_t *amo = (AMO_t *) __va(part->remote_amos_page_pa +
+                                (XPC_DISENGAGE_REQUEST_AMO * sizeof(AMO_t)));
+        local_irq_save(irq_flags);
+        /* clear bit corresponding to our partid in remote partition's AMO */
+        FETCHOP_STORE_OP(TO_AMO((u64) &amo->variable), FETCHOP_AND,
+                                                ~(1UL << sn_partition_id));
+        /*
+         * We must always use the nofault function regardless of whether we
+         * are on a Shub 1.1 system or a Shub 1.2 slice 0xc processor. If we
+         * didn't, we'd never know that the other partition is down and would
+         * keep sending IPIs and AMOs to it until the heartbeat times out.
+         */
+        (void) xp_nofault_PIOR((u64 *) GLOBAL_MMR_ADDR(NASID_GET(&amo->
+                                variable), xp_nofault_PIOR_target));
+        local_irq_restore(irq_flags);
+}
+static inline u64
+xpc_partition_engaged(u64 partid_mask)
+{
+        AMO_t *amo = xpc_vars->amos_page + XPC_ENGAGED_PARTITIONS_AMO;
+        /* return our partition's AMO variable ANDed with partid_mask */
+        return (FETCHOP_LOAD_OP(TO_AMO((u64) &amo->variable), FETCHOP_LOAD) &
+                                                                partid_mask);
+}
+static inline u64
+xpc_partition_disengage_requested(u64 partid_mask)
+{
+        AMO_t *amo = xpc_vars->amos_page + XPC_DISENGAGE_REQUEST_AMO;
+        /* return our partition's AMO variable ANDed with partid_mask */
+        return (FETCHOP_LOAD_OP(TO_AMO((u64) &amo->variable), FETCHOP_LOAD) &
+                                                                partid_mask);
+}
+static inline void
+xpc_clear_partition_engaged(u64 partid_mask)
+{
+        AMO_t *amo = xpc_vars->amos_page + XPC_ENGAGED_PARTITIONS_AMO;
+        /* clear bit(s) based on partid_mask in our partition's AMO */
+        FETCHOP_STORE_OP(TO_AMO((u64) &amo->variable), FETCHOP_AND,
+                                                                ~partid_mask);
+}
+static inline void
+xpc_clear_partition_disengage_request(u64 partid_mask)
+{
+        AMO_t *amo = xpc_vars->amos_page + XPC_DISENGAGE_REQUEST_AMO;
+        /* clear bit(s) based on partid_mask in our partition's AMO */
+        FETCHOP_STORE_OP(TO_AMO((u64) &amo->variable), FETCHOP_AND,
+                                                                ~partid_mask);
+}
+/*
+ * The following set of macros and inlines are used for the sending and
+ * receiving of IPIs (also known as IRQs). There are two flavors of IPIs,
+ * one that is associated with partition activity (SGI_XPC_ACTIVATE) and
+ * the other that is associated with channel activity (SGI_XPC_NOTIFY).
+ */
+static inline u64
+xpc_IPI_receive(AMO_t *amo)
+{
+        return FETCHOP_LOAD_OP(TO_AMO((u64) &amo->variable), FETCHOP_CLEAR);
+}
+static inline enum xpc_retval
+xpc_IPI_send(AMO_t *amo, u64 flag, int nasid, int phys_cpuid, int vector)
+{
+        int ret = 0;
+        unsigned long irq_flags;
+        local_irq_save(irq_flags);
+        FETCHOP_STORE_OP(TO_AMO((u64) &amo->variable), FETCHOP_OR, flag);
+        sn_send_IPI_phys(nasid, phys_cpuid, vector, 0);
+        /*
+         * We must always use the nofault function regardless of whether we
+         * are on a Shub 1.1 system or a Shub 1.2 slice 0xc processor. If we
+         * didn't, we'd never know that the other partition is down and would
+         * keep sending IPIs and AMOs to it until the heartbeat times out.
+         */
+        ret = xp_nofault_PIOR((u64 *) GLOBAL_MMR_ADDR(NASID_GET(&amo->variable),
+                                xp_nofault_PIOR_target));
+        local_irq_restore(irq_flags);
+        return ((ret == 0) ? xpcSuccess : xpcPioReadError);
+}
+/*
+ * IPIs associated with SGI_XPC_ACTIVATE IRQ.
+ */
+/*
+ * Flag the appropriate AMO variable and send an IPI to the specified node.
+ */
+static inline void
+xpc_activate_IRQ_send(u64 amos_page_pa, int from_nasid, int to_nasid,
+                        int to_phys_cpuid)
+{
+        int w_index = XPC_NASID_W_INDEX(from_nasid);
+        int b_index = XPC_NASID_B_INDEX(from_nasid);
+        AMO_t *amos = (AMO_t *) __va(amos_page_pa +
+                                (XPC_ACTIVATE_IRQ_AMOS * sizeof(AMO_t)));
+        (void) xpc_IPI_send(&amos[w_index], (1UL << b_index), to_nasid,
+                                to_phys_cpuid, SGI_XPC_ACTIVATE);
+}
+static inline void
+xpc_IPI_send_activate(struct xpc_vars *vars)
+{
+        xpc_activate_IRQ_send(vars->amos_page_pa, cnodeid_to_nasid(0),
+                                vars->act_nasid, vars->act_phys_cpuid);
+}
+static inline void
+xpc_IPI_send_activated(struct xpc_partition *part)
+{
+        xpc_activate_IRQ_send(part->remote_amos_page_pa, cnodeid_to_nasid(0),
+                        part->remote_act_nasid, part->remote_act_phys_cpuid);
+}
+static inline void
+xpc_IPI_send_reactivate(struct xpc_partition *part)
+{
+        xpc_activate_IRQ_send(xpc_vars->amos_page_pa, part->reactivate_nasid,
+                                xpc_vars->act_nasid, xpc_vars->act_phys_cpuid);
+}
+static inline void
+xpc_IPI_send_disengage(struct xpc_partition *part)
+{
+        xpc_activate_IRQ_send(part->remote_amos_page_pa, cnodeid_to_nasid(0),
+                        part->remote_act_nasid, part->remote_act_phys_cpuid);
+}
+/*
+ * IPIs associated with SGI_XPC_NOTIFY IRQ.
+ */
+/*
+ * Send an IPI to the remote partition that is associated with the
+ * specified channel.
+ */
+#define XPC_NOTIFY_IRQ_SEND(_ch, _ipi_f, _irq_f) \
+                xpc_notify_IRQ_send(_ch, _ipi_f, #_ipi_f, _irq_f)
+static inline void
+xpc_notify_IRQ_send(struct xpc_channel *ch, u8 ipi_flag, char *ipi_flag_string,
+                        unsigned long *irq_flags)
+{
+        struct xpc_partition *part = &xpc_partitions[ch->partid];
+        enum xpc_retval ret;
+        if (likely(part->act_state != XPC_P_DEACTIVATING)) {
+                ret = xpc_IPI_send(part->remote_IPI_amo_va,
+                                        (u64) ipi_flag << (ch->number * 8),
+                                        part->remote_IPI_nasid,
+                                        part->remote_IPI_phys_cpuid,
+                                        SGI_XPC_NOTIFY);
+                dev_dbg(xpc_chan, "%s sent to partid=%d, channel=%d, ret=%d\n",
+                        ipi_flag_string, ch->partid, ch->number, ret);
+                if (unlikely(ret != xpcSuccess)) {
+                        if (irq_flags != NULL) {
+                                spin_unlock_irqrestore(&ch->lock, *irq_flags);
+                        }
+                        XPC_DEACTIVATE_PARTITION(part, ret);
+                        if (irq_flags != NULL) {
+                                spin_lock_irqsave(&ch->lock, *irq_flags);
+                        }
+                }
+        }
+}
+/*
+ * Make it look like the remote partition, which is associated with the
+ * specified channel, sent us an IPI. This faked IPI will be handled
+ * by xpc_dropped_IPI_check().
+ */
+#define XPC_NOTIFY_IRQ_SEND_LOCAL(_ch, _ipi_f) \
+                xpc_notify_IRQ_send_local(_ch, _ipi_f, #_ipi_f)
+static inline void
+xpc_notify_IRQ_send_local(struct xpc_channel *ch, u8 ipi_flag,
+                                char *ipi_flag_string)
+{
+        struct xpc_partition *part = &xpc_partitions[ch->partid];
+        FETCHOP_STORE_OP(TO_AMO((u64) &part->local_IPI_amo_va->variable),
+                        FETCHOP_OR, ((u64) ipi_flag << (ch->number * 8)));
+        dev_dbg(xpc_chan, "%s sent local from partid=%d, channel=%d\n",
+                ipi_flag_string, ch->partid, ch->number);
+}
+/*
+ * The sending and receiving of IPIs includes the setting of an AMO variable
+ * to indicate the reason the IPI was sent. The 64-bit variable is divided
+ * up into eight bytes, ordered from right to left. Byte zero pertains to
+ * channel 0, byte one to channel 1, and so on. Each byte is described by
+ * the following IPI flags.
+ */
+#define XPC_IPI_CLOSEREQUEST    0x01
+#define XPC_IPI_CLOSEREPLY      0x02
+#define XPC_IPI_OPENREQUEST     0x04
+#define XPC_IPI_OPENREPLY       0x08
+#define XPC_IPI_MSGREQUEST      0x10
+/* given an AMO variable and a channel#, get its associated IPI flags */
+#define XPC_GET_IPI_FLAGS(_amo, _c)     ((u8) (((_amo) >> ((_c) * 8)) & 0xff))
+#define XPC_SET_IPI_FLAGS(_amo, _c, _f) (_amo) |= ((u64) (_f) << ((_c) * 8))
+#define XPC_ANY_OPENCLOSE_IPI_FLAGS_SET(_amo) ((_amo) & 0x0f0f0f0f0f0f0f0f)
+#define XPC_ANY_MSG_IPI_FLAGS_SET(_amo)       ((_amo) & 0x1010101010101010)
+static inline void
+xpc_IPI_send_closerequest(struct xpc_channel *ch, unsigned long *irq_flags)
+{
+        struct xpc_openclose_args *args = ch->local_openclose_args;
+        args->reason = ch->reason;
+        XPC_NOTIFY_IRQ_SEND(ch, XPC_IPI_CLOSEREQUEST, irq_flags);
+}
+static inline void
+xpc_IPI_send_closereply(struct xpc_channel *ch, unsigned long *irq_flags)
+{
+        XPC_NOTIFY_IRQ_SEND(ch, XPC_IPI_CLOSEREPLY, irq_flags);
+}
+static inline void
+xpc_IPI_send_openrequest(struct xpc_channel *ch, unsigned long *irq_flags)
+{
+        struct xpc_openclose_args *args = ch->local_openclose_args;
+        args->msg_size = ch->msg_size;
+        args->local_nentries = ch->local_nentries;
+        XPC_NOTIFY_IRQ_SEND(ch, XPC_IPI_OPENREQUEST, irq_flags);
+}
+static inline void
+xpc_IPI_send_openreply(struct xpc_channel *ch, unsigned long *irq_flags)
+{
+        struct xpc_openclose_args *args = ch->local_openclose_args;
+        args->remote_nentries = ch->remote_nentries;
+        args->local_nentries = ch->local_nentries;
+        args->local_msgqueue_pa = __pa(ch->local_msgqueue);
+        XPC_NOTIFY_IRQ_SEND(ch, XPC_IPI_OPENREPLY, irq_flags);
+}
+static inline void
+xpc_IPI_send_msgrequest(struct xpc_channel *ch)
+{
+        XPC_NOTIFY_IRQ_SEND(ch, XPC_IPI_MSGREQUEST, NULL);
+}
+static inline void
+xpc_IPI_send_local_msgrequest(struct xpc_channel *ch)
+{
+        XPC_NOTIFY_IRQ_SEND_LOCAL(ch, XPC_IPI_MSGREQUEST);
+}
+/*
+ * Memory for XPC's AMO variables is allocated by the MSPEC driver. These
+ * pages are located in the lowest granule. The lowest granule uses 4k pages
+ * for cached references and an alternate TLB handler to never provide a
+ * cacheable mapping for the entire region. This will prevent speculative
+ * reading of cached copies of our lines from being issued which will cause
+ * a PI FSB Protocol error to be generated by the SHUB. For XPC, we need 64
+ * AMO variables (based on XP_MAX_PARTITIONS) for message notification and an
+ * additional 128 AMO variables (based on XP_NASID_MASK_WORDS) for partition
+ * activation and 2 AMO variables for partition deactivation.
+ */
+static inline AMO_t *
+xpc_IPI_init(int index)
+{
+        AMO_t *amo = xpc_vars->amos_page + index;
+        (void) xpc_IPI_receive(amo);    /* clear AMO variable */
+        return amo;
+}
+static inline enum xpc_retval
+xpc_map_bte_errors(bte_result_t error)
+{
+        switch (error) {
+        case BTE_SUCCESS:       return xpcSuccess;
+        case BTEFAIL_DIR:       return xpcBteDirectoryError;
+        case BTEFAIL_POISON:    return xpcBtePoisonError;
+        case BTEFAIL_WERR:      return xpcBteWriteError;
+        case BTEFAIL_ACCESS:    return xpcBteAccessError;
+        case BTEFAIL_PWERR:     return xpcBtePWriteError;
+        case BTEFAIL_PRERR:     return xpcBtePReadError;
+        case BTEFAIL_TOUT:      return xpcBteTimeOutError;
+        case BTEFAIL_XTERR:     return xpcBteXtalkError;
+        case BTEFAIL_NOTAVAIL:  return xpcBteNotAvailable;
+        default:                return xpcBteUnmappedError;
+        }
+}
+static inline void *
+xpc_kmalloc_cacheline_aligned(size_t size, gfp_t flags, void **base)
+{
+        /* see if kmalloc will give us cachline aligned memory by default */
+        *base = kmalloc(size, flags);
+        if (*base == NULL) {
+                return NULL;
+        }
+        if ((u64) *base == L1_CACHE_ALIGN((u64) *base)) {
+                return *base;
+        }
+        kfree(*base);
+        /* nope, we'll have to do it ourselves */
+        *base = kmalloc(size + L1_CACHE_BYTES, flags);
+        if (*base == NULL) {
+                return NULL;
+        }
+        return (void *) L1_CACHE_ALIGN((u64) *base);
+}
+/*
+ * Check to see if there is any channel activity to/from the specified
+ * partition.
+ */
+static inline void
+xpc_check_for_channel_activity(struct xpc_partition *part)
+{
+        u64 IPI_amo;
+        unsigned long irq_flags;
+        IPI_amo = xpc_IPI_receive(part->local_IPI_amo_va);
+        if (IPI_amo == 0) {
+                return;
+        }
+        spin_lock_irqsave(&part->IPI_lock, irq_flags);
+        part->local_IPI_amo |= IPI_amo;
+        spin_unlock_irqrestore(&part->IPI_lock, irq_flags);
+        dev_dbg(xpc_chan, "received IPI from partid=%d, IPI_amo=0x%lx\n",
+                XPC_PARTID(part), IPI_amo);
+        xpc_wakeup_channel_mgr(part);
+}
+#endif /* _ASM_IA64_SN_XPC_H */
diff --git a/include/asm-ia64/thread_info.h b/include/asm-ia64/thread_info.h
index 653bb7f9a753..1d6518fe1f02 100644
--- a/include/asm-ia64/thread_info.h
+++ b/include/asm-ia64/thread_info.h
@@ -93,6 +93,7 @@ struct thread_info {
 #define TIF_POLLING_NRFLAG      16      /* true if poll_idle() is polling TIF_NEED_RESCHED */
 #define TIF_MEMDIE              17
 #define TIF_MCA_INIT            18      /* this task is processing MCA or INIT */
+#define TIF_DB_DISABLED         19      /* debug trap disabled for fsyscall */
 #define _TIF_SYSCALL_TRACE      (1 << TIF_SYSCALL_TRACE)
 #define _TIF_SYSCALL_AUDIT      (1 << TIF_SYSCALL_AUDIT)
@@ -100,9 +101,10 @@ struct thread_info {
 #define _TIF_NOTIFY_RESUME      (1 << TIF_NOTIFY_RESUME)
 #define _TIF_SIGPENDING         (1 << TIF_SIGPENDING)
 #define _TIF_NEED_RESCHED       (1 << TIF_NEED_RESCHED)
-#define _TIF_SIGDELAYED (1 << TIF_SIGDELAYED)
+#define _TIF_SIGDELAYED         (1 << TIF_SIGDELAYED)
 #define _TIF_POLLING_NRFLAG     (1 << TIF_POLLING_NRFLAG)
 #define _TIF_MCA_INIT           (1 << TIF_MCA_INIT)
+#define _TIF_DB_DISABLED        (1 << TIF_DB_DISABLED)
 /* "work to do on user-return" bits */
 #define TIF_ALLWORK_MASK        (_TIF_NOTIFY_RESUME|_TIF_SIGPENDING|_TIF_NEED_RESCHED|_TIF_SYSCALL_TRACE|_TIF_SYSCALL_AUDIT|_TIF_SIGDELAYED)
diff --git a/include/asm-powerpc/atomic.h b/include/asm-powerpc/atomic.h
index 248f9aec959c..147a38dcc766 100644
--- a/include/asm-powerpc/atomic.h
+++ b/include/asm-powerpc/atomic.h
@@ -36,7 +36,7 @@ static __inline__ int atomic_add_return(int a, atomic_t *v)
        int t;
        __asm__ __volatile__(
-        EIEIO_ON_SMP
+        LWSYNC_ON_SMP
 "1:     lwarx   %0,0,%2         # atomic_add_return\n\
        add     %0,%1,%0\n"
        PPC405_ERR77(0,%2)
@@ -72,7 +72,7 @@ static __inline__ int atomic_sub_return(int a, atomic_t *v)
        int t;
        __asm__ __volatile__(
-        EIEIO_ON_SMP
+        LWSYNC_ON_SMP
 "1:     lwarx   %0,0,%2         # atomic_sub_return\n\
        subf    %0,%1,%0\n"
        PPC405_ERR77(0,%2)
@@ -106,7 +106,7 @@ static __inline__ int atomic_inc_return(atomic_t *v)
        int t;
        __asm__ __volatile__(
-        EIEIO_ON_SMP
+        LWSYNC_ON_SMP
 "1:     lwarx   %0,0,%1         # atomic_inc_return\n\
        addic   %0,%0,1\n"
        PPC405_ERR77(0,%1)
@@ -150,7 +150,7 @@ static __inline__ int atomic_dec_return(atomic_t *v)
        int t;
        __asm__ __volatile__(
-        EIEIO_ON_SMP
+        LWSYNC_ON_SMP
 "1:     lwarx   %0,0,%1         # atomic_dec_return\n\
        addic   %0,%0,-1\n"
        PPC405_ERR77(0,%1)
@@ -176,19 +176,19 @@ static __inline__ int atomic_dec_return(atomic_t *v)
 * Atomically adds @a to @v, so long as it was not @u.
 * Returns non-zero if @v was not @u, and zero otherwise.
 */
-#define atomic_add_unless(v, a, u)                                                       \
+#define atomic_add_unless(v, a, u)                      \
-({                                                                                                                       \
+({                                                      \
-           int c, old;                                                                                   \
+        int c, old;                                     \
-           c = atomic_read(v);                                                                   \
+        c = atomic_read(v);                             \
-           for (;;) {                                                                                     \
+        for (;;) {                                      \
-                           if (unlikely(c == (u)))                                               \
+                if (unlikely(c == (u)))                 \
-                                           break;                                                                 \
+                        break;                          \
-                           old = atomic_cmpxchg((v), c, c + (a));                 \
+                old = atomic_cmpxchg((v), c, c + (a));  \
-                           if (likely(old == c))                                                   \
+                if (likely(old == c))                   \
-                                           break;                                                                 \
+                        break;                          \
-                           c = old;                                                                             \
+                c = old;                                \
-           }                                                                                                       \
+        }                                               \
-           c != (u);                                                                                       \
+        c != (u);                                       \
 })
 #define atomic_inc_not_zero(v) atomic_add_unless((v), 1, 0)
@@ -204,7 +204,7 @@ static __inline__ int atomic_dec_if_positive(atomic_t *v)
        int t;
        __asm__ __volatile__(
-        EIEIO_ON_SMP
+        LWSYNC_ON_SMP
 "1:     lwarx   %0,0,%1         # atomic_dec_if_positive\n\
        addic.  %0,%0,-1\n\
        blt-    2f\n"
@@ -253,7 +253,7 @@ static __inline__ long atomic64_add_return(long a, atomic64_t *v)
        long t;
        __asm__ __volatile__(
-        EIEIO_ON_SMP
+        LWSYNC_ON_SMP
 "1:     ldarx   %0,0,%2         # atomic64_add_return\n\
        add     %0,%1,%0\n\
        stdcx.  %0,0,%2 \n\
@@ -287,7 +287,7 @@ static __inline__ long atomic64_sub_return(long a, atomic64_t *v)
        long t;
        __asm__ __volatile__(
-        EIEIO_ON_SMP
+        LWSYNC_ON_SMP
 "1:     ldarx   %0,0,%2         # atomic64_sub_return\n\
        subf    %0,%1,%0\n\
        stdcx.  %0,0,%2 \n\
@@ -319,7 +319,7 @@ static __inline__ long atomic64_inc_return(atomic64_t *v)
        long t;
        __asm__ __volatile__(
-        EIEIO_ON_SMP
+        LWSYNC_ON_SMP
 "1:     ldarx   %0,0,%1         # atomic64_inc_return\n\
        addic   %0,%0,1\n\
        stdcx.  %0,0,%1 \n\
@@ -361,7 +361,7 @@ static __inline__ long atomic64_dec_return(atomic64_t *v)
        long t;
        __asm__ __volatile__(
-        EIEIO_ON_SMP
+        LWSYNC_ON_SMP
 "1:     ldarx   %0,0,%1         # atomic64_dec_return\n\
        addic   %0,%0,-1\n\
        stdcx.  %0,0,%1\n\
@@ -386,7 +386,7 @@ static __inline__ long atomic64_dec_if_positive(atomic64_t *v)
        long t;
        __asm__ __volatile__(
-        EIEIO_ON_SMP
+        LWSYNC_ON_SMP
 "1:     ldarx   %0,0,%1         # atomic64_dec_if_positive\n\
        addic.  %0,%0,-1\n\
        blt-    2f\n\
diff --git a/include/asm-powerpc/bitops.h b/include/asm-powerpc/bitops.h
index 1996eaa8aeae..bf6941a810b8 100644
--- a/include/asm-powerpc/bitops.h
+++ b/include/asm-powerpc/bitops.h
@@ -112,7 +112,7 @@ static __inline__ int test_and_set_bit(unsigned long nr,
        unsigned long *p = ((unsigned long *)addr) + BITOP_WORD(nr);
        __asm__ __volatile__(
-        EIEIO_ON_SMP
+        LWSYNC_ON_SMP
 "1:"    PPC_LLARX "%0,0,%3              # test_and_set_bit\n"
        "or     %1,%0,%2 \n"
        PPC405_ERR77(0,%3)
@@ -134,7 +134,7 @@ static __inline__ int test_and_clear_bit(unsigned long nr,
        unsigned long *p = ((unsigned long *)addr) + BITOP_WORD(nr);
        __asm__ __volatile__(
-        EIEIO_ON_SMP
+        LWSYNC_ON_SMP
 "1:"    PPC_LLARX "%0,0,%3              # test_and_clear_bit\n"
        "andc   %1,%0,%2 \n"
        PPC405_ERR77(0,%3)
@@ -156,7 +156,7 @@ static __inline__ int test_and_change_bit(unsigned long nr,
        unsigned long *p = ((unsigned long *)addr) + BITOP_WORD(nr);
        __asm__ __volatile__(
-        EIEIO_ON_SMP
+        LWSYNC_ON_SMP
 "1:"    PPC_LLARX "%0,0,%3              # test_and_change_bit\n"
        "xor    %1,%0,%2 \n"
        PPC405_ERR77(0,%3)
diff --git a/include/asm-powerpc/cputable.h b/include/asm-powerpc/cputable.h
index ef6ead34a773..64210549f56b 100644
--- a/include/asm-powerpc/cputable.h
+++ b/include/asm-powerpc/cputable.h
@@ -19,6 +19,7 @@
 #define PPC_FEATURE_POWER5              0x00040000
 #define PPC_FEATURE_POWER5_PLUS         0x00020000
 #define PPC_FEATURE_CELL                0x00010000
+#define PPC_FEATURE_BOOKE               0x00008000
 #ifdef __KERNEL__
 #ifndef __ASSEMBLY__
@@ -31,11 +32,11 @@ struct cpu_spec;
 typedef void (*cpu_setup_t)(unsigned long offset, struct cpu_spec* spec);
 enum powerpc_oprofile_type {
-        INVALID = 0,
+        PPC_OPROFILE_INVALID = 0,
-        RS64 = 1,
+        PPC_OPROFILE_RS64 = 1,
-        POWER4 = 2,
+        PPC_OPROFILE_POWER4 = 2,
-        G4 = 3,
+        PPC_OPROFILE_G4 = 3,
-        BOOKE = 4,
+        PPC_OPROFILE_BOOKE = 4,
 };
 struct cpu_spec {
@@ -64,6 +65,9 @@ struct cpu_spec {
        /* Processor specific oprofile operations */
        enum powerpc_oprofile_type oprofile_type;
+        /* Name of processor class, for the ELF AT_PLATFORM entry */
+        char            *platform;
 };
 extern struct cpu_spec          *cur_cpu_spec;
diff --git a/include/asm-powerpc/elf.h b/include/asm-powerpc/elf.h
index 45f2af6f89c4..94d228f9c6ac 100644
--- a/include/asm-powerpc/elf.h
+++ b/include/asm-powerpc/elf.h
@@ -221,20 +221,18 @@ extern int dump_task_fpu(struct task_struct *, elf_fpregset_t *);
   instruction set this cpu supports.  This could be done in userspace,
   but it's not easy, and we've already done it here.  */
 # define ELF_HWCAP      (cur_cpu_spec->cpu_user_features)
-#ifdef __powerpc64__
-# define ELF_PLAT_INIT(_r, load_addr)   do {    \
-        _r->gpr[2] = load_addr;                 \
-} while (0)
-#endif /* __powerpc64__ */
 /* This yields a string that ld.so will use to load implementation
   specific libraries for optimization.  This is more specific in
-   intent than poking at uname or /proc/cpuinfo.
+   intent than poking at uname or /proc/cpuinfo.  */
-   For the moment, we have only optimizations for the Intel generations,
+#define ELF_PLATFORM    (cur_cpu_spec->platform)
-   but that could change... */
-#define ELF_PLATFORM    (NULL)
+#ifdef __powerpc64__
+# define ELF_PLAT_INIT(_r, load_addr)   do {    \
+        _r->gpr[2] = load_addr;                 \
+} while (0)
+#endif /* __powerpc64__ */
 #ifdef __KERNEL__
diff --git a/include/asm-powerpc/futex.h b/include/asm-powerpc/futex.h
index f0319d50b129..39e85f320a76 100644
--- a/include/asm-powerpc/futex.h
+++ b/include/asm-powerpc/futex.h
@@ -11,7 +11,7 @@
 #define __futex_atomic_op(insn, ret, oldval, uaddr, oparg) \
  __asm__ __volatile ( \
-        SYNC_ON_SMP \
+        LWSYNC_ON_SMP \
 "1:     lwarx   %0,0,%2\n" \
        insn \
        PPC405_ERR77(0, %2) \
diff --git a/include/asm-powerpc/hvcall.h b/include/asm-powerpc/hvcall.h
index da7af5a720e0..38ca9ad6110d 100644
--- a/include/asm-powerpc/hvcall.h
+++ b/include/asm-powerpc/hvcall.h
@@ -6,7 +6,10 @@
 #define H_Success       0
 #define H_Busy          1       /* Hardware busy -- retry later */
+#define H_Closed        2       /* Resource closed */
 #define H_Constrained   4       /* Resource request constrained to max allowed */
+#define H_InProgress   14       /* Kind of like busy */
+#define H_Continue     18       /* Returned from H_Join on success */
 #define H_LongBusyStartRange   9900  /* Start of long busy range */
 #define H_LongBusyOrder1msec   9900  /* Long busy, hint that 1msec is a good time to retry */
 #define H_LongBusyOrder10msec  9901  /* Long busy, hint that 10msec is a good time to retry */
@@ -114,6 +117,8 @@
 #define H_REGISTER_VTERM        0x154
 #define H_FREE_VTERM            0x158
 #define H_POLL_PENDING          0x1D8
+#define H_JOIN                  0x298
+#define H_ENABLE_CRQ            0x2B0
 #ifndef __ASSEMBLY__
diff --git a/include/asm-powerpc/kexec.h b/include/asm-powerpc/kexec.h
index fffdf690b840..640a6459f2f4 100644
--- a/include/asm-powerpc/kexec.h
+++ b/include/asm-powerpc/kexec.h
@@ -31,12 +31,80 @@
 #define KEXEC_ARCH KEXEC_ARCH_PPC
 #endif
-#define HAVE_ARCH_COPY_OLDMEM_PAGE
-#ifndef __ASSEMBLY__
 #ifdef CONFIG_KEXEC
+#ifdef __powerpc64__
+/*
+ * This function is responsible for capturing register states if coming
+ * via panic or invoking dump using sysrq-trigger.
+ */
+static inline void crash_setup_regs(struct pt_regs *newregs,
+                                        struct pt_regs *oldregs)
+{
+        if (oldregs)
+                memcpy(newregs, oldregs, sizeof(*newregs));
+        else {
+                /* FIXME Merge this with xmon_save_regs ?? */
+                unsigned long tmp1, tmp2;
+                __asm__ __volatile__ (
+                        "std    0,0(%2)\n"
+                        "std    1,8(%2)\n"
+                        "std    2,16(%2)\n"
+                        "std    3,24(%2)\n"
+                        "std    4,32(%2)\n"
+                        "std    5,40(%2)\n"
+                        "std    6,48(%2)\n"
+                        "std    7,56(%2)\n"
+                        "std    8,64(%2)\n"
+                        "std    9,72(%2)\n"
+                        "std    10,80(%2)\n"
+                        "std    11,88(%2)\n"
+                        "std    12,96(%2)\n"
+                        "std    13,104(%2)\n"
+                        "std    14,112(%2)\n"
+                        "std    15,120(%2)\n"
+                        "std    16,128(%2)\n"
+                        "std    17,136(%2)\n"
+                        "std    18,144(%2)\n"
+                        "std    19,152(%2)\n"
+                        "std    20,160(%2)\n"
+                        "std    21,168(%2)\n"
+                        "std    22,176(%2)\n"
+                        "std    23,184(%2)\n"
+                        "std    24,192(%2)\n"
+                        "std    25,200(%2)\n"
+                        "std    26,208(%2)\n"
+                        "std    27,216(%2)\n"
+                        "std    28,224(%2)\n"
+                        "std    29,232(%2)\n"
+                        "std    30,240(%2)\n"
+                        "std    31,248(%2)\n"
+                        "mfmsr  %0\n"
+                        "std    %0, 264(%2)\n"
+                        "mfctr  %0\n"
+                        "std    %0, 280(%2)\n"
+                        "mflr   %0\n"
+                        "std    %0, 288(%2)\n"
+                        "bl     1f\n"
+                "1:     mflr   %1\n"
+                        "std    %1, 256(%2)\n"
+                        "mtlr   %0\n"
+                        "mfxer  %0\n"
+                        "std    %0, 296(%2)\n"
+                        : "=&r" (tmp1), "=&r" (tmp2)
+                        : "b" (newregs));
+        }
+}
+#else
+/*
+ * Provide a dummy definition to avoid build failures. Will remain
+ * empty till crash dump support is enabled.
+ */
+static inline void crash_setup_regs(struct pt_regs *newregs,
+                                        struct pt_regs *oldregs) { }
+#endif /* !__powerpc64 __ */
+#ifndef __ASSEMBLY__
 #define MAX_NOTE_BYTES 1024
 #ifdef __powerpc64__
@@ -53,14 +121,7 @@ extern void default_machine_kexec(struct kimage *image);
 extern int default_machine_kexec_prepare(struct kimage *image);
 extern void default_machine_crash_shutdown(struct pt_regs *regs);
-#endif /* !CONFIG_KEXEC */
-/*
- * Provide a dummy definition to avoid build failures. Will remain
- * empty till crash dump support is enabled.
- */
-static inline void crash_setup_regs(struct pt_regs *newregs,
-                                        struct pt_regs *oldregs) { }
 #endif /* ! __ASSEMBLY__ */
+#endif /* CONFIG_KEXEC */
 #endif /* __KERNEL__ */
 #endif /* _ASM_POWERPC_KEXEC_H */
diff --git a/include/asm-powerpc/lppaca.h b/include/asm-powerpc/lppaca.h
index ff82ea7c4829..cd9f11f1ef14 100644
--- a/include/asm-powerpc/lppaca.h
+++ b/include/asm-powerpc/lppaca.h
@@ -29,7 +29,9 @@
 //----------------------------------------------------------------------------
 #include <asm/types.h>
-struct lppaca {
+/* The Hypervisor barfs if the lppaca crosses a page boundary.  A 1k
+ * alignment is sufficient to prevent this */
+struct __attribute__((__aligned__(0x400))) lppaca {
 //=============================================================================
 // CACHE_LINE_1 0x0000 - 0x007F Contains read-only data
 // NOTE: The xDynXyz fields are fields that will be dynamically changed by
@@ -129,5 +131,7 @@ struct lppaca {
        u8      pmc_save_area[256];     // PMC interrupt Area           x00-xFF
 };
+extern struct lppaca lppaca[];
 #endif /* __KERNEL__ */
 #endif /* _ASM_POWERPC_LPPACA_H */
diff --git a/include/asm-powerpc/paca.h b/include/asm-powerpc/paca.h
index a64b4d425dab..c9add8f1ad94 100644
--- a/include/asm-powerpc/paca.h
+++ b/include/asm-powerpc/paca.h
@@ -23,6 +23,7 @@
 register struct paca_struct *local_paca asm("r13");
 #define get_paca()      local_paca
+#define get_lppaca()    (get_paca()->lppaca_ptr)
 struct task_struct;
@@ -95,19 +96,6 @@ struct paca_struct {
        u64 saved_r1;                   /* r1 save for RTAS calls */
        u64 saved_msr;                  /* MSR saved here by enter_rtas */
        u8 proc_enabled;                /* irq soft-enable flag */
-        /*
-         * iSeries structure which the hypervisor knows about -
-         * this structure should not cross a page boundary.
-         * The vpa_init/register_vpa call is now known to fail if the
-         * lppaca structure crosses a page boundary.
-         * The lppaca is also used on POWER5 pSeries boxes.
-         * The lppaca is 640 bytes long, and cannot readily change
-         * since the hypervisor knows its layout, so a 1kB
-         * alignment will suffice to ensure that it doesn't
-         * cross a page boundary.
-         */
-        struct lppaca lppaca __attribute__((__aligned__(0x400)));
 };
 extern struct paca_struct paca[];
diff --git a/include/asm-powerpc/ppc_asm.h b/include/asm-powerpc/ppc_asm.h
index 0dc798d46ea4..ab8688d39024 100644
--- a/include/asm-powerpc/ppc_asm.h
+++ b/include/asm-powerpc/ppc_asm.h
@@ -156,52 +156,56 @@ n:
 #endif
 /* 
- * LOADADDR( rn, name )
+ * LOAD_REG_IMMEDIATE(rn, expr)
- *   loads the address of 'name' into 'rn'
+ *   Loads the value of the constant expression 'expr' into register 'rn'
+ *   using immediate instructions only.  Use this when it's important not
+ *   to reference other data (i.e. on ppc64 when the TOC pointer is not
+ *   valid).
 *
- * LOADBASE( rn, name )
+ * LOAD_REG_ADDR(rn, name)
- *   loads the address (possibly without the low 16 bits) of 'name' into 'rn'
+ *   Loads the address of label 'name' into register 'rn'.  Use this when
- *   suitable for base+disp addressing
+ *   you don't particularly need immediate instructions only, but you need
+ *   the whole address in one register (e.g. it's a structure address and
+ *   you want to access various offsets within it).  On ppc32 this is
+ *   identical to LOAD_REG_IMMEDIATE.
+ *
+ * LOAD_REG_ADDRBASE(rn, name)
+ * ADDROFF(name)
+ *   LOAD_REG_ADDRBASE loads part of the address of label 'name' into
+ *   register 'rn'.  ADDROFF(name) returns the remainder of the address as
+ *   a constant expression.  ADDROFF(name) is a signed expression < 16 bits
+ *   in size, so is suitable for use directly as an offset in load and store
+ *   instructions.  Use this when loading/storing a single word or less as:
+ *      LOAD_REG_ADDRBASE(rX, name)
+ *      ld      rY,ADDROFF(name)(rX)
 */
 #ifdef __powerpc64__
-#define LOADADDR(rn,name) \
+#define LOAD_REG_IMMEDIATE(reg,expr)            \
-        lis     rn,name##@highest;      \
+        lis     (reg),(expr)@highest;           \
-        ori     rn,rn,name##@higher;    \
+        ori     (reg),(reg),(expr)@higher;      \
-        rldicr  rn,rn,32,31;            \
+        rldicr  (reg),(reg),32,31;              \
-        oris    rn,rn,name##@h;         \
+        oris    (reg),(reg),(expr)@h;           \
-        ori     rn,rn,name##@l
+        ori     (reg),(reg),(expr)@l;
-#define LOADBASE(rn,name)               \
+#define LOAD_REG_ADDR(reg,name)                 \
-        ld      rn,name@got(r2)
+        ld      (reg),name@got(r2)
-#define OFF(name)       0
+#define LOAD_REG_ADDRBASE(reg,name)     LOAD_REG_ADDR(reg,name)
+#define ADDROFF(name)                   0
-#define SET_REG_TO_CONST(reg, value)                    \
-        lis     reg,(((value)>>48)&0xFFFF);             \
-        ori     reg,reg,(((value)>>32)&0xFFFF);         \
-        rldicr  reg,reg,32,31;                          \
-        oris    reg,reg,(((value)>>16)&0xFFFF);         \
-        ori     reg,reg,((value)&0xFFFF);
-#define SET_REG_TO_LABEL(reg, label)                    \
-        lis     reg,(label)@highest;                    \
-        ori     reg,reg,(label)@higher;                 \
-        rldicr  reg,reg,32,31;                          \
-        oris    reg,reg,(label)@h;                      \
-        ori     reg,reg,(label)@l;
 /* offsets for stack frame layout */
 #define LRSAVE  16
 #else /* 32-bit */
-#define LOADADDR(rn,name) \
-        lis     rn,name@ha;     \
-        addi    rn,rn,name@l
-#define LOADBASE(rn,name)       \
+#define LOAD_REG_IMMEDIATE(reg,expr)            \
-        lis     rn,name@ha
+        lis     (reg),(expr)@ha;                \
+        addi    (reg),(reg),(expr)@l;
+#define LOAD_REG_ADDR(reg,name)         LOAD_REG_IMMEDIATE(reg, name)
-#define OFF(name)       name@l
+#define LOAD_REG_ADDRBASE(reg, name)    lis     (reg),name@ha
+#define ADDROFF(name)                   name@l
 /* offsets for stack frame layout */
 #define LRSAVE  4
diff --git a/include/asm-powerpc/prom.h b/include/asm-powerpc/prom.h
index 329e9bf62260..5b2bd4eefb01 100644
--- a/include/asm-powerpc/prom.h
+++ b/include/asm-powerpc/prom.h
@@ -87,6 +87,7 @@ struct device_node {
        char    *full_name;
        struct  property *properties;
+        struct  property *deadprops; /* removed properties */
        struct  device_node *parent;
        struct  device_node *child;
        struct  device_node *sibling;
@@ -135,6 +136,9 @@ extern struct device_node *of_find_all_nodes(struct device_node *prev);
 extern struct device_node *of_get_parent(const struct device_node *node);
 extern struct device_node *of_get_next_child(const struct device_node *node,
                                             struct device_node *prev);
+extern struct property *of_find_property(struct device_node *np,
+                                         const char *name,
+                                         int *lenp);
 extern struct device_node *of_node_get(struct device_node *node);
 extern void of_node_put(struct device_node *node);
@@ -164,6 +168,10 @@ extern int prom_n_size_cells(struct device_node* np);
 extern int prom_n_intr_cells(struct device_node* np);
 extern void prom_get_irq_senses(unsigned char *senses, int off, int max);
 extern int prom_add_property(struct device_node* np, struct property* prop);
+extern int prom_remove_property(struct device_node *np, struct property *prop);
+extern int prom_update_property(struct device_node *np,
+                                struct property *newprop,
+                                struct property *oldprop);
 #ifdef CONFIG_PPC32
 /*
diff --git a/include/asm-powerpc/spinlock.h b/include/asm-powerpc/spinlock.h
index 754900901cd8..895cb6d3a42a 100644
--- a/include/asm-powerpc/spinlock.h
+++ b/include/asm-powerpc/spinlock.h
@@ -46,7 +46,7 @@ static __inline__ unsigned long __spin_trylock(raw_spinlock_t *lock)
        token = LOCK_TOKEN;
        __asm__ __volatile__(
-"1:     lwarx           %0,0,%2         # __spin_trylock\n\
+"1:     lwarx           %0,0,%2\n\
        cmpwi           0,%0,0\n\
        bne-            2f\n\
        stwcx.          %1,0,%2\n\
@@ -80,7 +80,7 @@ static int __inline__ __raw_spin_trylock(raw_spinlock_t *lock)
 #if defined(CONFIG_PPC_SPLPAR) || defined(CONFIG_PPC_ISERIES)
 /* We only yield to the hypervisor if we are in shared processor mode */
-#define SHARED_PROCESSOR (get_paca()->lppaca.shared_proc)
+#define SHARED_PROCESSOR (get_lppaca()->shared_proc)
 extern void __spin_yield(raw_spinlock_t *lock);
 extern void __rw_yield(raw_rwlock_t *lock);
 #else /* SPLPAR || ISERIES */
@@ -124,8 +124,8 @@ static void __inline__ __raw_spin_lock_flags(raw_spinlock_t *lock, unsigned long
 static __inline__ void __raw_spin_unlock(raw_spinlock_t *lock)
 {
-        __asm__ __volatile__(SYNC_ON_SMP"       # __raw_spin_unlock"
+        __asm__ __volatile__("# __raw_spin_unlock\n\t"
-                             : : :"memory");
+                                LWSYNC_ON_SMP: : :"memory");
        lock->slock = 0;
 }
@@ -167,7 +167,7 @@ static long __inline__ __read_trylock(raw_rwlock_t *rw)
        long tmp;
        __asm__ __volatile__(
-"1:     lwarx           %0,0,%1         # read_trylock\n"
+"1:     lwarx           %0,0,%1\n"
        __DO_SIGN_EXTEND
 "       addic.          %0,%0,1\n\
        ble-            2f\n"
@@ -192,7 +192,7 @@ static __inline__ long __write_trylock(raw_rwlock_t *rw)
        token = WRLOCK_TOKEN;
        __asm__ __volatile__(
-"1:     lwarx           %0,0,%2 # write_trylock\n\
+"1:     lwarx           %0,0,%2\n\
        cmpwi           0,%0,0\n\
        bne-            2f\n"
        PPC405_ERR77(0,%1)
@@ -249,8 +249,9 @@ static void __inline__ __raw_read_unlock(raw_rwlock_t *rw)
        long tmp;
        __asm__ __volatile__(
-        "eieio                          # read_unlock\n\
+        "# read_unlock\n\t"
-1:      lwarx           %0,0,%1\n\
+        LWSYNC_ON_SMP
+"1:     lwarx           %0,0,%1\n\
        addic           %0,%0,-1\n"
        PPC405_ERR77(0,%1)
 "       stwcx.          %0,0,%1\n\
@@ -262,8 +263,8 @@ static void __inline__ __raw_read_unlock(raw_rwlock_t *rw)
 static __inline__ void __raw_write_unlock(raw_rwlock_t *rw)
 {
-        __asm__ __volatile__(SYNC_ON_SMP"       # write_unlock"
+        __asm__ __volatile__("# write_unlock\n\t"
-                             : : :"memory");
+                                LWSYNC_ON_SMP: : :"memory");
        rw->lock = 0;
 }
diff --git a/include/asm-powerpc/synch.h b/include/asm-powerpc/synch.h
index 794870ab8fd3..c90d9d9aae72 100644
--- a/include/asm-powerpc/synch.h
+++ b/include/asm-powerpc/synch.h
@@ -2,6 +2,8 @@
 #define _ASM_POWERPC_SYNCH_H 
 #ifdef __KERNEL__
+#include <linux/stringify.h>
 #ifdef __powerpc64__
 #define __SUBARCH_HAS_LWSYNC
 #endif
@@ -12,20 +14,12 @@
 #    define LWSYNC      sync
 #endif
-/*
- * Arguably the bitops and *xchg operations don't imply any memory barrier
- * or SMP ordering, but in fact a lot of drivers expect them to imply
- * both, since they do on x86 cpus.
- */
 #ifdef CONFIG_SMP
-#define EIEIO_ON_SMP    "eieio\n"
 #define ISYNC_ON_SMP    "\n\tisync"
-#define SYNC_ON_SMP     __stringify(LWSYNC) "\n"
+#define LWSYNC_ON_SMP   __stringify(LWSYNC) "\n"
 #else
-#define EIEIO_ON_SMP
 #define ISYNC_ON_SMP
-#define SYNC_ON_SMP
+#define LWSYNC_ON_SMP
 #endif
 static inline void eieio(void)
@@ -38,14 +32,5 @@ static inline void isync(void)
        __asm__ __volatile__ ("isync" : : : "memory");
 }
-#ifdef CONFIG_SMP
-#define eieio_on_smp()  eieio()
-#define isync_on_smp()  isync()
-#else
-#define eieio_on_smp()  __asm__ __volatile__("": : :"memory")
-#define isync_on_smp()  __asm__ __volatile__("": : :"memory")
-#endif
 #endif /* __KERNEL__ */
 #endif  /* _ASM_POWERPC_SYNCH_H */
diff --git a/include/asm-powerpc/system.h b/include/asm-powerpc/system.h
index 9b822afa7d0e..d9bf53653b10 100644
--- a/include/asm-powerpc/system.h
+++ b/include/asm-powerpc/system.h
@@ -212,7 +212,7 @@ __xchg_u32(volatile void *p, unsigned long val)
        unsigned long prev;
        __asm__ __volatile__(
-        EIEIO_ON_SMP
+        LWSYNC_ON_SMP
 "1:     lwarx   %0,0,%2 \n"
        PPC405_ERR77(0,%2)
 "       stwcx.  %3,0,%2 \n\
@@ -232,7 +232,7 @@ __xchg_u64(volatile void *p, unsigned long val)
        unsigned long prev;
        __asm__ __volatile__(
-        EIEIO_ON_SMP
+        LWSYNC_ON_SMP
 "1:     ldarx   %0,0,%2 \n"
        PPC405_ERR77(0,%2)
 "       stdcx.  %3,0,%2 \n\
@@ -287,7 +287,7 @@ __cmpxchg_u32(volatile unsigned int *p, unsigned long old, unsigned long new)
        unsigned int prev;
        __asm__ __volatile__ (
-        EIEIO_ON_SMP
+        LWSYNC_ON_SMP
 "1:     lwarx   %0,0,%2         # __cmpxchg_u32\n\
        cmpw    0,%0,%3\n\
        bne-    2f\n"
@@ -311,7 +311,7 @@ __cmpxchg_u64(volatile unsigned long *p, unsigned long old, unsigned long new)
        unsigned long prev;
        __asm__ __volatile__ (
-        EIEIO_ON_SMP
+        LWSYNC_ON_SMP
 "1:     ldarx   %0,0,%2         # __cmpxchg_u64\n\
        cmpd    0,%0,%3\n\
        bne-    2f\n\
diff --git a/include/asm-powerpc/time.h b/include/asm-powerpc/time.h
index d9b86a17271b..baddc9ab57ad 100644
--- a/include/asm-powerpc/time.h
+++ b/include/asm-powerpc/time.h
@@ -175,11 +175,10 @@ static inline void set_dec(int val)
        set_dec_cpu6(val);
 #else
 #ifdef CONFIG_PPC_ISERIES
-        struct paca_struct *lpaca = get_paca();
        int cur_dec;
-        if (lpaca->lppaca.shared_proc) {
+        if (get_lppaca()->shared_proc) {
-                lpaca->lppaca.virtual_decr = val;
+                get_lppaca()->virtual_decr = val;
                cur_dec = get_dec();
                if (cur_dec > val)
                        HvCall_setVirtualDecr();
diff --git a/include/asm-ppc/prom.h b/include/asm-ppc/prom.h
index eb317a0806e4..6d431d6fb022 100644
--- a/include/asm-ppc/prom.h
+++ b/include/asm-ppc/prom.h
@@ -167,6 +167,14 @@ extern int of_address_to_resource(struct device_node *dev, int index,
 extern int of_pci_address_to_resource(struct device_node *dev, int bar,
                                      struct resource *r);
+#ifndef CONFIG_PPC_OF
+/*
+ * Fallback definitions for builds where we don't have prom.c included.
+ */
+#define machine_is_compatible(x)                0
+#define of_find_compatible_node(f, t, c)        NULL
+#define get_property(p, n, l)                   NULL
+#endif
 #endif /* _PPC_PROM_H */
 #endif /* __KERNEL__ */
diff --git a/include/asm-s390/s390_rdev.h b/include/asm-s390/s390_rdev.h
index 3ad78f2b9c48..6fa20442a48c 100644
--- a/include/asm-s390/s390_rdev.h
+++ b/include/asm-s390/s390_rdev.h
@@ -2,7 +2,7 @@
 *  include/asm-s390/ccwdev.h
 *
 *    Copyright (C) 2002,2005 IBM Deutschland Entwicklung GmbH, IBM Corporation
- *    Author(s): Cornelia Huck <cohuck@de.ibm.com>
+ *    Author(s): Cornelia Huck <cornelia.huck@de.ibm.com>
 *               Carsten Otte  <cotte@de.ibm.com>
 *
 *  Interface for s390 root device
diff --git a/include/asm-s390/sigcontext.h b/include/asm-s390/sigcontext.h
index 803545351dd8..aeb6e0b13329 100644
--- a/include/asm-s390/sigcontext.h
+++ b/include/asm-s390/sigcontext.h
@@ -8,6 +8,8 @@
 #ifndef _ASM_S390_SIGCONTEXT_H
 #define _ASM_S390_SIGCONTEXT_H
+#include <linux/compiler.h>
 #define __NUM_GPRS 16
 #define __NUM_FPRS 16
 #define __NUM_ACRS 16
diff --git a/include/asm-s390/system.h b/include/asm-s390/system.h
index c7c3a9ad593f..b2e65e8bf812 100644
--- a/include/asm-s390/system.h
+++ b/include/asm-s390/system.h
@@ -115,13 +115,14 @@ static inline void sched_cacheflush(void)
 }
 #ifdef CONFIG_VIRT_CPU_ACCOUNTING
-extern void account_user_vtime(struct task_struct *);
+extern void account_vtime(struct task_struct *);
+extern void account_tick_vtime(struct task_struct *);
 extern void account_system_vtime(struct task_struct *);
 #endif
 #define finish_arch_switch(prev) do {                                        \
        set_fs(current->thread.mm_segment);                                  \
-        account_system_vtime(prev);                                          \
+        account_vtime(prev);                                                 \
 } while (0)
 #define nop() __asm__ __volatile__ ("nop")
diff --git a/include/asm-x86_64/fixmap.h b/include/asm-x86_64/fixmap.h
index a582cfcf2231..7b286bd21d1d 100644
--- a/include/asm-x86_64/fixmap.h
+++ b/include/asm-x86_64/fixmap.h
@@ -76,7 +76,7 @@ extern void __this_fixmap_does_not_exist(void);
 * directly without translation, we catch the bug with a NULL-deference
 * kernel oops. Illegal ranges of incoming indices are caught too.
 */
-static inline unsigned long fix_to_virt(const unsigned int idx)
+static __always_inline unsigned long fix_to_virt(const unsigned int idx)
 {
        /*
         * this branch gets completely eliminated after inlining,
diff --git a/include/asm-x86_64/uaccess.h b/include/asm-x86_64/uaccess.h
index 2892c4b7a28b..bddffcb591b8 100644
--- a/include/asm-x86_64/uaccess.h
+++ b/include/asm-x86_64/uaccess.h
@@ -244,7 +244,7 @@ extern unsigned long copy_to_user(void __user *to, const void *from, unsigned le
 extern unsigned long copy_from_user(void *to, const void __user *from, unsigned len); 
 extern unsigned long copy_in_user(void __user *to, const void __user *from, unsigned len); 
-static inline int __copy_from_user(void *dst, const void __user *src, unsigned size) 
+static __always_inline int __copy_from_user(void *dst, const void __user *src, unsigned size)
 { 
       int ret = 0;
        if (!__builtin_constant_p(size))
@@ -273,7 +273,7 @@ static inline int __copy_from_user(void *dst, const void __user *src, unsigned s
        }
 }       
-static inline int __copy_to_user(void __user *dst, const void *src, unsigned size) 
+static __always_inline int __copy_to_user(void __user *dst, const void *src, unsigned size)
 { 
       int ret = 0;
        if (!__builtin_constant_p(size))
@@ -305,7 +305,7 @@ static inline int __copy_to_user(void __user *dst, const void *src, unsigned siz
 }       
-static inline int __copy_in_user(void __user *dst, const void __user *src, unsigned size) 
+static __always_inline int __copy_in_user(void __user *dst, const void __user *src, unsigned size)
 { 
       int ret = 0;
        if (!__builtin_constant_p(size))
diff --git a/include/linux/auxvec.h b/include/linux/auxvec.h
index 9a7b374c9fb4..d2bc0d66e65d 100644
--- a/include/linux/auxvec.h
+++ b/include/linux/auxvec.h
@@ -26,6 +26,6 @@
 #define AT_SECURE 23   /* secure mode boolean */
-#define AT_VECTOR_SIZE  42 /* Size of auxiliary table.  */
+#define AT_VECTOR_SIZE  44 /* Size of auxiliary table.  */
 #endif /* _LINUX_AUXVEC_H */
diff --git a/include/linux/compiler-gcc3.h b/include/linux/compiler-gcc3.h
index 4209082ee934..1698b845761f 100644
--- a/include/linux/compiler-gcc3.h
+++ b/include/linux/compiler-gcc3.h
@@ -13,3 +13,4 @@
 #define __must_check            __attribute__((warn_unused_result))
 #endif
+#define __always_inline         inline __attribute__((always_inline))
diff --git a/include/linux/compiler-gcc4.h b/include/linux/compiler-gcc4.h
index e913e9beaf69..6f5cc6f0e7a6 100644
--- a/include/linux/compiler-gcc4.h
+++ b/include/linux/compiler-gcc4.h
@@ -3,7 +3,16 @@
 /* These definitions are for GCC v4.x.  */
 #include <linux/compiler-gcc.h>
+#ifdef CONFIG_FORCED_INLINING
+# undef inline
+# undef __inline__
+# undef __inline
+# define inline                 inline          __attribute__((always_inline))
+# define __inline__             __inline__      __attribute__((always_inline))
+# define __inline               __inline        __attribute__((always_inline))
+#endif
 #define __attribute_used__      __attribute__((__used__))
 #define __must_check            __attribute__((warn_unused_result))
 #define __compiler_offsetof(a,b) __builtin_offsetof(a,b)
+#define __always_inline         inline __attribute__((always_inline))
diff --git a/include/linux/cpuset.h b/include/linux/cpuset.h
index c472f972bd6d..3bc606927116 100644
--- a/include/linux/cpuset.h
+++ b/include/linux/cpuset.h
@@ -48,6 +48,9 @@ extern void __cpuset_memory_pressure_bump(void);
 extern struct file_operations proc_cpuset_operations;
 extern char *cpuset_task_status_allowed(struct task_struct *task, char *buffer);
+extern void cpuset_lock(void);
+extern void cpuset_unlock(void);
 #else /* !CONFIG_CPUSETS */
 static inline int cpuset_init_early(void) { return 0; }
@@ -93,6 +96,9 @@ static inline char *cpuset_task_status_allowed(struct task_struct *task,
        return buffer;
 }
+static inline void cpuset_lock(void) {}
+static inline void cpuset_unlock(void) {}
 #endif /* !CONFIG_CPUSETS */
 #endif /* _LINUX_CPUSET_H */
diff --git a/include/linux/device.h b/include/linux/device.h
index 0cdee78e5ce1..58df18d9cd3e 100644
--- a/include/linux/device.h
+++ b/include/linux/device.h
@@ -49,6 +49,9 @@ struct bus_type {
        int             (*match)(struct device * dev, struct device_driver * drv);
        int             (*uevent)(struct device *dev, char **envp,
                                  int num_envp, char *buffer, int buffer_size);
+        int             (*probe)(struct device * dev);
+        int             (*remove)(struct device * dev);
+        void            (*shutdown)(struct device * dev);
        int             (*suspend)(struct device * dev, pm_message_t state);
        int             (*resume)(struct device * dev);
 };
diff --git a/include/linux/fb.h b/include/linux/fb.h
index a973be2cfe61..2cb19e6503aa 100644
--- a/include/linux/fb.h
+++ b/include/linux/fb.h
@@ -608,15 +608,15 @@ struct fb_ops {
        int (*fb_sync)(struct fb_info *info);
        /* perform fb specific ioctl (optional) */
-        int (*fb_ioctl)(struct inode *inode, struct file *file, unsigned int cmd,
+        int (*fb_ioctl)(struct fb_info *info, unsigned int cmd,
-                        unsigned long arg, struct fb_info *info);
+                        unsigned long arg);
        /* Handle 32bit compat ioctl (optional) */
-        long (*fb_compat_ioctl)(struct file *f, unsigned cmd, unsigned long arg,
+        int (*fb_compat_ioctl)(struct fb_info *info, unsigned cmd,
-                               struct fb_info *info);
+                        unsigned long arg);
        /* perform fb specific mmap */
-        int (*fb_mmap)(struct fb_info *info, struct file *file, struct vm_area_struct *vma);
+        int (*fb_mmap)(struct fb_info *info, struct vm_area_struct *vma);
        /* save current hardware state */
        void (*fb_save_state)(struct fb_info *info);
diff --git a/include/linux/fs.h b/include/linux/fs.h
index d1e370d25f7b..552cedfa6064 100644
--- a/include/linux/fs.h
+++ b/include/linux/fs.h
@@ -1383,6 +1383,12 @@ extern int register_chrdev(unsigned int, const char *,
 extern int unregister_chrdev(unsigned int, const char *);
 extern void unregister_chrdev_region(dev_t, unsigned);
 extern int chrdev_open(struct inode *, struct file *);
+extern int get_chrdev_list(char *);
+extern void *acquire_chrdev_list(void);
+extern int count_chrdev_list(void);
+extern void *get_next_chrdev(void *);
+extern int get_chrdev_info(void *, int *, char **);
+extern void release_chrdev_list(void *);
 /* fs/block_dev.c */
 #define BDEVNAME_SIZE   32      /* Largest string for a blockdev identifier */
@@ -1391,6 +1397,11 @@ extern const char *bdevname(struct block_device *bdev, char *buffer);
 extern struct block_device *lookup_bdev(const char *);
 extern struct block_device *open_bdev_excl(const char *, int, void *);
 extern void close_bdev_excl(struct block_device *);
+extern void *acquire_blkdev_list(void);
+extern int count_blkdev_list(void);
+extern void *get_next_blkdev(void *);
+extern int get_blkdev_info(void *, int *, char **);
+extern void release_blkdev_list(void *);
 extern void init_special_inode(struct inode *, umode_t, dev_t);
diff --git a/include/linux/hardirq.h b/include/linux/hardirq.h
index 71d2b8a723b9..eab537091f2a 100644
--- a/include/linux/hardirq.h
+++ b/include/linux/hardirq.h
@@ -93,10 +93,6 @@ extern void synchronize_irq(unsigned int irq);
 struct task_struct;
 #ifndef CONFIG_VIRT_CPU_ACCOUNTING
-static inline void account_user_vtime(struct task_struct *tsk)
-{
-}
 static inline void account_system_vtime(struct task_struct *tsk)
 {
 }
diff --git a/include/linux/ide.h b/include/linux/ide.h
index f2e1b5b22898..110b3cfac021 100644
--- a/include/linux/ide.h
+++ b/include/linux/ide.h
@@ -983,8 +983,13 @@ typedef struct ide_driver_s {
        ide_startstop_t (*abort)(ide_drive_t *, struct request *rq);
        ide_proc_entry_t        *proc;
        struct device_driver    gen_driver;
+        int             (*probe)(ide_drive_t *);
+        void            (*remove)(ide_drive_t *);
+        void            (*shutdown)(ide_drive_t *);
 } ide_driver_t;
+#define to_ide_driver(drv) container_of(drv, ide_driver_t, gen_driver)
 int generic_ide_ioctl(ide_drive_t *, struct file *, struct block_device *, unsigned, unsigned long);
 /*
diff --git a/include/linux/ioc3.h b/include/linux/ioc3.h
new file mode 100644
index 000000000000..e7906a72a4f1
--- /dev/null
+++ b/include/linux/ioc3.h
@@ -0,0 +1,93 @@
+/*
+ * This file is subject to the terms and conditions of the GNU General Public
+ * License.  See the file "COPYING" in the main directory of this archive
+ * for more details.
+ *
+ * Copyright (c) 2005 Stanislaw Skowronek <skylark@linux-mips.org>
+ */
+#ifndef _LINUX_IOC3_H
+#define _LINUX_IOC3_H
+#include <asm/sn/ioc3.h>
+#define IOC3_MAX_SUBMODULES     32
+#define IOC3_CLASS_NONE         0
+#define IOC3_CLASS_BASE_IP27    1
+#define IOC3_CLASS_BASE_IP30    2
+#define IOC3_CLASS_MENET_123    3
+#define IOC3_CLASS_MENET_4      4
+#define IOC3_CLASS_CADDUO       5
+#define IOC3_CLASS_SERIAL       6
+/* One of these per IOC3 */
+struct ioc3_driver_data {
+        struct list_head list;
+        int id;                         /* IOC3 sequence number */
+        /* PCI mapping */
+        unsigned long pma;              /* physical address */
+        struct __iomem ioc3 *vma;       /* pointer to registers */
+        struct pci_dev *pdev;           /* PCI device */
+        /* IRQ stuff */
+        int dual_irq;                   /* set if separate IRQs are used */
+        int irq_io, irq_eth;            /* IRQ numbers */
+        /* GPIO magic */
+        spinlock_t gpio_lock;
+        unsigned int gpdr_shadow;
+        /* NIC identifiers */
+        char nic_part[32];
+        char nic_serial[16];
+        char nic_mac[6];
+        /* submodule set */
+        int class;
+        void *data[IOC3_MAX_SUBMODULES];        /* for submodule use */
+        int active[IOC3_MAX_SUBMODULES];        /* set if probe succeeds */
+        /* is_ir_lock must be held while
+         * modifying sio_ie values, so
+         * we can be sure that sio_ie is
+         * not changing when we read it
+         * along with sio_ir.
+         */
+        spinlock_t ir_lock;     /* SIO_IE[SC] mod lock */
+};
+/* One per submodule */
+struct ioc3_submodule {
+        char *name;             /* descriptive submodule name */
+        struct module *owner;   /* owning kernel module */
+        int ethernet;           /* set for ethernet drivers */
+        int (*probe) (struct ioc3_submodule *, struct ioc3_driver_data *);
+        int (*remove) (struct ioc3_submodule *, struct ioc3_driver_data *);
+        int id;                 /* assigned by IOC3, index for the "data" array */
+        /* IRQ stuff */
+        unsigned int irq_mask;  /* IOC3 IRQ mask, leave clear for Ethernet */
+        int reset_mask;         /* non-zero if you want the ioc3.c module to reset interrupts */
+        int (*intr) (struct ioc3_submodule *, struct ioc3_driver_data *, unsigned int, struct pt_regs *);
+        /* private submodule data */
+        void *data;             /* assigned by submodule */
+};
+/**********************************
+ * Functions needed by submodules *
+ **********************************/
+#define IOC3_W_IES              0
+#define IOC3_W_IEC              1
+/* registers a submodule for all existing and future IOC3 chips */
+extern int ioc3_register_submodule(struct ioc3_submodule *);
+/* unregisters a submodule */
+extern void ioc3_unregister_submodule(struct ioc3_submodule *);
+/* enables IRQs indicated by irq_mask for a specified IOC3 chip */
+extern void ioc3_enable(struct ioc3_submodule *, struct ioc3_driver_data *, unsigned int);
+/* ackowledges specified IRQs */
+extern void ioc3_ack(struct ioc3_submodule *, struct ioc3_driver_data *, unsigned int);
+/* disables IRQs indicated by irq_mask for a specified IOC3 chip */
+extern void ioc3_disable(struct ioc3_submodule *, struct ioc3_driver_data *, unsigned int);
+/* atomically sets GPCR bits */
+extern void ioc3_gpcr_set(struct ioc3_driver_data *, unsigned int);
+/* general ireg writer */
+extern void ioc3_write_ireg(struct ioc3_driver_data *idd, uint32_t value, int reg);
+#endif
diff --git a/include/linux/kernel.h b/include/linux/kernel.h
index e6ee2d95da7a..323924edb26a 100644
--- a/include/linux/kernel.h
+++ b/include/linux/kernel.h
@@ -216,6 +216,7 @@ extern void dump_stack(void);
        ((unsigned char *)&addr)[1], \
        ((unsigned char *)&addr)[2], \
        ((unsigned char *)&addr)[3]
+#define NIPQUAD_FMT "%u.%u.%u.%u"
 #define NIP6(addr) \
        ntohs((addr).s6_addr16[0]), \
@@ -226,6 +227,7 @@ extern void dump_stack(void);
        ntohs((addr).s6_addr16[5]), \
        ntohs((addr).s6_addr16[6]), \
        ntohs((addr).s6_addr16[7])
+#define NIP6_FMT "%04x:%04x:%04x:%04x:%04x:%04x:%04x:%04x"
 #if defined(__LITTLE_ENDIAN)
 #define HIPQUAD(addr) \
diff --git a/include/linux/mempolicy.h b/include/linux/mempolicy.h
index c7ac77e873b3..d6a53ed6ab6c 100644
--- a/include/linux/mempolicy.h
+++ b/include/linux/mempolicy.h
@@ -132,12 +132,8 @@ struct shared_policy {
        spinlock_t lock;
 };
-static inline void mpol_shared_policy_init(struct shared_policy *info)
+void mpol_shared_policy_init(struct shared_policy *info, int policy,
-{
+                                nodemask_t *nodes);
-        info->root = RB_ROOT;
-        spin_lock_init(&info->lock);
-}
 int mpol_set_shared_policy(struct shared_policy *info,
                                struct vm_area_struct *vma,
                                struct mempolicy *new);
@@ -211,7 +207,8 @@ static inline int mpol_set_shared_policy(struct shared_policy *info,
        return -EINVAL;
 }
-static inline void mpol_shared_policy_init(struct shared_policy *info)
+static inline void mpol_shared_policy_init(struct shared_policy *info,
+                                        int policy, nodemask_t *nodes)
 {
 }
diff --git a/include/linux/mm.h b/include/linux/mm.h
index c643016499a1..85854b867463 100644
--- a/include/linux/mm.h
+++ b/include/linux/mm.h
@@ -512,7 +512,7 @@ static inline void set_page_links(struct page *page, unsigned long zone,
 extern struct page *mem_map;
 #endif
-static inline void *lowmem_page_address(struct page *page)
+static __always_inline void *lowmem_page_address(struct page *page)
 {
        return __va(page_to_pfn(page) << PAGE_SHIFT);
 }
diff --git a/include/linux/ncp_fs.h b/include/linux/ncp_fs.h
index 7297e4372c0f..e01342568530 100644
--- a/include/linux/ncp_fs.h
+++ b/include/linux/ncp_fs.h
@@ -201,34 +201,6 @@ static inline struct ncp_inode_info *NCP_FINFO(struct inode *inode)
        return container_of(inode, struct ncp_inode_info, vfs_inode);
 }
-#ifdef DEBUG_NCP_MALLOC
-#include <linux/slab.h>
-extern int ncp_malloced;
-extern int ncp_current_malloced;
-static inline void *
- ncp_kmalloc(unsigned int size, int priority)
-{
-        ncp_malloced += 1;
-        ncp_current_malloced += 1;
-        return kmalloc(size, priority);
-}
-static inline void ncp_kfree_s(void *obj, int size)
-{
-        ncp_current_malloced -= 1;
-        kfree(obj);
-}
-#else                           /* DEBUG_NCP_MALLOC */
-#define ncp_kmalloc(s,p) kmalloc(s,p)
-#define ncp_kfree_s(o,s) kfree(o)
-#endif                          /* DEBUG_NCP_MALLOC */
 /* linux/fs/ncpfs/inode.c */
 int ncp_notify_change(struct dentry *, struct iattr *);
 struct inode *ncp_iget(struct super_block *, struct ncp_entry_info *);
diff --git a/include/linux/netfilter/nf_conntrack_common.h b/include/linux/netfilter/nf_conntrack_common.h
index 6d39b518486b..3ff88c878308 100644
--- a/include/linux/netfilter/nf_conntrack_common.h
+++ b/include/linux/netfilter/nf_conntrack_common.h
@@ -154,6 +154,9 @@ struct ip_conntrack_stat
        unsigned int expect_delete;
 };
+/* call to create an explicit dependency on nf_conntrack. */
+extern void need_conntrack(void);
 #endif /* __KERNEL__ */
 #endif /* _NF_CONNTRACK_COMMON_H */
diff --git a/include/linux/netfilter/x_tables.h b/include/linux/netfilter/x_tables.h
new file mode 100644
index 000000000000..472f04834809
--- /dev/null
+++ b/include/linux/netfilter/x_tables.h
@@ -0,0 +1,224 @@
+#ifndef _X_TABLES_H
+#define _X_TABLES_H
+#define XT_FUNCTION_MAXNAMELEN 30
+#define XT_TABLE_MAXNAMELEN 32
+/* The argument to IPT_SO_GET_REVISION_*.  Returns highest revision
+ * kernel supports, if >= revision. */
+struct xt_get_revision
+{
+        char name[XT_FUNCTION_MAXNAMELEN-1];
+        u_int8_t revision;
+};
+/* CONTINUE verdict for targets */
+#define XT_CONTINUE 0xFFFFFFFF
+/* For standard target */
+#define XT_RETURN (-NF_REPEAT - 1)
+#define XT_ALIGN(s) (((s) + (__alignof__(void *)-1)) & ~(__alignof__(void *)-1))
+/* Standard return verdict, or do jump. */
+#define XT_STANDARD_TARGET ""
+/* Error verdict. */
+#define XT_ERROR_TARGET "ERROR"
+/*
+ * New IP firewall options for [gs]etsockopt at the RAW IP level.
+ * Unlike BSD Linux inherits IP options so you don't have to use a raw
+ * socket for this. Instead we check rights in the calls. */
+#define XT_BASE_CTL             64      /* base for firewall socket options */
+#define XT_SO_SET_REPLACE       (XT_BASE_CTL)
+#define XT_SO_SET_ADD_COUNTERS  (XT_BASE_CTL + 1)
+#define XT_SO_SET_MAX           XT_SO_SET_ADD_COUNTERS
+#define XT_SO_GET_INFO                  (XT_BASE_CTL)
+#define XT_SO_GET_ENTRIES               (XT_BASE_CTL + 1)
+#define XT_SO_GET_REVISION_MATCH        (XT_BASE_CTL + 2)
+#define XT_SO_GET_REVISION_TARGET       (XT_BASE_CTL + 3)
+#define XT_SO_GET_MAX                   XT_SO_GET_REVISION_TARGET
+#define SET_COUNTER(c,b,p) do { (c).bcnt = (b); (c).pcnt = (p); } while(0)
+#define ADD_COUNTER(c,b,p) do { (c).bcnt += (b); (c).pcnt += (p); } while(0)
+struct xt_counters
+{
+        u_int64_t pcnt, bcnt;                   /* Packet and byte counters */
+};
+/* The argument to IPT_SO_ADD_COUNTERS. */
+struct xt_counters_info
+{
+        /* Which table. */
+        char name[XT_TABLE_MAXNAMELEN];
+        unsigned int num_counters;
+        /* The counters (actually `number' of these). */
+        struct xt_counters counters[0];
+};
+#define XT_INV_PROTO            0x40    /* Invert the sense of PROTO. */
+#ifdef __KERNEL__
+#include <linux/netdevice.h>
+#define ASSERT_READ_LOCK(x)
+#define ASSERT_WRITE_LOCK(x)
+#include <linux/netfilter_ipv4/listhelp.h>
+struct xt_match
+{
+        struct list_head list;
+        const char name[XT_FUNCTION_MAXNAMELEN-1];
+        u_int8_t revision;
+        /* Return true or false: return FALSE and set *hotdrop = 1 to
+           force immediate packet drop. */
+        /* Arguments changed since 2.6.9, as this must now handle
+           non-linear skb, using skb_header_pointer and
+           skb_ip_make_writable. */
+        int (*match)(const struct sk_buff *skb,
+                     const struct net_device *in,
+                     const struct net_device *out,
+                     const void *matchinfo,
+                     int offset,
+                     unsigned int protoff,
+                     int *hotdrop);
+        /* Called when user tries to insert an entry of this type. */
+        /* Should return true or false. */
+        int (*checkentry)(const char *tablename,
+                          const void *ip,
+                          void *matchinfo,
+                          unsigned int matchinfosize,
+                          unsigned int hook_mask);
+        /* Called when entry of this type deleted. */
+        void (*destroy)(void *matchinfo, unsigned int matchinfosize);
+        /* Set this to THIS_MODULE if you are a module, otherwise NULL */
+        struct module *me;
+};
+/* Registration hooks for targets. */
+struct xt_target
+{
+        struct list_head list;
+        const char name[XT_FUNCTION_MAXNAMELEN-1];
+        u_int8_t revision;
+        /* Returns verdict. Argument order changed since 2.6.9, as this
+           must now handle non-linear skbs, using skb_copy_bits and
+           skb_ip_make_writable. */
+        unsigned int (*target)(struct sk_buff **pskb,
+                               const struct net_device *in,
+                               const struct net_device *out,
+                               unsigned int hooknum,
+                               const void *targinfo,
+                               void *userdata);
+        /* Called when user tries to insert an entry of this type:
+           hook_mask is a bitmask of hooks from which it can be
+           called. */
+        /* Should return true or false. */
+        int (*checkentry)(const char *tablename,
+                          const void *entry,
+                          void *targinfo,
+                          unsigned int targinfosize,
+                          unsigned int hook_mask);
+        /* Called when entry of this type deleted. */
+        void (*destroy)(void *targinfo, unsigned int targinfosize);
+        /* Set this to THIS_MODULE if you are a module, otherwise NULL */
+        struct module *me;
+};
+/* Furniture shopping... */
+struct xt_table
+{
+        struct list_head list;
+        /* A unique name... */
+        char name[XT_TABLE_MAXNAMELEN];
+        /* What hooks you will enter on */
+        unsigned int valid_hooks;
+        /* Lock for the curtain */
+        rwlock_t lock;
+        /* Man behind the curtain... */
+        //struct ip6t_table_info *private;
+        void *private;
+        /* Set this to THIS_MODULE if you are a module, otherwise NULL */
+        struct module *me;
+        int af;         /* address/protocol family */
+};
+#include <linux/netfilter_ipv4.h>
+/* The table itself */
+struct xt_table_info
+{
+        /* Size per table */
+        unsigned int size;
+        /* Number of entries: FIXME. --RR */
+        unsigned int number;
+        /* Initial number of entries. Needed for module usage count */
+        unsigned int initial_entries;
+        /* Entry points and underflows */
+        unsigned int hook_entry[NF_IP_NUMHOOKS];
+        unsigned int underflow[NF_IP_NUMHOOKS];
+        /* ipt_entry tables: one per CPU */
+        char *entries[NR_CPUS];
+};
+extern int xt_register_target(int af, struct xt_target *target);
+extern void xt_unregister_target(int af, struct xt_target *target);
+extern int xt_register_match(int af, struct xt_match *target);
+extern void xt_unregister_match(int af, struct xt_match *target);
+extern int xt_register_table(struct xt_table *table,
+                             struct xt_table_info *bootstrap,
+                             struct xt_table_info *newinfo);
+extern void *xt_unregister_table(struct xt_table *table);
+extern struct xt_table_info *xt_replace_table(struct xt_table *table,
+                                              unsigned int num_counters,
+                                              struct xt_table_info *newinfo,
+                                              int *error);
+extern struct xt_match *xt_find_match(int af, const char *name, u8 revision);
+extern struct xt_target *xt_find_target(int af, const char *name, u8 revision);
+extern struct xt_target *xt_request_find_target(int af, const char *name, 
+                                                u8 revision);
+extern int xt_find_revision(int af, const char *name, u8 revision, int target,
+                            int *err);
+extern struct xt_table *xt_find_table_lock(int af, const char *name);
+extern void xt_table_unlock(struct xt_table *t);
+extern int xt_proto_init(int af);
+extern void xt_proto_fini(int af);
+extern struct xt_table_info *xt_alloc_table_info(unsigned int size);
+extern void xt_free_table_info(struct xt_table_info *info);
+#endif /* __KERNEL__ */
+#endif /* _X_TABLES_H */
diff --git a/include/linux/netfilter/xt_CLASSIFY.h b/include/linux/netfilter/xt_CLASSIFY.h
new file mode 100644
index 000000000000..58111355255d
--- /dev/null
+++ b/include/linux/netfilter/xt_CLASSIFY.h
@@ -0,0 +1,8 @@
+#ifndef _XT_CLASSIFY_H
+#define _XT_CLASSIFY_H
+struct xt_classify_target_info {
+        u_int32_t priority;
+};
+#endif /*_XT_CLASSIFY_H */
diff --git a/include/linux/netfilter/xt_CONNMARK.h b/include/linux/netfilter/xt_CONNMARK.h
new file mode 100644
index 000000000000..9f744689fffc
--- /dev/null
+++ b/include/linux/netfilter/xt_CONNMARK.h
@@ -0,0 +1,25 @@
+#ifndef _XT_CONNMARK_H_target
+#define _XT_CONNMARK_H_target
+/* Copyright (C) 2002,2004 MARA Systems AB <http://www.marasystems.com>
+ * by Henrik Nordstrom <hno@marasystems.com>
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; either version 2 of the License, or
+ * (at your option) any later version.
+ */
+enum {
+        XT_CONNMARK_SET = 0,
+        XT_CONNMARK_SAVE,
+        XT_CONNMARK_RESTORE
+};
+struct xt_connmark_target_info {
+        unsigned long mark;
+        unsigned long mask;
+        u_int8_t mode;
+};
+#endif /*_XT_CONNMARK_H_target*/
diff --git a/include/linux/netfilter/xt_MARK.h b/include/linux/netfilter/xt_MARK.h
new file mode 100644
index 000000000000..b021e93ee5d6
--- /dev/null
+++ b/include/linux/netfilter/xt_MARK.h
@@ -0,0 +1,21 @@
+#ifndef _XT_MARK_H_target
+#define _XT_MARK_H_target
+/* Version 0 */
+struct xt_mark_target_info {
+        unsigned long mark;
+};
+/* Version 1 */
+enum {
+        XT_MARK_SET=0,
+        XT_MARK_AND,
+        XT_MARK_OR,
+};
+struct xt_mark_target_info_v1 {
+        unsigned long mark;
+        u_int8_t mode;
+};
+#endif /*_XT_MARK_H_target */
diff --git a/include/linux/netfilter/xt_NFQUEUE.h b/include/linux/netfilter/xt_NFQUEUE.h
new file mode 100644
index 000000000000..9a9af79f74d2
--- /dev/null
+++ b/include/linux/netfilter/xt_NFQUEUE.h
@@ -0,0 +1,16 @@
+/* iptables module for using NFQUEUE mechanism
+ *
+ * (C) 2005 Harald Welte <laforge@netfilter.org>
+ *
+ * This software is distributed under GNU GPL v2, 1991
+ * 
+*/
+#ifndef _XT_NFQ_TARGET_H
+#define _XT_NFQ_TARGET_H
+/* target info */
+struct xt_NFQ_info {
+        u_int16_t queuenum;
+};
+#endif /* _XT_NFQ_TARGET_H */
diff --git a/include/linux/netfilter/xt_comment.h b/include/linux/netfilter/xt_comment.h
new file mode 100644
index 000000000000..eacfedc6b5d0
--- /dev/null
+++ b/include/linux/netfilter/xt_comment.h
@@ -0,0 +1,10 @@
+#ifndef _XT_COMMENT_H
+#define _XT_COMMENT_H
+#define XT_MAX_COMMENT_LEN 256
+struct xt_comment_info {
+        unsigned char comment[XT_MAX_COMMENT_LEN];
+};
+#endif /* XT_COMMENT_H */
diff --git a/include/linux/netfilter/xt_connbytes.h b/include/linux/netfilter/xt_connbytes.h
new file mode 100644
index 000000000000..c022c989754d
--- /dev/null
+++ b/include/linux/netfilter/xt_connbytes.h
@@ -0,0 +1,25 @@
+#ifndef _XT_CONNBYTES_H
+#define _XT_CONNBYTES_H
+enum xt_connbytes_what {
+        XT_CONNBYTES_PKTS,
+        XT_CONNBYTES_BYTES,
+        XT_CONNBYTES_AVGPKT,
+};
+enum xt_connbytes_direction {
+        XT_CONNBYTES_DIR_ORIGINAL,
+        XT_CONNBYTES_DIR_REPLY,
+        XT_CONNBYTES_DIR_BOTH,
+};
+struct xt_connbytes_info
+{
+        struct {
+                aligned_u64 from;       /* count to be matched */
+                aligned_u64 to;         /* count to be matched */
+        } count;
+        u_int8_t what;          /* ipt_connbytes_what */
+        u_int8_t direction;     /* ipt_connbytes_direction */
+};
+#endif
diff --git a/include/linux/netfilter/xt_connmark.h b/include/linux/netfilter/xt_connmark.h
new file mode 100644
index 000000000000..c592f6ae0883
--- /dev/null
+++ b/include/linux/netfilter/xt_connmark.h
@@ -0,0 +1,18 @@
+#ifndef _XT_CONNMARK_H
+#define _XT_CONNMARK_H
+/* Copyright (C) 2002,2004 MARA Systems AB <http://www.marasystems.com>
+ * by Henrik Nordstrom <hno@marasystems.com>
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; either version 2 of the License, or
+ * (at your option) any later version.
+ */
+struct xt_connmark_info {
+        unsigned long mark, mask;
+        u_int8_t invert;
+};
+#endif /*_XT_CONNMARK_H*/
diff --git a/include/linux/netfilter/xt_conntrack.h b/include/linux/netfilter/xt_conntrack.h
new file mode 100644
index 000000000000..34f63cf2e293
--- /dev/null
+++ b/include/linux/netfilter/xt_conntrack.h
@@ -0,0 +1,63 @@
+/* Header file for kernel module to match connection tracking information.
+ * GPL (C) 2001  Marc Boucher (marc@mbsi.ca).
+ */
+#ifndef _XT_CONNTRACK_H
+#define _XT_CONNTRACK_H
+#include <linux/netfilter/nf_conntrack_tuple_common.h>
+#include <linux/in.h>
+#define XT_CONNTRACK_STATE_BIT(ctinfo) (1 << ((ctinfo)%IP_CT_IS_REPLY+1))
+#define XT_CONNTRACK_STATE_INVALID (1 << 0)
+#define XT_CONNTRACK_STATE_SNAT (1 << (IP_CT_NUMBER + 1))
+#define XT_CONNTRACK_STATE_DNAT (1 << (IP_CT_NUMBER + 2))
+#define XT_CONNTRACK_STATE_UNTRACKED (1 << (IP_CT_NUMBER + 3))
+/* flags, invflags: */
+#define XT_CONNTRACK_STATE      0x01
+#define XT_CONNTRACK_PROTO      0x02
+#define XT_CONNTRACK_ORIGSRC    0x04
+#define XT_CONNTRACK_ORIGDST    0x08
+#define XT_CONNTRACK_REPLSRC    0x10
+#define XT_CONNTRACK_REPLDST    0x20
+#define XT_CONNTRACK_STATUS     0x40
+#define XT_CONNTRACK_EXPIRES    0x80
+/* This is exposed to userspace, so remains frozen in time. */
+struct ip_conntrack_old_tuple
+{
+        struct {
+                __u32 ip;
+                union {
+                        __u16 all;
+                } u;
+        } src;
+        struct {
+                __u32 ip;
+                union {
+                        __u16 all;
+                } u;
+                /* The protocol. */
+                u16 protonum;
+        } dst;
+};
+struct xt_conntrack_info
+{
+        unsigned int statemask, statusmask;
+        struct ip_conntrack_old_tuple tuple[IP_CT_DIR_MAX];
+        struct in_addr sipmsk[IP_CT_DIR_MAX], dipmsk[IP_CT_DIR_MAX];
+        unsigned long expires_min, expires_max;
+        /* Flags word */
+        u_int8_t flags;
+        /* Inverse flags */
+        u_int8_t invflags;
+};
+#endif /*_XT_CONNTRACK_H*/
diff --git a/include/linux/netfilter/xt_dccp.h b/include/linux/netfilter/xt_dccp.h
new file mode 100644
index 000000000000..e0221b9d32cb
--- /dev/null
+++ b/include/linux/netfilter/xt_dccp.h
@@ -0,0 +1,23 @@
+#ifndef _XT_DCCP_H_
+#define _XT_DCCP_H_
+#define XT_DCCP_SRC_PORTS               0x01
+#define XT_DCCP_DEST_PORTS              0x02
+#define XT_DCCP_TYPE                    0x04
+#define XT_DCCP_OPTION                  0x08
+#define XT_DCCP_VALID_FLAGS             0x0f
+struct xt_dccp_info {
+        u_int16_t dpts[2];  /* Min, Max */
+        u_int16_t spts[2];  /* Min, Max */
+        u_int16_t flags;
+        u_int16_t invflags;
+        u_int16_t typemask;
+        u_int8_t option;
+};
+#endif /* _XT_DCCP_H_ */
diff --git a/include/linux/netfilter/xt_helper.h b/include/linux/netfilter/xt_helper.h
new file mode 100644
index 000000000000..6b42763f999d
--- /dev/null
+++ b/include/linux/netfilter/xt_helper.h
@@ -0,0 +1,8 @@
+#ifndef _XT_HELPER_H
+#define _XT_HELPER_H
+struct xt_helper_info {
+        int invert;
+        char name[30];
+};
+#endif /* _XT_HELPER_H */
diff --git a/include/linux/netfilter/xt_length.h b/include/linux/netfilter/xt_length.h
new file mode 100644
index 000000000000..7c2b439f73fe
--- /dev/null
+++ b/include/linux/netfilter/xt_length.h
@@ -0,0 +1,9 @@
+#ifndef _XT_LENGTH_H
+#define _XT_LENGTH_H
+struct xt_length_info {
+    u_int16_t   min, max;
+    u_int8_t    invert;
+};
+#endif /*_XT_LENGTH_H*/
diff --git a/include/linux/netfilter/xt_limit.h b/include/linux/netfilter/xt_limit.h
new file mode 100644
index 000000000000..b3ce65375ecb
--- /dev/null
+++ b/include/linux/netfilter/xt_limit.h
@@ -0,0 +1,21 @@
+#ifndef _XT_RATE_H
+#define _XT_RATE_H
+/* timings are in milliseconds. */
+#define XT_LIMIT_SCALE 10000
+/* 1/10,000 sec period => max of 10,000/sec.  Min rate is then 429490
+   seconds, or one every 59 hours. */
+struct xt_rateinfo {
+        u_int32_t avg;    /* Average secs between packets * scale */
+        u_int32_t burst;  /* Period multiplier for upper limit. */
+        /* Used internally by the kernel */
+        unsigned long prev;
+        u_int32_t credit;
+        u_int32_t credit_cap, cost;
+        /* Ugly, ugly fucker. */
+        struct xt_rateinfo *master;
+};
+#endif /*_XT_RATE_H*/
diff --git a/include/linux/netfilter/xt_mac.h b/include/linux/netfilter/xt_mac.h
new file mode 100644
index 000000000000..b892cdc67e06
--- /dev/null
+++ b/include/linux/netfilter/xt_mac.h
@@ -0,0 +1,8 @@
+#ifndef _XT_MAC_H
+#define _XT_MAC_H
+struct xt_mac_info {
+    unsigned char srcaddr[ETH_ALEN];
+    int invert;
+};
+#endif /*_XT_MAC_H*/
diff --git a/include/linux/netfilter/xt_mark.h b/include/linux/netfilter/xt_mark.h
new file mode 100644
index 000000000000..802dd4842caf
--- /dev/null
+++ b/include/linux/netfilter/xt_mark.h
@@ -0,0 +1,9 @@
+#ifndef _XT_MARK_H
+#define _XT_MARK_H
+struct xt_mark_info {
+    unsigned long mark, mask;
+    u_int8_t invert;
+};
+#endif /*_XT_MARK_H*/
diff --git a/include/linux/netfilter/xt_physdev.h b/include/linux/netfilter/xt_physdev.h
new file mode 100644
index 000000000000..25a7a1815b5b
--- /dev/null
+++ b/include/linux/netfilter/xt_physdev.h
@@ -0,0 +1,24 @@
+#ifndef _XT_PHYSDEV_H
+#define _XT_PHYSDEV_H
+#ifdef __KERNEL__
+#include <linux/if.h>
+#endif
+#define XT_PHYSDEV_OP_IN                0x01
+#define XT_PHYSDEV_OP_OUT               0x02
+#define XT_PHYSDEV_OP_BRIDGED           0x04
+#define XT_PHYSDEV_OP_ISIN              0x08
+#define XT_PHYSDEV_OP_ISOUT             0x10
+#define XT_PHYSDEV_OP_MASK              (0x20 - 1)
+struct xt_physdev_info {
+        char physindev[IFNAMSIZ];
+        char in_mask[IFNAMSIZ];
+        char physoutdev[IFNAMSIZ];
+        char out_mask[IFNAMSIZ];
+        u_int8_t invert;
+        u_int8_t bitmask;
+};
+#endif /*_XT_PHYSDEV_H*/
diff --git a/include/linux/netfilter/xt_pkttype.h b/include/linux/netfilter/xt_pkttype.h
new file mode 100644
index 000000000000..f265cf52faea
--- /dev/null
+++ b/include/linux/netfilter/xt_pkttype.h
@@ -0,0 +1,8 @@
+#ifndef _XT_PKTTYPE_H
+#define _XT_PKTTYPE_H
+struct xt_pkttype_info {
+        int     pkttype;
+        int     invert;
+};
+#endif /*_XT_PKTTYPE_H*/
diff --git a/include/linux/netfilter/xt_realm.h b/include/linux/netfilter/xt_realm.h
new file mode 100644
index 000000000000..220e87245716
--- /dev/null
+++ b/include/linux/netfilter/xt_realm.h
@@ -0,0 +1,10 @@
+#ifndef _XT_REALM_H
+#define _XT_REALM_H
+struct xt_realm_info {
+        u_int32_t id;
+        u_int32_t mask;
+        u_int8_t invert;
+};
+#endif /* _XT_REALM_H */
diff --git a/include/linux/netfilter/xt_sctp.h b/include/linux/netfilter/xt_sctp.h
new file mode 100644
index 000000000000..b157897e7792
--- /dev/null
+++ b/include/linux/netfilter/xt_sctp.h
@@ -0,0 +1,107 @@
+#ifndef _XT_SCTP_H_
+#define _XT_SCTP_H_
+#define XT_SCTP_SRC_PORTS               0x01
+#define XT_SCTP_DEST_PORTS              0x02
+#define XT_SCTP_CHUNK_TYPES             0x04
+#define XT_SCTP_VALID_FLAGS             0x07
+#define ELEMCOUNT(x) (sizeof(x)/sizeof(x[0]))
+struct xt_sctp_flag_info {
+        u_int8_t chunktype;
+        u_int8_t flag;
+        u_int8_t flag_mask;
+};
+#define XT_NUM_SCTP_FLAGS       4
+struct xt_sctp_info {
+        u_int16_t dpts[2];  /* Min, Max */
+        u_int16_t spts[2];  /* Min, Max */
+        u_int32_t chunkmap[256 / sizeof (u_int32_t)];  /* Bit mask of chunks to be matched according to RFC 2960 */
+#define SCTP_CHUNK_MATCH_ANY   0x01  /* Match if any of the chunk types are present */
+#define SCTP_CHUNK_MATCH_ALL   0x02  /* Match if all of the chunk types are present */
+#define SCTP_CHUNK_MATCH_ONLY  0x04  /* Match if these are the only chunk types present */
+        u_int32_t chunk_match_type;
+        struct xt_sctp_flag_info flag_info[XT_NUM_SCTP_FLAGS];
+        int flag_count;
+        u_int32_t flags;
+        u_int32_t invflags;
+};
+#define bytes(type) (sizeof(type) * 8)
+#define SCTP_CHUNKMAP_SET(chunkmap, type)               \
+        do {                                            \
+                chunkmap[type / bytes(u_int32_t)] |=    \
+                        1 << (type % bytes(u_int32_t)); \
+        } while (0)
+#define SCTP_CHUNKMAP_CLEAR(chunkmap, type)                     \
+        do {                                                    \
+                chunkmap[type / bytes(u_int32_t)] &=            \
+                        ~(1 << (type % bytes(u_int32_t)));      \
+        } while (0)
+#define SCTP_CHUNKMAP_IS_SET(chunkmap, type)                    \
+({                                                              \
+        (chunkmap[type / bytes (u_int32_t)] &                   \
+                (1 << (type % bytes (u_int32_t)))) ? 1: 0;      \
+})
+#define SCTP_CHUNKMAP_RESET(chunkmap)                           \
+        do {                                                    \
+                int i;                                          \
+                for (i = 0; i < ELEMCOUNT(chunkmap); i++)       \
+                        chunkmap[i] = 0;                        \
+        } while (0)
+#define SCTP_CHUNKMAP_SET_ALL(chunkmap)                         \
+        do {                                                    \
+                int i;                                          \
+                for (i = 0; i < ELEMCOUNT(chunkmap); i++)       \
+                        chunkmap[i] = ~0;                       \
+        } while (0)
+#define SCTP_CHUNKMAP_COPY(destmap, srcmap)                     \
+        do {                                                    \
+                int i;                                          \
+                for (i = 0; i < ELEMCOUNT(chunkmap); i++)       \
+                        destmap[i] = srcmap[i];                 \
+        } while (0)
+#define SCTP_CHUNKMAP_IS_CLEAR(chunkmap)                \
+({                                                      \
+        int i;                                          \
+        int flag = 1;                                   \
+        for (i = 0; i < ELEMCOUNT(chunkmap); i++) {     \
+                if (chunkmap[i]) {                      \
+                        flag = 0;                       \
+                        break;                          \
+                }                                       \
+        }                                               \
+        flag;                                           \
+})
+#define SCTP_CHUNKMAP_IS_ALL_SET(chunkmap)              \
+({                                                      \
+        int i;                                          \
+        int flag = 1;                                   \
+        for (i = 0; i < ELEMCOUNT(chunkmap); i++) {     \
+                if (chunkmap[i] != ~0) {                \
+                        flag = 0;                       \
+                                break;                  \
+                }                                       \
+        }                                               \
+        flag;                                           \
+})
+#endif /* _XT_SCTP_H_ */
diff --git a/include/linux/netfilter/xt_state.h b/include/linux/netfilter/xt_state.h
new file mode 100644
index 000000000000..c06f32edee07
--- /dev/null
+++ b/include/linux/netfilter/xt_state.h
@@ -0,0 +1,13 @@
+#ifndef _XT_STATE_H
+#define _XT_STATE_H
+#define XT_STATE_BIT(ctinfo) (1 << ((ctinfo)%IP_CT_IS_REPLY+1))
+#define XT_STATE_INVALID (1 << 0)
+#define XT_STATE_UNTRACKED (1 << (IP_CT_NUMBER + 1))
+struct xt_state_info
+{
+        unsigned int statemask;
+};
+#endif /*_XT_STATE_H*/
diff --git a/include/linux/netfilter/xt_string.h b/include/linux/netfilter/xt_string.h
new file mode 100644
index 000000000000..3b3419f2637d
--- /dev/null
+++ b/include/linux/netfilter/xt_string.h
@@ -0,0 +1,18 @@
+#ifndef _XT_STRING_H
+#define _XT_STRING_H
+#define XT_STRING_MAX_PATTERN_SIZE 128
+#define XT_STRING_MAX_ALGO_NAME_SIZE 16
+struct xt_string_info
+{
+        u_int16_t from_offset;
+        u_int16_t to_offset;
+        char      algo[XT_STRING_MAX_ALGO_NAME_SIZE];
+        char      pattern[XT_STRING_MAX_PATTERN_SIZE];
+        u_int8_t  patlen;
+        u_int8_t  invert;
+        struct ts_config __attribute__((aligned(8))) *config;
+};
+#endif /*_XT_STRING_H*/
diff --git a/include/linux/netfilter/xt_tcpmss.h b/include/linux/netfilter/xt_tcpmss.h
new file mode 100644
index 000000000000..e03274c4c790
--- /dev/null
+++ b/include/linux/netfilter/xt_tcpmss.h
@@ -0,0 +1,9 @@
+#ifndef _XT_TCPMSS_MATCH_H
+#define _XT_TCPMSS_MATCH_H
+struct xt_tcpmss_match_info {
+    u_int16_t mss_min, mss_max;
+    u_int8_t invert;
+};
+#endif /*_XT_TCPMSS_MATCH_H*/
diff --git a/include/linux/netfilter/xt_tcpudp.h b/include/linux/netfilter/xt_tcpudp.h
new file mode 100644
index 000000000000..78bc65f11adf
--- /dev/null
+++ b/include/linux/netfilter/xt_tcpudp.h
@@ -0,0 +1,36 @@
+#ifndef _XT_TCPUDP_H
+#define _XT_TCPUDP_H
+/* TCP matching stuff */
+struct xt_tcp
+{
+        u_int16_t spts[2];                      /* Source port range. */
+        u_int16_t dpts[2];                      /* Destination port range. */
+        u_int8_t option;                        /* TCP Option iff non-zero*/
+        u_int8_t flg_mask;                      /* TCP flags mask byte */
+        u_int8_t flg_cmp;                       /* TCP flags compare byte */
+        u_int8_t invflags;                      /* Inverse flags */
+};
+/* Values for "inv" field in struct ipt_tcp. */
+#define XT_TCP_INV_SRCPT        0x01    /* Invert the sense of source ports. */
+#define XT_TCP_INV_DSTPT        0x02    /* Invert the sense of dest ports. */
+#define XT_TCP_INV_FLAGS        0x04    /* Invert the sense of TCP flags. */
+#define XT_TCP_INV_OPTION       0x08    /* Invert the sense of option test. */
+#define XT_TCP_INV_MASK         0x0F    /* All possible flags. */
+/* UDP matching stuff */
+struct xt_udp
+{
+        u_int16_t spts[2];                      /* Source port range. */
+        u_int16_t dpts[2];                      /* Destination port range. */
+        u_int8_t invflags;                      /* Inverse flags */
+};
+/* Values for "invflags" field in struct ipt_udp. */
+#define XT_UDP_INV_SRCPT        0x01    /* Invert the sense of source ports. */
+#define XT_UDP_INV_DSTPT        0x02    /* Invert the sense of dest ports. */
+#define XT_UDP_INV_MASK 0x03    /* All possible flags. */
+#endif
diff --git a/include/linux/netfilter_arp/arp_tables.h b/include/linux/netfilter_arp/arp_tables.h
index e98a870a20be..fd21796e5131 100644
--- a/include/linux/netfilter_arp/arp_tables.h
+++ b/include/linux/netfilter_arp/arp_tables.h
@@ -19,8 +19,12 @@
 #include <linux/compiler.h>
 #include <linux/netfilter_arp.h>
-#define ARPT_FUNCTION_MAXNAMELEN 30
+#include <linux/netfilter/x_tables.h>
-#define ARPT_TABLE_MAXNAMELEN 32
+#define ARPT_FUNCTION_MAXNAMELEN XT_FUNCTION_MAXNAMELEN
+#define ARPT_TABLE_MAXNAMELEN XT_TABLE_MAXNAMELEN
+#define arpt_target xt_target
+#define arpt_table xt_table
 #define ARPT_DEV_ADDR_LEN_MAX 16
@@ -91,11 +95,6 @@ struct arpt_standard_target
        int verdict;
 };
-struct arpt_counters
-{
-        u_int64_t pcnt, bcnt;                   /* Packet and byte counters */
-};
 /* Values for "flag" field in struct arpt_ip (general arp structure).
 * No flags defined yet.
 */
@@ -130,7 +129,7 @@ struct arpt_entry
        unsigned int comefrom;
        /* Packet and byte counters. */
-        struct arpt_counters counters;
+        struct xt_counters counters;
        /* The matches (if any), then the target. */
        unsigned char elems[0];
@@ -141,23 +140,24 @@ struct arpt_entry
 * Unlike BSD Linux inherits IP options so you don't have to use a raw
 * socket for this. Instead we check rights in the calls.
 */
-#define ARPT_BASE_CTL           96      /* base for firewall socket options */
+#define ARPT_CTL_OFFSET         32
+#define ARPT_BASE_CTL           (XT_BASE_CTL+ARPT_CTL_OFFSET)
-#define ARPT_SO_SET_REPLACE             (ARPT_BASE_CTL)
+#define ARPT_SO_SET_REPLACE             (XT_SO_SET_REPLACE+ARPT_CTL_OFFSET)
-#define ARPT_SO_SET_ADD_COUNTERS        (ARPT_BASE_CTL + 1)
+#define ARPT_SO_SET_ADD_COUNTERS        (XT_SO_SET_ADD_COUNTERS+ARPT_CTL_OFFSET)
-#define ARPT_SO_SET_MAX                 ARPT_SO_SET_ADD_COUNTERS
+#define ARPT_SO_SET_MAX                 (XT_SO_SET_MAX+ARPT_CTL_OFFSET)
-#define ARPT_SO_GET_INFO                (ARPT_BASE_CTL)
+#define ARPT_SO_GET_INFO                (XT_SO_GET_INFO+ARPT_CTL_OFFSET)
-#define ARPT_SO_GET_ENTRIES             (ARPT_BASE_CTL + 1)
+#define ARPT_SO_GET_ENTRIES             (XT_SO_GET_ENTRIES+ARPT_CTL_OFFSET)
-/* #define ARPT_SO_GET_REVISION_MATCH   (ARPT_BASE_CTL + 2)*/
+/* #define ARPT_SO_GET_REVISION_MATCH   XT_SO_GET_REVISION_MATCH  */
-#define ARPT_SO_GET_REVISION_TARGET     (ARPT_BASE_CTL + 3)
+#define ARPT_SO_GET_REVISION_TARGET     (XT_SO_GET_REVISION_TARGET+ARPT_CTL_OFFSET)
-#define ARPT_SO_GET_MAX                 ARPT_SO_GET_REVISION_TARGET
+#define ARPT_SO_GET_MAX                 (XT_SO_GET_REVISION_TARGET+ARPT_CTL_OFFSET)
 /* CONTINUE verdict for targets */
-#define ARPT_CONTINUE 0xFFFFFFFF
+#define ARPT_CONTINUE XT_CONTINUE
 /* For standard target */
-#define ARPT_RETURN (-NF_REPEAT - 1)
+#define ARPT_RETURN XT_RETURN
 /* The argument to ARPT_SO_GET_INFO */
 struct arpt_getinfo
@@ -208,23 +208,14 @@ struct arpt_replace
        /* Number of counters (must be equal to current number of entries). */
        unsigned int num_counters;
        /* The old entries' counters. */
-        struct arpt_counters __user *counters;
+        struct xt_counters __user *counters;
        /* The entries (hang off end: not really an array). */
        struct arpt_entry entries[0];
 };
 /* The argument to ARPT_SO_ADD_COUNTERS. */
-struct arpt_counters_info
+#define arpt_counters_info xt_counters_info
-{
-        /* Which table. */
-        char name[ARPT_TABLE_MAXNAMELEN];
-        unsigned int num_counters;
-        /* The counters (actually `number' of these). */
-        struct arpt_counters counters[0];
-};
 /* The argument to ARPT_SO_GET_ENTRIES. */
 struct arpt_get_entries
@@ -239,19 +230,10 @@ struct arpt_get_entries
        struct arpt_entry entrytable[0];
 };
-/* The argument to ARPT_SO_GET_REVISION_*.  Returns highest revision
- * kernel supports, if >= revision. */
-struct arpt_get_revision
-{
-        char name[ARPT_FUNCTION_MAXNAMELEN-1];
-        u_int8_t revision;
-};
 /* Standard return verdict, or do jump. */
-#define ARPT_STANDARD_TARGET ""
+#define ARPT_STANDARD_TARGET XT_STANDARD_TARGET
 /* Error verdict. */
-#define ARPT_ERROR_TARGET "ERROR"
+#define ARPT_ERROR_TARGET XT_ERROR_TARGET
 /* Helper functions */
 static __inline__ struct arpt_entry_target *arpt_get_target(struct arpt_entry *e)
@@ -281,63 +263,8 @@ static __inline__ struct arpt_entry_target *arpt_get_target(struct arpt_entry *e
 */
 #ifdef __KERNEL__
-/* Registration hooks for targets. */
+#define arpt_register_target(tgt) xt_register_target(NF_ARP, tgt)
-struct arpt_target
+#define arpt_unregister_target(tgt) xt_unregister_target(NF_ARP, tgt)
-{
-        struct list_head list;
-        const char name[ARPT_FUNCTION_MAXNAMELEN-1];
-        u_int8_t revision;
-        /* Returns verdict. */
-        unsigned int (*target)(struct sk_buff **pskb,
-                               unsigned int hooknum,
-                               const struct net_device *in,
-                               const struct net_device *out,
-                               const void *targinfo,
-                               void *userdata);
-        /* Called when user tries to insert an entry of this type:
-           hook_mask is a bitmask of hooks from which it can be
-           called. */
-        /* Should return true or false. */
-        int (*checkentry)(const char *tablename,
-                          const struct arpt_entry *e,
-                          void *targinfo,
-                          unsigned int targinfosize,
-                          unsigned int hook_mask);
-        /* Called when entry of this type deleted. */
-        void (*destroy)(void *targinfo, unsigned int targinfosize);
-        /* Set this to THIS_MODULE if you are a module, otherwise NULL */
-        struct module *me;
-};
-extern int arpt_register_target(struct arpt_target *target);
-extern void arpt_unregister_target(struct arpt_target *target);
-/* Furniture shopping... */
-struct arpt_table
-{
-        struct list_head list;
-        /* A unique name... */
-        char name[ARPT_TABLE_MAXNAMELEN];
-        /* What hooks you will enter on */
-        unsigned int valid_hooks;
-        /* Lock for the curtain */
-        rwlock_t lock;
-        /* Man behind the curtain... */
-        struct arpt_table_info *private;
-        /* Set this to THIS_MODULE if you are a module, otherwise NULL */
-        struct module *me;
-};
 extern int arpt_register_table(struct arpt_table *table,
                               const struct arpt_replace *repl);
diff --git a/include/linux/netfilter_ipv4/ip_conntrack.h b/include/linux/netfilter_ipv4/ip_conntrack.h
index b3432ab59a17..215765f043e6 100644
--- a/include/linux/netfilter_ipv4/ip_conntrack.h
+++ b/include/linux/netfilter_ipv4/ip_conntrack.h
@@ -199,9 +199,6 @@ ip_conntrack_put(struct ip_conntrack *ct)
        nf_conntrack_put(&ct->ct_general);
 }
-/* call to create an explicit dependency on ip_conntrack. */
-extern void need_ip_conntrack(void);
 extern int invert_tuplepr(struct ip_conntrack_tuple *inverse,
                          const struct ip_conntrack_tuple *orig);
diff --git a/include/linux/netfilter_ipv4/ip_tables.h b/include/linux/netfilter_ipv4/ip_tables.h
index d19d65cf4530..76ba24b68515 100644
--- a/include/linux/netfilter_ipv4/ip_tables.h
+++ b/include/linux/netfilter_ipv4/ip_tables.h
@@ -25,8 +25,14 @@
 #include <linux/compiler.h>
 #include <linux/netfilter_ipv4.h>
-#define IPT_FUNCTION_MAXNAMELEN 30
+#include <linux/netfilter/x_tables.h>
-#define IPT_TABLE_MAXNAMELEN 32
+#define IPT_FUNCTION_MAXNAMELEN XT_FUNCTION_MAXNAMELEN
+#define IPT_TABLE_MAXNAMELEN XT_FUNCTION_MAXNAMELEN
+#define ipt_match xt_match
+#define ipt_target xt_target
+#define ipt_table xt_table
+#define ipt_get_revision xt_get_revision
 /* Yes, Virginia, you have to zero the padding. */
 struct ipt_ip {
@@ -102,10 +108,7 @@ struct ipt_standard_target
        int verdict;
 };
-struct ipt_counters
+#define ipt_counters xt_counters
-{
-        u_int64_t pcnt, bcnt;                   /* Packet and byte counters */
-};
 /* Values for "flag" field in struct ipt_ip (general ip structure). */
 #define IPT_F_FRAG              0x01    /* Set if rule is a fragment rule */
@@ -119,7 +122,7 @@ struct ipt_counters
 #define IPT_INV_SRCIP           0x08    /* Invert the sense of SRC IP. */
 #define IPT_INV_DSTIP           0x10    /* Invert the sense of DST OP. */
 #define IPT_INV_FRAG            0x20    /* Invert the sense of FRAG. */
-#define IPT_INV_PROTO           0x40    /* Invert the sense of PROTO. */
+#define IPT_INV_PROTO           XT_INV_PROTO
 #define IPT_INV_MASK            0x7F    /* All possible flag bits mask. */
 /* This structure defines each of the firewall rules.  Consists of 3
@@ -141,7 +144,7 @@ struct ipt_entry
        unsigned int comefrom;
        /* Packet and byte counters. */
-        struct ipt_counters counters;
+        struct xt_counters counters;
        /* The matches (if any), then the target. */
        unsigned char elems[0];
@@ -151,54 +154,34 @@ struct ipt_entry
 * New IP firewall options for [gs]etsockopt at the RAW IP level.
 * Unlike BSD Linux inherits IP options so you don't have to use a raw
 * socket for this. Instead we check rights in the calls. */
-#define IPT_BASE_CTL            64      /* base for firewall socket options */
+#define IPT_BASE_CTL            XT_BASE_CTL
-#define IPT_SO_SET_REPLACE      (IPT_BASE_CTL)
+#define IPT_SO_SET_REPLACE      XT_SO_SET_REPLACE
-#define IPT_SO_SET_ADD_COUNTERS (IPT_BASE_CTL + 1)
+#define IPT_SO_SET_ADD_COUNTERS XT_SO_SET_ADD_COUNTERS
-#define IPT_SO_SET_MAX          IPT_SO_SET_ADD_COUNTERS
+#define IPT_SO_SET_MAX          XT_SO_SET_MAX
-#define IPT_SO_GET_INFO                 (IPT_BASE_CTL)
+#define IPT_SO_GET_INFO                 XT_SO_GET_INFO
-#define IPT_SO_GET_ENTRIES              (IPT_BASE_CTL + 1)
+#define IPT_SO_GET_ENTRIES              XT_SO_GET_ENTRIES
-#define IPT_SO_GET_REVISION_MATCH       (IPT_BASE_CTL + 2)
+#define IPT_SO_GET_REVISION_MATCH       XT_SO_GET_REVISION_MATCH
-#define IPT_SO_GET_REVISION_TARGET      (IPT_BASE_CTL + 3)
+#define IPT_SO_GET_REVISION_TARGET      XT_SO_GET_REVISION_TARGET
-#define IPT_SO_GET_MAX                  IPT_SO_GET_REVISION_TARGET
+#define IPT_SO_GET_MAX                  XT_SO_GET_REVISION_TARGET
-/* CONTINUE verdict for targets */
+#define IPT_CONTINUE XT_CONTINUE
-#define IPT_CONTINUE 0xFFFFFFFF
+#define IPT_RETURN XT_RETURN
-/* For standard target */
+#include <linux/netfilter/xt_tcpudp.h>
-#define IPT_RETURN (-NF_REPEAT - 1)
+#define ipt_udp xt_udp
+#define ipt_tcp xt_tcp
-/* TCP matching stuff */
+#define IPT_TCP_INV_SRCPT       XT_TCP_INV_SRCPT
-struct ipt_tcp
+#define IPT_TCP_INV_DSTPT       XT_TCP_INV_DSTPT
-{
+#define IPT_TCP_INV_FLAGS       XT_TCP_INV_FLAGS
-        u_int16_t spts[2];                      /* Source port range. */
+#define IPT_TCP_INV_OPTION      XT_TCP_INV_OPTION
-        u_int16_t dpts[2];                      /* Destination port range. */
+#define IPT_TCP_INV_MASK        XT_TCP_INV_MASK
-        u_int8_t option;                        /* TCP Option iff non-zero*/
-        u_int8_t flg_mask;                      /* TCP flags mask byte */
-        u_int8_t flg_cmp;                       /* TCP flags compare byte */
-        u_int8_t invflags;                      /* Inverse flags */
-};
-/* Values for "inv" field in struct ipt_tcp. */
-#define IPT_TCP_INV_SRCPT       0x01    /* Invert the sense of source ports. */
-#define IPT_TCP_INV_DSTPT       0x02    /* Invert the sense of dest ports. */
-#define IPT_TCP_INV_FLAGS       0x04    /* Invert the sense of TCP flags. */
-#define IPT_TCP_INV_OPTION      0x08    /* Invert the sense of option test. */
-#define IPT_TCP_INV_MASK        0x0F    /* All possible flags. */
-/* UDP matching stuff */
-struct ipt_udp
-{
-        u_int16_t spts[2];                      /* Source port range. */
-        u_int16_t dpts[2];                      /* Destination port range. */
-        u_int8_t invflags;                      /* Inverse flags */
-};
-/* Values for "invflags" field in struct ipt_udp. */
+#define IPT_UDP_INV_SRCPT       XT_UDP_INV_SRCPT
-#define IPT_UDP_INV_SRCPT       0x01    /* Invert the sense of source ports. */
+#define IPT_UDP_INV_DSTPT       XT_UDP_INV_DSTPT
-#define IPT_UDP_INV_DSTPT       0x02    /* Invert the sense of dest ports. */
+#define IPT_UDP_INV_MASK        XT_UDP_INV_MASK
-#define IPT_UDP_INV_MASK        0x03    /* All possible flags. */
 /* ICMP matching stuff */
 struct ipt_icmp
@@ -260,23 +243,14 @@ struct ipt_replace
        /* Number of counters (must be equal to current number of entries). */
        unsigned int num_counters;
        /* The old entries' counters. */
-        struct ipt_counters __user *counters;
+        struct xt_counters __user *counters;
        /* The entries (hang off end: not really an array). */
        struct ipt_entry entries[0];
 };
 /* The argument to IPT_SO_ADD_COUNTERS. */
-struct ipt_counters_info
+#define ipt_counters_info xt_counters_info
-{
-        /* Which table. */
-        char name[IPT_TABLE_MAXNAMELEN];
-        unsigned int num_counters;
-        /* The counters (actually `number' of these). */
-        struct ipt_counters counters[0];
-};
 /* The argument to IPT_SO_GET_ENTRIES. */
 struct ipt_get_entries
@@ -291,19 +265,10 @@ struct ipt_get_entries
        struct ipt_entry entrytable[0];
 };
-/* The argument to IPT_SO_GET_REVISION_*.  Returns highest revision
- * kernel supports, if >= revision. */
-struct ipt_get_revision
-{
-        char name[IPT_FUNCTION_MAXNAMELEN-1];
-        u_int8_t revision;
-};
 /* Standard return verdict, or do jump. */
-#define IPT_STANDARD_TARGET ""
+#define IPT_STANDARD_TARGET XT_STANDARD_TARGET
 /* Error verdict. */
-#define IPT_ERROR_TARGET "ERROR"
+#define IPT_ERROR_TARGET XT_ERROR_TARGET
 /* Helper functions */
 static __inline__ struct ipt_entry_target *
@@ -356,103 +321,18 @@ ipt_get_target(struct ipt_entry *e)
 #include <linux/init.h>
 extern void ipt_init(void) __init;
-struct ipt_match
+#define ipt_register_target(tgt) xt_register_target(AF_INET, tgt)
-{
+#define ipt_unregister_target(tgt) xt_unregister_target(AF_INET, tgt)
-        struct list_head list;
-        const char name[IPT_FUNCTION_MAXNAMELEN-1];
-        u_int8_t revision;
-        /* Return true or false: return FALSE and set *hotdrop = 1 to
-           force immediate packet drop. */
-        /* Arguments changed since 2.4, as this must now handle
-           non-linear skbs, using skb_copy_bits and
-           skb_ip_make_writable. */
-        int (*match)(const struct sk_buff *skb,
-                     const struct net_device *in,
-                     const struct net_device *out,
-                     const void *matchinfo,
-                     int offset,
-                     int *hotdrop);
-        /* Called when user tries to insert an entry of this type. */
-        /* Should return true or false. */
-        int (*checkentry)(const char *tablename,
-                          const struct ipt_ip *ip,
-                          void *matchinfo,
-                          unsigned int matchinfosize,
-                          unsigned int hook_mask);
-        /* Called when entry of this type deleted. */
-        void (*destroy)(void *matchinfo, unsigned int matchinfosize);
-        /* Set this to THIS_MODULE. */
-        struct module *me;
-};
-/* Registration hooks for targets. */
-struct ipt_target
-{
-        struct list_head list;
-        const char name[IPT_FUNCTION_MAXNAMELEN-1];
-        u_int8_t revision;
-        /* Called when user tries to insert an entry of this type:
-           hook_mask is a bitmask of hooks from which it can be
-           called. */
-        /* Should return true or false. */
-        int (*checkentry)(const char *tablename,
-                          const struct ipt_entry *e,
-                          void *targinfo,
-                          unsigned int targinfosize,
-                          unsigned int hook_mask);
-        /* Called when entry of this type deleted. */
-        void (*destroy)(void *targinfo, unsigned int targinfosize);
-        /* Returns verdict.  Argument order changed since 2.4, as this
-           must now handle non-linear skbs, using skb_copy_bits and
-           skb_ip_make_writable. */
-        unsigned int (*target)(struct sk_buff **pskb,
-                               const struct net_device *in,
-                               const struct net_device *out,
-                               unsigned int hooknum,
-                               const void *targinfo,
-                               void *userdata);
-        /* Set this to THIS_MODULE. */
-        struct module *me;
-};
-extern int ipt_register_target(struct ipt_target *target);
+#define ipt_register_match(mtch) xt_register_match(AF_INET, mtch)
-extern void ipt_unregister_target(struct ipt_target *target);
+#define ipt_unregister_match(mtch) xt_unregister_match(AF_INET, mtch)
-extern int ipt_register_match(struct ipt_match *match);
+//#define ipt_register_table(tbl, repl) xt_register_table(AF_INET, tbl, repl)
-extern void ipt_unregister_match(struct ipt_match *match);
+//#define ipt_unregister_table(tbl) xt_unregister_table(AF_INET, tbl)
-/* Furniture shopping... */
+extern int ipt_register_table(struct ipt_table *table,
-struct ipt_table
+                              const struct ipt_replace *repl);
-{
+extern void ipt_unregister_table(struct ipt_table *table);
-        struct list_head list;
-        /* A unique name... */
-        char name[IPT_TABLE_MAXNAMELEN];
-        /* What hooks you will enter on */
-        unsigned int valid_hooks;
-        /* Lock for the curtain */
-        rwlock_t lock;
-        /* Man behind the curtain... */
-        struct ipt_table_info *private;
-        /* Set to THIS_MODULE. */
-        struct module *me;
-};
 /* net/sched/ipt.c: Gimme access to your targets!  Gets target->me. */
 extern struct ipt_target *ipt_find_target(const char *name, u8 revision);
@@ -476,9 +356,6 @@ struct ipt_error
        struct ipt_error_target target;
 };
-extern int ipt_register_table(struct ipt_table *table,
-                              const struct ipt_replace *repl);
-extern void ipt_unregister_table(struct ipt_table *table);
 extern unsigned int ipt_do_table(struct sk_buff **pskb,
                                 unsigned int hook,
                                 const struct net_device *in,
@@ -486,6 +363,6 @@ extern unsigned int ipt_do_table(struct sk_buff **pskb,
                                 struct ipt_table *table,
                                 void *userdata);
-#define IPT_ALIGN(s) (((s) + (__alignof__(struct ipt_entry)-1)) & ~(__alignof__(struct ipt_entry)-1))
+#define IPT_ALIGN(s) XT_ALIGN(s)
 #endif /*__KERNEL__*/
 #endif /* _IPTABLES_H */
diff --git a/include/linux/netfilter_ipv4/ipt_CLASSIFY.h b/include/linux/netfilter_ipv4/ipt_CLASSIFY.h
index 7596e3dd00ca..a46d511b5c36 100644
--- a/include/linux/netfilter_ipv4/ipt_CLASSIFY.h
+++ b/include/linux/netfilter_ipv4/ipt_CLASSIFY.h
@@ -1,8 +1,7 @@
 #ifndef _IPT_CLASSIFY_H
 #define _IPT_CLASSIFY_H
-struct ipt_classify_target_info {
+#include <linux/netfilter/xt_CLASSIFY.h>
-        u_int32_t priority;
+#define ipt_classify_target_info xt_classify_target_info
-};
 #endif /*_IPT_CLASSIFY_H */
diff --git a/include/linux/netfilter_ipv4/ipt_CONNMARK.h b/include/linux/netfilter_ipv4/ipt_CONNMARK.h
index d3c02536fc4c..9ecfee0a9e33 100644
--- a/include/linux/netfilter_ipv4/ipt_CONNMARK.h
+++ b/include/linux/netfilter_ipv4/ipt_CONNMARK.h
@@ -9,17 +9,11 @@
 * the Free Software Foundation; either version 2 of the License, or
 * (at your option) any later version.
 */
+#include <linux/netfilter/xt_CONNMARK.h>
+#define IPT_CONNMARK_SET        XT_CONNMARK_SET
+#define IPT_CONNMARK_SAVE       XT_CONNMARK_SAVE
+#define IPT_CONNMARK_RESTORE    XT_CONNMARK_RESTORE
-enum {
+#define ipt_connmark_target_info xt_connmark_target_info
-        IPT_CONNMARK_SET = 0,
-        IPT_CONNMARK_SAVE,
-        IPT_CONNMARK_RESTORE
-};
-struct ipt_connmark_target_info {
-        unsigned long mark;
-        unsigned long mask;
-        u_int8_t mode;
-};
 #endif /*_IPT_CONNMARK_H_target*/
diff --git a/include/linux/netfilter_ipv4/ipt_MARK.h b/include/linux/netfilter_ipv4/ipt_MARK.h
index f47485790ed4..697a486a96d3 100644
--- a/include/linux/netfilter_ipv4/ipt_MARK.h
+++ b/include/linux/netfilter_ipv4/ipt_MARK.h
@@ -1,20 +1,18 @@
 #ifndef _IPT_MARK_H_target
 #define _IPT_MARK_H_target
+/* Backwards compatibility for old userspace */
+#include <linux/netfilter/xt_MARK.h>
 /* Version 0 */
-struct ipt_mark_target_info {
+#define ipt_mark_target_info xt_mark_target_info
-        unsigned long mark;
-};
 /* Version 1 */
-enum {
+#define IPT_MARK_SET    XT_MARK_SET
-        IPT_MARK_SET=0,
+#define IPT_MARK_AND    XT_MARK_AND
-        IPT_MARK_AND,
+#define IPT_MARK_OR     XT_MARK_OR
-        IPT_MARK_OR
-};
+#define ipt_mark_target_info_v1 xt_mark_target_info_v1
-struct ipt_mark_target_info_v1 {
-        unsigned long mark;
-        u_int8_t mode;
-};
 #endif /*_IPT_MARK_H_target*/
diff --git a/include/linux/netfilter_ipv4/ipt_NFQUEUE.h b/include/linux/netfilter_ipv4/ipt_NFQUEUE.h
index b5b2943b0c66..97a2a7557cb9 100644
--- a/include/linux/netfilter_ipv4/ipt_NFQUEUE.h
+++ b/include/linux/netfilter_ipv4/ipt_NFQUEUE.h
@@ -8,9 +8,9 @@
 #ifndef _IPT_NFQ_TARGET_H
 #define _IPT_NFQ_TARGET_H
-/* target info */
+/* Backwards compatibility for old userspace */
-struct ipt_NFQ_info {
+#include <linux/netfilter/xt_NFQUEUE.h>
-        u_int16_t queuenum;
-};
+#define ipt_NFQ_info xt_NFQ_info
 #endif /* _IPT_DSCP_TARGET_H */
diff --git a/include/linux/netfilter_ipv4/ipt_comment.h b/include/linux/netfilter_ipv4/ipt_comment.h
index 85c1123c29ce..ae2afc2f7481 100644
--- a/include/linux/netfilter_ipv4/ipt_comment.h
+++ b/include/linux/netfilter_ipv4/ipt_comment.h
@@ -1,10 +1,10 @@
 #ifndef _IPT_COMMENT_H
 #define _IPT_COMMENT_H
-#define IPT_MAX_COMMENT_LEN 256
+#include <linux/netfilter/xt_comment.h>
-struct ipt_comment_info {
+#define IPT_MAX_COMMENT_LEN XT_MAX_COMMENT_LEN
-        unsigned char comment[IPT_MAX_COMMENT_LEN];
-};
+#define ipt_comment_info xt_comment_info
 #endif /* _IPT_COMMENT_H */
diff --git a/include/linux/netfilter_ipv4/ipt_connbytes.h b/include/linux/netfilter_ipv4/ipt_connbytes.h
index 9e5532f8d8ac..b04dfa3083c9 100644
--- a/include/linux/netfilter_ipv4/ipt_connbytes.h
+++ b/include/linux/netfilter_ipv4/ipt_connbytes.h
@@ -1,25 +1,18 @@
 #ifndef _IPT_CONNBYTES_H
 #define _IPT_CONNBYTES_H
-enum ipt_connbytes_what {
+#include <net/netfilter/xt_connbytes.h>
-        IPT_CONNBYTES_PKTS,
+#define ipt_connbytes_what xt_connbytes_what
-        IPT_CONNBYTES_BYTES,
-        IPT_CONNBYTES_AVGPKT,
-};
-enum ipt_connbytes_direction {
+#define IPT_CONNBYTES_PKTS      XT_CONNBYTES_PACKETS
-        IPT_CONNBYTES_DIR_ORIGINAL,
+#define IPT_CONNBYTES_BYTES     XT_CONNBYTES_BYTES
-        IPT_CONNBYTES_DIR_REPLY,
+#define IPT_CONNBYTES_AVGPKT    XT_CONNBYTES_AVGPKT
-        IPT_CONNBYTES_DIR_BOTH,
-};
+#define ipt_connbytes_direction         xt_connbytes_direction
+#define IPT_CONNBYTES_DIR_ORIGINAL      XT_CONNBYTES_DIR_ORIGINAL
+#define IPT_CONNBYTES_DIR_REPLY         XT_CONNBYTES_DIR_REPLY
+#define IPT_CONNBYTES_DIR_BOTH          XT_CONNBYTES_DIR_BOTH
+#define ipt_connbytes_info xt_connbytes_info
-struct ipt_connbytes_info
-{
-        struct {
-                aligned_u64 from;       /* count to be matched */
-                aligned_u64 to;         /* count to be matched */
-        } count;
-        u_int8_t what;          /* ipt_connbytes_what */
-        u_int8_t direction;     /* ipt_connbytes_direction */
-};
 #endif
diff --git a/include/linux/netfilter_ipv4/ipt_connmark.h b/include/linux/netfilter_ipv4/ipt_connmark.h
index 46573270d9aa..c7ba6560d44c 100644
--- a/include/linux/netfilter_ipv4/ipt_connmark.h
+++ b/include/linux/netfilter_ipv4/ipt_connmark.h
@@ -1,18 +1,7 @@
 #ifndef _IPT_CONNMARK_H
 #define _IPT_CONNMARK_H
-/* Copyright (C) 2002,2004 MARA Systems AB <http://www.marasystems.com>
+#include <linux/netfilter/xt_connmark.h>
- * by Henrik Nordstrom <hno@marasystems.com>
+#define ipt_connmark_info xt_connmark_info
- *
- * This program is free software; you can redistribute it and/or modify
- * it under the terms of the GNU General Public License as published by
- * the Free Software Foundation; either version 2 of the License, or
- * (at your option) any later version.
- */
-struct ipt_connmark_info {
-        unsigned long mark, mask;
-        u_int8_t invert;
-};
 #endif /*_IPT_CONNMARK_H*/
diff --git a/include/linux/netfilter_ipv4/ipt_conntrack.h b/include/linux/netfilter_ipv4/ipt_conntrack.h
index 413c5658bd3a..cde6762949c5 100644
--- a/include/linux/netfilter_ipv4/ipt_conntrack.h
+++ b/include/linux/netfilter_ipv4/ipt_conntrack.h
@@ -5,56 +5,24 @@
 #ifndef _IPT_CONNTRACK_H
 #define _IPT_CONNTRACK_H
-#define IPT_CONNTRACK_STATE_BIT(ctinfo) (1 << ((ctinfo)%IP_CT_IS_REPLY+1))
+#include <linux/netfilter/xt_conntrack.h>
-#define IPT_CONNTRACK_STATE_INVALID (1 << 0)
-#define IPT_CONNTRACK_STATE_SNAT (1 << (IP_CT_NUMBER + 1))
+#define IPT_CONNTRACK_STATE_BIT(ctinfo) XT_CONNTRACK_STATE_BIT(ctinfo)
-#define IPT_CONNTRACK_STATE_DNAT (1 << (IP_CT_NUMBER + 2))
+#define IPT_CONNTRACK_STATE_INVALID     XT_CONNTRACK_STATE_INVALID
-#define IPT_CONNTRACK_STATE_UNTRACKED (1 << (IP_CT_NUMBER + 3))
-/* flags, invflags: */
+#define IPT_CONNTRACK_STATE_SNAT        XT_CONNTRACK_STATE_SNAT
-#define IPT_CONNTRACK_STATE     0x01
+#define IPT_CONNTRACK_STATE_DNAT        XT_CONNTRACK_STATE_DNAT
-#define IPT_CONNTRACK_PROTO     0x02
+#define IPT_CONNTRACK_STATE_UNTRACKED   XT_CONNTRACK_STATE_UNTRACKED
-#define IPT_CONNTRACK_ORIGSRC   0x04
-#define IPT_CONNTRACK_ORIGDST   0x08
-#define IPT_CONNTRACK_REPLSRC   0x10
-#define IPT_CONNTRACK_REPLDST   0x20
-#define IPT_CONNTRACK_STATUS    0x40
-#define IPT_CONNTRACK_EXPIRES   0x80
-/* This is exposed to userspace, so remains frozen in time. */
-struct ip_conntrack_old_tuple
-{
-        struct {
-                __u32 ip;
-                union {
-                        __u16 all;
-                } u;
-        } src;
-        struct {
-                __u32 ip;
-                union {
-                        __u16 all;
-                } u;
-                /* The protocol. */
-                u16 protonum;
-        } dst;
-};
-struct ipt_conntrack_info
+/* flags, invflags: */
-{
+#define IPT_CONNTRACK_STATE             XT_CONNTRACK_STATE
-        unsigned int statemask, statusmask;
+#define IPT_CONNTRACK_PROTO             XT_CONNTRACK_PROTO
+#define IPT_CONNTRACK_ORIGSRC           XT_CONNTRACK_ORIGSRC
-        struct ip_conntrack_old_tuple tuple[IP_CT_DIR_MAX];
+#define IPT_CONNTRACK_ORIGDST           XT_CONNTRACK_ORIGDST
-        struct in_addr sipmsk[IP_CT_DIR_MAX], dipmsk[IP_CT_DIR_MAX];
+#define IPT_CONNTRACK_REPLSRC           XT_CONNTRACK_REPLSRC
+#define IPT_CONNTRACK_REPLDST           XT_CONNTRACK_REPLDST
-        unsigned long expires_min, expires_max;
+#define IPT_CONNTRACK_STATUS            XT_CONNTRACK_STATUS
+#define IPT_CONNTRACK_EXPIRES           XT_CONNTRACK_EXPIRES
-        /* Flags word */
-        u_int8_t flags;
+#define ipt_conntrack_info              xt_conntrack_info
-        /* Inverse flags */
-        u_int8_t invflags;
-};
 #endif /*_IPT_CONNTRACK_H*/
diff --git a/include/linux/netfilter_ipv4/ipt_dccp.h b/include/linux/netfilter_ipv4/ipt_dccp.h
index 3cb3a522e62b..e70d11e1f53c 100644
--- a/include/linux/netfilter_ipv4/ipt_dccp.h
+++ b/include/linux/netfilter_ipv4/ipt_dccp.h
@@ -1,23 +1,15 @@
 #ifndef _IPT_DCCP_H_
 #define _IPT_DCCP_H_
-#define IPT_DCCP_SRC_PORTS              0x01
+#include <linux/netfilter/xt_dccp.h>
-#define IPT_DCCP_DEST_PORTS             0x02
+#define IPT_DCCP_SRC_PORTS      XT_DCCP_SRC_PORTS
-#define IPT_DCCP_TYPE                   0x04
+#define IPT_DCCP_DEST_PORTS     XT_DCCP_DEST_PORTS
-#define IPT_DCCP_OPTION                 0x08
+#define IPT_DCCP_TYPE           XT_DCCP_TYPE
+#define IPT_DCCP_OPTION         XT_DCCP_OPTION
-#define IPT_DCCP_VALID_FLAGS            0x0f
+#define IPT_DCCP_VALID_FLAGS    XT_DCCP_VALID_FLAGS
-struct ipt_dccp_info {
+#define ipt_dccp_info xt_dccp_info
-        u_int16_t dpts[2];  /* Min, Max */
-        u_int16_t spts[2];  /* Min, Max */
-        u_int16_t flags;
-        u_int16_t invflags;
-        u_int16_t typemask;
-        u_int8_t option;
-};
 #endif /* _IPT_DCCP_H_ */
diff --git a/include/linux/netfilter_ipv4/ipt_helper.h b/include/linux/netfilter_ipv4/ipt_helper.h
index 6f12ecb8c93d..80452c218551 100644
--- a/include/linux/netfilter_ipv4/ipt_helper.h
+++ b/include/linux/netfilter_ipv4/ipt_helper.h
@@ -1,8 +1,7 @@
 #ifndef _IPT_HELPER_H
 #define _IPT_HELPER_H
-struct ipt_helper_info {
+#include <linux/netfilter/xt_helper.h>
-        int invert;
+#define ipt_helper_info xt_helper_info
-        char name[30];
-};
 #endif /* _IPT_HELPER_H */
diff --git a/include/linux/netfilter_ipv4/ipt_length.h b/include/linux/netfilter_ipv4/ipt_length.h
index 6e0885229615..9b45206ffcef 100644
--- a/include/linux/netfilter_ipv4/ipt_length.h
+++ b/include/linux/netfilter_ipv4/ipt_length.h
@@ -1,9 +1,7 @@
 #ifndef _IPT_LENGTH_H
 #define _IPT_LENGTH_H
-struct ipt_length_info {
+#include <linux/netfilter/xt_length.h>
-    u_int16_t   min, max;
+#define ipt_length_info xt_length_info
-    u_int8_t    invert;
-};
 #endif /*_IPT_LENGTH_H*/
diff --git a/include/linux/netfilter_ipv4/ipt_limit.h b/include/linux/netfilter_ipv4/ipt_limit.h
index 256453409e21..92f5cd07bbc4 100644
--- a/include/linux/netfilter_ipv4/ipt_limit.h
+++ b/include/linux/netfilter_ipv4/ipt_limit.h
@@ -1,21 +1,8 @@
 #ifndef _IPT_RATE_H
 #define _IPT_RATE_H
-/* timings are in milliseconds. */
+#include <linux/netfilter/xt_limit.h>
-#define IPT_LIMIT_SCALE 10000
+#define IPT_LIMIT_SCALE XT_LIMIT_SCALE
+#define ipt_rateinfo xt_rateinfo
-/* 1/10,000 sec period => max of 10,000/sec.  Min rate is then 429490
-   seconds, or one every 59 hours. */
-struct ipt_rateinfo {
-        u_int32_t avg;    /* Average secs between packets * scale */
-        u_int32_t burst;  /* Period multiplier for upper limit. */
-        /* Used internally by the kernel */
-        unsigned long prev;
-        u_int32_t credit;
-        u_int32_t credit_cap, cost;
-        /* Ugly, ugly fucker. */
-        struct ipt_rateinfo *master;
-};
 #endif /*_IPT_RATE_H*/
diff --git a/include/linux/netfilter_ipv4/ipt_mac.h b/include/linux/netfilter_ipv4/ipt_mac.h
index f8d5b8e7ccdb..b186008a3c47 100644
--- a/include/linux/netfilter_ipv4/ipt_mac.h
+++ b/include/linux/netfilter_ipv4/ipt_mac.h
@@ -1,8 +1,7 @@
 #ifndef _IPT_MAC_H
 #define _IPT_MAC_H
-struct ipt_mac_info {
+#include <linux/netfilter/xt_mac.h>
-    unsigned char srcaddr[ETH_ALEN];
+#define ipt_mac_info xt_mac_info
-    int invert;
-};
 #endif /*_IPT_MAC_H*/
diff --git a/include/linux/netfilter_ipv4/ipt_mark.h b/include/linux/netfilter_ipv4/ipt_mark.h
index f3952b563d4c..bfde67c61224 100644
--- a/include/linux/netfilter_ipv4/ipt_mark.h
+++ b/include/linux/netfilter_ipv4/ipt_mark.h
@@ -1,9 +1,9 @@
 #ifndef _IPT_MARK_H
 #define _IPT_MARK_H
-struct ipt_mark_info {
+/* Backwards compatibility for old userspace */
-    unsigned long mark, mask;
+#include <linux/netfilter/xt_mark.h>
-    u_int8_t invert;
-};
+#define ipt_mark_info xt_mark_info
 #endif /*_IPT_MARK_H*/
diff --git a/include/linux/netfilter_ipv4/ipt_physdev.h b/include/linux/netfilter_ipv4/ipt_physdev.h
index 7538c8655ec0..2400e7140f26 100644
--- a/include/linux/netfilter_ipv4/ipt_physdev.h
+++ b/include/linux/netfilter_ipv4/ipt_physdev.h
@@ -1,24 +1,17 @@
 #ifndef _IPT_PHYSDEV_H
 #define _IPT_PHYSDEV_H
-#ifdef __KERNEL__
+/* Backwards compatibility for old userspace */
-#include <linux/if.h>
-#endif
-#define IPT_PHYSDEV_OP_IN               0x01
+#include <linux/netfilter/xt_physdev.h>
-#define IPT_PHYSDEV_OP_OUT              0x02
-#define IPT_PHYSDEV_OP_BRIDGED          0x04
-#define IPT_PHYSDEV_OP_ISIN             0x08
-#define IPT_PHYSDEV_OP_ISOUT            0x10
-#define IPT_PHYSDEV_OP_MASK             (0x20 - 1)
-struct ipt_physdev_info {
+#define IPT_PHYSDEV_OP_IN               XT_PHYSDEV_OP_IN
-        char physindev[IFNAMSIZ];
+#define IPT_PHYSDEV_OP_OUT              XT_PHYSDEV_OP_OUT
-        char in_mask[IFNAMSIZ];
+#define IPT_PHYSDEV_OP_BRIDGED          XT_PHYSDEV_OP_BRIDGED
-        char physoutdev[IFNAMSIZ];
+#define IPT_PHYSDEV_OP_ISIN             XT_PHYSDEV_OP_ISIN
-        char out_mask[IFNAMSIZ];
+#define IPT_PHYSDEV_OP_ISOUT            XT_PHYSDEV_OP_ISOUT
-        u_int8_t invert;
+#define IPT_PHYSDEV_OP_MASK             XT_PHYSDEV_OP_MASK
-        u_int8_t bitmask;
-};
+#define ipt_physdev_info xt_physdev_info
 #endif /*_IPT_PHYSDEV_H*/
diff --git a/include/linux/netfilter_ipv4/ipt_pkttype.h b/include/linux/netfilter_ipv4/ipt_pkttype.h
index d53a65848683..ff1fbc949a0c 100644
--- a/include/linux/netfilter_ipv4/ipt_pkttype.h
+++ b/include/linux/netfilter_ipv4/ipt_pkttype.h
@@ -1,8 +1,7 @@
 #ifndef _IPT_PKTTYPE_H
 #define _IPT_PKTTYPE_H
-struct ipt_pkttype_info {
+#include <linux/netfilter/xt_pkttype.h>
-        int     pkttype;
+#define ipt_pkttype_info xt_pkttype_info
-        int     invert;
-};
 #endif /*_IPT_PKTTYPE_H*/
diff --git a/include/linux/netfilter_ipv4/ipt_realm.h b/include/linux/netfilter_ipv4/ipt_realm.h
index a4d6698723ac..b3996eaa0188 100644
--- a/include/linux/netfilter_ipv4/ipt_realm.h
+++ b/include/linux/netfilter_ipv4/ipt_realm.h
@@ -1,10 +1,7 @@
 #ifndef _IPT_REALM_H
 #define _IPT_REALM_H
-struct ipt_realm_info {
+#include <linux/netfilter/xt_realm.h>
-        u_int32_t id;
+#define ipt_realm_info xt_realm_info
-        u_int32_t mask;
-        u_int8_t invert;
-};
 #endif /* _IPT_REALM_H */
diff --git a/include/linux/netfilter_ipv4/ipt_state.h b/include/linux/netfilter_ipv4/ipt_state.h
index 5df37868933d..a44a99cc28cc 100644
--- a/include/linux/netfilter_ipv4/ipt_state.h
+++ b/include/linux/netfilter_ipv4/ipt_state.h
@@ -1,13 +1,15 @@
 #ifndef _IPT_STATE_H
 #define _IPT_STATE_H
-#define IPT_STATE_BIT(ctinfo) (1 << ((ctinfo)%IP_CT_IS_REPLY+1))
+/* Backwards compatibility for old userspace */
-#define IPT_STATE_INVALID (1 << 0)
-#define IPT_STATE_UNTRACKED (1 << (IP_CT_NUMBER + 1))
+#include <linux/netfilter/xt_state.h>
+#define IPT_STATE_BIT           XT_STATE_BIT
+#define IPT_STATE_INVALID       XT_STATE_INVALID
+#define IPT_STATE_UNTRACKED     XT_STATE_UNTRACKED
+#define ipt_state_info          xt_state_info
-struct ipt_state_info
-{
-        unsigned int statemask;
-};
 #endif /*_IPT_STATE_H*/
diff --git a/include/linux/netfilter_ipv4/ipt_string.h b/include/linux/netfilter_ipv4/ipt_string.h
index a265f6e44eab..c26de3059903 100644
--- a/include/linux/netfilter_ipv4/ipt_string.h
+++ b/include/linux/netfilter_ipv4/ipt_string.h
@@ -1,18 +1,10 @@
 #ifndef _IPT_STRING_H
 #define _IPT_STRING_H
-#define IPT_STRING_MAX_PATTERN_SIZE 128
+#include <linux/netfilter/xt_string.h>
-#define IPT_STRING_MAX_ALGO_NAME_SIZE 16
-struct ipt_string_info
+#define IPT_STRING_MAX_PATTERN_SIZE XT_STRING_MAX_PATTERN_SIZE
-{
+#define IPT_STRING_MAX_ALGO_NAME_SIZE XT_STRING_MAX_ALGO_NAME_SIZE
-        u_int16_t from_offset;
+#define ipt_string_info xt_string_info
-        u_int16_t to_offset;
-        char      algo[IPT_STRING_MAX_ALGO_NAME_SIZE];
-        char      pattern[IPT_STRING_MAX_PATTERN_SIZE];
-        u_int8_t  patlen;
-        u_int8_t  invert;
-        struct ts_config __attribute__((aligned(8))) *config;
-};
 #endif /*_IPT_STRING_H*/
diff --git a/include/linux/netfilter_ipv4/ipt_tcpmss.h b/include/linux/netfilter_ipv4/ipt_tcpmss.h
index e2b14397f701..18bbc8e8e009 100644
--- a/include/linux/netfilter_ipv4/ipt_tcpmss.h
+++ b/include/linux/netfilter_ipv4/ipt_tcpmss.h
@@ -1,9 +1,7 @@
 #ifndef _IPT_TCPMSS_MATCH_H
 #define _IPT_TCPMSS_MATCH_H
-struct ipt_tcpmss_match_info {
+#include <linux/netfilter/xt_tcpmss.h>
-    u_int16_t mss_min, mss_max;
+#define ipt_tcpmss_match_info xt_tcpmss_match_info
-    u_int8_t invert;
-};
 #endif /*_IPT_TCPMSS_MATCH_H*/
diff --git a/include/linux/netfilter_ipv6/ip6_tables.h b/include/linux/netfilter_ipv6/ip6_tables.h
index c163ba31aab7..f249b574f0fa 100644
--- a/include/linux/netfilter_ipv6/ip6_tables.h
+++ b/include/linux/netfilter_ipv6/ip6_tables.h
@@ -25,8 +25,15 @@
 #include <linux/compiler.h>
 #include <linux/netfilter_ipv6.h>
-#define IP6T_FUNCTION_MAXNAMELEN 30
+#include <linux/netfilter/x_tables.h>
-#define IP6T_TABLE_MAXNAMELEN 32
+#define IP6T_FUNCTION_MAXNAMELEN XT_FUNCTION_MAXNAMELEN
+#define IP6T_TABLE_MAXNAMELEN XT_TABLE_MAXNAMELEN
+#define ip6t_match xt_match
+#define ip6t_target xt_target
+#define ip6t_table xt_table
+#define ip6t_get_revision xt_get_revision
 /* Yes, Virginia, you have to zero the padding. */
 struct ip6t_ip6 {
@@ -104,10 +111,7 @@ struct ip6t_standard_target
        int verdict;
 };
-struct ip6t_counters
+#define ip6t_counters   xt_counters
-{
-        u_int64_t pcnt, bcnt;                   /* Packet and byte counters */
-};
 /* Values for "flag" field in struct ip6t_ip6 (general ip6 structure). */
 #define IP6T_F_PROTO            0x01    /* Set if rule cares about upper 
@@ -123,7 +127,7 @@ struct ip6t_counters
 #define IP6T_INV_SRCIP          0x08    /* Invert the sense of SRC IP. */
 #define IP6T_INV_DSTIP          0x10    /* Invert the sense of DST OP. */
 #define IP6T_INV_FRAG           0x20    /* Invert the sense of FRAG. */
-#define IP6T_INV_PROTO          0x40    /* Invert the sense of PROTO. */
+#define IP6T_INV_PROTO          XT_INV_PROTO
 #define IP6T_INV_MASK           0x7F    /* All possible flag bits mask. */
 /* This structure defines each of the firewall rules.  Consists of 3
@@ -145,7 +149,7 @@ struct ip6t_entry
        unsigned int comefrom;
        /* Packet and byte counters. */
-        struct ip6t_counters counters;
+        struct xt_counters counters;
        /* The matches (if any), then the target. */
        unsigned char elems[0];
@@ -155,54 +159,41 @@ struct ip6t_entry
 * New IP firewall options for [gs]etsockopt at the RAW IP level.
 * Unlike BSD Linux inherits IP options so you don't have to use
 * a raw socket for this. Instead we check rights in the calls. */
-#define IP6T_BASE_CTL                   64      /* base for firewall socket options */
+#define IP6T_BASE_CTL                   XT_BASE_CTL
-#define IP6T_SO_SET_REPLACE             (IP6T_BASE_CTL)
+#define IP6T_SO_SET_REPLACE             XT_SO_SET_REPLACE
-#define IP6T_SO_SET_ADD_COUNTERS        (IP6T_BASE_CTL + 1)
+#define IP6T_SO_SET_ADD_COUNTERS        XT_SO_SET_ADD_COUNTERS
-#define IP6T_SO_SET_MAX                 IP6T_SO_SET_ADD_COUNTERS
+#define IP6T_SO_SET_MAX                 XT_SO_SET_MAX
-#define IP6T_SO_GET_INFO                (IP6T_BASE_CTL)
+#define IP6T_SO_GET_INFO                XT_SO_GET_INFO
-#define IP6T_SO_GET_ENTRIES             (IP6T_BASE_CTL + 1)
+#define IP6T_SO_GET_ENTRIES             XT_SO_GET_ENTRIES
-#define IP6T_SO_GET_REVISION_MATCH      (IP6T_BASE_CTL + 2)
+#define IP6T_SO_GET_REVISION_MATCH      XT_SO_GET_REVISION_MATCH
-#define IP6T_SO_GET_REVISION_TARGET     (IP6T_BASE_CTL + 3)
+#define IP6T_SO_GET_REVISION_TARGET     XT_SO_GET_REVISION_TARGET
-#define IP6T_SO_GET_MAX                 IP6T_SO_GET_REVISION_TARGET
+#define IP6T_SO_GET_MAX                 XT_SO_GET_REVISION_TARGET
 /* CONTINUE verdict for targets */
-#define IP6T_CONTINUE 0xFFFFFFFF
+#define IP6T_CONTINUE XT_CONTINUE
 /* For standard target */
-#define IP6T_RETURN (-NF_REPEAT - 1)
+#define IP6T_RETURN XT_RETURN
-/* TCP matching stuff */
+/* TCP/UDP matching stuff */
-struct ip6t_tcp
+#include <linux/netfilter/xt_tcpudp.h>
-{
-        u_int16_t spts[2];                      /* Source port range. */
+#define ip6t_tcp xt_tcp
-        u_int16_t dpts[2];                      /* Destination port range. */
+#define ip6t_udp xt_udp
-        u_int8_t option;                        /* TCP Option iff non-zero*/
-        u_int8_t flg_mask;                      /* TCP flags mask byte */
-        u_int8_t flg_cmp;                       /* TCP flags compare byte */
-        u_int8_t invflags;                      /* Inverse flags */
-};
 /* Values for "inv" field in struct ipt_tcp. */
-#define IP6T_TCP_INV_SRCPT      0x01    /* Invert the sense of source ports. */
+#define IP6T_TCP_INV_SRCPT      XT_TCP_INV_SRCPT
-#define IP6T_TCP_INV_DSTPT      0x02    /* Invert the sense of dest ports. */
+#define IP6T_TCP_INV_DSTPT      XT_TCP_INV_DSTPT
-#define IP6T_TCP_INV_FLAGS      0x04    /* Invert the sense of TCP flags. */
+#define IP6T_TCP_INV_FLAGS      XT_TCP_INV_FLAGS
-#define IP6T_TCP_INV_OPTION     0x08    /* Invert the sense of option test. */
+#define IP6T_TCP_INV_OPTION     XT_TCP_INV_OPTION
-#define IP6T_TCP_INV_MASK       0x0F    /* All possible flags. */
+#define IP6T_TCP_INV_MASK       XT_TCP_INV_MASK
-/* UDP matching stuff */
-struct ip6t_udp
-{
-        u_int16_t spts[2];                      /* Source port range. */
-        u_int16_t dpts[2];                      /* Destination port range. */
-        u_int8_t invflags;                      /* Inverse flags */
-};
 /* Values for "invflags" field in struct ipt_udp. */
-#define IP6T_UDP_INV_SRCPT      0x01    /* Invert the sense of source ports. */
+#define IP6T_UDP_INV_SRCPT      XT_UDP_INV_SRCPT
-#define IP6T_UDP_INV_DSTPT      0x02    /* Invert the sense of dest ports. */
+#define IP6T_UDP_INV_DSTPT      XT_UDP_INV_DSTPT
-#define IP6T_UDP_INV_MASK       0x03    /* All possible flags. */
+#define IP6T_UDP_INV_MASK       XT_UDP_INV_MASK
 /* ICMP matching stuff */
 struct ip6t_icmp
@@ -264,23 +255,14 @@ struct ip6t_replace
        /* Number of counters (must be equal to current number of entries). */
        unsigned int num_counters;
        /* The old entries' counters. */
-        struct ip6t_counters __user *counters;
+        struct xt_counters __user *counters;
        /* The entries (hang off end: not really an array). */
        struct ip6t_entry entries[0];
 };
 /* The argument to IP6T_SO_ADD_COUNTERS. */
-struct ip6t_counters_info
+#define ip6t_counters_info xt_counters_info
-{
-        /* Which table. */
-        char name[IP6T_TABLE_MAXNAMELEN];
-        unsigned int num_counters;
-        /* The counters (actually `number' of these). */
-        struct ip6t_counters counters[0];
-};
 /* The argument to IP6T_SO_GET_ENTRIES. */
 struct ip6t_get_entries
@@ -295,19 +277,10 @@ struct ip6t_get_entries
        struct ip6t_entry entrytable[0];
 };
-/* The argument to IP6T_SO_GET_REVISION_*.  Returns highest revision
- * kernel supports, if >= revision. */
-struct ip6t_get_revision
-{
-        char name[IP6T_FUNCTION_MAXNAMELEN-1];
-        u_int8_t revision;
-};
 /* Standard return verdict, or do jump. */
-#define IP6T_STANDARD_TARGET ""
+#define IP6T_STANDARD_TARGET XT_STANDARD_TARGET
 /* Error verdict. */
-#define IP6T_ERROR_TARGET "ERROR"
+#define IP6T_ERROR_TARGET XT_ERROR_TARGET
 /* Helper functions */
 static __inline__ struct ip6t_entry_target *
@@ -361,104 +334,11 @@ ip6t_get_target(struct ip6t_entry *e)
 #include <linux/init.h>
 extern void ip6t_init(void) __init;
-struct ip6t_match
+#define ip6t_register_target(tgt) xt_register_target(AF_INET6, tgt)
-{
+#define ip6t_unregister_target(tgt) xt_unregister_target(AF_INET6, tgt)
-        struct list_head list;
-        const char name[IP6T_FUNCTION_MAXNAMELEN-1];
-        u_int8_t revision;
-        /* Return true or false: return FALSE and set *hotdrop = 1 to
-           force immediate packet drop. */
-        /* Arguments changed since 2.6.9, as this must now handle
-           non-linear skb, using skb_header_pointer and
-           skb_ip_make_writable. */
-        int (*match)(const struct sk_buff *skb,
-                     const struct net_device *in,
-                     const struct net_device *out,
-                     const void *matchinfo,
-                     int offset,
-                     unsigned int protoff,
-                     int *hotdrop);
-        /* Called when user tries to insert an entry of this type. */
-        /* Should return true or false. */
-        int (*checkentry)(const char *tablename,
-                          const struct ip6t_ip6 *ip,
-                          void *matchinfo,
-                          unsigned int matchinfosize,
-                          unsigned int hook_mask);
-        /* Called when entry of this type deleted. */
-        void (*destroy)(void *matchinfo, unsigned int matchinfosize);
-        /* Set this to THIS_MODULE if you are a module, otherwise NULL */
-        struct module *me;
-};
-/* Registration hooks for targets. */
-struct ip6t_target
-{
-        struct list_head list;
-        const char name[IP6T_FUNCTION_MAXNAMELEN-1];
-        u_int8_t revision;
-        /* Returns verdict. Argument order changed since 2.6.9, as this
-           must now handle non-linear skbs, using skb_copy_bits and
-           skb_ip_make_writable. */
-        unsigned int (*target)(struct sk_buff **pskb,
-                               const struct net_device *in,
-                               const struct net_device *out,
-                               unsigned int hooknum,
-                               const void *targinfo,
-                               void *userdata);
-        /* Called when user tries to insert an entry of this type:
-           hook_mask is a bitmask of hooks from which it can be
-           called. */
-        /* Should return true or false. */
-        int (*checkentry)(const char *tablename,
-                          const struct ip6t_entry *e,
-                          void *targinfo,
-                          unsigned int targinfosize,
-                          unsigned int hook_mask);
-        /* Called when entry of this type deleted. */
-        void (*destroy)(void *targinfo, unsigned int targinfosize);
-        /* Set this to THIS_MODULE if you are a module, otherwise NULL */
-        struct module *me;
-};
-extern int ip6t_register_target(struct ip6t_target *target);
-extern void ip6t_unregister_target(struct ip6t_target *target);
-extern int ip6t_register_match(struct ip6t_match *match);
-extern void ip6t_unregister_match(struct ip6t_match *match);
-/* Furniture shopping... */
+#define ip6t_register_match(match) xt_register_match(AF_INET6, match)
-struct ip6t_table
+#define ip6t_unregister_match(match) xt_unregister_match(AF_INET6, match)
-{
-        struct list_head list;
-        /* A unique name... */
-        char name[IP6T_TABLE_MAXNAMELEN];
-        /* What hooks you will enter on */
-        unsigned int valid_hooks;
-        /* Lock for the curtain */
-        rwlock_t lock;
-        /* Man behind the curtain... */
-        struct ip6t_table_info *private;
-        /* Set this to THIS_MODULE if you are a module, otherwise NULL */
-        struct module *me;
-};
 extern int ip6t_register_table(struct ip6t_table *table,
                               const struct ip6t_replace *repl);
diff --git a/include/linux/netfilter_ipv6/ip6t_MARK.h b/include/linux/netfilter_ipv6/ip6t_MARK.h
index 7ade8d8f5246..7cf629a8ab92 100644
--- a/include/linux/netfilter_ipv6/ip6t_MARK.h
+++ b/include/linux/netfilter_ipv6/ip6t_MARK.h
@@ -1,8 +1,9 @@
 #ifndef _IP6T_MARK_H_target
 #define _IP6T_MARK_H_target
-struct ip6t_mark_target_info {
+/* Backwards compatibility for old userspace */
-        unsigned long mark;
+#include <linux/netfilter/xt_MARK.h>
-};
-#endif /*_IPT_MARK_H_target*/
+#define ip6t_mark_target_info xt_mark_target_info
+#endif /*_IP6T_MARK_H_target*/
diff --git a/include/linux/netfilter_ipv6/ip6t_length.h b/include/linux/netfilter_ipv6/ip6t_length.h
index 7fc09f9f9d63..9e9689d03ed7 100644
--- a/include/linux/netfilter_ipv6/ip6t_length.h
+++ b/include/linux/netfilter_ipv6/ip6t_length.h
@@ -1,10 +1,8 @@
 #ifndef _IP6T_LENGTH_H
 #define _IP6T_LENGTH_H
-struct ip6t_length_info {
+#include <linux/netfilter/xt_length.h>
-        u_int16_t  min, max;
+#define ip6t_length_info xt_length_info
-        u_int8_t   invert;
-};
 #endif /*_IP6T_LENGTH_H*/
        
diff --git a/include/linux/netfilter_ipv6/ip6t_limit.h b/include/linux/netfilter_ipv6/ip6t_limit.h
index f2866e50f3b4..487e5ea342c6 100644
--- a/include/linux/netfilter_ipv6/ip6t_limit.h
+++ b/include/linux/netfilter_ipv6/ip6t_limit.h
@@ -1,21 +1,8 @@
 #ifndef _IP6T_RATE_H
 #define _IP6T_RATE_H
-/* timings are in milliseconds. */
+#include <linux/netfilter/xt_limit.h>
-#define IP6T_LIMIT_SCALE 10000
+#define IP6T_LIMIT_SCALE XT_LIMIT_SCALE
+#define ip6t_rateinfo xt_rateinfo
-/* 1/10,000 sec period => max of 10,000/sec.  Min rate is then 429490
+#endif /*_IP6T_RATE_H*/
-   seconds, or one every 59 hours. */
-struct ip6t_rateinfo {
-        u_int32_t avg;    /* Average secs between packets * scale */
-        u_int32_t burst;  /* Period multiplier for upper limit. */
-        /* Used internally by the kernel */
-        unsigned long prev;
-        u_int32_t credit;
-        u_int32_t credit_cap, cost;
-        /* Ugly, ugly fucker. */
-        struct ip6t_rateinfo *master;
-};
-#endif /*_IPT_RATE_H*/
diff --git a/include/linux/netfilter_ipv6/ip6t_mac.h b/include/linux/netfilter_ipv6/ip6t_mac.h
index 87c088c21848..ac58e83e9423 100644
--- a/include/linux/netfilter_ipv6/ip6t_mac.h
+++ b/include/linux/netfilter_ipv6/ip6t_mac.h
@@ -1,8 +1,7 @@
 #ifndef _IP6T_MAC_H
 #define _IP6T_MAC_H
-struct ip6t_mac_info {
+#include <linux/netfilter/xt_mac.h>
-    unsigned char srcaddr[ETH_ALEN];
+#define ip6t_mac_info xt_mac_info
-    int invert;
-};
+#endif /*_IP6T_MAC_H*/
-#endif /*_IPT_MAC_H*/
diff --git a/include/linux/netfilter_ipv6/ip6t_mark.h b/include/linux/netfilter_ipv6/ip6t_mark.h
index a734441e1c19..ff204951ddc3 100644
--- a/include/linux/netfilter_ipv6/ip6t_mark.h
+++ b/include/linux/netfilter_ipv6/ip6t_mark.h
@@ -1,9 +1,9 @@
 #ifndef _IP6T_MARK_H
 #define _IP6T_MARK_H
-struct ip6t_mark_info {
+/* Backwards compatibility for old userspace */
-    unsigned long mark, mask;
+#include <linux/netfilter/xt_mark.h>
-    u_int8_t invert;
-};
+#define ip6t_mark_info xt_mark_info
 #endif /*_IPT_MARK_H*/
diff --git a/include/linux/netfilter_ipv6/ip6t_physdev.h b/include/linux/netfilter_ipv6/ip6t_physdev.h
index c234731cd66b..c161c0a81b55 100644
--- a/include/linux/netfilter_ipv6/ip6t_physdev.h
+++ b/include/linux/netfilter_ipv6/ip6t_physdev.h
@@ -1,24 +1,17 @@
 #ifndef _IP6T_PHYSDEV_H
 #define _IP6T_PHYSDEV_H
-#ifdef __KERNEL__
+/* Backwards compatibility for old userspace */
-#include <linux/if.h>
-#endif
-#define IP6T_PHYSDEV_OP_IN              0x01
+#include <linux/netfilter/xt_physdev.h>
-#define IP6T_PHYSDEV_OP_OUT             0x02
-#define IP6T_PHYSDEV_OP_BRIDGED         0x04
-#define IP6T_PHYSDEV_OP_ISIN            0x08
-#define IP6T_PHYSDEV_OP_ISOUT           0x10
-#define IP6T_PHYSDEV_OP_MASK            (0x20 - 1)
-struct ip6t_physdev_info {
+#define IP6T_PHYSDEV_OP_IN              XT_PHYSDEV_OP_IN
-        char physindev[IFNAMSIZ];
+#define IP6T_PHYSDEV_OP_OUT             XT_PHYSDEV_OP_OUT
-        char in_mask[IFNAMSIZ];
+#define IP6T_PHYSDEV_OP_BRIDGED         XT_PHYSDEV_OP_BRIDGED
-        char physoutdev[IFNAMSIZ];
+#define IP6T_PHYSDEV_OP_ISIN            XT_PHYSDEV_OP_ISIN
-        char out_mask[IFNAMSIZ];
+#define IP6T_PHYSDEV_OP_ISOUT           XT_PHYSDEV_OP_ISOUT
-        u_int8_t invert;
+#define IP6T_PHYSDEV_OP_MASK            XT_PHYSDEV_OP_MASK
-        u_int8_t bitmask;
-};
+#define ip6t_physdev_info xt_physdev_info
 #endif /*_IP6T_PHYSDEV_H*/
diff --git a/include/linux/pci_ids.h b/include/linux/pci_ids.h
index 7fb397e3f2d3..5403257ae3e7 100644
--- a/include/linux/pci_ids.h
+++ b/include/linux/pci_ids.h
@@ -181,6 +181,7 @@
 #define PCI_DEVICE_ID_LSI_FC929X        0x0626
 #define PCI_DEVICE_ID_LSI_FC939X        0x0642
 #define PCI_DEVICE_ID_LSI_FC949X        0x0640
+#define PCI_DEVICE_ID_LSI_FC949ES       0x0646
 #define PCI_DEVICE_ID_LSI_FC919X        0x0628
 #define PCI_DEVICE_ID_NCR_YELLOWFIN     0x0701
 #define PCI_DEVICE_ID_LSI_61C102        0x0901
diff --git a/include/linux/proc_fs.h b/include/linux/proc_fs.h
index 74488e49166d..aa6322d45198 100644
--- a/include/linux/proc_fs.h
+++ b/include/linux/proc_fs.h
@@ -146,6 +146,11 @@ struct property;
 extern void proc_device_tree_init(void);
 extern void proc_device_tree_add_node(struct device_node *, struct proc_dir_entry *);
 extern void proc_device_tree_add_prop(struct proc_dir_entry *pde, struct property *prop);
+extern void proc_device_tree_remove_prop(struct proc_dir_entry *pde,
+                                         struct property *prop);
+extern void proc_device_tree_update_prop(struct proc_dir_entry *pde,
+                                         struct property *newprop,
+                                         struct property *oldprop);
 #endif /* CONFIG_PROC_DEVICETREE */
 extern struct proc_dir_entry *proc_symlink(const char *,
diff --git a/include/linux/raid_class.h b/include/linux/raid_class.h
index 48831eac2910..d0dd38b3a2fd 100644
--- a/include/linux/raid_class.h
+++ b/include/linux/raid_class.h
@@ -31,9 +31,11 @@ enum raid_level {
        RAID_LEVEL_LINEAR,
        RAID_LEVEL_0,
        RAID_LEVEL_1,
+        RAID_LEVEL_10,
        RAID_LEVEL_3,
        RAID_LEVEL_4,
        RAID_LEVEL_5,
+        RAID_LEVEL_50,
        RAID_LEVEL_6,
 };
diff --git a/include/linux/sched.h b/include/linux/sched.h
index a72e17135421..2df1a1a2fee5 100644
--- a/include/linux/sched.h
+++ b/include/linux/sched.h
@@ -160,6 +160,7 @@ extern unsigned long nr_iowait(void);
 #define SCHED_NORMAL            0
 #define SCHED_FIFO              1
 #define SCHED_RR                2
+#define SCHED_BATCH             3
 struct sched_param {
        int sched_priority;
@@ -470,9 +471,9 @@ struct signal_struct {
 /*
 * Priority of a process goes from 0..MAX_PRIO-1, valid RT
- * priority is 0..MAX_RT_PRIO-1, and SCHED_NORMAL tasks are
+ * priority is 0..MAX_RT_PRIO-1, and SCHED_NORMAL/SCHED_BATCH
- * in the range MAX_RT_PRIO..MAX_PRIO-1. Priority values
+ * tasks are in the range MAX_RT_PRIO..MAX_PRIO-1. Priority
- * are inverted: lower p->prio value means higher priority.
+ * values are inverted: lower p->prio value means higher priority.
 *
 * The MAX_USER_RT_PRIO value allows the actual maximum
 * RT priority to be separate from the value exported to
diff --git a/include/linux/serial_core.h b/include/linux/serial_core.h
index a8187c3c8a7b..ec351005bf9d 100644
--- a/include/linux/serial_core.h
+++ b/include/linux/serial_core.h
@@ -136,6 +136,7 @@
 #include <linux/spinlock.h>
 #include <linux/sched.h>
 #include <linux/tty.h>
+#include <linux/mutex.h>
 struct uart_port;
 struct uart_info;
@@ -284,7 +285,7 @@ struct uart_state {
        struct uart_info        *info;
        struct uart_port        *port;
-        struct semaphore        sem;
+        struct mutex            mutex;
 };
 #define UART_XMIT_SIZE  PAGE_SIZE
diff --git a/include/linux/shmem_fs.h b/include/linux/shmem_fs.h
index c3e598276e78..c057f0b32318 100644
--- a/include/linux/shmem_fs.h
+++ b/include/linux/shmem_fs.h
@@ -26,6 +26,8 @@ struct shmem_sb_info {
        unsigned long free_blocks;  /* How many are left for allocation */
        unsigned long max_inodes;   /* How many inodes are allowed */
        unsigned long free_inodes;  /* How many are left for allocation */
+        int policy;                 /* Default NUMA memory alloc policy */
+        nodemask_t policy_nodes;    /* nodemask for preferred and bind */
        spinlock_t    stat_lock;
 };
diff --git a/include/linux/smb_fs.h b/include/linux/smb_fs.h
index c4153120ade6..621a3d3662f3 100644
--- a/include/linux/smb_fs.h
+++ b/include/linux/smb_fs.h
@@ -58,53 +58,6 @@ static inline struct smb_inode_info *SMB_I(struct inode *inode)
 /* where to find the base of the SMB packet proper */
 #define smb_base(buf) ((u8 *)(((u8 *)(buf))+4))
-#ifdef DEBUG_SMB_MALLOC
-#include <linux/slab.h>
-extern int smb_malloced;
-extern int smb_current_vmalloced;
-extern int smb_current_kmalloced;
-static inline void *
-smb_vmalloc(unsigned int size)
-{
-        smb_malloced += 1;
-        smb_current_vmalloced += 1;
-        return vmalloc(size);
-}
-static inline void
-smb_vfree(void *obj)
-{
-        smb_current_vmalloced -= 1;
-        vfree(obj);
-}
-static inline void *
-smb_kmalloc(size_t size, int flags)
-{
-        smb_malloced += 1;
-        smb_current_kmalloced += 1;
-        return kmalloc(size, flags);
-}
-static inline void
-smb_kfree(void *obj)
-{
-        smb_current_kmalloced -= 1;
-        kfree(obj);
-}
-#else /* DEBUG_SMB_MALLOC */
-#define smb_kmalloc(s,p)        kmalloc(s,p)
-#define smb_kfree(o)            kfree(o)
-#define smb_vmalloc(s)          vmalloc(s)
-#define smb_vfree(o)            vfree(o)
-#endif /* DEBUG_SMB_MALLOC */
 /*
 * Flags for the in-memory inode
 */
diff --git a/include/linux/socket.h b/include/linux/socket.h
index 9f4019156fd8..b02dda4ee83d 100644
--- a/include/linux/socket.h
+++ b/include/linux/socket.h
@@ -186,6 +186,7 @@ struct ucred {
 #define AF_PPPOX        24      /* PPPoX sockets                */
 #define AF_WANPIPE      25      /* Wanpipe API Sockets */
 #define AF_LLC          26      /* Linux LLC                    */
+#define AF_TIPC         30      /* TIPC sockets                 */
 #define AF_BLUETOOTH    31      /* Bluetooth sockets            */
 #define AF_MAX          32      /* For now.. */
@@ -218,6 +219,7 @@ struct ucred {
 #define PF_PPPOX        AF_PPPOX
 #define PF_WANPIPE      AF_WANPIPE
 #define PF_LLC          AF_LLC
+#define PF_TIPC         AF_TIPC
 #define PF_BLUETOOTH    AF_BLUETOOTH
 #define PF_MAX          AF_MAX
@@ -279,6 +281,7 @@ struct ucred {
 #define SOL_LLC         268
 #define SOL_DCCP        269
 #define SOL_NETLINK     270
+#define SOL_TIPC        271
 /* IPX options */
 #define IPX_TYPE        1
diff --git a/include/linux/spi/ads7846.h b/include/linux/spi/ads7846.h
new file mode 100644
index 000000000000..72261e0f2ac1
--- /dev/null
+++ b/include/linux/spi/ads7846.h
@@ -0,0 +1,18 @@
+/* linux/spi/ads7846.h */
+/* Touchscreen characteristics vary between boards and models.  The
+ * platform_data for the device's "struct device" holds this information.
+ *
+ * It's OK if the min/max values are zero.
+ */
+struct ads7846_platform_data {
+        u16     model;                  /* 7843, 7845, 7846. */
+        u16     vref_delay_usecs;       /* 0 for external vref; etc */
+        u16     x_plate_ohms;
+        u16     y_plate_ohms;
+        u16     x_min, x_max;
+        u16     y_min, y_max;
+        u16     pressure_min, pressure_max;
+};
diff --git a/include/linux/spi/flash.h b/include/linux/spi/flash.h
new file mode 100644
index 000000000000..3f22932e67a4
--- /dev/null
+++ b/include/linux/spi/flash.h
@@ -0,0 +1,31 @@
+#ifndef LINUX_SPI_FLASH_H
+#define LINUX_SPI_FLASH_H
+struct mtd_partition;
+/**
+ * struct flash_platform_data: board-specific flash data
+ * @name: optional flash device name (eg, as used with mtdparts=)
+ * @parts: optional array of mtd_partitions for static partitioning
+ * @nr_parts: number of mtd_partitions for static partitoning
+ * @type: optional flash device type (e.g. m25p80 vs m25p64), for use
+ *      with chips that can't be queried for JEDEC or other IDs
+ *
+ * Board init code (in arch/.../mach-xxx/board-yyy.c files) can
+ * provide information about SPI flash parts (such as DataFlash) to
+ * help set up the device and its appropriate default partitioning.
+ *
+ * Note that for DataFlash, sizes for pages, blocks, and sectors are
+ * rarely powers of two; and partitions should be sector-aligned.
+ */
+struct flash_platform_data {
+        char            *name;
+        struct mtd_partition *parts;
+        unsigned int    nr_parts;
+        char            *type;
+        /* we'll likely add more ... use JEDEC IDs, etc */
+};
+#endif
diff --git a/include/linux/spi/spi.h b/include/linux/spi/spi.h
new file mode 100644
index 000000000000..b05f1463a267
--- /dev/null
+++ b/include/linux/spi/spi.h
@@ -0,0 +1,668 @@
+/*
+ * Copyright (C) 2005 David Brownell
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; either version 2 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
+ */
+#ifndef __LINUX_SPI_H
+#define __LINUX_SPI_H
+/*
+ * INTERFACES between SPI master-side drivers and SPI infrastructure.
+ * (There's no SPI slave support for Linux yet...)
+ */
+extern struct bus_type spi_bus_type;
+/**
+ * struct spi_device - Master side proxy for an SPI slave device
+ * @dev: Driver model representation of the device.
+ * @master: SPI controller used with the device.
+ * @max_speed_hz: Maximum clock rate to be used with this chip
+ *      (on this board); may be changed by the device's driver.
+ * @chip-select: Chipselect, distinguishing chips handled by "master".
+ * @mode: The spi mode defines how data is clocked out and in.
+ *      This may be changed by the device's driver.
+ * @bits_per_word: Data transfers involve one or more words; word sizes
+ *      like eight or 12 bits are common.  In-memory wordsizes are
+ *      powers of two bytes (e.g. 20 bit samples use 32 bits).
+ *      This may be changed by the device's driver.
+ * @irq: Negative, or the number passed to request_irq() to receive
+ *      interrupts from this device.
+ * @controller_state: Controller's runtime state
+ * @controller_data: Board-specific definitions for controller, such as
+ *      FIFO initialization parameters; from board_info.controller_data
+ *
+ * An spi_device is used to interchange data between an SPI slave
+ * (usually a discrete chip) and CPU memory.
+ *
+ * In "dev", the platform_data is used to hold information about this
+ * device that's meaningful to the device's protocol driver, but not
+ * to its controller.  One example might be an identifier for a chip
+ * variant with slightly different functionality.
+ */
+struct spi_device {
+        struct device           dev;
+        struct spi_master       *master;
+        u32                     max_speed_hz;
+        u8                      chip_select;
+        u8                      mode;
+#define SPI_CPHA        0x01                    /* clock phase */
+#define SPI_CPOL        0x02                    /* clock polarity */
+#define SPI_MODE_0      (0|0)                   /* (original MicroWire) */
+#define SPI_MODE_1      (0|SPI_CPHA)
+#define SPI_MODE_2      (SPI_CPOL|0)
+#define SPI_MODE_3      (SPI_CPOL|SPI_CPHA)
+#define SPI_CS_HIGH     0x04                    /* chipselect active high? */
+        u8                      bits_per_word;
+        int                     irq;
+        void                    *controller_state;
+        void                    *controller_data;
+        const char              *modalias;
+        // likely need more hooks for more protocol options affecting how
+        // the controller talks to each chip, like:
+        //  - bit order (default is wordwise msb-first)
+        //  - memory packing (12 bit samples into low bits, others zeroed)
+        //  - priority
+        //  - drop chipselect after each word
+        //  - chipselect delays
+        //  - ...
+};
+static inline struct spi_device *to_spi_device(struct device *dev)
+{
+        return dev ? container_of(dev, struct spi_device, dev) : NULL;
+}
+/* most drivers won't need to care about device refcounting */
+static inline struct spi_device *spi_dev_get(struct spi_device *spi)
+{
+        return (spi && get_device(&spi->dev)) ? spi : NULL;
+}
+static inline void spi_dev_put(struct spi_device *spi)
+{
+        if (spi)
+                put_device(&spi->dev);
+}
+/* ctldata is for the bus_master driver's runtime state */
+static inline void *spi_get_ctldata(struct spi_device *spi)
+{
+        return spi->controller_state;
+}
+static inline void spi_set_ctldata(struct spi_device *spi, void *state)
+{
+        spi->controller_state = state;
+}
+struct spi_message;
+struct spi_driver {
+        int                     (*probe)(struct spi_device *spi);
+        int                     (*remove)(struct spi_device *spi);
+        void                    (*shutdown)(struct spi_device *spi);
+        int                     (*suspend)(struct spi_device *spi, pm_message_t mesg);
+        int                     (*resume)(struct spi_device *spi);
+        struct device_driver    driver;
+};
+static inline struct spi_driver *to_spi_driver(struct device_driver *drv)
+{
+        return drv ? container_of(drv, struct spi_driver, driver) : NULL;
+}
+extern int spi_register_driver(struct spi_driver *sdrv);
+static inline void spi_unregister_driver(struct spi_driver *sdrv)
+{
+        if (!sdrv)
+                return;
+        driver_unregister(&sdrv->driver);
+}
+/**
+ * struct spi_master - interface to SPI master controller
+ * @cdev: class interface to this driver
+ * @bus_num: board-specific (and often SOC-specific) identifier for a
+ *      given SPI controller.
+ * @num_chipselect: chipselects are used to distinguish individual
+ *      SPI slaves, and are numbered from zero to num_chipselects.
+ *      each slave has a chipselect signal, but it's common that not
+ *      every chipselect is connected to a slave.
+ * @setup: updates the device mode and clocking records used by a
+ *      device's SPI controller; protocol code may call this.
+ * @transfer: adds a message to the controller's transfer queue.
+ * @cleanup: frees controller-specific state
+ *
+ * Each SPI master controller can communicate with one or more spi_device
+ * children.  These make a small bus, sharing MOSI, MISO and SCK signals
+ * but not chip select signals.  Each device may be configured to use a
+ * different clock rate, since those shared signals are ignored unless
+ * the chip is selected.
+ *
+ * The driver for an SPI controller manages access to those devices through
+ * a queue of spi_message transactions, copyin data between CPU memory and
+ * an SPI slave device).  For each such message it queues, it calls the
+ * message's completion function when the transaction completes.
+ */
+struct spi_master {
+        struct class_device     cdev;
+        /* other than zero (== assign one dynamically), bus_num is fully
+         * board-specific.  usually that simplifies to being SOC-specific.
+         * example:  one SOC has three SPI controllers, numbered 1..3,
+         * and one board's schematics might show it using SPI-2.  software
+         * would normally use bus_num=2 for that controller.
+         */
+        u16                     bus_num;
+        /* chipselects will be integral to many controllers; some others
+         * might use board-specific GPIOs.
+         */
+        u16                     num_chipselect;
+        /* setup mode and clock, etc (spi driver may call many times) */
+        int                     (*setup)(struct spi_device *spi);
+        /* bidirectional bulk transfers
+         *
+         * + The transfer() method may not sleep; its main role is
+         *   just to add the message to the queue.
+         * + For now there's no remove-from-queue operation, or
+         *   any other request management
+         * + To a given spi_device, message queueing is pure fifo
+         *
+         * + The master's main job is to process its message queue,
+         *   selecting a chip then transferring data
+         * + If there are multiple spi_device children, the i/o queue
+         *   arbitration algorithm is unspecified (round robin, fifo,
+         *   priority, reservations, preemption, etc)
+         *
+         * + Chipselect stays active during the entire message
+         *   (unless modified by spi_transfer.cs_change != 0).
+         * + The message transfers use clock and SPI mode parameters
+         *   previously established by setup() for this device
+         */
+        int                     (*transfer)(struct spi_device *spi,
+                                                struct spi_message *mesg);
+        /* called on release() to free memory provided by spi_master */
+        void                    (*cleanup)(const struct spi_device *spi);
+};
+static inline void *spi_master_get_devdata(struct spi_master *master)
+{
+        return class_get_devdata(&master->cdev);
+}
+static inline void spi_master_set_devdata(struct spi_master *master, void *data)
+{
+        class_set_devdata(&master->cdev, data);
+}
+static inline struct spi_master *spi_master_get(struct spi_master *master)
+{
+        if (!master || !class_device_get(&master->cdev))
+                return NULL;
+        return master;
+}
+static inline void spi_master_put(struct spi_master *master)
+{
+        if (master)
+                class_device_put(&master->cdev);
+}
+/* the spi driver core manages memory for the spi_master classdev */
+extern struct spi_master *
+spi_alloc_master(struct device *host, unsigned size);
+extern int spi_register_master(struct spi_master *master);
+extern void spi_unregister_master(struct spi_master *master);
+extern struct spi_master *spi_busnum_to_master(u16 busnum);
+/*---------------------------------------------------------------------------*/
+/*
+ * I/O INTERFACE between SPI controller and protocol drivers
+ *
+ * Protocol drivers use a queue of spi_messages, each transferring data
+ * between the controller and memory buffers.
+ *
+ * The spi_messages themselves consist of a series of read+write transfer
+ * segments.  Those segments always read the same number of bits as they
+ * write; but one or the other is easily ignored by passing a null buffer
+ * pointer.  (This is unlike most types of I/O API, because SPI hardware
+ * is full duplex.)
+ *
+ * NOTE:  Allocation of spi_transfer and spi_message memory is entirely
+ * up to the protocol driver, which guarantees the integrity of both (as
+ * well as the data buffers) for as long as the message is queued.
+ */
+/**
+ * struct spi_transfer - a read/write buffer pair
+ * @tx_buf: data to be written (dma-safe memory), or NULL
+ * @rx_buf: data to be read (dma-safe memory), or NULL
+ * @tx_dma: DMA address of tx_buf, if spi_message.is_dma_mapped
+ * @rx_dma: DMA address of rx_buf, if spi_message.is_dma_mapped
+ * @len: size of rx and tx buffers (in bytes)
+ * @cs_change: affects chipselect after this transfer completes
+ * @delay_usecs: microseconds to delay after this transfer before
+ *      (optionally) changing the chipselect status, then starting
+ *      the next transfer or completing this spi_message.
+ * @transfer_list: transfers are sequenced through spi_message.transfers
+ *
+ * SPI transfers always write the same number of bytes as they read.
+ * Protocol drivers should always provide rx_buf and/or tx_buf.
+ * In some cases, they may also want to provide DMA addresses for
+ * the data being transferred; that may reduce overhead, when the
+ * underlying driver uses dma.
+ *
+ * If the transmit buffer is null, undefined data will be shifted out
+ * while filling rx_buf.  If the receive buffer is null, the data
+ * shifted in will be discarded.  Only "len" bytes shift out (or in).
+ * It's an error to try to shift out a partial word.  (For example, by
+ * shifting out three bytes with word size of sixteen or twenty bits;
+ * the former uses two bytes per word, the latter uses four bytes.)
+ *
+ * All SPI transfers start with the relevant chipselect active.  Normally
+ * it stays selected until after the last transfer in a message.  Drivers
+ * can affect the chipselect signal using cs_change:
+ *
+ * (i) If the transfer isn't the last one in the message, this flag is
+ * used to make the chipselect briefly go inactive in the middle of the
+ * message.  Toggling chipselect in this way may be needed to terminate
+ * a chip command, letting a single spi_message perform all of group of
+ * chip transactions together.
+ *
+ * (ii) When the transfer is the last one in the message, the chip may
+ * stay selected until the next transfer.  This is purely a performance
+ * hint; the controller driver may need to select a different device
+ * for the next message.
+ *
+ * The code that submits an spi_message (and its spi_transfers)
+ * to the lower layers is responsible for managing its memory.
+ * Zero-initialize every field you don't set up explicitly, to
+ * insulate against future API updates.  After you submit a message
+ * and its transfers, ignore them until its completion callback.
+ */
+struct spi_transfer {
+        /* it's ok if tx_buf == rx_buf (right?)
+         * for MicroWire, one buffer must be null
+         * buffers must work with dma_*map_single() calls, unless
+         *   spi_message.is_dma_mapped reports a pre-existing mapping
+         */
+        const void      *tx_buf;
+        void            *rx_buf;
+        unsigned        len;
+        dma_addr_t      tx_dma;
+        dma_addr_t      rx_dma;
+        unsigned        cs_change:1;
+        u16             delay_usecs;
+        struct list_head transfer_list;
+};
+/**
+ * struct spi_message - one multi-segment SPI transaction
+ * @transfers: list of transfer segments in this transaction
+ * @spi: SPI device to which the transaction is queued
+ * @is_dma_mapped: if true, the caller provided both dma and cpu virtual
+ *      addresses for each transfer buffer
+ * @complete: called to report transaction completions
+ * @context: the argument to complete() when it's called
+ * @actual_length: the total number of bytes that were transferred in all
+ *      successful segments
+ * @status: zero for success, else negative errno
+ * @queue: for use by whichever driver currently owns the message
+ * @state: for use by whichever driver currently owns the message
+ *
+ * An spi_message is used to execute an atomic sequence of data transfers,
+ * each represented by a struct spi_transfer.  The sequence is "atomic"
+ * in the sense that no other spi_message may use that SPI bus until that
+ * sequence completes.  On some systems, many such sequences can execute as
+ * as single programmed DMA transfer.  On all systems, these messages are
+ * queued, and might complete after transactions to other devices.  Messages
+ * sent to a given spi_device are alway executed in FIFO order.
+ *
+ * The code that submits an spi_message (and its spi_transfers)
+ * to the lower layers is responsible for managing its memory.
+ * Zero-initialize every field you don't set up explicitly, to
+ * insulate against future API updates.  After you submit a message
+ * and its transfers, ignore them until its completion callback.
+ */
+struct spi_message {
+        struct list_head        transfers;
+        struct spi_device       *spi;
+        unsigned                is_dma_mapped:1;
+        /* REVISIT:  we might want a flag affecting the behavior of the
+         * last transfer ... allowing things like "read 16 bit length L"
+         * immediately followed by "read L bytes".  Basically imposing
+         * a specific message scheduling algorithm.
+         *
+         * Some controller drivers (message-at-a-time queue processing)
+         * could provide that as their default scheduling algorithm.  But
+         * others (with multi-message pipelines) could need a flag to
+         * tell them about such special cases.
+         */
+        /* completion is reported through a callback */
+        void                    (*complete)(void *context);
+        void                    *context;
+        unsigned                actual_length;
+        int                     status;
+        /* for optional use by whatever driver currently owns the
+         * spi_message ...  between calls to spi_async and then later
+         * complete(), that's the spi_master controller driver.
+         */
+        struct list_head        queue;
+        void                    *state;
+};
+static inline void spi_message_init(struct spi_message *m)
+{
+        memset(m, 0, sizeof *m);
+        INIT_LIST_HEAD(&m->transfers);
+}
+static inline void
+spi_message_add_tail(struct spi_transfer *t, struct spi_message *m)
+{
+        list_add_tail(&t->transfer_list, &m->transfers);
+}
+static inline void
+spi_transfer_del(struct spi_transfer *t)
+{
+        list_del(&t->transfer_list);
+}
+/* It's fine to embed message and transaction structures in other data
+ * structures so long as you don't free them while they're in use.
+ */
+static inline struct spi_message *spi_message_alloc(unsigned ntrans, gfp_t flags)
+{
+        struct spi_message *m;
+        m = kzalloc(sizeof(struct spi_message)
+                        + ntrans * sizeof(struct spi_transfer),
+                        flags);
+        if (m) {
+                int i;
+                struct spi_transfer *t = (struct spi_transfer *)(m + 1);
+                INIT_LIST_HEAD(&m->transfers);
+                for (i = 0; i < ntrans; i++, t++)
+                        spi_message_add_tail(t, m);
+        }
+        return m;
+}
+static inline void spi_message_free(struct spi_message *m)
+{
+        kfree(m);
+}
+/**
+ * spi_setup -- setup SPI mode and clock rate
+ * @spi: the device whose settings are being modified
+ *
+ * SPI protocol drivers may need to update the transfer mode if the
+ * device doesn't work with the mode 0 default.  They may likewise need
+ * to update clock rates or word sizes from initial values.  This function
+ * changes those settings, and must be called from a context that can sleep.
+ * The changes take effect the next time the device is selected and data
+ * is transferred to or from it.
+ */
+static inline int
+spi_setup(struct spi_device *spi)
+{
+        return spi->master->setup(spi);
+}
+/**
+ * spi_async -- asynchronous SPI transfer
+ * @spi: device with which data will be exchanged
+ * @message: describes the data transfers, including completion callback
+ *
+ * This call may be used in_irq and other contexts which can't sleep,
+ * as well as from task contexts which can sleep.
+ *
+ * The completion callback is invoked in a context which can't sleep.
+ * Before that invocation, the value of message->status is undefined.
+ * When the callback is issued, message->status holds either zero (to
+ * indicate complete success) or a negative error code.  After that
+ * callback returns, the driver which issued the transfer request may
+ * deallocate the associated memory; it's no longer in use by any SPI
+ * core or controller driver code.
+ *
+ * Note that although all messages to a spi_device are handled in
+ * FIFO order, messages may go to different devices in other orders.
+ * Some device might be higher priority, or have various "hard" access
+ * time requirements, for example.
+ *
+ * On detection of any fault during the transfer, processing of
+ * the entire message is aborted, and the device is deselected.
+ * Until returning from the associated message completion callback,
+ * no other spi_message queued to that device will be processed.
+ * (This rule applies equally to all the synchronous transfer calls,
+ * which are wrappers around this core asynchronous primitive.)
+ */
+static inline int
+spi_async(struct spi_device *spi, struct spi_message *message)
+{
+        message->spi = spi;
+        return spi->master->transfer(spi, message);
+}
+/*---------------------------------------------------------------------------*/
+/* All these synchronous SPI transfer routines are utilities layered
+ * over the core async transfer primitive.  Here, "synchronous" means
+ * they will sleep uninterruptibly until the async transfer completes.
+ */
+extern int spi_sync(struct spi_device *spi, struct spi_message *message);
+/**
+ * spi_write - SPI synchronous write
+ * @spi: device to which data will be written
+ * @buf: data buffer
+ * @len: data buffer size
+ *
+ * This writes the buffer and returns zero or a negative error code.
+ * Callable only from contexts that can sleep.
+ */
+static inline int
+spi_write(struct spi_device *spi, const u8 *buf, size_t len)
+{
+        struct spi_transfer     t = {
+                        .tx_buf         = buf,
+                        .len            = len,
+                };
+        struct spi_message      m;
+        spi_message_init(&m);
+        spi_message_add_tail(&t, &m);
+        return spi_sync(spi, &m);
+}
+/**
+ * spi_read - SPI synchronous read
+ * @spi: device from which data will be read
+ * @buf: data buffer
+ * @len: data buffer size
+ *
+ * This writes the buffer and returns zero or a negative error code.
+ * Callable only from contexts that can sleep.
+ */
+static inline int
+spi_read(struct spi_device *spi, u8 *buf, size_t len)
+{
+        struct spi_transfer     t = {
+                        .rx_buf         = buf,
+                        .len            = len,
+                };
+        struct spi_message      m;
+        spi_message_init(&m);
+        spi_message_add_tail(&t, &m);
+        return spi_sync(spi, &m);
+}
+/* this copies txbuf and rxbuf data; for small transfers only! */
+extern int spi_write_then_read(struct spi_device *spi,
+                const u8 *txbuf, unsigned n_tx,
+                u8 *rxbuf, unsigned n_rx);
+/**
+ * spi_w8r8 - SPI synchronous 8 bit write followed by 8 bit read
+ * @spi: device with which data will be exchanged
+ * @cmd: command to be written before data is read back
+ *
+ * This returns the (unsigned) eight bit number returned by the
+ * device, or else a negative error code.  Callable only from
+ * contexts that can sleep.
+ */
+static inline ssize_t spi_w8r8(struct spi_device *spi, u8 cmd)
+{
+        ssize_t                 status;
+        u8                      result;
+        status = spi_write_then_read(spi, &cmd, 1, &result, 1);
+        /* return negative errno or unsigned value */
+        return (status < 0) ? status : result;
+}
+/**
+ * spi_w8r16 - SPI synchronous 8 bit write followed by 16 bit read
+ * @spi: device with which data will be exchanged
+ * @cmd: command to be written before data is read back
+ *
+ * This returns the (unsigned) sixteen bit number returned by the
+ * device, or else a negative error code.  Callable only from
+ * contexts that can sleep.
+ *
+ * The number is returned in wire-order, which is at least sometimes
+ * big-endian.
+ */
+static inline ssize_t spi_w8r16(struct spi_device *spi, u8 cmd)
+{
+        ssize_t                 status;
+        u16                     result;
+        status = spi_write_then_read(spi, &cmd, 1, (u8 *) &result, 2);
+        /* return negative errno or unsigned value */
+        return (status < 0) ? status : result;
+}
+/*---------------------------------------------------------------------------*/
+/*
+ * INTERFACE between board init code and SPI infrastructure.
+ *
+ * No SPI driver ever sees these SPI device table segments, but
+ * it's how the SPI core (or adapters that get hotplugged) grows
+ * the driver model tree.
+ *
+ * As a rule, SPI devices can't be probed.  Instead, board init code
+ * provides a table listing the devices which are present, with enough
+ * information to bind and set up the device's driver.  There's basic
+ * support for nonstatic configurations too; enough to handle adding
+ * parport adapters, or microcontrollers acting as USB-to-SPI bridges.
+ */
+/* board-specific information about each SPI device */
+struct spi_board_info {
+        /* the device name and module name are coupled, like platform_bus;
+         * "modalias" is normally the driver name.
+         *
+         * platform_data goes to spi_device.dev.platform_data,
+         * controller_data goes to spi_device.controller_data,
+         * irq is copied too
+         */
+        char            modalias[KOBJ_NAME_LEN];
+        const void      *platform_data;
+        void            *controller_data;
+        int             irq;
+        /* slower signaling on noisy or low voltage boards */
+        u32             max_speed_hz;
+        /* bus_num is board specific and matches the bus_num of some
+         * spi_master that will probably be registered later.
+         *
+         * chip_select reflects how this chip is wired to that master;
+         * it's less than num_chipselect.
+         */
+        u16             bus_num;
+        u16             chip_select;
+        /* ... may need additional spi_device chip config data here.
+         * avoid stuff protocol drivers can set; but include stuff
+         * needed to behave without being bound to a driver:
+         *  - chipselect polarity
+         *  - quirks like clock rate mattering when not selected
+         */
+};
+#ifdef  CONFIG_SPI
+extern int
+spi_register_board_info(struct spi_board_info const *info, unsigned n);
+#else
+/* board init code may ignore whether SPI is configured or not */
+static inline int
+spi_register_board_info(struct spi_board_info const *info, unsigned n)
+        { return 0; }
+#endif
+/* If you're hotplugging an adapter with devices (parport, usb, etc)
+ * use spi_new_device() to describe each device.  You can also call
+ * spi_unregister_device() to start making that device vanish, but
+ * normally that would be handled by spi_unregister_master().
+ */
+extern struct spi_device *
+spi_new_device(struct spi_master *, struct spi_board_info *);
+static inline void
+spi_unregister_device(struct spi_device *spi)
+{
+        if (spi)
+                device_unregister(&spi->dev);
+}
+#endif /* __LINUX_SPI_H */
diff --git a/include/linux/spi/spi_bitbang.h b/include/linux/spi/spi_bitbang.h
new file mode 100644
index 000000000000..c961fe9bf3eb
--- /dev/null
+++ b/include/linux/spi/spi_bitbang.h
@@ -0,0 +1,135 @@
+#ifndef __SPI_BITBANG_H
+#define __SPI_BITBANG_H
+/*
+ * Mix this utility code with some glue code to get one of several types of
+ * simple SPI master driver.  Two do polled word-at-a-time I/O:
+ *
+ *   -  GPIO/parport bitbangers.  Provide chipselect() and txrx_word[](),
+ *      expanding the per-word routines from the inline templates below.
+ *
+ *   -  Drivers for controllers resembling bare shift registers.  Provide
+ *      chipselect() and txrx_word[](), with custom setup()/cleanup() methods
+ *      that use your controller's clock and chipselect registers.
+ *
+ * Some hardware works well with requests at spi_transfer scope:
+ *
+ *   -  Drivers leveraging smarter hardware, with fifos or DMA; or for half
+ *      duplex (MicroWire) controllers.  Provide chipslect() and txrx_bufs(),
+ *      and custom setup()/cleanup() methods.
+ */
+struct spi_bitbang {
+        struct workqueue_struct *workqueue;
+        struct work_struct      work;
+        spinlock_t              lock;
+        struct list_head        queue;
+        u8                      busy;
+        u8                      shutdown;
+        u8                      use_dma;
+        struct spi_master       *master;
+        void    (*chipselect)(struct spi_device *spi, int is_on);
+#define BITBANG_CS_ACTIVE       1       /* normally nCS, active low */
+#define BITBANG_CS_INACTIVE     0
+        /* txrx_bufs() may handle dma mapping for transfers that don't
+         * already have one (transfer.{tx,rx}_dma is zero), or use PIO
+         */
+        int     (*txrx_bufs)(struct spi_device *spi, struct spi_transfer *t);
+        /* txrx_word[SPI_MODE_*]() just looks like a shift register */
+        u32     (*txrx_word[4])(struct spi_device *spi,
+                        unsigned nsecs,
+                        u32 word, u8 bits);
+};
+/* you can call these default bitbang->master methods from your custom
+ * methods, if you like.
+ */
+extern int spi_bitbang_setup(struct spi_device *spi);
+extern void spi_bitbang_cleanup(const struct spi_device *spi);
+extern int spi_bitbang_transfer(struct spi_device *spi, struct spi_message *m);
+/* start or stop queue processing */
+extern int spi_bitbang_start(struct spi_bitbang *spi);
+extern int spi_bitbang_stop(struct spi_bitbang *spi);
+#endif  /* __SPI_BITBANG_H */
+/*-------------------------------------------------------------------------*/
+#ifdef  EXPAND_BITBANG_TXRX
+/*
+ * The code that knows what GPIO pins do what should have declared four
+ * functions, ideally as inlines, before #defining EXPAND_BITBANG_TXRX
+ * and including this header:
+ *
+ *  void setsck(struct spi_device *, int is_on);
+ *  void setmosi(struct spi_device *, int is_on);
+ *  int getmiso(struct spi_device *);
+ *  void spidelay(unsigned);
+ *
+ * A non-inlined routine would call bitbang_txrx_*() routines.  The
+ * main loop could easily compile down to a handful of instructions,
+ * especially if the delay is a NOP (to run at peak speed).
+ *
+ * Since this is software, the timings may not be exactly what your board's
+ * chips need ... there may be several reasons you'd need to tweak timings
+ * in these routines, not just make to make it faster or slower to match a
+ * particular CPU clock rate.
+ */
+static inline u32
+bitbang_txrx_be_cpha0(struct spi_device *spi,
+                unsigned nsecs, unsigned cpol,
+                u32 word, u8 bits)
+{
+        /* if (cpol == 0) this is SPI_MODE_0; else this is SPI_MODE_2 */
+        /* clock starts at inactive polarity */
+        for (word <<= (32 - bits); likely(bits); bits--) {
+                /* setup MSB (to slave) on trailing edge */
+                setmosi(spi, word & (1 << 31));
+                spidelay(nsecs);        /* T(setup) */
+                setsck(spi, !cpol);
+                spidelay(nsecs);
+                /* sample MSB (from slave) on leading edge */
+                word <<= 1;
+                word |= getmiso(spi);
+                setsck(spi, cpol);
+        }
+        return word;
+}
+static inline u32
+bitbang_txrx_be_cpha1(struct spi_device *spi,
+                unsigned nsecs, unsigned cpol,
+                u32 word, u8 bits)
+{
+        /* if (cpol == 0) this is SPI_MODE_1; else this is SPI_MODE_3 */
+        /* clock starts at inactive polarity */
+        for (word <<= (32 - bits); likely(bits); bits--) {
+                /* setup MSB (to slave) on leading edge */
+                setsck(spi, !cpol);
+                setmosi(spi, word & (1 << 31));
+                spidelay(nsecs); /* T(setup) */
+                setsck(spi, cpol);
+                spidelay(nsecs);
+                /* sample MSB (from slave) on trailing edge */
+                word <<= 1;
+                word |= getmiso(spi);
+        }
+        return word;
+}
+#endif  /* EXPAND_BITBANG_TXRX */
diff --git a/include/linux/swap.h b/include/linux/swap.h
index 389d1c382e20..e92054d6530b 100644
--- a/include/linux/swap.h
+++ b/include/linux/swap.h
@@ -180,6 +180,11 @@ extern int isolate_lru_page(struct page *p);
 extern int putback_lru_pages(struct list_head *l);
 extern int migrate_pages(struct list_head *l, struct list_head *t,
                struct list_head *moved, struct list_head *failed);
+#else
+static inline int isolate_lru_page(struct page *p) { return -ENOSYS; }
+static inline int putback_lru_pages(struct list_head *l) { return 0; }
+static inline int migrate_pages(struct list_head *l, struct list_head *t,
+        struct list_head *moved, struct list_head *failed) { return -ENOSYS; }
 #endif
 #ifdef CONFIG_MMU
diff --git a/include/linux/tipc.h b/include/linux/tipc.h
new file mode 100644
index 000000000000..243a15f54002
--- /dev/null
+++ b/include/linux/tipc.h
@@ -0,0 +1,212 @@
+/*
+ * include/linux/tipc.h: Include file for TIPC socket interface
+ * 
+ * Copyright (c) 2003-2006, Ericsson AB
+ * Copyright (c) 2005, Wind River Systems
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are met:
+ *
+ * 1. Redistributions of source code must retain the above copyright
+ *    notice, this list of conditions and the following disclaimer.
+ * 2. Redistributions in binary form must reproduce the above copyright
+ *    notice, this list of conditions and the following disclaimer in the
+ *    documentation and/or other materials provided with the distribution.
+ * 3. Neither the names of the copyright holders nor the names of its
+ *    contributors may be used to endorse or promote products derived from
+ *    this software without specific prior written permission.
+ *
+ * Alternatively, this software may be distributed under the terms of the
+ * GNU General Public License ("GPL") version 2 as published by the Free
+ * Software Foundation.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
+ * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+ * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+ * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE
+ * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
+ * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
+ * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
+ * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
+ * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
+ * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
+ * POSSIBILITY OF SUCH DAMAGE.
+ */
+#ifndef _LINUX_TIPC_H_
+#define _LINUX_TIPC_H_
+#include <linux/types.h>
+/*
+ * TIPC addressing primitives
+ */
+ 
+struct tipc_portid {
+        __u32 ref;
+        __u32 node;
+};
+struct tipc_name {
+        __u32 type;
+        __u32 instance;
+};
+struct tipc_name_seq {
+        __u32 type;
+        __u32 lower;
+        __u32 upper;
+};
+static inline __u32 tipc_addr(unsigned int zone,
+                              unsigned int cluster,
+                              unsigned int node)
+{
+        return (zone << 24) | (cluster << 12) | node;
+}
+static inline unsigned int tipc_zone(__u32 addr)
+{
+        return addr >> 24;
+}
+static inline unsigned int tipc_cluster(__u32 addr)
+{
+        return (addr >> 12) & 0xfff;
+}
+static inline unsigned int tipc_node(__u32 addr)
+{
+        return addr & 0xfff;
+}
+/*
+ * Application-accessible port name types
+ */
+#define TIPC_CFG_SRV            0       /* configuration service name type */
+#define TIPC_TOP_SRV            1       /* topology service name type */
+#define TIPC_RESERVED_TYPES     64      /* lowest user-publishable name type */
+/* 
+ * Publication scopes when binding port names and port name sequences
+ */
+#define TIPC_ZONE_SCOPE         1
+#define TIPC_CLUSTER_SCOPE      2
+#define TIPC_NODE_SCOPE         3
+/*
+ * Limiting values for messages
+ */
+#define TIPC_MAX_USER_MSG_SIZE  66000
+/*
+ * Message importance levels
+ */
+#define TIPC_LOW_IMPORTANCE             0  /* default */
+#define TIPC_MEDIUM_IMPORTANCE          1
+#define TIPC_HIGH_IMPORTANCE            2
+#define TIPC_CRITICAL_IMPORTANCE        3
+/* 
+ * Msg rejection/connection shutdown reasons
+ */
+#define TIPC_OK                 0
+#define TIPC_ERR_NO_NAME        1
+#define TIPC_ERR_NO_PORT        2
+#define TIPC_ERR_NO_NODE        3
+#define TIPC_ERR_OVERLOAD       4
+#define TIPC_CONN_SHUTDOWN      5
+/*
+ * TIPC topology subscription service definitions
+ */
+#define TIPC_SUB_PORTS          0x01    /* filter for port availability */
+#define TIPC_SUB_SERVICE        0x02    /* filter for service availability */
+#if 0
+/* The following filter options are not currently implemented */
+#define TIPC_SUB_NO_BIND_EVTS   0x04    /* filter out "publish" events */
+#define TIPC_SUB_NO_UNBIND_EVTS 0x08    /* filter out "withdraw" events */
+#define TIPC_SUB_SINGLE_EVT     0x10    /* expire after first event */
+#endif
+#define TIPC_WAIT_FOREVER       ~0      /* timeout for permanent subscription */
+struct tipc_subscr {
+        struct tipc_name_seq seq;       /* name sequence of interest */
+        __u32 timeout;                  /* subscription duration (in ms) */
+        __u32 filter;                   /* bitmask of filter options */
+        char usr_handle[8];             /* available for subscriber use */
+};
+#define TIPC_PUBLISHED          1       /* publication event */
+#define TIPC_WITHDRAWN          2       /* withdraw event */
+#define TIPC_SUBSCR_TIMEOUT     3       /* subscription timeout event */
+struct tipc_event {
+        __u32 event;                    /* event type */
+        __u32 found_lower;              /* matching name seq instances */
+        __u32 found_upper;              /*    "      "    "     "      */
+        struct tipc_portid port;        /* associated port */
+        struct tipc_subscr s;           /* associated subscription */
+};
+/*
+ * Socket API
+ */
+#ifndef AF_TIPC
+#define AF_TIPC         30
+#endif
+#ifndef PF_TIPC
+#define PF_TIPC         AF_TIPC
+#endif
+#ifndef SOL_TIPC
+#define SOL_TIPC        271
+#endif
+#define TIPC_ADDR_NAMESEQ       1
+#define TIPC_ADDR_MCAST         1
+#define TIPC_ADDR_NAME          2
+#define TIPC_ADDR_ID            3
+struct sockaddr_tipc {
+        unsigned short family;
+        unsigned char  addrtype;
+        signed   char  scope;
+        union {
+                struct tipc_portid id;
+                struct tipc_name_seq nameseq;
+                struct {
+                        struct tipc_name name;
+                        __u32 domain; /* 0: own zone */
+                } name;
+        } addr;
+};
+/*
+ * Ancillary data objects supported by recvmsg()
+ */
+#define TIPC_ERRINFO    1       /* error info */
+#define TIPC_RETDATA    2       /* returned data */
+#define TIPC_DESTNAME   3       /* destination name */
+/*
+ * TIPC-specific socket option values
+ */
+#define TIPC_IMPORTANCE         127     /* Default: TIPC_LOW_IMPORTANCE */
+#define TIPC_SRC_DROPPABLE      128     /* Default: 0 (resend congested msg) */
+#define TIPC_DEST_DROPPABLE     129     /* Default: based on socket type */
+#define TIPC_CONN_TIMEOUT       130     /* Default: 8000 (ms)  */
+#endif
diff --git a/include/linux/tipc_config.h b/include/linux/tipc_config.h
new file mode 100644
index 000000000000..a52c8c64a5a3
--- /dev/null
+++ b/include/linux/tipc_config.h
@@ -0,0 +1,407 @@
+/*
+ * include/linux/tipc_config.h: Include file for TIPC configuration interface
+ * 
+ * Copyright (c) 2003-2006, Ericsson AB
+ * Copyright (c) 2005, Wind River Systems
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are met:
+ *
+ * 1. Redistributions of source code must retain the above copyright
+ *    notice, this list of conditions and the following disclaimer.
+ * 2. Redistributions in binary form must reproduce the above copyright
+ *    notice, this list of conditions and the following disclaimer in the
+ *    documentation and/or other materials provided with the distribution.
+ * 3. Neither the names of the copyright holders nor the names of its
+ *    contributors may be used to endorse or promote products derived from
+ *    this software without specific prior written permission.
+ *
+ * Alternatively, this software may be distributed under the terms of the
+ * GNU General Public License ("GPL") version 2 as published by the Free
+ * Software Foundation.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
+ * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+ * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+ * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE
+ * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
+ * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
+ * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
+ * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
+ * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
+ * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
+ * POSSIBILITY OF SUCH DAMAGE.
+ */
+#ifndef _LINUX_TIPC_CONFIG_H_
+#define _LINUX_TIPC_CONFIG_H_
+#include <linux/types.h>
+#include <linux/string.h>
+#include <asm/byteorder.h>
+/*
+ * Configuration
+ *
+ * All configuration management messaging involves sending a request message
+ * to the TIPC configuration service on a node, which sends a reply message
+ * back.  (In the future multi-message replies may be supported.)
+ *
+ * Both request and reply messages consist of a transport header and payload.
+ * The transport header contains info about the desired operation;
+ * the payload consists of zero or more type/length/value (TLV) items
+ * which specify parameters or results for the operation.
+ *
+ * For many operations, the request and reply messages have a fixed number
+ * of TLVs (usually zero or one); however, some reply messages may return 
+ * a variable number of TLVs.  A failed request is denoted by the presence
+ * of an "error string" TLV in the reply message instead of the TLV(s) the
+ * reply should contain if the request succeeds.
+ */
+ 
+/* 
+ * Public commands:
+ * May be issued by any process.
+ * Accepted by own node, or by remote node only if remote management enabled.                       
+ */
+ 
+#define  TIPC_CMD_NOOP              0x0000    /* tx none, rx none */
+#define  TIPC_CMD_GET_NODES         0x0001    /* tx net_addr, rx node_info(s) */
+#define  TIPC_CMD_GET_MEDIA_NAMES   0x0002    /* tx none, rx media_name(s) */
+#define  TIPC_CMD_GET_BEARER_NAMES  0x0003    /* tx none, rx bearer_name(s) */
+#define  TIPC_CMD_GET_LINKS         0x0004    /* tx net_addr, rx link_info(s) */
+#define  TIPC_CMD_SHOW_NAME_TABLE   0x0005    /* tx name_tbl_query, rx ultra_string */
+#define  TIPC_CMD_SHOW_PORTS        0x0006    /* tx none, rx ultra_string */
+#define  TIPC_CMD_SHOW_LINK_STATS   0x000B    /* tx link_name, rx ultra_string */
+#if 0
+#define  TIPC_CMD_SHOW_PORT_STATS   0x0008    /* tx port_ref, rx ultra_string */
+#define  TIPC_CMD_RESET_PORT_STATS  0x0009    /* tx port_ref, rx none */
+#define  TIPC_CMD_GET_ROUTES        0x000A    /* tx ?, rx ? */
+#define  TIPC_CMD_GET_LINK_PEER     0x000D    /* tx link_name, rx ? */
+#endif
+/* 
+ * Protected commands:
+ * May only be issued by "network administration capable" process.
+ * Accepted by own node, or by remote node only if remote management enabled
+ * and this node is zone manager.                       
+ */
+#define  TIPC_CMD_GET_REMOTE_MNG    0x4003    /* tx none, rx unsigned */
+#define  TIPC_CMD_GET_MAX_PORTS     0x4004    /* tx none, rx unsigned */
+#define  TIPC_CMD_GET_MAX_PUBL      0x4005    /* tx none, rx unsigned */
+#define  TIPC_CMD_GET_MAX_SUBSCR    0x4006    /* tx none, rx unsigned */
+#define  TIPC_CMD_GET_MAX_ZONES     0x4007    /* tx none, rx unsigned */
+#define  TIPC_CMD_GET_MAX_CLUSTERS  0x4008    /* tx none, rx unsigned */
+#define  TIPC_CMD_GET_MAX_NODES     0x4009    /* tx none, rx unsigned */
+#define  TIPC_CMD_GET_MAX_SLAVES    0x400A    /* tx none, rx unsigned */
+#define  TIPC_CMD_GET_NETID         0x400B    /* tx none, rx unsigned */
+#define  TIPC_CMD_ENABLE_BEARER     0x4101    /* tx bearer_config, rx none */
+#define  TIPC_CMD_DISABLE_BEARER    0x4102    /* tx bearer_name, rx none */
+#define  TIPC_CMD_SET_LINK_TOL      0x4107    /* tx link_config, rx none */
+#define  TIPC_CMD_SET_LINK_PRI      0x4108    /* tx link_config, rx none */
+#define  TIPC_CMD_SET_LINK_WINDOW   0x4109    /* tx link_config, rx none */
+#define  TIPC_CMD_SET_LOG_SIZE      0x410A    /* tx unsigned, rx none */
+#define  TIPC_CMD_DUMP_LOG          0x410B    /* tx none, rx ultra_string */
+#define  TIPC_CMD_RESET_LINK_STATS  0x410C    /* tx link_name, rx none */
+#if 0
+#define  TIPC_CMD_CREATE_LINK       0x4103    /* tx link_create, rx none */
+#define  TIPC_CMD_REMOVE_LINK       0x4104    /* tx link_name, rx none */
+#define  TIPC_CMD_BLOCK_LINK        0x4105    /* tx link_name, rx none */
+#define  TIPC_CMD_UNBLOCK_LINK      0x4106    /* tx link_name, rx none */
+#endif
+/* 
+ * Private commands:
+ * May only be issued by "network administration capable" process.
+ * Accepted by own node only; cannot be used on a remote node.                       
+ */
+#define  TIPC_CMD_SET_NODE_ADDR     0x8001    /* tx net_addr, rx none */
+#if 0
+#define  TIPC_CMD_SET_ZONE_MASTER   0x8002    /* tx none, rx none */
+#endif
+#define  TIPC_CMD_SET_REMOTE_MNG    0x8003    /* tx unsigned, rx none */
+#define  TIPC_CMD_SET_MAX_PORTS     0x8004    /* tx unsigned, rx none */
+#define  TIPC_CMD_SET_MAX_PUBL      0x8005    /* tx unsigned, rx none */
+#define  TIPC_CMD_SET_MAX_SUBSCR    0x8006    /* tx unsigned, rx none */
+#define  TIPC_CMD_SET_MAX_ZONES     0x8007    /* tx unsigned, rx none */
+#define  TIPC_CMD_SET_MAX_CLUSTERS  0x8008    /* tx unsigned, rx none */
+#define  TIPC_CMD_SET_MAX_NODES     0x8009    /* tx unsigned, rx none */
+#define  TIPC_CMD_SET_MAX_SLAVES    0x800A    /* tx unsigned, rx none */
+#define  TIPC_CMD_SET_NETID         0x800B    /* tx unsigned, rx none */
+/*
+ * TLV types defined for TIPC
+ */
+#define TIPC_TLV_NONE           0       /* no TLV present */
+#define TIPC_TLV_VOID           1       /* empty TLV (0 data bytes)*/
+#define TIPC_TLV_UNSIGNED       2       /* 32-bit integer */
+#define TIPC_TLV_STRING         3       /* char[128] (max) */
+#define TIPC_TLV_LARGE_STRING   4       /* char[2048] (max) */
+#define TIPC_TLV_ULTRA_STRING   5       /* char[32768] (max) */
+#define TIPC_TLV_ERROR_STRING   16      /* char[128] containing "error code" */
+#define TIPC_TLV_NET_ADDR       17      /* 32-bit integer denoting <Z.C.N> */
+#define TIPC_TLV_MEDIA_NAME     18      /* char[TIPC_MAX_MEDIA_NAME] */
+#define TIPC_TLV_BEARER_NAME    19      /* char[TIPC_MAX_BEARER_NAME] */
+#define TIPC_TLV_LINK_NAME      20      /* char[TIPC_MAX_LINK_NAME] */
+#define TIPC_TLV_NODE_INFO      21      /* struct tipc_node_info */
+#define TIPC_TLV_LINK_INFO      22      /* struct tipc_link_info */
+#define TIPC_TLV_BEARER_CONFIG  23      /* struct tipc_bearer_config */
+#define TIPC_TLV_LINK_CONFIG    24      /* struct tipc_link_config */
+#define TIPC_TLV_NAME_TBL_QUERY 25      /* struct tipc_name_table_query */
+#define TIPC_TLV_PORT_REF       26      /* 32-bit port reference */
+/*
+ * Maximum sizes of TIPC bearer-related names (including terminating NUL)
+ */ 
+#define TIPC_MAX_MEDIA_NAME     16      /* format = media */
+#define TIPC_MAX_IF_NAME        16      /* format = interface */
+#define TIPC_MAX_BEARER_NAME    32      /* format = media:interface */
+#define TIPC_MAX_LINK_NAME      60      /* format = Z.C.N:interface-Z.C.N:interface */
+/*
+ * Link priority limits (range from 0 to # priorities - 1)
+ */
+#define TIPC_NUM_LINK_PRI 32
+/*
+ * Link tolerance limits (min, default, max), in ms
+ */
+#define TIPC_MIN_LINK_TOL 50
+#define TIPC_DEF_LINK_TOL 1500
+#define TIPC_MAX_LINK_TOL 30000
+/*
+ * Link window limits (min, default, max), in packets
+ */
+#define TIPC_MIN_LINK_WIN 16
+#define TIPC_DEF_LINK_WIN 50
+#define TIPC_MAX_LINK_WIN 150
+struct tipc_node_info {
+        __u32 addr;                     /* network address of node */
+        __u32 up;                       /* 0=down, 1= up */
+};
+struct tipc_link_info {
+        __u32 dest;                     /* network address of peer node */
+        __u32 up;                       /* 0=down, 1=up */
+        char str[TIPC_MAX_LINK_NAME];   /* link name */
+};
+struct tipc_bearer_config {
+        __u32 priority;                 /* Range [1,31]. Override per link  */
+        __u32 detect_scope;     
+        char name[TIPC_MAX_BEARER_NAME];
+};
+struct tipc_link_config {
+        __u32 value;
+        char name[TIPC_MAX_LINK_NAME];
+};
+#define TIPC_NTQ_ALLTYPES 0x80000000
+struct tipc_name_table_query {
+        __u32 depth;    /* 1:type, 2:+name info, 3:+port info, 4+:+debug info */
+        __u32 type;     /* {t,l,u} info ignored if high bit of "depth" is set */
+        __u32 lowbound; /* (i.e. displays all entries of name table) */
+        __u32 upbound;
+};
+/*
+ * The error string TLV is a null-terminated string describing the cause 
+ * of the request failure.  To simplify error processing (and to save space)
+ * the first character of the string can be a special error code character
+ * (lying by the range 0x80 to 0xFF) which represents a pre-defined reason.
+ */
+#define TIPC_CFG_TLV_ERROR      "\x80"  /* request contains incorrect TLV(s) */
+#define TIPC_CFG_NOT_NET_ADMIN  "\x81"  /* must be network administrator */
+#define TIPC_CFG_NOT_ZONE_MSTR  "\x82"  /* must be zone master */
+#define TIPC_CFG_NO_REMOTE      "\x83"  /* remote management not enabled */
+#define TIPC_CFG_NOT_SUPPORTED  "\x84"  /* request is not supported by TIPC */
+#define TIPC_CFG_INVALID_VALUE  "\x85"  /* request has invalid argument value */
+#if 0
+/* prototypes TLV structures for proposed commands */
+struct tipc_link_create {
+        __u32   domain;
+        struct tipc_media_addr peer_addr;
+        char bearer_name[TIPC_MAX_BEARER_NAME];
+};
+struct tipc_route_info {
+        __u32 dest;
+        __u32 router;
+};
+#endif
+/*
+ * A TLV consists of a descriptor, followed by the TLV value.
+ * TLV descriptor fields are stored in network byte order; 
+ * TLV values must also be stored in network byte order (where applicable).
+ * TLV descriptors must be aligned to addresses which are multiple of 4,
+ * so up to 3 bytes of padding may exist at the end of the TLV value area.
+ * There must not be any padding between the TLV descriptor and its value.
+ */
+struct tlv_desc {
+        __u16 tlv_len;          /* TLV length (descriptor + value) */
+        __u16 tlv_type;         /* TLV identifier */
+};
+#define TLV_ALIGNTO 4
+#define TLV_ALIGN(datalen) (((datalen)+(TLV_ALIGNTO-1)) & ~(TLV_ALIGNTO-1))
+#define TLV_LENGTH(datalen) (sizeof(struct tlv_desc) + (datalen))
+#define TLV_SPACE(datalen) (TLV_ALIGN(TLV_LENGTH(datalen)))
+#define TLV_DATA(tlv) ((void *)((char *)(tlv) + TLV_LENGTH(0)))
+static inline int TLV_OK(const void *tlv, __u16 space)
+{
+        /*
+         * Would also like to check that "tlv" is a multiple of 4,
+         * but don't know how to do this in a portable way.
+         * - Tried doing (!(tlv & (TLV_ALIGNTO-1))), but GCC compiler
+         *   won't allow binary "&" with a pointer.
+         * - Tried casting "tlv" to integer type, but causes warning about size
+         *   mismatch when pointer is bigger than chosen type (int, long, ...).
+         */
+        return (space >= TLV_SPACE(0)) &&
+                (ntohs(((struct tlv_desc *)tlv)->tlv_len) <= space);
+}
+static inline int TLV_CHECK(const void *tlv, __u16 space, __u16 exp_type)
+{
+        return TLV_OK(tlv, space) && 
+                (ntohs(((struct tlv_desc *)tlv)->tlv_type) == exp_type);
+}
+static inline int TLV_SET(void *tlv, __u16 type, void *data, __u16 len)
+{
+        struct tlv_desc *tlv_ptr;
+        int tlv_len;
+        tlv_len = TLV_LENGTH(len);
+        tlv_ptr = (struct tlv_desc *)tlv;
+        tlv_ptr->tlv_type = htons(type);
+        tlv_ptr->tlv_len  = htons(tlv_len);
+        if (len && data)
+                memcpy(TLV_DATA(tlv_ptr), data, tlv_len);
+        return TLV_SPACE(len);
+}
+/*
+ * A TLV list descriptor simplifies processing of messages 
+ * containing multiple TLVs.
+ */
+struct tlv_list_desc {
+        struct tlv_desc *tlv_ptr;       /* ptr to current TLV */
+        __u32 tlv_space;                /* # bytes from curr TLV to list end */
+};
+static inline void TLV_LIST_INIT(struct tlv_list_desc *list, 
+                                 void *data, __u32 space)
+{
+        list->tlv_ptr = (struct tlv_desc *)data;
+        list->tlv_space = space;
+}
+             
+static inline int TLV_LIST_EMPTY(struct tlv_list_desc *list)
+{ 
+        return (list->tlv_space == 0);
+}
+static inline int TLV_LIST_CHECK(struct tlv_list_desc *list, __u16 exp_type)
+{
+        return TLV_CHECK(list->tlv_ptr, list->tlv_space, exp_type);
+}
+static inline void *TLV_LIST_DATA(struct tlv_list_desc *list)
+{
+        return TLV_DATA(list->tlv_ptr);
+}
+static inline void TLV_LIST_STEP(struct tlv_list_desc *list)
+{
+        __u16 tlv_space = TLV_ALIGN(ntohs(list->tlv_ptr->tlv_len));
+        list->tlv_ptr = (struct tlv_desc *)((char *)list->tlv_ptr + tlv_space);
+        list->tlv_space -= tlv_space;
+}
+/*
+ * Configuration messages exchanged via NETLINK_GENERIC use the following
+ * family id, name, version and command.
+ */
+#define TIPC_GENL_NAME          "TIPC"
+#define TIPC_GENL_VERSION       0x1
+#define TIPC_GENL_CMD           0x1
+/*
+ * TIPC specific header used in NETLINK_GENERIC requests.
+ */
+struct tipc_genlmsghdr {
+        __u32 dest;             /* Destination address */
+        __u16 cmd;              /* Command */
+        __u16 reserved;         /* Unused */
+};
+#define TIPC_GENL_HDRLEN        NLMSG_ALIGN(sizeof(struct tipc_genlmsghdr))
+/*
+ * Configuration messages exchanged via TIPC sockets use the TIPC configuration 
+ * message header, which is defined below.  This structure is analogous 
+ * to the Netlink message header, but fields are stored in network byte order 
+ * and no padding is permitted between the header and the message data 
+ * that follows.
+ */
+struct tipc_cfg_msg_hdr
+{
+        __u32 tcm_len;          /* Message length (including header) */
+        __u16 tcm_type;         /* Command type */
+        __u16 tcm_flags;        /* Additional flags */
+        char  tcm_reserved[8];  /* Unused */
+};
+#define TCM_F_REQUEST   0x1     /* Flag: Request message */
+#define TCM_F_MORE      0x2     /* Flag: Message to be continued */
+#define TCM_ALIGN(datalen)  (((datalen)+3) & ~3)
+#define TCM_LENGTH(datalen) (sizeof(struct tipc_cfg_msg_hdr) + datalen)
+#define TCM_SPACE(datalen)  (TCM_ALIGN(TCM_LENGTH(datalen)))
+#define TCM_DATA(tcm_hdr)   ((void *)((char *)(tcm_hdr) + TCM_LENGTH(0)))
+static inline int TCM_SET(void *msg, __u16 cmd, __u16 flags,
+                          void *data, __u16 data_len)
+{
+        struct tipc_cfg_msg_hdr *tcm_hdr;
+        int msg_len;
+        msg_len = TCM_LENGTH(data_len);
+        tcm_hdr = (struct tipc_cfg_msg_hdr *)msg;
+        tcm_hdr->tcm_len   = htonl(msg_len);
+        tcm_hdr->tcm_type  = htons(cmd);
+        tcm_hdr->tcm_flags = htons(flags);
+        if (data_len && data)
+                memcpy(TCM_DATA(msg), data, data_len);
+        return TCM_SPACE(data_len);
+}
+#endif
diff --git a/include/net/genetlink.h b/include/net/genetlink.h
index c5b96b2b8155..805de50df00d 100644
--- a/include/net/genetlink.h
+++ b/include/net/genetlink.h
@@ -22,7 +22,6 @@ struct genl_family
        char                    name[GENL_NAMSIZ];
        unsigned int            version;
        unsigned int            maxattr;
-        struct module *         owner;
        struct nlattr **        attrbuf;        /* private */
        struct list_head        ops_list;       /* private */
        struct list_head        family_list;    /* private */
diff --git a/include/net/netfilter/ipv4/nf_conntrack_ipv4.h b/include/net/netfilter/ipv4/nf_conntrack_ipv4.h
index 25b081a730e6..91684436af8e 100644
--- a/include/net/netfilter/ipv4/nf_conntrack_ipv4.h
+++ b/include/net/netfilter/ipv4/nf_conntrack_ipv4.h
@@ -37,7 +37,4 @@ struct nf_conntrack_ipv4 {
 struct sk_buff *
 nf_ct_ipv4_ct_gather_frags(struct sk_buff *skb);
-/* call to create an explicit dependency on nf_conntrack_l3proto_ipv4. */
-extern void need_ip_conntrack(void);
 #endif /*_NF_CONNTRACK_IPV4_H*/
diff --git a/include/net/netfilter/nf_conntrack.h b/include/net/netfilter/nf_conntrack.h
index 64b82b74a650..6d075ca16e6e 100644
--- a/include/net/netfilter/nf_conntrack.h
+++ b/include/net/netfilter/nf_conntrack.h
@@ -221,9 +221,6 @@ extern void nf_ct_helper_put(struct nf_conntrack_helper *helper);
 extern struct nf_conntrack_helper *
 __nf_conntrack_helper_find_byname(const char *name);
-/* call to create an explicit dependency on nf_conntrack. */
-extern void need_nf_conntrack(void);
 extern int nf_ct_invert_tuplepr(struct nf_conntrack_tuple *inverse,
                                const struct nf_conntrack_tuple *orig);
diff --git a/include/net/netfilter/nf_conntrack_tuple.h b/include/net/netfilter/nf_conntrack_tuple.h
index 14ce790e5c65..530ef1f75283 100644
--- a/include/net/netfilter/nf_conntrack_tuple.h
+++ b/include/net/netfilter/nf_conntrack_tuple.h
@@ -111,7 +111,7 @@ struct nf_conntrack_tuple
 #ifdef __KERNEL__
 #define NF_CT_DUMP_TUPLE(tp)                                                \
-DEBUGP("tuple %p: %u %u %04x:%04x:%04x:%04x:%04x:%04x:%04x:%04x %hu -> %04x:%04x:%04x:%04x:%04x:%04x:%04x:%04x %hu\n",                                      \
+DEBUGP("tuple %p: %u %u " NIP6_FMT " %hu -> " NIP6_FMT " %hu\n",            \
        (tp), (tp)->src.l3num, (tp)->dst.protonum,                          \
        NIP6(*(struct in6_addr *)(tp)->src.u3.all), ntohs((tp)->src.u.all), \
        NIP6(*(struct in6_addr *)(tp)->dst.u3.all), ntohs((tp)->dst.u.all))
diff --git a/include/net/sctp/sctp.h b/include/net/sctp/sctp.h
index 8f241216f46b..a553f39f6aee 100644
--- a/include/net/sctp/sctp.h
+++ b/include/net/sctp/sctp.h
@@ -225,13 +225,13 @@ extern int sctp_debug_flag;
        if (sctp_debug_flag) { \
                if (saddr->sa.sa_family == AF_INET6) { \
                        printk(KERN_DEBUG \
-                               lead "%04x:%04x:%04x:%04x:%04x:%04x:%04x:%04x" trail, \
+                               lead NIP6_FMT trail, \
                               leadparm, \
                               NIP6(saddr->v6.sin6_addr), \
                               otherparms); \
                } else { \
                        printk(KERN_DEBUG \
-                               lead "%u.%u.%u.%u" trail, \
+                               lead NIPQUAD_FMT trail, \
                               leadparm, \
                               NIPQUAD(saddr->v4.sin_addr.s_addr), \
                               otherparms); \
diff --git a/include/net/tipc/tipc.h b/include/net/tipc/tipc.h
new file mode 100644
index 000000000000..9566608c88cf
--- /dev/null
+++ b/include/net/tipc/tipc.h
@@ -0,0 +1,257 @@
+/*
+ * include/net/tipc/tipc.h: Main include file for TIPC users
+ * 
+ * Copyright (c) 2003-2006, Ericsson AB
+ * Copyright (c) 2005, Wind River Systems
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are met:
+ *
+ * 1. Redistributions of source code must retain the above copyright
+ *    notice, this list of conditions and the following disclaimer.
+ * 2. Redistributions in binary form must reproduce the above copyright
+ *    notice, this list of conditions and the following disclaimer in the
+ *    documentation and/or other materials provided with the distribution.
+ * 3. Neither the names of the copyright holders nor the names of its
+ *    contributors may be used to endorse or promote products derived from
+ *    this software without specific prior written permission.
+ *
+ * Alternatively, this software may be distributed under the terms of the
+ * GNU General Public License ("GPL") version 2 as published by the Free
+ * Software Foundation.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
+ * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+ * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+ * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE
+ * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
+ * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
+ * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
+ * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
+ * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
+ * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
+ * POSSIBILITY OF SUCH DAMAGE.
+ */
+#ifndef _NET_TIPC_H_
+#define _NET_TIPC_H_
+#ifdef __KERNEL__
+#include <linux/tipc.h>
+#include <linux/skbuff.h>
+/* 
+ * Native API
+ */
+/*
+ * TIPC operating mode routines
+ */
+u32 tipc_get_addr(void);
+#define TIPC_NOT_RUNNING  0
+#define TIPC_NODE_MODE    1
+#define TIPC_NET_MODE     2
+typedef void (*tipc_mode_event)(void *usr_handle, int mode, u32 addr);
+int tipc_attach(unsigned int *userref, tipc_mode_event, void *usr_handle);
+void tipc_detach(unsigned int userref);
+int tipc_get_mode(void);
+/*
+ * TIPC port manipulation routines
+ */
+typedef void (*tipc_msg_err_event) (void *usr_handle,
+                                    u32 portref,
+                                    struct sk_buff **buf,
+                                    unsigned char const *data,
+                                    unsigned int size,
+                                    int reason, 
+                                    struct tipc_portid const *attmpt_destid);
+typedef void (*tipc_named_msg_err_event) (void *usr_handle,
+                                          u32 portref,
+                                          struct sk_buff **buf,
+                                          unsigned char const *data,
+                                          unsigned int size,
+                                          int reason, 
+                                          struct tipc_name_seq const *attmpt_dest);
+typedef void (*tipc_conn_shutdown_event) (void *usr_handle,
+                                          u32 portref,
+                                          struct sk_buff **buf,
+                                          unsigned char const *data,
+                                          unsigned int size,
+                                          int reason);
+typedef void (*tipc_msg_event) (void *usr_handle,
+                                u32 portref,
+                                struct sk_buff **buf,
+                                unsigned char const *data,
+                                unsigned int size,
+                                unsigned int importance, 
+                                struct tipc_portid const *origin);
+typedef void (*tipc_named_msg_event) (void *usr_handle,
+                                      u32 portref,
+                                      struct sk_buff **buf,
+                                      unsigned char const *data,
+                                      unsigned int size,
+                                      unsigned int importance, 
+                                      struct tipc_portid const *orig,
+                                      struct tipc_name_seq const *dest);
+typedef void (*tipc_conn_msg_event) (void *usr_handle,
+                                     u32 portref,
+                                     struct sk_buff **buf,
+                                     unsigned char const *data,
+                                     unsigned int size);
+typedef void (*tipc_continue_event) (void *usr_handle, 
+                                     u32 portref);
+int tipc_createport(unsigned int tipc_user, 
+                    void *usr_handle, 
+                    unsigned int importance, 
+                    tipc_msg_err_event error_cb, 
+                    tipc_named_msg_err_event named_error_cb, 
+                    tipc_conn_shutdown_event conn_error_cb, 
+                    tipc_msg_event message_cb, 
+                    tipc_named_msg_event named_message_cb, 
+                    tipc_conn_msg_event conn_message_cb, 
+                    tipc_continue_event continue_event_cb,/* May be zero */
+                    u32 *portref);
+int tipc_deleteport(u32 portref);
+int tipc_ownidentity(u32 portref, struct tipc_portid *port);
+int tipc_portimportance(u32 portref, unsigned int *importance);
+int tipc_set_portimportance(u32 portref, unsigned int importance);
+int tipc_portunreliable(u32 portref, unsigned int *isunreliable);
+int tipc_set_portunreliable(u32 portref, unsigned int isunreliable);
+int tipc_portunreturnable(u32 portref, unsigned int *isunreturnable);
+int tipc_set_portunreturnable(u32 portref, unsigned int isunreturnable);
+int tipc_publish(u32 portref, unsigned int scope, 
+                 struct tipc_name_seq const *name_seq);
+int tipc_withdraw(u32 portref, unsigned int scope,
+                  struct tipc_name_seq const *name_seq); /* 0: all */
+int tipc_connect2port(u32 portref, struct tipc_portid const *port);
+int tipc_disconnect(u32 portref);
+int tipc_shutdown(u32 ref); /* Sends SHUTDOWN msg */
+int tipc_isconnected(u32 portref, int *isconnected);
+int tipc_peer(u32 portref, struct tipc_portid *peer);
+int tipc_ref_valid(u32 portref); 
+/*
+ * TIPC messaging routines
+ */
+#define TIPC_PORT_IMPORTANCE 100        /* send using current port setting */
+int tipc_send(u32 portref,
+              unsigned int num_sect,
+              struct iovec const *msg_sect);
+int tipc_send_buf(u32 portref,
+                  struct sk_buff *buf,
+                  unsigned int dsz);
+int tipc_send2name(u32 portref, 
+                   struct tipc_name const *name, 
+                   u32 domain,  /* 0:own zone */
+                   unsigned int num_sect,
+                   struct iovec const *msg_sect);
+int tipc_send_buf2name(u32 portref,
+                       struct tipc_name const *name,
+                       u32 domain,
+                       struct sk_buff *buf,
+                       unsigned int dsz);
+int tipc_forward2name(u32 portref, 
+                      struct tipc_name const *name, 
+                      u32 domain,   /*0: own zone */
+                      unsigned int section_count,
+                      struct iovec const *msg_sect,
+                      struct tipc_portid const *origin,
+                      unsigned int importance);
+int tipc_forward_buf2name(u32 portref,
+                          struct tipc_name const *name,
+                          u32 domain,
+                          struct sk_buff *buf,
+                          unsigned int dsz,
+                          struct tipc_portid const *orig,
+                          unsigned int importance);
+int tipc_send2port(u32 portref,
+                   struct tipc_portid const *dest,
+                   unsigned int num_sect,
+                   struct iovec const *msg_sect);
+int tipc_send_buf2port(u32 portref,
+                       struct tipc_portid const *dest,
+                       struct sk_buff *buf,
+                       unsigned int dsz);
+int tipc_forward2port(u32 portref,
+                      struct tipc_portid const *dest,
+                      unsigned int num_sect,
+                      struct iovec const *msg_sect,
+                      struct tipc_portid const *origin,
+                      unsigned int importance);
+int tipc_forward_buf2port(u32 portref,
+                          struct tipc_portid const *dest,
+                          struct sk_buff *buf,
+                          unsigned int dsz,
+                          struct tipc_portid const *orig,
+                          unsigned int importance);
+int tipc_multicast(u32 portref, 
+                   struct tipc_name_seq const *seq, 
+                   u32 domain,  /* 0:own zone */
+                   unsigned int section_count,
+                   struct iovec const *msg);
+#if 0
+int tipc_multicast_buf(u32 portref, 
+                       struct tipc_name_seq const *seq, 
+                       u32 domain,      /* 0:own zone */
+                       void *buf,
+                       unsigned int size);
+#endif
+/*
+ * TIPC subscription routines
+ */
+int tipc_ispublished(struct tipc_name const *name);
+/*
+ * Get number of available nodes within specified domain (excluding own node)
+ */
+unsigned int tipc_available_nodes(const u32 domain);
+#endif
+#endif
diff --git a/include/net/tipc/tipc_bearer.h b/include/net/tipc/tipc_bearer.h
new file mode 100644
index 000000000000..098607cd4b78
--- /dev/null
+++ b/include/net/tipc/tipc_bearer.h
@@ -0,0 +1,121 @@
+/*
+ * include/net/tipc/tipc_bearer.h: Include file for privileged access to TIPC bearers
+ * 
+ * Copyright (c) 2003-2006, Ericsson AB
+ * Copyright (c) 2005, Wind River Systems
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are met:
+ *
+ * 1. Redistributions of source code must retain the above copyright
+ *    notice, this list of conditions and the following disclaimer.
+ * 2. Redistributions in binary form must reproduce the above copyright
+ *    notice, this list of conditions and the following disclaimer in the
+ *    documentation and/or other materials provided with the distribution.
+ * 3. Neither the names of the copyright holders nor the names of its
+ *    contributors may be used to endorse or promote products derived from
+ *    this software without specific prior written permission.
+ *
+ * Alternatively, this software may be distributed under the terms of the
+ * GNU General Public License ("GPL") version 2 as published by the Free
+ * Software Foundation.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
+ * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+ * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+ * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE
+ * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
+ * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
+ * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
+ * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
+ * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
+ * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
+ * POSSIBILITY OF SUCH DAMAGE.
+ */
+#ifndef _NET_TIPC_BEARER_H_
+#define _NET_TIPC_BEARER_H_
+#ifdef __KERNEL__
+#include <linux/tipc_config.h>
+#include <linux/skbuff.h>
+#include <linux/spinlock.h>
+/*
+ * Identifiers of supported TIPC media types
+ */
+#define TIPC_MEDIA_TYPE_ETH     1
+struct tipc_media_addr {
+        __u32  type;
+        union {
+                __u8   eth_addr[6];     /* Ethernet bearer */ 
+#if 0
+                /* Prototypes for other possible bearer types */
+                struct {
+                        __u16 sin_family;
+                        __u16 sin_port;
+                        struct {
+                                __u32 s_addr;
+                        } sin_addr;
+                        char pad[4];
+                } addr_in;              /* IP-based bearer */
+                __u16  sock_descr;      /* generic socket bearer */
+#endif
+        } dev_addr;
+};
+/**
+ * struct tipc_bearer - TIPC bearer info available to privileged users
+ * @usr_handle: pointer to additional user-defined information about bearer
+ * @mtu: max packet size bearer can support
+ * @blocked: non-zero if bearer is blocked
+ * @lock: spinlock for controlling access to bearer
+ * @addr: media-specific address associated with bearer
+ * @name: bearer name (format = media:interface)
+ * 
+ * Note: TIPC initializes "name" and "lock" fields; user is responsible for
+ * initialization all other fields when a bearer is enabled.
+ */
+struct tipc_bearer {
+        void *usr_handle;
+        u32 mtu;
+        int blocked;
+        spinlock_t lock;
+        struct tipc_media_addr addr;
+        char name[TIPC_MAX_BEARER_NAME];
+};
+int  tipc_register_media(u32 media_type,
+                         char *media_name, 
+                         int (*enable)(struct tipc_bearer *), 
+                         void (*disable)(struct tipc_bearer *), 
+                         int (*send_msg)(struct sk_buff *, 
+                                         struct tipc_bearer *,
+                                         struct tipc_media_addr *), 
+                         char *(*addr2str)(struct tipc_media_addr *a,
+                                           char *str_buf,
+                                           int str_size),
+                         struct tipc_media_addr *bcast_addr,
+                         const u32 bearer_priority,
+                         const u32 link_tolerance,  /* [ms] */
+                         const u32 send_window_limit); 
+void tipc_recv_msg(struct sk_buff *buf, struct tipc_bearer *tb_ptr);
+int  tipc_block_bearer(const char *name);
+void tipc_continue(struct tipc_bearer *tb_ptr); 
+int tipc_enable_bearer(const char *bearer_name, u32 bcast_scope, u32 priority);
+int tipc_disable_bearer(const char *name);
+#endif
+#endif
diff --git a/include/net/tipc/tipc_msg.h b/include/net/tipc/tipc_msg.h
new file mode 100644
index 000000000000..4d096eebc93f
--- /dev/null
+++ b/include/net/tipc/tipc_msg.h
@@ -0,0 +1,223 @@
+/*
+ * include/net/tipc/tipc_msg.h: Include file for privileged access to TIPC message headers
+ * 
+ * Copyright (c) 2003-2006, Ericsson AB
+ * Copyright (c) 2005, Wind River Systems
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are met:
+ *
+ * 1. Redistributions of source code must retain the above copyright
+ *    notice, this list of conditions and the following disclaimer.
+ * 2. Redistributions in binary form must reproduce the above copyright
+ *    notice, this list of conditions and the following disclaimer in the
+ *    documentation and/or other materials provided with the distribution.
+ * 3. Neither the names of the copyright holders nor the names of its
+ *    contributors may be used to endorse or promote products derived from
+ *    this software without specific prior written permission.
+ *
+ * Alternatively, this software may be distributed under the terms of the
+ * GNU General Public License ("GPL") version 2 as published by the Free
+ * Software Foundation.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
+ * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+ * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+ * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE
+ * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
+ * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
+ * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
+ * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
+ * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
+ * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
+ * POSSIBILITY OF SUCH DAMAGE.
+ */
+#ifndef _NET_TIPC_MSG_H_
+#define _NET_TIPC_MSG_H_
+#ifdef __KERNEL__
+struct tipc_msg {
+        u32 hdr[15];
+};
+/*
+                TIPC user data message header format, version 2:
+       1 0 9 8 7 6 5 4|3 2 1 0 9 8 7 6|5 4 3 2 1 0 9 8|7 6 5 4 3 2 1 0 
+      +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
+   w0:|vers | user  |hdr sz |n|d|s|-|          message size           |
+      +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
+   w1:|mstyp| error |rer cnt|lsc|opt p|      broadcast ack no         |
+      +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
+   w2:|        link level ack no      |   broadcast/link level seq no |
+      +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
+   w3:|                       previous node                           |
+      +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
+   w4:|                      originating port                         |
+      +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
+   w5:|                      destination port                         |
+      +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+    
+   w6:|                      originating node                         |
+      +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
+   w7:|                      destination node                         |
+      +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
+   w8:|            name type / transport sequence number              |
+      +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
+   w9:|              name instance/multicast lower bound              |
+      +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+    
+   wA:|                    multicast upper bound                      |
+      +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+    
+      /                                                               /
+      \                           options                             \
+      /                                                               /
+      +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
+*/
+#define TIPC_CONN_MSG   0
+#define TIPC_MCAST_MSG  1
+#define TIPC_NAMED_MSG  2
+#define TIPC_DIRECT_MSG 3
+static inline u32 msg_word(struct tipc_msg *m, u32 pos)
+{
+        return ntohl(m->hdr[pos]);
+}
+static inline u32 msg_bits(struct tipc_msg *m, u32 w, u32 pos, u32 mask)
+{
+        return (msg_word(m, w) >> pos) & mask;
+}
+static inline u32 msg_importance(struct tipc_msg *m)
+{
+        return msg_bits(m, 0, 25, 0xf);
+}
+static inline u32 msg_hdr_sz(struct tipc_msg *m)
+{
+        return msg_bits(m, 0, 21, 0xf) << 2;
+}
+static inline int msg_short(struct tipc_msg *m)
+{
+        return (msg_hdr_sz(m) == 24);
+}
+static inline u32 msg_size(struct tipc_msg *m)
+{
+        return msg_bits(m, 0, 0, 0x1ffff);
+}
+static inline u32 msg_data_sz(struct tipc_msg *m)
+{
+        return (msg_size(m) - msg_hdr_sz(m));
+}
+static inline unchar *msg_data(struct tipc_msg *m)
+{
+        return ((unchar *)m) + msg_hdr_sz(m);
+}
+static inline u32 msg_type(struct tipc_msg *m)
+{
+        return msg_bits(m, 1, 29, 0x7);
+}
+static inline u32 msg_direct(struct tipc_msg *m)
+{
+        return (msg_type(m) == TIPC_DIRECT_MSG);
+}
+static inline u32 msg_named(struct tipc_msg *m)
+{
+        return (msg_type(m) == TIPC_NAMED_MSG);
+}
+static inline u32 msg_mcast(struct tipc_msg *m)
+{
+        return (msg_type(m) == TIPC_MCAST_MSG);
+}
+static inline u32 msg_connected(struct tipc_msg *m)
+{
+        return (msg_type(m) == TIPC_CONN_MSG);
+}
+static inline u32 msg_errcode(struct tipc_msg *m)
+{
+        return msg_bits(m, 1, 25, 0xf);
+}
+static inline u32 msg_prevnode(struct tipc_msg *m)
+{
+        return msg_word(m, 3);
+}
+static inline u32 msg_origport(struct tipc_msg *m)
+{
+        return msg_word(m, 4);
+}
+static inline u32 msg_destport(struct tipc_msg *m)
+{
+        return msg_word(m, 5);
+}
+static inline u32 msg_mc_netid(struct tipc_msg *m)
+{
+        return msg_word(m, 5);
+}
+static inline u32 msg_orignode(struct tipc_msg *m)
+{
+        if (likely(msg_short(m)))
+                return msg_prevnode(m);
+        return msg_word(m, 6);
+}
+static inline u32 msg_destnode(struct tipc_msg *m)
+{
+        return msg_word(m, 7);
+}
+static inline u32 msg_nametype(struct tipc_msg *m)
+{
+        return msg_word(m, 8);
+}
+static inline u32 msg_nameinst(struct tipc_msg *m)
+{
+        return msg_word(m, 9);
+}
+static inline u32 msg_namelower(struct tipc_msg *m)
+{
+        return msg_nameinst(m);
+}
+static inline u32 msg_nameupper(struct tipc_msg *m)
+{
+        return msg_word(m, 10);
+}
+static inline char *msg_options(struct tipc_msg *m, u32 *len)
+{
+        u32 pos = msg_bits(m, 1, 16, 0x7);
+        if (!pos)
+                return 0;
+        pos = (pos * 4) + 28;
+        *len = msg_hdr_sz(m) - pos;
+        return (char *)&m->hdr[pos/4];
+}
+#endif
+#endif
diff --git a/include/net/tipc/tipc_port.h b/include/net/tipc/tipc_port.h
new file mode 100644
index 000000000000..333bba6dc522
--- /dev/null
+++ b/include/net/tipc/tipc_port.h
@@ -0,0 +1,108 @@
+/*
+ * include/net/tipc/tipc_port.h: Include file for privileged access to TIPC ports
+ * 
+ * Copyright (c) 1994-2006, Ericsson AB
+ * Copyright (c) 2005, Wind River Systems
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are met:
+ *
+ * 1. Redistributions of source code must retain the above copyright
+ *    notice, this list of conditions and the following disclaimer.
+ * 2. Redistributions in binary form must reproduce the above copyright
+ *    notice, this list of conditions and the following disclaimer in the
+ *    documentation and/or other materials provided with the distribution.
+ * 3. Neither the names of the copyright holders nor the names of its
+ *    contributors may be used to endorse or promote products derived from
+ *    this software without specific prior written permission.
+ *
+ * Alternatively, this software may be distributed under the terms of the
+ * GNU General Public License ("GPL") version 2 as published by the Free
+ * Software Foundation.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
+ * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+ * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+ * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE
+ * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
+ * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
+ * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
+ * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
+ * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
+ * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
+ * POSSIBILITY OF SUCH DAMAGE.
+ */
+#ifndef _NET_TIPC_PORT_H_
+#define _NET_TIPC_PORT_H_
+#ifdef __KERNEL__
+#include <linux/tipc.h>
+#include <linux/skbuff.h>
+#include <net/tipc/tipc_msg.h>
+#define TIPC_FLOW_CONTROL_WIN 512
+/**
+ * struct tipc_port - native TIPC port info available to privileged users
+ * @usr_handle: pointer to additional user-defined information about port
+ * @lock: pointer to spinlock for controlling access to port
+ * @connected: non-zero if port is currently connected to a peer port
+ * @conn_type: TIPC type used when connection was established
+ * @conn_instance: TIPC instance used when connection was established
+ * @conn_unacked: number of unacknowledged messages received from peer port
+ * @published: non-zero if port has one or more associated names
+ * @congested: non-zero if cannot send because of link or port congestion
+ * @ref: unique reference to port in TIPC object registry
+ * @phdr: preformatted message header used when sending messages
+ */
+struct tipc_port {
+        void *usr_handle;
+        spinlock_t *lock;
+        int connected;
+        u32 conn_type;
+        u32 conn_instance;
+        u32 conn_unacked;
+        int published;
+        u32 congested;
+        u32 ref;
+        struct tipc_msg phdr;
+};
+/**
+ * tipc_createport_raw - create a native TIPC port and return it's reference
+ *
+ * Note: 'dispatcher' and 'wakeup' deliver a locked port.
+ */
+u32 tipc_createport_raw(void *usr_handle,
+                        u32 (*dispatcher)(struct tipc_port *, struct sk_buff *),
+                        void (*wakeup)(struct tipc_port *),
+                        const u32 importance);
+/*
+ * tipc_set_msg_option(): port must be locked.
+ */
+int tipc_set_msg_option(struct tipc_port *tp_ptr,
+                        const char *opt,
+                        const u32 len);
+int tipc_reject_msg(struct sk_buff *buf, u32 err);
+int tipc_send_buf_fast(struct sk_buff *buf, u32 destnode);
+void tipc_acknowledge(u32 port_ref,u32 ack);
+struct tipc_port *tipc_get_port(const u32 ref);
+void *tipc_get_handle(const u32 ref);
+#endif
+#endif
diff --git a/include/rdma/ib_verbs.h b/include/rdma/ib_verbs.h
index a7f4c355a91f..22fc886b9695 100644
--- a/include/rdma/ib_verbs.h
+++ b/include/rdma/ib_verbs.h
@@ -88,7 +88,6 @@ enum ib_atomic_cap {
 struct ib_device_attr {
        u64                     fw_ver;
-        __be64                  node_guid;
        __be64                  sys_image_guid;
        u64                     max_mr_size;
        u64                     page_size_cap;
@@ -951,6 +950,7 @@ struct ib_device {
        u64                          uverbs_cmd_mask;
        int                          uverbs_abi_ver;
+        __be64                       node_guid;
        u8                           node_type;
        u8                           phys_port_cnt;
 };
diff --git a/include/scsi/iscsi_if.h b/include/scsi/iscsi_if.h
index be1bc792ab18..3e5cb5ab2d34 100644
--- a/include/scsi/iscsi_if.h
+++ b/include/scsi/iscsi_if.h
@@ -168,6 +168,12 @@ typedef uint64_t iscsi_connh_t;		/* iSCSI Data-Path connection handle */
 #define iscsi_ptr(_handle) ((void*)(unsigned long)_handle)
 #define iscsi_handle(_ptr) ((uint64_t)(unsigned long)_ptr)
+#define hostdata_session(_hostdata) (iscsi_ptr(*(unsigned long *)_hostdata))
+/**
+ * iscsi_hostdata - get LLD hostdata from scsi_host
+ * @_hostdata: pointer to scsi host's hostdata
+ **/
 #define iscsi_hostdata(_hostdata) ((void*)_hostdata + sizeof(unsigned long))
 /*
diff --git a/include/scsi/scsi.h b/include/scsi/scsi.h
index 6cb1e2788d8b..c60b8ff2f5e4 100644
--- a/include/scsi/scsi.h
+++ b/include/scsi/scsi.h
@@ -32,6 +32,12 @@ extern const unsigned char scsi_command_size[8];
 extern const char *const scsi_device_types[MAX_SCSI_DEVICE_CODE];
 /*
+ * Special value for scanning to specify scanning or rescanning of all
+ * possible channels, (target) ids, or luns on a given shost.
+ */
+#define SCAN_WILD_CARD  ~0
+/*
 *      SCSI opcodes
 */
diff --git a/include/scsi/scsi_cmnd.h b/include/scsi/scsi_cmnd.h
index 41cfc29be899..7529f4388bb4 100644
--- a/include/scsi/scsi_cmnd.h
+++ b/include/scsi/scsi_cmnd.h
@@ -151,6 +151,5 @@ extern struct scsi_cmnd *scsi_get_command(struct scsi_device *, gfp_t);
 extern void scsi_put_command(struct scsi_cmnd *);
 extern void scsi_io_completion(struct scsi_cmnd *, unsigned int, unsigned int);
 extern void scsi_finish_command(struct scsi_cmnd *cmd);
-extern void scsi_setup_blk_pc_cmnd(struct scsi_cmnd *cmd);
 #endif /* _SCSI_SCSI_CMND_H */
diff --git a/include/scsi/scsi_host.h b/include/scsi/scsi_host.h
index 230bc55c0bfa..467274a764d1 100644
--- a/include/scsi/scsi_host.h
+++ b/include/scsi/scsi_host.h
@@ -5,6 +5,7 @@
 #include <linux/list.h>
 #include <linux/types.h>
 #include <linux/workqueue.h>
+#include <linux/mutex.h>
 struct block_device;
 struct completion;
@@ -469,7 +470,7 @@ struct Scsi_Host {
        spinlock_t              default_lock;
        spinlock_t              *host_lock;
-        struct semaphore        scan_mutex;/* serialize scanning activity */
+        struct mutex            scan_mutex;/* serialize scanning activity */
        struct list_head        eh_cmd_q;
        struct task_struct    * ehandler;  /* Error recovery thread. */
diff --git a/include/scsi/scsi_transport.h b/include/scsi/scsi_transport.h
index f6e0bb484c63..e7b1054adf86 100644
--- a/include/scsi/scsi_transport.h
+++ b/include/scsi/scsi_transport.h
@@ -30,12 +30,9 @@ struct scsi_transport_template {
        struct transport_container device_attrs;
        /*
-         * If set, call target_parent prior to allocating a scsi_target,
+         * If set, called from sysfs and legacy procfs rescanning code.
-         * so we get the appropriate parent for the target. This function
-         * is required for transports like FC and iSCSI that do not put the
-         * scsi_target under scsi_host.
         */
-        struct device *(*target_parent)(struct Scsi_Host *, int, uint);
+        int (*user_scan)(struct Scsi_Host *, uint, uint, uint);
        /* The size of the specific transport attribute structure (a
         * space of this size will be left at the end of the
diff --git a/include/scsi/scsi_transport_fc.h b/include/scsi/scsi_transport_fc.h
index 394f14a5b7cb..cf3fec8be1e3 100644
--- a/include/scsi/scsi_transport_fc.h
+++ b/include/scsi/scsi_transport_fc.h
@@ -303,6 +303,7 @@ struct fc_host_attrs {
        /* Fixed Attributes */
        u64 node_name;
        u64 port_name;
+        u64 permanent_port_name;
        u32 supported_classes;
        u8  supported_fc4s[FC_FC4_LIST_SIZE];
        char symbolic_name[FC_SYMBOLIC_NAME_SIZE];
@@ -338,6 +339,8 @@ struct fc_host_attrs {
        (((struct fc_host_attrs *)(x)->shost_data)->node_name)
 #define fc_host_port_name(x)    \
        (((struct fc_host_attrs *)(x)->shost_data)->port_name)
+#define fc_host_permanent_port_name(x)  \
+        (((struct fc_host_attrs *)(x)->shost_data)->permanent_port_name)
 #define fc_host_supported_classes(x)    \
        (((struct fc_host_attrs *)(x)->shost_data)->supported_classes)
 #define fc_host_supported_fc4s(x)       \
@@ -426,6 +429,7 @@ struct fc_function_template {
        /* host fixed attributes */
        unsigned long   show_host_node_name:1;
        unsigned long   show_host_port_name:1;
+        unsigned long   show_host_permanent_port_name:1;
        unsigned long   show_host_supported_classes:1;
        unsigned long   show_host_supported_fc4s:1;
        unsigned long   show_host_symbolic_name:1;
diff --git a/include/scsi/scsi_transport_iscsi.h b/include/scsi/scsi_transport_iscsi.h
index f25041c386ec..16602a547a63 100644
--- a/include/scsi/scsi_transport_iscsi.h
+++ b/include/scsi/scsi_transport_iscsi.h
@@ -23,8 +23,14 @@
 #ifndef SCSI_TRANSPORT_ISCSI_H
 #define SCSI_TRANSPORT_ISCSI_H
+#include <linux/device.h>
 #include <scsi/iscsi_if.h>
+struct scsi_transport_template;
+struct Scsi_Host;
+struct mempool_zone;
+struct iscsi_cls_conn;
 /**
 * struct iscsi_transport - iSCSI Transport template
 *
@@ -48,23 +54,31 @@ struct iscsi_transport {
        char *name;
        unsigned int caps;
        struct scsi_host_template *host_template;
+        /* LLD session/scsi_host data size */
        int hostdata_size;
+        /* LLD iscsi_host data size */
+        int ihostdata_size;
+        /* LLD connection data size */
+        int conndata_size;
        int max_lun;
        unsigned int max_conn;
        unsigned int max_cmd_len;
-        iscsi_sessionh_t (*create_session) (uint32_t initial_cmdsn,
+        struct Scsi_Host *(*create_session) (struct scsi_transport_template *t,
-                                            struct Scsi_Host *shost);
+                                             uint32_t initial_cmdsn);
-        void (*destroy_session) (iscsi_sessionh_t session);
+        void (*destroy_session) (struct Scsi_Host *shost);
-        iscsi_connh_t (*create_conn) (iscsi_sessionh_t session, uint32_t cid);
+        struct iscsi_cls_conn *(*create_conn) (struct Scsi_Host *shost,
+                                uint32_t cid);
        int (*bind_conn) (iscsi_sessionh_t session, iscsi_connh_t conn,
                          uint32_t transport_fd, int is_leading);
        int (*start_conn) (iscsi_connh_t conn);
        void (*stop_conn) (iscsi_connh_t conn, int flag);
-        void (*destroy_conn) (iscsi_connh_t conn);
+        void (*destroy_conn) (struct iscsi_cls_conn *conn);
        int (*set_param) (iscsi_connh_t conn, enum iscsi_param param,
                          uint32_t value);
-        int (*get_param) (iscsi_connh_t conn, enum iscsi_param param,
+        int (*get_conn_param) (void *conndata, enum iscsi_param param,
-                          uint32_t *value);
+                               uint32_t *value);
+        int (*get_session_param) (struct Scsi_Host *shost,
+                                  enum iscsi_param param, uint32_t *value);
        int (*send_pdu) (iscsi_connh_t conn, struct iscsi_hdr *hdr,
                         char *data, uint32_t data_size);
        void (*get_stats) (iscsi_connh_t conn, struct iscsi_stats *stats);
@@ -73,7 +87,7 @@ struct iscsi_transport {
 /*
 * transport registration upcalls
 */
-extern int iscsi_register_transport(struct iscsi_transport *tt);
+extern struct scsi_transport_template *iscsi_register_transport(struct iscsi_transport *tt);
 extern int iscsi_unregister_transport(struct iscsi_transport *tt);
 /*
@@ -83,4 +97,49 @@ extern void iscsi_conn_error(iscsi_connh_t conn, enum iscsi_err error);
 extern int iscsi_recv_pdu(iscsi_connh_t conn, struct iscsi_hdr *hdr,
                          char *data, uint32_t data_size);
+struct iscsi_cls_conn {
+        struct list_head conn_list;     /* item in connlist */
+        void *dd_data;                  /* LLD private data */
+        struct iscsi_transport *transport;
+        iscsi_connh_t connh;
+        int active;                     /* must be accessed with the connlock */
+        struct device dev;              /* sysfs transport/container device */
+        struct mempool_zone *z_error;
+        struct mempool_zone *z_pdu;
+        struct list_head freequeue;
+};
+#define iscsi_dev_to_conn(_dev) \
+        container_of(_dev, struct iscsi_cls_conn, dev)
+struct iscsi_cls_session {
+        struct list_head list;  /* item in session_list */
+        struct iscsi_transport *transport;
+        struct device dev;      /* sysfs transport/container device */
+};
+#define iscsi_dev_to_session(_dev) \
+        container_of(_dev, struct iscsi_cls_session, dev)
+#define iscsi_session_to_shost(_session) \
+        dev_to_shost(_session->dev.parent)
+/*
+ * session and connection functions that can be used by HW iSCSI LLDs
+ */
+extern struct iscsi_cls_session *iscsi_create_session(struct Scsi_Host *shost,
+                                struct iscsi_transport *t);
+extern int iscsi_destroy_session(struct iscsi_cls_session *session);
+extern struct iscsi_cls_conn *iscsi_create_conn(struct iscsi_cls_session *sess,
+                                            uint32_t cid);
+extern int iscsi_destroy_conn(struct iscsi_cls_conn *conn);
+/*
+ * session functions used by software iscsi
+ */
+extern struct Scsi_Host *
+iscsi_transport_create_session(struct scsi_transport_template *scsit,
+                               struct iscsi_transport *transport);
+extern int iscsi_transport_destroy_session(struct Scsi_Host *shost);
 #endif
diff --git a/include/scsi/scsi_transport_spi.h b/include/scsi/scsi_transport_spi.h
index 54a89611e9c5..2b5930ba69ec 100644
--- a/include/scsi/scsi_transport_spi.h
+++ b/include/scsi/scsi_transport_spi.h
@@ -54,7 +54,7 @@ struct spi_transport_attrs {
        unsigned int support_qas; /* supports quick arbitration and selection */
        /* Private Fields */
        unsigned int dv_pending:1; /* Internal flag */
-        struct semaphore dv_sem; /* semaphore to serialise dv */
+        struct mutex dv_mutex; /* semaphore to serialise dv */
 };
 enum spi_signal_type {
author	Mauro Carvalho Chehab <mchehab@infradead.org>	2006-01-15 17:59:29 -0500
committer	Mauro Carvalho Chehab <mchehab@infradead.org>	2006-01-15 17:59:29 -0500
commit	f1dccedc8148026d9071c6805f7cb77374a9e56f (patch)
tree	ba4a630084b8d21309930321ff53a6ed4381c0f3 /include
parent	c943aa859c392eb4cc76d911daa1f261555075b2 (diff)
parent	0238cb4e7583c521bb3538060f98a73e65f61324 (diff)