202 files changed, 5347 insertions, 1946 deletions
diff --git a/include/linux/acpi.h b/include/linux/acpi.h
index 026c3c011dc0..84d3d9f034ce 100644
--- a/include/linux/acpi.h
+++ b/include/linux/acpi.h
@@ -435,7 +435,7 @@ extern int sbf_port ;
 #endif  /* !CONFIG_ACPI */
-int acpi_register_gsi (u32 gsi, int edge_level, int active_high_low);
+int acpi_register_gsi (u32 gsi, int triggering, int polarity);
 int acpi_gsi_to_irq (u32 gsi, unsigned int *irq);
 /*
diff --git a/include/linux/aio.h b/include/linux/aio.h
index 49fd37629ee4..00c8efa95cc3 100644
--- a/include/linux/aio.h
+++ b/include/linux/aio.h
@@ -94,26 +94,27 @@ struct kiocb {
        ssize_t                 (*ki_retry)(struct kiocb *);
        void                    (*ki_dtor)(struct kiocb *);
-        struct list_head        ki_list;        /* the aio core uses this
-                                                 * for cancellation */
        union {
                void __user             *user;
                struct task_struct      *tsk;
        } ki_obj;
        __u64                   ki_user_data;   /* user's data for completion */
+        wait_queue_t            ki_wait;
        loff_t                  ki_pos;
+        void                    *private;
        /* State that we remember to be able to restart/retry  */
        unsigned short          ki_opcode;
        size_t                  ki_nbytes;      /* copy of iocb->aio_nbytes */
        char                    __user *ki_buf; /* remaining iocb->aio_buf */
        size_t                  ki_left;        /* remaining bytes */
-        wait_queue_t            ki_wait;
        long                    ki_retried;     /* just for testing */
        long                    ki_kicked;      /* just for testing */
        long                    ki_queued;      /* just for testing */
-        void                    *private;
+        struct list_head        ki_list;        /* the aio core uses this
+                                                 * for cancellation */
 };
 #define is_sync_kiocb(iocb)     ((iocb)->ki_key == KIOCB_SYNC_KEY)
@@ -126,6 +127,7 @@ struct kiocb {
                (x)->ki_filp = (filp);                  \
                (x)->ki_ctx = NULL;                     \
                (x)->ki_cancel = NULL;                  \
+                (x)->ki_retry = NULL;                   \
                (x)->ki_dtor = NULL;                    \
                (x)->ki_obj.tsk = tsk;                  \
                (x)->ki_user_data = 0;                  \
diff --git a/include/linux/amba/bus.h b/include/linux/amba/bus.h
new file mode 100644
index 000000000000..51e6e54b2aa1
--- /dev/null
+++ b/include/linux/amba/bus.h
@@ -0,0 +1,55 @@
+/*
+ *  linux/include/asm-arm/hardware/amba.h
+ *
+ *  Copyright (C) 2003 Deep Blue Solutions Ltd, 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 version 2 as
+ * published by the Free Software Foundation.
+ */
+#ifndef ASMARM_AMBA_H
+#define ASMARM_AMBA_H
+#define AMBA_NR_IRQS    2
+struct amba_device {
+        struct device           dev;
+        struct resource         res;
+        u64                     dma_mask;
+        unsigned int            periphid;
+        unsigned int            irq[AMBA_NR_IRQS];
+};
+struct amba_id {
+        unsigned int            id;
+        unsigned int            mask;
+        void                    *data;
+};
+struct amba_driver {
+        struct device_driver    drv;
+        int                     (*probe)(struct amba_device *, void *);
+        int                     (*remove)(struct amba_device *);
+        void                    (*shutdown)(struct amba_device *);
+        int                     (*suspend)(struct amba_device *, pm_message_t);
+        int                     (*resume)(struct amba_device *);
+        struct amba_id          *id_table;
+};
+#define amba_get_drvdata(d)     dev_get_drvdata(&d->dev)
+#define amba_set_drvdata(d,p)   dev_set_drvdata(&d->dev, p)
+int amba_driver_register(struct amba_driver *);
+void amba_driver_unregister(struct amba_driver *);
+int amba_device_register(struct amba_device *, struct resource *);
+void amba_device_unregister(struct amba_device *);
+struct amba_device *amba_find_device(const char *, struct device *, unsigned int, unsigned int);
+int amba_request_regions(struct amba_device *, const char *);
+void amba_release_regions(struct amba_device *);
+#define amba_config(d)  (((d)->periphid >> 24) & 0xff)
+#define amba_rev(d)     (((d)->periphid >> 20) & 0x0f)
+#define amba_manf(d)    (((d)->periphid >> 12) & 0xff)
+#define amba_part(d)    ((d)->periphid & 0xfff)
+#endif
diff --git a/include/linux/amba/clcd.h b/include/linux/amba/clcd.h
new file mode 100644
index 000000000000..6b8d73dc1ab0
--- /dev/null
+++ b/include/linux/amba/clcd.h
@@ -0,0 +1,271 @@
+/*
+ * linux/include/asm-arm/hardware/amba_clcd.h -- Integrator LCD panel.
+ *
+ * David A Rusling
+ *
+ * Copyright (C) 2001 ARM Limited
+ *
+ * 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.
+ */
+#include <linux/config.h>
+#include <linux/fb.h>
+/*
+ * CLCD Controller Internal Register addresses
+ */
+#define CLCD_TIM0               0x00000000
+#define CLCD_TIM1               0x00000004
+#define CLCD_TIM2               0x00000008
+#define CLCD_TIM3               0x0000000c
+#define CLCD_UBAS               0x00000010
+#define CLCD_LBAS               0x00000014
+#if !defined(CONFIG_ARCH_VERSATILE) && !defined(CONFIG_ARCH_REALVIEW)
+#define CLCD_IENB               0x00000018
+#define CLCD_CNTL               0x0000001c
+#else
+/*
+ * Someone rearranged these two registers on the Versatile
+ * platform...
+ */
+#define CLCD_IENB               0x0000001c
+#define CLCD_CNTL               0x00000018
+#endif
+#define CLCD_STAT               0x00000020
+#define CLCD_INTR               0x00000024
+#define CLCD_UCUR               0x00000028
+#define CLCD_LCUR               0x0000002C
+#define CLCD_PALL               0x00000200
+#define CLCD_PALETTE            0x00000200
+#define TIM2_CLKSEL             (1 << 5)
+#define TIM2_IVS                (1 << 11)
+#define TIM2_IHS                (1 << 12)
+#define TIM2_IPC                (1 << 13)
+#define TIM2_IOE                (1 << 14)
+#define TIM2_BCD                (1 << 26)
+#define CNTL_LCDEN              (1 << 0)
+#define CNTL_LCDBPP1            (0 << 1)
+#define CNTL_LCDBPP2            (1 << 1)
+#define CNTL_LCDBPP4            (2 << 1)
+#define CNTL_LCDBPP8            (3 << 1)
+#define CNTL_LCDBPP16           (4 << 1)
+#define CNTL_LCDBPP24           (5 << 1)
+#define CNTL_LCDBW              (1 << 4)
+#define CNTL_LCDTFT             (1 << 5)
+#define CNTL_LCDMONO8           (1 << 6)
+#define CNTL_LCDDUAL            (1 << 7)
+#define CNTL_BGR                (1 << 8)
+#define CNTL_BEBO               (1 << 9)
+#define CNTL_BEPO               (1 << 10)
+#define CNTL_LCDPWR             (1 << 11)
+#define CNTL_LCDVCOMP(x)        ((x) << 12)
+#define CNTL_LDMAFIFOTIME       (1 << 15)
+#define CNTL_WATERMARK          (1 << 16)
+struct clcd_panel {
+        struct fb_videomode     mode;
+        signed short            width;  /* width in mm */
+        signed short            height; /* height in mm */
+        u32                     tim2;
+        u32                     tim3;
+        u32                     cntl;
+        unsigned int            bpp:8,
+                                fixedtimings:1,
+                                grayscale:1;
+        unsigned int            connector;
+};
+struct clcd_regs {
+        u32                     tim0;
+        u32                     tim1;
+        u32                     tim2;
+        u32                     tim3;
+        u32                     cntl;
+        unsigned long           pixclock;
+};
+struct clcd_fb;
+/*
+ * the board-type specific routines
+ */
+struct clcd_board {
+        const char *name;
+        /*
+         * Optional.  Check whether the var structure is acceptable
+         * for this display.
+         */
+        int     (*check)(struct clcd_fb *fb, struct fb_var_screeninfo *var);
+        /*
+         * Compulsary.  Decode fb->fb.var into regs->*.  In the case of
+         * fixed timing, set regs->* to the register values required.
+         */
+        void    (*decode)(struct clcd_fb *fb, struct clcd_regs *regs);
+        /*
+         * Optional.  Disable any extra display hardware.
+         */
+        void    (*disable)(struct clcd_fb *);
+        /*
+         * Optional.  Enable any extra display hardware.
+         */
+        void    (*enable)(struct clcd_fb *);
+        /*
+         * Setup platform specific parts of CLCD driver
+         */
+        int     (*setup)(struct clcd_fb *);
+        /*
+         * mmap the framebuffer memory
+         */
+        int     (*mmap)(struct clcd_fb *, struct vm_area_struct *);
+        /*
+         * Remove platform specific parts of CLCD driver
+         */
+        void    (*remove)(struct clcd_fb *);
+};
+struct amba_device;
+struct clk;
+/* this data structure describes each frame buffer device we find */
+struct clcd_fb {
+        struct fb_info          fb;
+        struct amba_device      *dev;
+        struct clk              *clk;
+        struct clcd_panel       *panel;
+        struct clcd_board       *board;
+        void                    *board_data;
+        void __iomem            *regs;
+        u32                     clcd_cntl;
+        u32                     cmap[16];
+};
+static inline void clcdfb_decode(struct clcd_fb *fb, struct clcd_regs *regs)
+{
+        u32 val, cpl;
+        /*
+         * Program the CLCD controller registers and start the CLCD
+         */
+        val = ((fb->fb.var.xres / 16) - 1) << 2;
+        val |= (fb->fb.var.hsync_len - 1) << 8;
+        val |= (fb->fb.var.right_margin - 1) << 16;
+        val |= (fb->fb.var.left_margin - 1) << 24;
+        regs->tim0 = val;
+        val = fb->fb.var.yres;
+        if (fb->panel->cntl & CNTL_LCDDUAL)
+                val /= 2;
+        val -= 1;
+        val |= (fb->fb.var.vsync_len - 1) << 10;
+        val |= fb->fb.var.lower_margin << 16;
+        val |= fb->fb.var.upper_margin << 24;
+        regs->tim1 = val;
+        val = fb->panel->tim2;
+        val |= fb->fb.var.sync & FB_SYNC_HOR_HIGH_ACT  ? 0 : TIM2_IHS;
+        val |= fb->fb.var.sync & FB_SYNC_VERT_HIGH_ACT ? 0 : TIM2_IVS;
+        cpl = fb->fb.var.xres_virtual;
+        if (fb->panel->cntl & CNTL_LCDTFT)        /* TFT */
+                /* / 1 */;
+        else if (!fb->fb.var.grayscale)           /* STN color */
+                cpl = cpl * 8 / 3;
+        else if (fb->panel->cntl & CNTL_LCDMONO8) /* STN monochrome, 8bit */
+                cpl /= 8;
+        else                                      /* STN monochrome, 4bit */
+                cpl /= 4;
+        regs->tim2 = val | ((cpl - 1) << 16);
+        regs->tim3 = fb->panel->tim3;
+        val = fb->panel->cntl;
+        if (fb->fb.var.grayscale)
+                val |= CNTL_LCDBW;
+        switch (fb->fb.var.bits_per_pixel) {
+        case 1:
+                val |= CNTL_LCDBPP1;
+                break;
+        case 2:
+                val |= CNTL_LCDBPP2;
+                break;
+        case 4:
+                val |= CNTL_LCDBPP4;
+                break;
+        case 8:
+                val |= CNTL_LCDBPP8;
+                break;
+        case 16:
+                val |= CNTL_LCDBPP16;
+                break;
+        case 32:
+                val |= CNTL_LCDBPP24;
+                break;
+        }
+        regs->cntl = val;
+        regs->pixclock = fb->fb.var.pixclock;
+}
+static inline int clcdfb_check(struct clcd_fb *fb, struct fb_var_screeninfo *var)
+{
+        var->xres_virtual = var->xres = (var->xres + 15) & ~15;
+        var->yres_virtual = var->yres = (var->yres + 1) & ~1;
+#define CHECK(e,l,h) (var->e < l || var->e > h)
+        if (CHECK(right_margin, (5+1), 256) ||  /* back porch */
+            CHECK(left_margin, (5+1), 256) ||   /* front porch */
+            CHECK(hsync_len, (5+1), 256) ||
+            var->xres > 4096 ||
+            var->lower_margin > 255 ||          /* back porch */
+            var->upper_margin > 255 ||          /* front porch */
+            var->vsync_len > 32 ||
+            var->yres > 1024)
+                return -EINVAL;
+#undef CHECK
+        /* single panel mode: PCD = max(PCD, 1) */
+        /* dual panel mode: PCD = max(PCD, 5) */
+        /*
+         * You can't change the grayscale setting, and
+         * we can only do non-interlaced video.
+         */
+        if (var->grayscale != fb->fb.var.grayscale ||
+            (var->vmode & FB_VMODE_MASK) != FB_VMODE_NONINTERLACED)
+                return -EINVAL;
+#define CHECK(e) (var->e != fb->fb.var.e)
+        if (fb->panel->fixedtimings &&
+            (CHECK(xres)                ||
+             CHECK(yres)                ||
+             CHECK(bits_per_pixel)      ||
+             CHECK(pixclock)            ||
+             CHECK(left_margin)         ||
+             CHECK(right_margin)        ||
+             CHECK(upper_margin)        ||
+             CHECK(lower_margin)        ||
+             CHECK(hsync_len)           ||
+             CHECK(vsync_len)           ||
+             CHECK(sync)))
+                return -EINVAL;
+#undef CHECK
+        var->nonstd = 0;
+        var->accel_flags = 0;
+        return 0;
+}
diff --git a/include/linux/amba/kmi.h b/include/linux/amba/kmi.h
new file mode 100644
index 000000000000..a39e5be751b3
--- /dev/null
+++ b/include/linux/amba/kmi.h
@@ -0,0 +1,92 @@
+/*
+ *  linux/include/asm-arm/hardware/amba_kmi.h
+ *
+ *  Internal header file for AMBA KMI ports
+ *
+ *  Copyright (C) 2000 Deep Blue Solutions Ltd.
+ *
+ * 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
+ *
+ *
+ * ---------------------------------------------------------------------------
+ *  From ARM PrimeCell(tm) PS2 Keyboard/Mouse Interface (PL050) Technical
+ *  Reference Manual - ARM DDI 0143B - see http://www.arm.com/
+ * ---------------------------------------------------------------------------
+ */
+#ifndef ASM_ARM_HARDWARE_AMBA_KMI_H
+#define ASM_ARM_HARDWARE_AMBA_KMI_H
+/*
+ * KMI control register:
+ *  KMICR_TYPE       0 = PS2/AT mode, 1 = No line control bit mode
+ *  KMICR_RXINTREN   1 = enable RX interrupts
+ *  KMICR_TXINTREN   1 = enable TX interrupts
+ *  KMICR_EN         1 = enable KMI
+ *  KMICR_FD         1 = force KMI data low
+ *  KMICR_FC         1 = force KMI clock low
+ */
+#define KMICR           (KMI_BASE + 0x00)
+#define KMICR_TYPE              (1 << 5)
+#define KMICR_RXINTREN          (1 << 4)
+#define KMICR_TXINTREN          (1 << 3)
+#define KMICR_EN                (1 << 2)
+#define KMICR_FD                (1 << 1)
+#define KMICR_FC                (1 << 0)
+/*
+ * KMI status register:
+ *  KMISTAT_TXEMPTY  1 = transmitter register empty
+ *  KMISTAT_TXBUSY   1 = currently sending data
+ *  KMISTAT_RXFULL   1 = receiver register ready to be read
+ *  KMISTAT_RXBUSY   1 = currently receiving data
+ *  KMISTAT_RXPARITY parity of last databyte received
+ *  KMISTAT_IC       current level of KMI clock input
+ *  KMISTAT_ID       current level of KMI data input
+ */
+#define KMISTAT         (KMI_BASE + 0x04)
+#define KMISTAT_TXEMPTY         (1 << 6)
+#define KMISTAT_TXBUSY          (1 << 5)
+#define KMISTAT_RXFULL          (1 << 4)
+#define KMISTAT_RXBUSY          (1 << 3)
+#define KMISTAT_RXPARITY        (1 << 2)
+#define KMISTAT_IC              (1 << 1)
+#define KMISTAT_ID              (1 << 0)
+/*
+ * KMI data register
+ */
+#define KMIDATA         (KMI_BASE + 0x08)
+/*
+ * KMI clock divisor: to generate 8MHz internal clock
+ *  div = (ref / 8MHz) - 1; 0 <= div <= 15
+ */
+#define KMICLKDIV       (KMI_BASE + 0x0c)
+/*
+ * KMI interrupt register:
+ *  KMIIR_TXINTR     1 = transmit interrupt asserted
+ *  KMIIR_RXINTR     1 = receive interrupt asserted
+ */
+#define KMIIR           (KMI_BASE + 0x10)
+#define KMIIR_TXINTR            (1 << 1)
+#define KMIIR_RXINTR            (1 << 0)
+/*
+ * The size of the KMI primecell
+ */
+#define KMI_SIZE        (0x100)
+#endif
diff --git a/include/linux/amba/serial.h b/include/linux/amba/serial.h
new file mode 100644
index 000000000000..dc726ffccebd
--- /dev/null
+++ b/include/linux/amba/serial.h
@@ -0,0 +1,161 @@
+/*
+ *  linux/include/asm-arm/hardware/serial_amba.h
+ *
+ *  Internal header file for AMBA serial ports
+ *
+ *  Copyright (C) ARM Limited
+ *  Copyright (C) 2000 Deep Blue Solutions Ltd.
+ *
+ * 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_SERIAL_AMBA_H
+#define ASM_ARM_HARDWARE_SERIAL_AMBA_H
+/* -------------------------------------------------------------------------------
+ *  From AMBA UART (PL010) Block Specification
+ * -------------------------------------------------------------------------------
+ *  UART Register Offsets.
+ */
+#define UART01x_DR              0x00    /* Data read or written from the interface. */
+#define UART01x_RSR             0x04    /* Receive status register (Read). */
+#define UART01x_ECR             0x04    /* Error clear register (Write). */
+#define UART010_LCRH            0x08    /* Line control register, high byte. */
+#define UART010_LCRM            0x0C    /* Line control register, middle byte. */
+#define UART010_LCRL            0x10    /* Line control register, low byte. */
+#define UART010_CR              0x14    /* Control register. */
+#define UART01x_FR              0x18    /* Flag register (Read only). */
+#define UART010_IIR             0x1C    /* Interrupt indentification register (Read). */
+#define UART010_ICR             0x1C    /* Interrupt clear register (Write). */
+#define UART01x_ILPR            0x20    /* IrDA low power counter register. */
+#define UART011_IBRD            0x24    /* Integer baud rate divisor register. */
+#define UART011_FBRD            0x28    /* Fractional baud rate divisor register. */
+#define UART011_LCRH            0x2c    /* Line control register. */
+#define UART011_CR              0x30    /* Control register. */
+#define UART011_IFLS            0x34    /* Interrupt fifo level select. */
+#define UART011_IMSC            0x38    /* Interrupt mask. */
+#define UART011_RIS             0x3c    /* Raw interrupt status. */
+#define UART011_MIS             0x40    /* Masked interrupt status. */
+#define UART011_ICR             0x44    /* Interrupt clear register. */
+#define UART011_DMACR           0x48    /* DMA control register. */
+#define UART011_DR_OE           (1 << 11)
+#define UART011_DR_BE           (1 << 10)
+#define UART011_DR_PE           (1 << 9)
+#define UART011_DR_FE           (1 << 8)
+#define UART01x_RSR_OE          0x08
+#define UART01x_RSR_BE          0x04
+#define UART01x_RSR_PE          0x02
+#define UART01x_RSR_FE          0x01
+#define UART011_FR_RI           0x100
+#define UART011_FR_TXFE         0x080
+#define UART011_FR_RXFF         0x040
+#define UART01x_FR_TXFF         0x020
+#define UART01x_FR_RXFE         0x010
+#define UART01x_FR_BUSY         0x008
+#define UART01x_FR_DCD          0x004
+#define UART01x_FR_DSR          0x002
+#define UART01x_FR_CTS          0x001
+#define UART01x_FR_TMSK         (UART01x_FR_TXFF + UART01x_FR_BUSY)
+#define UART011_CR_CTSEN        0x8000  /* CTS hardware flow control */
+#define UART011_CR_RTSEN        0x4000  /* RTS hardware flow control */
+#define UART011_CR_OUT2         0x2000  /* OUT2 */
+#define UART011_CR_OUT1         0x1000  /* OUT1 */
+#define UART011_CR_RTS          0x0800  /* RTS */
+#define UART011_CR_DTR          0x0400  /* DTR */
+#define UART011_CR_RXE          0x0200  /* receive enable */
+#define UART011_CR_TXE          0x0100  /* transmit enable */
+#define UART011_CR_LBE          0x0080  /* loopback enable */
+#define UART010_CR_RTIE         0x0040
+#define UART010_CR_TIE          0x0020
+#define UART010_CR_RIE          0x0010
+#define UART010_CR_MSIE         0x0008
+#define UART01x_CR_IIRLP        0x0004  /* SIR low power mode */
+#define UART01x_CR_SIREN        0x0002  /* SIR enable */
+#define UART01x_CR_UARTEN       0x0001  /* UART enable */
+ 
+#define UART011_LCRH_SPS        0x80
+#define UART01x_LCRH_WLEN_8     0x60
+#define UART01x_LCRH_WLEN_7     0x40
+#define UART01x_LCRH_WLEN_6     0x20
+#define UART01x_LCRH_WLEN_5     0x00
+#define UART01x_LCRH_FEN        0x10
+#define UART01x_LCRH_STP2       0x08
+#define UART01x_LCRH_EPS        0x04
+#define UART01x_LCRH_PEN        0x02
+#define UART01x_LCRH_BRK        0x01
+#define UART010_IIR_RTIS        0x08
+#define UART010_IIR_TIS         0x04
+#define UART010_IIR_RIS         0x02
+#define UART010_IIR_MIS         0x01
+#define UART011_IFLS_RX1_8      (0 << 3)
+#define UART011_IFLS_RX2_8      (1 << 3)
+#define UART011_IFLS_RX4_8      (2 << 3)
+#define UART011_IFLS_RX6_8      (3 << 3)
+#define UART011_IFLS_RX7_8      (4 << 3)
+#define UART011_IFLS_TX1_8      (0 << 0)
+#define UART011_IFLS_TX2_8      (1 << 0)
+#define UART011_IFLS_TX4_8      (2 << 0)
+#define UART011_IFLS_TX6_8      (3 << 0)
+#define UART011_IFLS_TX7_8      (4 << 0)
+#define UART011_OEIM            (1 << 10)       /* overrun error interrupt mask */
+#define UART011_BEIM            (1 << 9)        /* break error interrupt mask */
+#define UART011_PEIM            (1 << 8)        /* parity error interrupt mask */
+#define UART011_FEIM            (1 << 7)        /* framing error interrupt mask */
+#define UART011_RTIM            (1 << 6)        /* receive timeout interrupt mask */
+#define UART011_TXIM            (1 << 5)        /* transmit interrupt mask */
+#define UART011_RXIM            (1 << 4)        /* receive interrupt mask */
+#define UART011_DSRMIM          (1 << 3)        /* DSR interrupt mask */
+#define UART011_DCDMIM          (1 << 2)        /* DCD interrupt mask */
+#define UART011_CTSMIM          (1 << 1)        /* CTS interrupt mask */
+#define UART011_RIMIM           (1 << 0)        /* RI interrupt mask */
+#define UART011_OEIS            (1 << 10)       /* overrun error interrupt status */
+#define UART011_BEIS            (1 << 9)        /* break error interrupt status */
+#define UART011_PEIS            (1 << 8)        /* parity error interrupt status */
+#define UART011_FEIS            (1 << 7)        /* framing error interrupt status */
+#define UART011_RTIS            (1 << 6)        /* receive timeout interrupt status */
+#define UART011_TXIS            (1 << 5)        /* transmit interrupt status */
+#define UART011_RXIS            (1 << 4)        /* receive interrupt status */
+#define UART011_DSRMIS          (1 << 3)        /* DSR interrupt status */
+#define UART011_DCDMIS          (1 << 2)        /* DCD interrupt status */
+#define UART011_CTSMIS          (1 << 1)        /* CTS interrupt status */
+#define UART011_RIMIS           (1 << 0)        /* RI interrupt status */
+#define UART011_OEIC            (1 << 10)       /* overrun error interrupt clear */
+#define UART011_BEIC            (1 << 9)        /* break error interrupt clear */
+#define UART011_PEIC            (1 << 8)        /* parity error interrupt clear */
+#define UART011_FEIC            (1 << 7)        /* framing error interrupt clear */
+#define UART011_RTIC            (1 << 6)        /* receive timeout interrupt clear */
+#define UART011_TXIC            (1 << 5)        /* transmit interrupt clear */
+#define UART011_RXIC            (1 << 4)        /* receive interrupt clear */
+#define UART011_DSRMIC          (1 << 3)        /* DSR interrupt clear */
+#define UART011_DCDMIC          (1 << 2)        /* DCD interrupt clear */
+#define UART011_CTSMIC          (1 << 1)        /* CTS interrupt clear */
+#define UART011_RIMIC           (1 << 0)        /* RI interrupt clear */
+#define UART011_DMAONERR        (1 << 2)        /* disable dma on error */
+#define UART011_TXDMAE          (1 << 1)        /* enable transmit dma */
+#define UART011_RXDMAE          (1 << 0)        /* enable receive dma */
+#define UART01x_RSR_ANY         (UART01x_RSR_OE|UART01x_RSR_BE|UART01x_RSR_PE|UART01x_RSR_FE)
+#define UART01x_FR_MODEM_ANY    (UART01x_FR_DCD|UART01x_FR_DSR|UART01x_FR_CTS)
+#endif
diff --git a/include/linux/atalk.h b/include/linux/atalk.h
index 911c09cb9bf9..6ba3aa8a81f4 100644
--- a/include/linux/atalk.h
+++ b/include/linux/atalk.h
@@ -155,15 +155,15 @@ struct elapaarp {
 #define AARP_REQUEST                    1
 #define AARP_REPLY                      2
 #define AARP_PROBE                      3
-        __u8    hw_src[ETH_ALEN]        __attribute__ ((packed));
+        __u8    hw_src[ETH_ALEN];
-        __u8    pa_src_zero             __attribute__ ((packed));
+        __u8    pa_src_zero;
-        __be16  pa_src_net              __attribute__ ((packed));
+        __be16  pa_src_net;
-        __u8    pa_src_node             __attribute__ ((packed));
+        __u8    pa_src_node;
-        __u8    hw_dst[ETH_ALEN]        __attribute__ ((packed));
+        __u8    hw_dst[ETH_ALEN];
-        __u8    pa_dst_zero             __attribute__ ((packed));
+        __u8    pa_dst_zero;
-        __be16  pa_dst_net              __attribute__ ((packed));
+        __be16  pa_dst_net;
-        __u8    pa_dst_node             __attribute__ ((packed));       
+        __u8    pa_dst_node;
-};
+} __attribute__ ((packed));
 static __inline__ struct elapaarp *aarp_hdr(struct sk_buff *skb)
 {
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/blkdev.h b/include/linux/blkdev.h
index fb0985377421..02a585faa62c 100644
--- a/include/linux/blkdev.h
+++ b/include/linux/blkdev.h
@@ -118,9 +118,9 @@ struct request_list {
 * try to put the fields that are referenced together in the same cacheline
 */
 struct request {
-        struct list_head queuelist; /* looking for ->queue? you must _not_
+        struct list_head queuelist;
-                                     * access it directly, use
+        struct list_head donelist;
-                                     * blkdev_dequeue_request! */
        unsigned long flags;            /* see REQ_ bits below */
        /* Maintain bio traversal state for part by part I/O submission.
@@ -141,6 +141,7 @@ struct request {
        struct bio *biotail;
        void *elevator_private;
+        void *completion_data;
        unsigned short ioprio;
@@ -291,6 +292,7 @@ typedef int (merge_bvec_fn) (request_queue_t *, struct bio *, struct bio_vec *);
 typedef void (activity_fn) (void *data, int rw);
 typedef int (issue_flush_fn) (request_queue_t *, struct gendisk *, sector_t *);
 typedef void (prepare_flush_fn) (request_queue_t *, struct request *);
+typedef void (softirq_done_fn)(struct request *);
 enum blk_queue_state {
        Queue_down,
@@ -332,6 +334,7 @@ struct request_queue
        activity_fn             *activity_fn;
        issue_flush_fn          *issue_flush_fn;
        prepare_flush_fn        *prepare_flush_fn;
+        softirq_done_fn         *softirq_done_fn;
        /*
         * Dispatch queue sorting
@@ -592,7 +595,6 @@ extern void generic_make_request(struct bio *bio);
 extern void blk_put_request(struct request *);
 extern void __blk_put_request(request_queue_t *, struct request *);
 extern void blk_end_sync_rq(struct request *rq, int error);
-extern void blk_attempt_remerge(request_queue_t *, struct request *);
 extern struct request *blk_get_request(request_queue_t *, int, gfp_t);
 extern void blk_insert_request(request_queue_t *, struct request *, int, void *);
 extern void blk_requeue_request(request_queue_t *, struct request *);
@@ -646,6 +648,17 @@ extern int end_that_request_first(struct request *, int, int);
 extern int end_that_request_chunk(struct request *, int, int);
 extern void end_that_request_last(struct request *, int);
 extern void end_request(struct request *req, int uptodate);
+extern void blk_complete_request(struct request *);
+static inline int rq_all_done(struct request *rq, unsigned int nr_bytes)
+{
+        if (blk_fs_request(rq))
+                return (nr_bytes >= (rq->hard_nr_sectors << 9));
+        else if (blk_pc_request(rq))
+                return nr_bytes >= rq->data_len;
+        return 0;
+}
 /*
 * end_that_request_first/chunk() takes an uptodate argument. we account
@@ -694,6 +707,7 @@ extern void blk_queue_segment_boundary(request_queue_t *, unsigned long);
 extern void blk_queue_prep_rq(request_queue_t *, prep_rq_fn *pfn);
 extern void blk_queue_merge_bvec(request_queue_t *, merge_bvec_fn *);
 extern void blk_queue_dma_alignment(request_queue_t *, int);
+extern void blk_queue_softirq_done(request_queue_t *, softirq_done_fn *);
 extern struct backing_dev_info *blk_get_backing_dev_info(struct block_device *bdev);
 extern int blk_queue_ordered(request_queue_t *, unsigned, prepare_flush_fn *);
 extern void blk_queue_issue_flush_fn(request_queue_t *, issue_flush_fn *);
diff --git a/include/linux/buffer_head.h b/include/linux/buffer_head.h
index 1db061bb6b08..9f159baf153f 100644
--- a/include/linux/buffer_head.h
+++ b/include/linux/buffer_head.h
@@ -197,7 +197,8 @@ int block_read_full_page(struct page*, get_block_t*);
 int block_prepare_write(struct page*, unsigned, unsigned, get_block_t*);
 int cont_prepare_write(struct page*, unsigned, unsigned, get_block_t*,
                                loff_t *);
-int generic_cont_expand(struct inode *inode, loff_t size) ;
+int generic_cont_expand(struct inode *inode, loff_t size);
+int generic_cont_expand_simple(struct inode *inode, loff_t size);
 int block_commit_write(struct page *page, unsigned from, unsigned to);
 int block_sync_page(struct page *);
 sector_t generic_block_bmap(struct address_space *, sector_t, get_block_t *);
diff --git a/include/linux/byteorder/generic.h b/include/linux/byteorder/generic.h
index 04bd756efc67..e86e4a938373 100644
--- a/include/linux/byteorder/generic.h
+++ b/include/linux/byteorder/generic.h
@@ -156,7 +156,7 @@ extern __be32			htonl(__u32);
 extern __u16                    ntohs(__be16);
 extern __be16                   htons(__u16);
-#if defined(__GNUC__) && (__GNUC__ >= 2) && defined(__OPTIMIZE__)
+#if defined(__GNUC__) && defined(__OPTIMIZE__)
 #define ___htonl(x) __cpu_to_be32(x)
 #define ___htons(x) __cpu_to_be16(x)
diff --git a/include/linux/byteorder/swab.h b/include/linux/byteorder/swab.h
index 2f1cb775125a..25f7f32883ec 100644
--- a/include/linux/byteorder/swab.h
+++ b/include/linux/byteorder/swab.h
@@ -110,7 +110,7 @@
 /*
 * Allow constant folding
 */
-#if defined(__GNUC__) && (__GNUC__ >= 2) && defined(__OPTIMIZE__)
+#if defined(__GNUC__) && defined(__OPTIMIZE__)
 #  define __swab16(x) \
 (__builtin_constant_p((__u16)(x)) ? \
 ___swab16((x)) : \
diff --git a/include/linux/byteorder/swabb.h b/include/linux/byteorder/swabb.h
index d5f2a3205109..ae5e5f914bf4 100644
--- a/include/linux/byteorder/swabb.h
+++ b/include/linux/byteorder/swabb.h
@@ -77,7 +77,7 @@
 /*
 * Allow constant folding
 */
-#if defined(__GNUC__) && (__GNUC__ >= 2) && defined(__OPTIMIZE__)
+#if defined(__GNUC__) && defined(__OPTIMIZE__)
 #  define __swahw32(x) \
 (__builtin_constant_p((__u32)(x)) ? \
 ___swahw32((x)) : \
diff --git a/include/linux/cache.h b/include/linux/cache.h
index 0b7ecf3af78a..d22e632f41fb 100644
--- a/include/linux/cache.h
+++ b/include/linux/cache.h
@@ -13,7 +13,7 @@
 #define SMP_CACHE_BYTES L1_CACHE_BYTES
 #endif
-#if defined(CONFIG_X86) || defined(CONFIG_SPARC64) || defined(CONFIG_IA64)
+#if defined(CONFIG_X86) || defined(CONFIG_SPARC64) || defined(CONFIG_IA64) || defined(CONFIG_PARISC)
 #define __read_mostly __attribute__((__section__(".data.read_mostly")))
 #else
 #define __read_mostly
@@ -45,12 +45,21 @@
 #endif /* CONFIG_SMP */
 #endif
-#if !defined(____cacheline_maxaligned_in_smp)
+/*
+ * The maximum alignment needed for some critical structures
+ * These could be inter-node cacheline sizes/L3 cacheline
+ * size etc.  Define this in asm/cache.h for your arch
+ */
+#ifndef INTERNODE_CACHE_SHIFT
+#define INTERNODE_CACHE_SHIFT L1_CACHE_SHIFT
+#endif
+#if !defined(____cacheline_internodealigned_in_smp)
 #if defined(CONFIG_SMP)
-#define ____cacheline_maxaligned_in_smp \
+#define ____cacheline_internodealigned_in_smp \
-        __attribute__((__aligned__(1 << (L1_CACHE_SHIFT_MAX))))
+        __attribute__((__aligned__(1 << (INTERNODE_CACHE_SHIFT))))
 #else
-#define ____cacheline_maxaligned_in_smp
+#define ____cacheline_internodealigned_in_smp
 #endif
 #endif
diff --git a/include/linux/calc64.h b/include/linux/calc64.h
new file mode 100644
index 000000000000..ebf4b8f38d88
--- /dev/null
+++ b/include/linux/calc64.h
@@ -0,0 +1,49 @@
+#ifndef _LINUX_CALC64_H
+#define _LINUX_CALC64_H
+#include <linux/types.h>
+#include <asm/div64.h>
+/*
+ * This is a generic macro which is used when the architecture
+ * specific div64.h does not provide a optimized one.
+ *
+ * The 64bit dividend is divided by the divisor (data type long), the
+ * result is returned and the remainder stored in the variable
+ * referenced by remainder (data type long *). In contrast to the
+ * do_div macro the dividend is kept intact.
+ */
+#ifndef div_long_long_rem
+#define div_long_long_rem(dividend, divisor, remainder) \
+        do_div_llr((dividend), divisor, remainder)
+static inline unsigned long do_div_llr(const long long dividend,
+                                       const long divisor, long *remainder)
+{
+        u64 result = dividend;
+        *(remainder) = do_div(result, divisor);
+        return (unsigned long) result;
+}
+#endif
+/*
+ * Sign aware variation of the above. On some architectures a
+ * negative dividend leads to an divide overflow exception, which
+ * is avoided by the sign check.
+ */
+static inline long div_long_long_rem_signed(const long long dividend,
+                                            const long divisor, long *remainder)
+{
+        long res;
+        if (unlikely(dividend < 0)) {
+                res = -div_long_long_rem(-dividend, divisor, remainder);
+                *remainder = -(*remainder);
+        } else
+                res = div_long_long_rem(dividend, divisor, remainder);
+        return res;
+}
+#endif
diff --git a/include/linux/capability.h b/include/linux/capability.h
index 6b4618902d3d..5a23ce752629 100644
--- a/include/linux/capability.h
+++ b/include/linux/capability.h
@@ -43,6 +43,7 @@ typedef struct __user_cap_data_struct {
 #ifdef __KERNEL__
 #include <linux/spinlock.h>
+#include <asm/current.h>
 /* #define STRICT_CAP_T_TYPECHECKS */
@@ -356,6 +357,8 @@ static inline kernel_cap_t cap_invert(kernel_cap_t c)
 #define cap_is_fs_cap(c)     (CAP_TO_MASK(c) & CAP_FS_MASK)
+extern int capable(int cap);
 #endif /* __KERNEL__ */
 #endif /* !_LINUX_CAPABILITY_H */
diff --git a/include/linux/clk.h b/include/linux/clk.h
new file mode 100644
index 000000000000..12848f81bb37
--- /dev/null
+++ b/include/linux/clk.h
@@ -0,0 +1,124 @@
+/*
+ *  linux/include/linux/clk.h
+ *
+ *  Copyright (C) 2004 ARM Limited.
+ *  Written by Deep Blue Solutions Limited.
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License version 2 as
+ * published by the Free Software Foundation.
+ */
+#ifndef ASMARM_CLOCK_H
+#define ASMARM_CLOCK_H
+struct device;
+/*
+ * The base API.
+ */
+/*
+ * struct clk - an machine class defined object / cookie.
+ */
+struct clk;
+/**
+ * clk_get - lookup and obtain a reference to a clock producer.
+ * @dev: device for clock "consumer"
+ * @id: clock comsumer ID
+ *
+ * Returns a struct clk corresponding to the clock producer, or
+ * valid IS_ERR() condition containing errno.  The implementation
+ * uses @dev and @id to determine the clock consumer, and thereby
+ * the clock producer.  (IOW, @id may be identical strings, but
+ * clk_get may return different clock producers depending on @dev.)
+ *
+ * Drivers must assume that the clock source is not enabled.
+ */
+struct clk *clk_get(struct device *dev, const char *id);
+/**
+ * clk_enable - inform the system when the clock source should be running.
+ * @clk: clock source
+ *
+ * If the clock can not be enabled/disabled, this should return success.
+ *
+ * Returns success (0) or negative errno.
+ */
+int clk_enable(struct clk *clk);
+/**
+ * clk_disable - inform the system when the clock source is no longer required.
+ * @clk: clock source
+ *
+ * Inform the system that a clock source is no longer required by
+ * a driver and may be shut down.
+ *
+ * Implementation detail: if the clock source is shared between
+ * multiple drivers, clk_enable() calls must be balanced by the
+ * same number of clk_disable() calls for the clock source to be
+ * disabled.
+ */
+void clk_disable(struct clk *clk);
+/**
+ * clk_get_rate - obtain the current clock rate (in Hz) for a clock source.
+ *                This is only valid once the clock source has been enabled.
+ * @clk: clock source
+ */
+unsigned long clk_get_rate(struct clk *clk);
+/**
+ * clk_put      - "free" the clock source
+ * @clk: clock source
+ *
+ * Note: drivers must ensure that all clk_enable calls made on this
+ * clock source are balanced by clk_disable calls prior to calling
+ * this function.
+ */
+void clk_put(struct clk *clk);
+/*
+ * The remaining APIs are optional for machine class support.
+ */
+/**
+ * clk_round_rate - adjust a rate to the exact rate a clock can provide
+ * @clk: clock source
+ * @rate: desired clock rate in Hz
+ *
+ * Returns rounded clock rate in Hz, or negative errno.
+ */
+long clk_round_rate(struct clk *clk, unsigned long rate);
+ 
+/**
+ * clk_set_rate - set the clock rate for a clock source
+ * @clk: clock source
+ * @rate: desired clock rate in Hz
+ *
+ * Returns success (0) or negative errno.
+ */
+int clk_set_rate(struct clk *clk, unsigned long rate);
+ 
+/**
+ * clk_set_parent - set the parent clock source for this clock
+ * @clk: clock source
+ * @parent: parent clock source
+ *
+ * Returns success (0) or negative errno.
+ */
+int clk_set_parent(struct clk *clk, struct clk *parent);
+/**
+ * clk_get_parent - get the parent clock source for this clock
+ * @clk: clock source
+ *
+ * Returns struct clk corresponding to parent clock source, or
+ * valid IS_ERR() condition containing errno.
+ */
+struct clk *clk_get_parent(struct clk *clk);
+#endif
diff --git a/include/linux/compat_ioctl.h b/include/linux/compat_ioctl.h
index 119f9d064cc6..8fad50f8e389 100644
--- a/include/linux/compat_ioctl.h
+++ b/include/linux/compat_ioctl.h
@@ -2,14 +2,6 @@
 * compatible types passed or none at all... Please include
 * only stuff that is compatible on *all architectures*.
 */
-#ifndef COMPATIBLE_IOCTL /* pointer to compatible structure or no argument */
-#define COMPATIBLE_IOCTL(cmd)  HANDLE_IOCTL((cmd),(ioctl_trans_handler_t)sys_ioctl)
-#endif
-#ifndef ULONG_IOCTL /* argument is an unsigned long integer, not a pointer */
-#define ULONG_IOCTL(cmd)  HANDLE_IOCTL((cmd),(ioctl_trans_handler_t)sys_ioctl)
-#endif
 COMPATIBLE_IOCTL(0x4B50)   /* KDGHWCLK - not in the kernel, but don't complain */
 COMPATIBLE_IOCTL(0x4B51)   /* KDSHWCLK - not in the kernel, but don't complain */
@@ -218,32 +210,6 @@ COMPATIBLE_IOCTL(VT_RESIZE)
 COMPATIBLE_IOCTL(VT_RESIZEX)
 COMPATIBLE_IOCTL(VT_LOCKSWITCH)
 COMPATIBLE_IOCTL(VT_UNLOCKSWITCH)
-/* Little v */
-/* Little v, the video4linux ioctls (conflict?) */
-COMPATIBLE_IOCTL(VIDIOCGCAP)
-COMPATIBLE_IOCTL(VIDIOCGCHAN)
-COMPATIBLE_IOCTL(VIDIOCSCHAN)
-COMPATIBLE_IOCTL(VIDIOCGPICT)
-COMPATIBLE_IOCTL(VIDIOCSPICT)
-COMPATIBLE_IOCTL(VIDIOCCAPTURE)
-COMPATIBLE_IOCTL(VIDIOCKEY)
-COMPATIBLE_IOCTL(VIDIOCGAUDIO)
-COMPATIBLE_IOCTL(VIDIOCSAUDIO)
-COMPATIBLE_IOCTL(VIDIOCSYNC)
-COMPATIBLE_IOCTL(VIDIOCMCAPTURE)
-COMPATIBLE_IOCTL(VIDIOCGMBUF)
-COMPATIBLE_IOCTL(VIDIOCGUNIT)
-COMPATIBLE_IOCTL(VIDIOCGCAPTURE)
-COMPATIBLE_IOCTL(VIDIOCSCAPTURE)
-/* BTTV specific... */
-COMPATIBLE_IOCTL(_IOW('v',  BASE_VIDIOCPRIVATE+0, char [256]))
-COMPATIBLE_IOCTL(_IOR('v',  BASE_VIDIOCPRIVATE+1, char [256]))
-COMPATIBLE_IOCTL(_IOR('v' , BASE_VIDIOCPRIVATE+2, unsigned int))
-COMPATIBLE_IOCTL(_IOW('v' , BASE_VIDIOCPRIVATE+3, char [16])) /* struct bttv_pll_info */
-COMPATIBLE_IOCTL(_IOR('v' , BASE_VIDIOCPRIVATE+4, int))
-COMPATIBLE_IOCTL(_IOR('v' , BASE_VIDIOCPRIVATE+5, int))
-COMPATIBLE_IOCTL(_IOR('v' , BASE_VIDIOCPRIVATE+6, int))
-COMPATIBLE_IOCTL(_IOR('v' , BASE_VIDIOCPRIVATE+7, int))
 /* Little p (/dev/rtc, /dev/envctrl, etc.) */
 COMPATIBLE_IOCTL(RTC_AIE_ON)
 COMPATIBLE_IOCTL(RTC_AIE_OFF)
diff --git a/include/linux/compiler-gcc.h b/include/linux/compiler-gcc.h
index 152734055403..6e1c44a935d4 100644
--- a/include/linux/compiler-gcc.h
+++ b/include/linux/compiler-gcc.h
@@ -11,7 +11,22 @@
 /* This macro obfuscates arithmetic on a variable address so that gcc
   shouldn't recognize the original var, and make assumptions about it */
+/*
+ * Versions of the ppc64 compiler before 4.1 had a bug where use of
+ * RELOC_HIDE could trash r30. The bug can be worked around by changing
+ * the inline assembly constraint from =g to =r, in this particular
+ * case either is valid.
+ */
 #define RELOC_HIDE(ptr, off)                                    \
  ({ unsigned long __ptr;                                       \
-    __asm__ ("" : "=g"(__ptr) : "0"(ptr));              \
+    __asm__ ("" : "=r"(__ptr) : "0"(ptr));              \
    (typeof(ptr)) (__ptr + (off)); })
+#define inline          inline          __attribute__((always_inline))
+#define __inline__      __inline__      __attribute__((always_inline))
+#define __inline        __inline        __attribute__((always_inline))
+#define __deprecated                    __attribute__((deprecated))
+#define  noinline                       __attribute__((noinline))
+#define __attribute_pure__              __attribute__((pure))
+#define __attribute_const__             __attribute__((__const__))
diff --git a/include/linux/compiler-gcc2.h b/include/linux/compiler-gcc2.h
deleted file mode 100644
index ebed17660c5f..000000000000
--- a/include/linux/compiler-gcc2.h
+++ /dev/null
@@ -1,29 +0,0 @@
-/* Never include this file directly.  Include <linux/compiler.h> instead.  */
-/* These definitions are for GCC v2.x.  */
-/* Somewhere in the middle of the GCC 2.96 development cycle, we implemented
-   a mechanism by which the user can annotate likely branch directions and
-   expect the blocks to be reordered appropriately.  Define __builtin_expect
-   to nothing for earlier compilers.  */
-#include <linux/compiler-gcc.h>
-#if __GNUC_MINOR__ < 96
-# define __builtin_expect(x, expected_value) (x)
-#endif
-#define __attribute_used__      __attribute__((__unused__))
-/*
- * The attribute `pure' is not implemented in GCC versions earlier
- * than 2.96.
- */
-#if __GNUC_MINOR__ >= 96
-# define __attribute_pure__     __attribute__((pure))
-# define __attribute_const__    __attribute__((__const__))
-#endif
-/* GCC 2.95.x/2.96 recognize __va_copy, but not va_copy. Actually later GCC's
- * define both va_copy and __va_copy, but the latter may go away, so limit this
- * to this header */
-#define va_copy                 __va_copy
diff --git a/include/linux/compiler-gcc3.h b/include/linux/compiler-gcc3.h
index a6fa615afab5..1698b845761f 100644
--- a/include/linux/compiler-gcc3.h
+++ b/include/linux/compiler-gcc3.h
@@ -3,30 +3,14 @@
 /* These definitions are for GCC v3.x.  */
 #include <linux/compiler-gcc.h>
-#if __GNUC_MINOR__ >= 1
-# define inline         inline          __attribute__((always_inline))
-# define __inline__     __inline__      __attribute__((always_inline))
-# define __inline       __inline        __attribute__((always_inline))
-#endif
-#if __GNUC_MINOR__ > 0
-# define __deprecated           __attribute__((deprecated))
-#endif
 #if __GNUC_MINOR__ >= 3
 # define __attribute_used__     __attribute__((__used__))
 #else
 # define __attribute_used__     __attribute__((__unused__))
 #endif
-#define __attribute_pure__      __attribute__((pure))
-#define __attribute_const__     __attribute__((__const__))
-#if __GNUC_MINOR__ >= 1
-#define  noinline               __attribute__((noinline))
-#endif
 #if __GNUC_MINOR__ >= 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 53686c037a06..6f5cc6f0e7a6 100644
--- a/include/linux/compiler-gcc4.h
+++ b/include/linux/compiler-gcc4.h
@@ -3,14 +3,16 @@
 /* These definitions are for GCC v4.x.  */
 #include <linux/compiler-gcc.h>
-#define inline                  inline          __attribute__((always_inline))
+#ifdef CONFIG_FORCED_INLINING
-#define __inline__              __inline__      __attribute__((always_inline))
+# undef inline
-#define __inline                __inline        __attribute__((always_inline))
+# undef __inline__
-#define __deprecated            __attribute__((deprecated))
+# 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 __attribute_pure__      __attribute__((pure))
-#define __attribute_const__     __attribute__((__const__))
-#define  noinline               __attribute__((noinline))
 #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/compiler.h b/include/linux/compiler.h
index d7378215b851..f23d3c6fc2c0 100644
--- a/include/linux/compiler.h
+++ b/include/linux/compiler.h
@@ -42,8 +42,6 @@ extern void __chk_io_ptr(void __iomem *);
 # include <linux/compiler-gcc4.h>
 #elif __GNUC__ == 3
 # include <linux/compiler-gcc3.h>
-#elif __GNUC__ == 2
-# include <linux/compiler-gcc2.h>
 #else
 # error Sorry, your compiler is too old/not recognized.
 #endif
diff --git a/include/linux/cpuset.h b/include/linux/cpuset.h
index 6e2deef96b34..3bc606927116 100644
--- a/include/linux/cpuset.h
+++ b/include/linux/cpuset.h
@@ -14,22 +14,46 @@
 #ifdef CONFIG_CPUSETS
+extern int number_of_cpusets;   /* How many cpusets are defined in system? */
+extern int cpuset_init_early(void);
 extern int cpuset_init(void);
 extern void cpuset_init_smp(void);
 extern void cpuset_fork(struct task_struct *p);
 extern void cpuset_exit(struct task_struct *p);
-extern cpumask_t cpuset_cpus_allowed(const struct task_struct *p);
+extern cpumask_t cpuset_cpus_allowed(struct task_struct *p);
+extern nodemask_t cpuset_mems_allowed(struct task_struct *p);
 void cpuset_init_current_mems_allowed(void);
-void cpuset_update_current_mems_allowed(void);
+void cpuset_update_task_memory_state(void);
-void cpuset_restrict_to_mems_allowed(unsigned long *nodes);
+#define cpuset_nodes_subset_current_mems_allowed(nodes) \
+                nodes_subset((nodes), current->mems_allowed)
 int cpuset_zonelist_valid_mems_allowed(struct zonelist *zl);
-extern int cpuset_zone_allowed(struct zone *z, gfp_t gfp_mask);
+extern int __cpuset_zone_allowed(struct zone *z, gfp_t gfp_mask);
+static int inline cpuset_zone_allowed(struct zone *z, gfp_t gfp_mask)
+{
+        return number_of_cpusets <= 1 || __cpuset_zone_allowed(z, gfp_mask);
+}
 extern int cpuset_excl_nodes_overlap(const struct task_struct *p);
+#define cpuset_memory_pressure_bump()                           \
+        do {                                                    \
+                if (cpuset_memory_pressure_enabled)             \
+                        __cpuset_memory_pressure_bump();        \
+        } while (0)
+extern int cpuset_memory_pressure_enabled;
+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; }
 static inline int cpuset_init(void) { return 0; }
 static inline void cpuset_init_smp(void) {}
 static inline void cpuset_fork(struct task_struct *p) {}
@@ -40,9 +64,14 @@ static inline cpumask_t cpuset_cpus_allowed(struct task_struct *p)
        return cpu_possible_map;
 }
+static inline nodemask_t cpuset_mems_allowed(struct task_struct *p)
+{
+        return node_possible_map;
+}
 static inline void cpuset_init_current_mems_allowed(void) {}
-static inline void cpuset_update_current_mems_allowed(void) {}
+static inline void cpuset_update_task_memory_state(void) {}
-static inline void cpuset_restrict_to_mems_allowed(unsigned long *nodes) {}
+#define cpuset_nodes_subset_current_mems_allowed(nodes) (1)
 static inline int cpuset_zonelist_valid_mems_allowed(struct zonelist *zl)
 {
@@ -59,12 +88,17 @@ static inline int cpuset_excl_nodes_overlap(const struct task_struct *p)
        return 1;
 }
+static inline void cpuset_memory_pressure_bump(void) {}
 static inline char *cpuset_task_status_allowed(struct task_struct *task,
                                                        char *buffer)
 {
        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/crypto.h b/include/linux/crypto.h
index 3c89df6e7768..d88bf8aa8b47 100644
--- a/include/linux/crypto.h
+++ b/include/linux/crypto.h
@@ -3,6 +3,7 @@
 *
 * Copyright (c) 2002 James Morris <jmorris@intercode.com.au>
 * Copyright (c) 2002 David S. Miller (davem@redhat.com)
+ * Copyright (c) 2005 Herbert Xu <herbert@gondor.apana.org.au>
 *
 * Portions derived from Cryptoapi, by Alexander Kjeldaas <astor@fast.no>
 * and Nettle, by Niels M�ller.
@@ -126,7 +127,11 @@ struct crypto_alg {
        unsigned int cra_blocksize;
        unsigned int cra_ctxsize;
        unsigned int cra_alignmask;
+        int cra_priority;
        const char cra_name[CRYPTO_MAX_ALG_NAME];
+        const char cra_driver_name[CRYPTO_MAX_ALG_NAME];
        union {
                struct cipher_alg cipher;
diff --git a/include/linux/cycx_x25.h b/include/linux/cycx_x25.h
index b10a7f3a8cac..f7a906583463 100644
--- a/include/linux/cycx_x25.h
+++ b/include/linux/cycx_x25.h
@@ -38,11 +38,11 @@ extern unsigned int cycx_debug;
 /* Data Structures */
 /* X.25 Command Block. */
 struct cycx_x25_cmd {
-        u16 command PACKED;
+        u16 command;
-        u16 link    PACKED; /* values: 0 or 1 */
+        u16 link;       /* values: 0 or 1 */
-        u16 len     PACKED; /* values: 0 thru 0x205 (517) */
+        u16 len;        /* values: 0 thru 0x205 (517) */
-        u32 buf     PACKED;
+        u32 buf;
-};
+} PACKED;
 /* Defines for the 'command' field. */
 #define X25_CONNECT_REQUEST             0x4401
@@ -92,34 +92,34 @@ struct cycx_x25_cmd {
 *      @flags - see dosx25.doc, in portuguese, for details
 */
 struct cycx_x25_config {
-        u8  link        PACKED;
+        u8  link;
-        u8  speed       PACKED;
+        u8  speed;
-        u8  clock       PACKED;
+        u8  clock;
-        u8  n2          PACKED;
+        u8  n2;
-        u8  n2win       PACKED;
+        u8  n2win;
-        u8  n3win       PACKED;
+        u8  n3win;
-        u8  nvc         PACKED;
+        u8  nvc;
-        u8  pktlen      PACKED;
+        u8  pktlen;
-        u8  locaddr     PACKED;
+        u8  locaddr;
-        u8  remaddr     PACKED;
+        u8  remaddr;
-        u16 t1          PACKED;
+        u16 t1;
-        u16 t2          PACKED;
+        u16 t2;
-        u8  t21         PACKED;
+        u8  t21;
-        u8  npvc        PACKED;
+        u8  npvc;
-        u8  t23         PACKED;
+        u8  t23;
-        u8  flags       PACKED;
+        u8  flags;
-};
+} PACKED;
 struct cycx_x25_stats {
-        u16 rx_crc_errors       PACKED;
+        u16 rx_crc_errors;
-        u16 rx_over_errors      PACKED;
+        u16 rx_over_errors;
-        u16 n2_tx_frames        PACKED;
+        u16 n2_tx_frames;
-        u16 n2_rx_frames        PACKED;
+        u16 n2_rx_frames;
-        u16 tx_timeouts         PACKED;
+        u16 tx_timeouts;
-        u16 rx_timeouts         PACKED;
+        u16 rx_timeouts;
-        u16 n3_tx_packets       PACKED;
+        u16 n3_tx_packets;
-        u16 n3_rx_packets       PACKED;
+        u16 n3_rx_packets;
-        u16 tx_aborts           PACKED;
+        u16 tx_aborts;
-        u16 rx_aborts           PACKED;
+        u16 rx_aborts;
-};
+} PACKED;
 #endif  /* _CYCX_X25_H */
diff --git a/include/linux/dcache.h b/include/linux/dcache.h
index 46a2ba617595..a3ed5e059d47 100644
--- a/include/linux/dcache.h
+++ b/include/linux/dcache.h
@@ -95,14 +95,19 @@ struct dentry {
        struct qstr d_name;
        struct list_head d_lru;         /* LRU list */
-        struct list_head d_child;       /* child of parent list */
+        /*
+         * d_child and d_rcu can share memory
+         */
+        union {
+                struct list_head d_child;       /* child of parent list */
+                struct rcu_head d_rcu;
+        } d_u;
        struct list_head d_subdirs;     /* our children */
        struct list_head d_alias;       /* inode alias list */
        unsigned long d_time;           /* used by d_revalidate */
        struct dentry_operations *d_op;
        struct super_block *d_sb;       /* The root of the dentry tree */
        void *d_fsdata;                 /* fs-specific data */
-        struct rcu_head d_rcu;
        struct dcookie_struct *d_cookie; /* cookie, if any */
        int d_mounted;
        unsigned char d_iname[DNAME_INLINE_LEN_MIN];    /* small names */
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/dmi.h b/include/linux/dmi.h
index 05f4132622fc..2e6bbe014157 100644
--- a/include/linux/dmi.h
+++ b/include/linux/dmi.h
@@ -2,6 +2,7 @@
 #define __DMI_H__
 #include <linux/list.h>
+#include <linux/config.h>
 enum dmi_field {
        DMI_NONE,
@@ -60,12 +61,14 @@ struct dmi_device {
        void *device_data;      /* Type specific data */
 };
-#if defined(CONFIG_X86_32)
+#ifdef CONFIG_DMI
 extern int dmi_check_system(struct dmi_system_id *list);
 extern char * dmi_get_system_info(int field);
 extern struct dmi_device * dmi_find_device(int type, const char *name,
        struct dmi_device *from);
+extern void dmi_scan_machine(void);
 #else
 static inline int dmi_check_system(struct dmi_system_id *list) { return 0; }
diff --git a/include/linux/dvb/frontend.h b/include/linux/dvb/frontend.h
index d41df7047ed7..c8cbd90ba375 100644
--- a/include/linux/dvb/frontend.h
+++ b/include/linux/dvb/frontend.h
@@ -240,6 +240,15 @@ struct dvb_frontend_event {
 };
+/**
+ * When set, this flag will disable any zigzagging or other "normal" tuning
+ * behaviour. Additionally, there will be no automatic monitoring of the lock
+ * status, and hence no frontend events will be generated. If a frontend device
+ * is closed, this flag will be automatically turned off when the device is
+ * reopened read-write.
+ */
+#define FE_TUNE_MODE_ONESHOT 0x01
 #define FE_GET_INFO                _IOR('o', 61, struct dvb_frontend_info)
@@ -260,6 +269,7 @@ struct dvb_frontend_event {
 #define FE_SET_FRONTEND            _IOW('o', 76, struct dvb_frontend_parameters)
 #define FE_GET_FRONTEND            _IOR('o', 77, struct dvb_frontend_parameters)
+#define FE_SET_FRONTEND_TUNE_MODE  _IO('o', 81) /* unsigned int */
 #define FE_GET_EVENT               _IOR('o', 78, struct dvb_frontend_event)
 #define FE_DISHNETWORK_SEND_LEGACY_CMD _IO('o', 80) /* unsigned int */
diff --git a/include/linux/elevator.h b/include/linux/elevator.h
index fb80fa44c4dd..23fe746a1d51 100644
--- a/include/linux/elevator.h
+++ b/include/linux/elevator.h
@@ -66,7 +66,7 @@ struct elevator_type
 };
 /*
- * each queue has an elevator_queue assoicated with it
+ * each queue has an elevator_queue associated with it
 */
 struct elevator_queue
 {
@@ -114,8 +114,6 @@ extern ssize_t elv_iosched_store(request_queue_t *, const char *, size_t);
 extern int elevator_init(request_queue_t *, char *);
 extern void elevator_exit(elevator_t *);
 extern int elv_rq_merge_ok(struct request *, struct bio *);
-extern int elv_try_merge(struct request *, struct bio *);
-extern int elv_try_last_merge(request_queue_t *, struct bio *);
 /*
 * Return values from elevator merger
diff --git a/include/linux/elf.h b/include/linux/elf.h
index ff955dbf510d..d3bfacb24496 100644
--- a/include/linux/elf.h
+++ b/include/linux/elf.h
@@ -151,6 +151,8 @@ typedef __s64	Elf64_Sxword;
 #define STT_FUNC    2
 #define STT_SECTION 3
 #define STT_FILE    4
+#define STT_COMMON  5
+#define STT_TLS     6
 #define ELF_ST_BIND(x)          ((x) >> 4)
 #define ELF_ST_TYPE(x)          (((unsigned int) x) & 0xf)
diff --git a/include/linux/ext3_fs_i.h b/include/linux/ext3_fs_i.h
index 2914f7b07156..e71dd98dbcae 100644
--- a/include/linux/ext3_fs_i.h
+++ b/include/linux/ext3_fs_i.h
@@ -87,7 +87,7 @@ struct ext3_inode_info {
 #ifdef CONFIG_EXT3_FS_XATTR
        /*
         * Extended attributes can be read independently of the main file
-         * data. Taking i_sem even when reading would cause contention
+         * data. Taking i_mutex even when reading would cause contention
         * between readers of EAs and writers of regular file data, so
         * instead we synchronize on xattr_sem when reading or changing
         * EAs.
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/fcntl.h b/include/linux/fcntl.h
index 8a7c82151de9..c52a63755fdd 100644
--- a/include/linux/fcntl.h
+++ b/include/linux/fcntl.h
@@ -23,6 +23,13 @@
 #define DN_ATTRIB       0x00000020      /* File changed attibutes */
 #define DN_MULTISHOT    0x80000000      /* Don't remove notifier */
+#define AT_FDCWD                -100    /* Special value used to indicate
+                                           openat should use the current
+                                           working directory. */
+#define AT_SYMLINK_NOFOLLOW     0x100   /* Do not follow symbolic links.  */
+#define AT_REMOVEDIR            0x200   /* Remove directory instead of
+                                           unlinking file.  */
 #ifdef __KERNEL__
 #ifndef force_o_largefile
diff --git a/include/linux/fs.h b/include/linux/fs.h
index 2c9c48d65630..84bb449b9b01 100644
--- a/include/linux/fs.h
+++ b/include/linux/fs.h
@@ -9,7 +9,6 @@
 #include <linux/config.h>
 #include <linux/limits.h>
 #include <linux/ioctl.h>
-#include <linux/rcuref.h>
 /*
 * It's silly to have NR_OPEN bigger than NR_FILE, but you can change
@@ -104,19 +103,18 @@ extern int dir_notify_enable;
 #define MS_MOVE         8192
 #define MS_REC          16384
 #define MS_VERBOSE      32768
+#define MS_POSIXACL     (1<<16) /* VFS does not apply the umask */
 #define MS_UNBINDABLE   (1<<17) /* change to unbindable */
 #define MS_PRIVATE      (1<<18) /* change to private */
 #define MS_SLAVE        (1<<19) /* change to slave */
 #define MS_SHARED       (1<<20) /* change to shared */
-#define MS_POSIXACL     (1<<16) /* VFS does not apply the umask */
 #define MS_ACTIVE       (1<<30)
 #define MS_NOUSER       (1<<31)
 /*
 * Superblock flags that can be altered by MS_REMOUNT
 */
-#define MS_RMT_MASK     (MS_RDONLY|MS_SYNCHRONOUS|MS_MANDLOCK|MS_NOATIME|\
+#define MS_RMT_MASK     (MS_RDONLY|MS_SYNCHRONOUS|MS_MANDLOCK)
-                         MS_NODIRATIME)
 /*
 * Old magic mount flag and mask
@@ -162,8 +160,6 @@ extern int dir_notify_enable;
 #define IS_NOQUOTA(inode)       ((inode)->i_flags & S_NOQUOTA)
 #define IS_APPEND(inode)        ((inode)->i_flags & S_APPEND)
 #define IS_IMMUTABLE(inode)     ((inode)->i_flags & S_IMMUTABLE)
-#define IS_NOATIME(inode)       (__IS_FLG(inode, MS_NOATIME) || ((inode)->i_flags & S_NOATIME))
-#define IS_NODIRATIME(inode)    __IS_FLG(inode, MS_NODIRATIME)
 #define IS_POSIXACL(inode)      __IS_FLG(inode, MS_POSIXACL)
 #define IS_DEADDIR(inode)       ((inode)->i_flags & S_DEAD)
@@ -220,11 +216,13 @@ extern int dir_notify_enable;
 #include <linux/prio_tree.h>
 #include <linux/init.h>
 #include <linux/sched.h>
+#include <linux/mutex.h>
 #include <asm/atomic.h>
 #include <asm/semaphore.h>
 #include <asm/byteorder.h>
+struct hd_geometry;
 struct iovec;
 struct nameidata;
 struct kiocb;
@@ -234,9 +232,6 @@ struct kstatfs;
 struct vm_area_struct;
 struct vfsmount;
-/* Used to be a macro which just called the function, now just a function */
-extern void update_atime (struct inode *);
 extern void __init inode_init(unsigned long);
 extern void __init inode_init_early(void);
 extern void __init mnt_init(unsigned long);
@@ -484,7 +479,7 @@ struct inode {
        unsigned long           i_blocks;
        unsigned short          i_bytes;
        spinlock_t              i_lock; /* i_blocks, i_bytes, maybe i_size */
-        struct semaphore        i_sem;
+        struct mutex            i_mutex;
        struct rw_semaphore     i_alloc_sem;
        struct inode_operations *i_op;
        struct file_operations  *i_fop; /* former ->i_op->default_file_ops */
@@ -653,7 +648,7 @@ extern spinlock_t files_lock;
 #define file_list_lock() spin_lock(&files_lock);
 #define file_list_unlock() spin_unlock(&files_lock);
-#define get_file(x)     rcuref_inc(&(x)->f_count)
+#define get_file(x)     atomic_inc(&(x)->f_count)
 #define file_count(x)   atomic_read(&(x)->f_count)
 #define MAX_NON_LFS     ((1UL<<31) - 1)
@@ -808,7 +803,6 @@ struct super_block {
        struct list_head        s_list;         /* Keep this first */
        dev_t                   s_dev;          /* search index; _not_ kdev_t */
        unsigned long           s_blocksize;
-        unsigned long           s_old_blocksize;
        unsigned char           s_blocksize_bits;
        unsigned char           s_dirt;
        unsigned long long      s_maxbytes;     /* Max file size */
@@ -821,7 +815,7 @@ struct super_block {
        unsigned long           s_magic;
        struct dentry           *s_root;
        struct rw_semaphore     s_umount;
-        struct semaphore        s_lock;
+        struct mutex            s_lock;
        int                     s_count;
        int                     s_syncing;
        int                     s_need_sync_fs;
@@ -893,13 +887,13 @@ static inline int has_fs_excl(void)
 static inline void lock_super(struct super_block * sb)
 {
        get_fs_excl();
-        down(&sb->s_lock);
+        mutex_lock(&sb->s_lock);
 }
 static inline void unlock_super(struct super_block * sb)
 {
        put_fs_excl();
-        up(&sb->s_lock);
+        mutex_unlock(&sb->s_lock);
 }
 /*
@@ -963,6 +957,7 @@ struct block_device_operations {
        int (*direct_access) (struct block_device *, sector_t, unsigned long *);
        int (*media_changed) (struct gendisk *);
        int (*revalidate_disk) (struct gendisk *);
+        int (*getgeo)(struct block_device *, struct hd_geometry *);
        struct module *owner;
 };
@@ -1117,12 +1112,7 @@ static inline void mark_inode_dirty_sync(struct inode *inode)
        __mark_inode_dirty(inode, I_DIRTY_SYNC);
 }
-static inline void touch_atime(struct vfsmount *mnt, struct dentry *dentry)
+extern void touch_atime(struct vfsmount *mnt, struct dentry *dentry);
-{
-        /* per-mountpoint checks will go here */
-        update_atime(dentry->d_inode);
-}
 static inline void file_accessed(struct file *file)
 {
        if (!(file->f_flags & O_NOATIME))
@@ -1191,7 +1181,7 @@ int sync_inode(struct inode *inode, struct writeback_control *wbc);
 *    directory.  The name should be stored in the @name (with the
 *    understanding that it is already pointing to a a %NAME_MAX+1 sized
 *    buffer.   get_name() should return %0 on success, a negative error code
- *    or error.  @get_name will be called without @parent->i_sem held.
+ *    or error.  @get_name will be called without @parent->i_mutex held.
 *
 * get_parent:
 *    @get_parent should find the parent directory for the given @child which
@@ -1213,7 +1203,7 @@ int sync_inode(struct inode *inode, struct writeback_control *wbc);
 *    nfsd_find_fh_dentry() in either the @obj or @parent parameters.
 *
 * Locking rules:
- *    get_parent is called with child->d_inode->i_sem down
+ *    get_parent is called with child->d_inode->i_mutex down
 *    get_name is not (which is possibly inconsistent)
 */
@@ -1300,6 +1290,9 @@ extern void mnt_set_mountpoint(struct vfsmount *, struct dentry *,
 extern int vfs_statfs(struct super_block *, struct kstatfs *);
+/* /sys/fs */
+extern struct subsystem fs_subsys;
 #define FLOCK_VERIFY_READ  1
 #define FLOCK_VERIFY_WRITE 2
@@ -1345,8 +1338,10 @@ static inline int break_lease(struct inode *inode, unsigned int mode)
 /* fs/open.c */
-extern int do_truncate(struct dentry *, loff_t start, struct file *filp);
+extern int do_truncate(struct dentry *, loff_t start, unsigned int time_attrs,
-extern long do_sys_open(const char __user *filename, int flags, int mode);
+                       struct file *filp);
+extern long do_sys_open(int fdf, const char __user *filename, int flags,
+                        int mode);
 extern struct file *filp_open(const char *, int, int);
 extern struct file * dentry_open(struct dentry *, struct vfsmount *, int);
 extern int filp_close(struct file *, fl_owner_t id);
@@ -1392,6 +1387,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 */
@@ -1400,6 +1401,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);
@@ -1474,7 +1480,7 @@ static inline void allow_write_access(struct file *file)
 }
 extern int do_pipe(int *);
-extern int open_namei(const char *, int, int, struct nameidata *);
+extern int open_namei(int dfd, const char *, int, int, struct nameidata *);
 extern int may_open(struct nameidata *, int, int);
 extern int kernel_read(struct file *, unsigned long, char *, unsigned long);
@@ -1672,6 +1678,8 @@ extern int vfs_readdir(struct file *, filldir_t, void *);
 extern int vfs_stat(char __user *, struct kstat *);
 extern int vfs_lstat(char __user *, struct kstat *);
+extern int vfs_stat_fd(int dfd, char __user *, struct kstat *);
+extern int vfs_lstat_fd(int dfd, char __user *, struct kstat *);
 extern int vfs_fstat(unsigned int, struct kstat *);
 extern int vfs_ioctl(struct file *, unsigned int, unsigned int, unsigned long);
@@ -1714,7 +1722,7 @@ extern ssize_t simple_read_from_buffer(void __user *, size_t, loff_t *, const vo
 extern int inode_change_ok(struct inode *, struct iattr *);
 extern int __must_check inode_setattr(struct inode *, struct iattr *);
-extern void inode_update_time(struct inode *inode, int ctime_too);
+extern void file_update_time(struct file *file);
 static inline ino_t parent_ino(struct dentry *dentry)
 {
diff --git a/include/linux/fsl_devices.h b/include/linux/fsl_devices.h
index 934aa9bda481..a9f1cfd096ff 100644
--- a/include/linux/fsl_devices.h
+++ b/include/linux/fsl_devices.h
@@ -50,14 +50,12 @@ struct gianfar_platform_data {
        /* board specific information */
        u32 board_flags;
-        const char *bus_id;
+        u32 bus_id;
+        u32 phy_id;
        u8 mac_addr[6];
 };
 struct gianfar_mdio_data {
-        /* device specific information */
-        u32 paddr;
        /* board specific information */
        int irq[32];
 };
diff --git a/include/linux/gfp.h b/include/linux/gfp.h
index 8b2eab90abb6..20f9148e38d9 100644
--- a/include/linux/gfp.h
+++ b/include/linux/gfp.h
@@ -57,6 +57,7 @@ struct vm_area_struct;
                        __GFP_NOFAIL|__GFP_NORETRY|__GFP_NO_GROW|__GFP_COMP| \
                        __GFP_NOMEMALLOC|__GFP_HARDWALL)
+/* GFP_ATOMIC means both !wait (__GFP_WAIT not set) and use emergency pool */
 #define GFP_ATOMIC      (__GFP_HIGH)
 #define GFP_NOIO        (__GFP_WAIT)
 #define GFP_NOFS        (__GFP_WAIT | __GFP_IO)
@@ -109,6 +110,10 @@ static inline struct page *alloc_pages_node(int nid, gfp_t gfp_mask,
        if (unlikely(order >= MAX_ORDER))
                return NULL;
+        /* Unknown node is current node */
+        if (nid < 0)
+                nid = numa_node_id();
        return __alloc_pages(gfp_mask, order,
                NODE_DATA(nid)->node_zonelists + gfp_zone(gfp_mask));
 }
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/hrtimer.h b/include/linux/hrtimer.h
new file mode 100644
index 000000000000..089bfb1fa01a
--- /dev/null
+++ b/include/linux/hrtimer.h
@@ -0,0 +1,139 @@
+/*
+ *  include/linux/hrtimer.h
+ *
+ *  hrtimers - High-resolution kernel timers
+ *
+ *   Copyright(C) 2005, Thomas Gleixner <tglx@linutronix.de>
+ *   Copyright(C) 2005, Red Hat, Inc., Ingo Molnar
+ *
+ *  data type definitions, declarations, prototypes
+ *
+ *  Started by: Thomas Gleixner and Ingo Molnar
+ *
+ *  For licencing details see kernel-base/COPYING
+ */
+#ifndef _LINUX_HRTIMER_H
+#define _LINUX_HRTIMER_H
+#include <linux/rbtree.h>
+#include <linux/ktime.h>
+#include <linux/init.h>
+#include <linux/list.h>
+#include <linux/wait.h>
+/*
+ * Mode arguments of xxx_hrtimer functions:
+ */
+enum hrtimer_mode {
+        HRTIMER_ABS,    /* Time value is absolute */
+        HRTIMER_REL,    /* Time value is relative to now */
+};
+enum hrtimer_restart {
+        HRTIMER_NORESTART,
+        HRTIMER_RESTART,
+};
+/*
+ * Timer states:
+ */
+enum hrtimer_state {
+        HRTIMER_INACTIVE,       /* Timer is inactive */
+        HRTIMER_EXPIRED,                /* Timer is expired */
+        HRTIMER_PENDING,                /* Timer is pending */
+};
+struct hrtimer_base;
+/**
+ * struct hrtimer - the basic hrtimer structure
+ *
+ * @node:       red black tree node for time ordered insertion
+ * @expires:    the absolute expiry time in the hrtimers internal
+ *              representation. The time is related to the clock on
+ *              which the timer is based.
+ * @state:      state of the timer
+ * @function:   timer expiry callback function
+ * @data:       argument for the callback function
+ * @base:       pointer to the timer base (per cpu and per clock)
+ *
+ * The hrtimer structure must be initialized by init_hrtimer_#CLOCKTYPE()
+ */
+struct hrtimer {
+        struct rb_node          node;
+        ktime_t                 expires;
+        enum hrtimer_state      state;
+        int                     (*function)(void *);
+        void                    *data;
+        struct hrtimer_base     *base;
+};
+/**
+ * struct hrtimer_base - the timer base for a specific clock
+ *
+ * @index:      clock type index for per_cpu support when moving a timer
+ *              to a base on another cpu.
+ * @lock:       lock protecting the base and associated timers
+ * @active:     red black tree root node for the active timers
+ * @first:      pointer to the timer node which expires first
+ * @resolution: the resolution of the clock, in nanoseconds
+ * @get_time:   function to retrieve the current time of the clock
+ * @curr_timer: the timer which is executing a callback right now
+ */
+struct hrtimer_base {
+        clockid_t               index;
+        spinlock_t              lock;
+        struct rb_root          active;
+        struct rb_node          *first;
+        ktime_t                 resolution;
+        ktime_t                 (*get_time)(void);
+        struct hrtimer          *curr_timer;
+};
+/*
+ * clock_was_set() is a NOP for non- high-resolution systems. The
+ * time-sorted order guarantees that a timer does not expire early and
+ * is expired in the next softirq when the clock was advanced.
+ */
+#define clock_was_set()         do { } while (0)
+/* Exported timer functions: */
+/* Initialize timers: */
+extern void hrtimer_init(struct hrtimer *timer, const clockid_t which_clock);
+extern void hrtimer_rebase(struct hrtimer *timer, const clockid_t which_clock);
+/* Basic timer operations: */
+extern int hrtimer_start(struct hrtimer *timer, ktime_t tim,
+                         const enum hrtimer_mode mode);
+extern int hrtimer_cancel(struct hrtimer *timer);
+extern int hrtimer_try_to_cancel(struct hrtimer *timer);
+#define hrtimer_restart(timer) hrtimer_start((timer), (timer)->expires, HRTIMER_ABS)
+/* Query timers: */
+extern ktime_t hrtimer_get_remaining(const struct hrtimer *timer);
+extern int hrtimer_get_res(const clockid_t which_clock, struct timespec *tp);
+static inline int hrtimer_active(const struct hrtimer *timer)
+{
+        return timer->state == HRTIMER_PENDING;
+}
+/* Forward a hrtimer so it expires after now: */
+extern unsigned long hrtimer_forward(struct hrtimer *timer, ktime_t interval);
+/* Precise sleep: */
+extern long hrtimer_nanosleep(struct timespec *rqtp,
+                              struct timespec __user *rmtp,
+                              const enum hrtimer_mode mode,
+                              const clockid_t clockid);
+/* Soft interrupt function to run the hrtimer queues: */
+extern void hrtimer_run_queues(void);
+/* Bootup initialization: */
+extern void __init hrtimers_init(void);
+#endif
diff --git a/include/linux/i2c-id.h b/include/linux/i2c-id.h
index fb46f8d56999..474c8f4f5d4f 100644
--- a/include/linux/i2c-id.h
+++ b/include/linux/i2c-id.h
@@ -103,6 +103,11 @@
 #define I2C_DRIVERID_SAA711X    73      /* saa711x video encoders       */
 #define I2C_DRIVERID_AKITAIOEXP 74      /* IO Expander on Sharp SL-C1000 */
 #define I2C_DRIVERID_INFRARED   75      /* I2C InfraRed on Video boards */
+#define I2C_DRIVERID_TVP5150    76      /* TVP5150 video decoder        */
+#define I2C_DRIVERID_WM8739     77      /* wm8739 audio processor       */
+#define I2C_DRIVERID_UPD64083   78      /* upd64083 video processor     */
+#define I2C_DRIVERID_UPD64031A  79      /* upd64031a video processor    */
+#define I2C_DRIVERID_SAA717X    80      /* saa717x video encoder        */
 #define I2C_DRIVERID_I2CDEV     900
 #define I2C_DRIVERID_ARP        902    /* SMBus ARP Client              */
diff --git a/include/linux/ide.h b/include/linux/ide.h
index 7b6a6a58e465..110b3cfac021 100644
--- a/include/linux/ide.h
+++ b/include/linux/ide.h
@@ -18,6 +18,7 @@
 #include <linux/bio.h>
 #include <linux/device.h>
 #include <linux/pci.h>
+#include <linux/completion.h>
 #include <asm/byteorder.h>
 #include <asm/system.h>
 #include <asm/io.h>
@@ -638,7 +639,7 @@ typedef struct ide_drive_s {
        int             crc_count;      /* crc counter to reduce drive speed */
        struct list_head list;
        struct device   gendev;
-        struct semaphore gendev_rel_sem;        /* to deal with device release() */
+        struct completion gendev_rel_comp;      /* to deal with device release() */
 } ide_drive_t;
 #define to_ide_device(dev)container_of(dev, ide_drive_t, gendev)
@@ -794,14 +795,14 @@ typedef struct hwif_s {
        unsigned        sg_mapped  : 1; /* sg_table and sg_nents are ready */
        struct device   gendev;
-        struct semaphore gendev_rel_sem; /* To deal with device release() */
+        struct completion gendev_rel_comp; /* To deal with device release() */
        void            *hwif_data;     /* extra hwif data */
        unsigned dma;
        void (*led_act)(void *data, int rw);
-} ____cacheline_maxaligned_in_smp ide_hwif_t;
+} ____cacheline_internodealigned_in_smp ide_hwif_t;
 /*
 *  internal ide interrupt handler type
@@ -982,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/if_ether.h b/include/linux/if_ether.h
index fe26d431de87..7a92c1ce1457 100644
--- a/include/linux/if_ether.h
+++ b/include/linux/if_ether.h
@@ -72,6 +72,7 @@
                                         * over Ethernet
                                         */
 #define ETH_P_AOE       0x88A2          /* ATA over Ethernet            */
+#define ETH_P_TIPC      0x88CA          /* TIPC                         */
 /*
 *      Non DIX types. Won't clash for 1500 types.
diff --git a/include/linux/if_frad.h b/include/linux/if_frad.h
index 511999c7eeda..395f0aad9cbf 100644
--- a/include/linux/if_frad.h
+++ b/include/linux/if_frad.h
@@ -131,17 +131,17 @@ struct frad_conf
 /* these are the fields of an RFC 1490 header */
 struct frhdr
 {
-   unsigned char  control       __attribute__((packed));
+   unsigned char  control;
   /* for IP packets, this can be the NLPID */
-   unsigned char  pad           __attribute__((packed)); 
+   unsigned char  pad;
-   unsigned char  NLPID         __attribute__((packed));
+   unsigned char  NLPID;
-   unsigned char  OUI[3]        __attribute__((packed));
+   unsigned char  OUI[3];
-   unsigned short PID           __attribute__((packed));
+   unsigned short PID;
 #define IP_NLPID pad 
-};
+} __attribute__((packed));
 /* see RFC 1490 for the definition of the following */
 #define FRAD_I_UI               0x03
diff --git a/include/linux/init.h b/include/linux/init.h
index 59008c3826cf..ff8d8b8632f4 100644
--- a/include/linux/init.h
+++ b/include/linux/init.h
@@ -241,6 +241,18 @@ void __init parse_early_param(void);
 #define __cpuexitdata   __exitdata
 #endif
+#ifdef CONFIG_MEMORY_HOTPLUG
+#define __meminit
+#define __meminitdata
+#define __memexit
+#define __memexitdata
+#else
+#define __meminit       __init
+#define __meminitdata __initdata
+#define __memexit __exit
+#define __memexitdata   __exitdata
+#endif
 /* Functions marked as __devexit may be discarded at kernel link time, depending
   on config options.  Newer versions of binutils detect references from
   retained sections to discarded sections and flag an error.  Pointers to
diff --git a/include/linux/interrupt.h b/include/linux/interrupt.h
index 41f150a3d2dd..2c08fdc2bdf7 100644
--- a/include/linux/interrupt.h
+++ b/include/linux/interrupt.h
@@ -79,7 +79,7 @@ static inline void __deprecated save_flags(unsigned long *x)
 {
        local_save_flags(*x);
 }
-#define save_flags(x) save_flags(&x);
+#define save_flags(x) save_flags(&x)
 static inline void __deprecated restore_flags(unsigned long x)
 {
        local_irq_restore(x);
@@ -112,7 +112,7 @@ enum
        TIMER_SOFTIRQ,
        NET_TX_SOFTIRQ,
        NET_RX_SOFTIRQ,
-        SCSI_SOFTIRQ,
+        BLOCK_SOFTIRQ,
        TASKLET_SOFTIRQ
 };
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/ipv6.h b/include/linux/ipv6.h
index 93bbed5c6cf4..9c8f4c9ed429 100644
--- a/include/linux/ipv6.h
+++ b/include/linux/ipv6.h
@@ -191,6 +191,10 @@ struct inet6_skb_parm {
        __u16                   srcrt;
        __u16                   dst1;
        __u16                   lastopt;
+        __u32                   nhoff;
+        __u16                   flags;
+#define IP6SKB_XFRM_TRANSFORMED 1
 };
 #define IP6CB(skb)      ((struct inet6_skb_parm*)((skb)->cb))
diff --git a/include/linux/isdnif.h b/include/linux/isdnif.h
index 7a4eacd77cb2..04e10f9f14f8 100644
--- a/include/linux/isdnif.h
+++ b/include/linux/isdnif.h
@@ -282,43 +282,43 @@ typedef struct setup_parm {
 typedef struct T30_s {
        /* session parameters */
-        __u8 resolution         __attribute__ ((packed));
+        __u8 resolution;
-        __u8 rate               __attribute__ ((packed));
+        __u8 rate;
-        __u8 width              __attribute__ ((packed));
+        __u8 width;
-        __u8 length             __attribute__ ((packed));
+        __u8 length;
-        __u8 compression        __attribute__ ((packed));
+        __u8 compression;
-        __u8 ecm                __attribute__ ((packed));
+        __u8 ecm;
-        __u8 binary             __attribute__ ((packed));
+        __u8 binary;
-        __u8 scantime           __attribute__ ((packed));
+        __u8 scantime;
-        __u8 id[FAXIDLEN]       __attribute__ ((packed));
+        __u8 id[FAXIDLEN];
        /* additional parameters */
-        __u8 phase              __attribute__ ((packed));
+        __u8 phase;
-        __u8 direction          __attribute__ ((packed));
+        __u8 direction;
-        __u8 code               __attribute__ ((packed));
+        __u8 code;
-        __u8 badlin             __attribute__ ((packed));
+        __u8 badlin;
-        __u8 badmul             __attribute__ ((packed));
+        __u8 badmul;
-        __u8 bor                __attribute__ ((packed));
+        __u8 bor;
-        __u8 fet                __attribute__ ((packed));
+        __u8 fet;
-        __u8 pollid[FAXIDLEN]   __attribute__ ((packed));
+        __u8 pollid[FAXIDLEN];
-        __u8 cq                 __attribute__ ((packed));
+        __u8 cq;
-        __u8 cr                 __attribute__ ((packed));
+        __u8 cr;
-        __u8 ctcrty             __attribute__ ((packed));
+        __u8 ctcrty;
-        __u8 minsp              __attribute__ ((packed));
+        __u8 minsp;
-        __u8 phcto              __attribute__ ((packed));
+        __u8 phcto;
-        __u8 rel                __attribute__ ((packed));
+        __u8 rel;
-        __u8 nbc                __attribute__ ((packed));
+        __u8 nbc;
        /* remote station parameters */
-        __u8 r_resolution       __attribute__ ((packed));
+        __u8 r_resolution;
-        __u8 r_rate             __attribute__ ((packed));
+        __u8 r_rate;
-        __u8 r_width            __attribute__ ((packed));
+        __u8 r_width;
-        __u8 r_length           __attribute__ ((packed));
+        __u8 r_length;
-        __u8 r_compression      __attribute__ ((packed));
+        __u8 r_compression;
-        __u8 r_ecm              __attribute__ ((packed));
+        __u8 r_ecm;
-        __u8 r_binary           __attribute__ ((packed));
+        __u8 r_binary;
-        __u8 r_scantime         __attribute__ ((packed));
+        __u8 r_scantime;
-        __u8 r_id[FAXIDLEN]     __attribute__ ((packed));
+        __u8 r_id[FAXIDLEN];
-        __u8 r_code             __attribute__ ((packed));
+        __u8 r_code;
-} T30_s;
+} __attribute__((packed)) T30_s;
 #define ISDN_TTY_FAX_CONN_IN    0
 #define ISDN_TTY_FAX_CONN_OUT   1
diff --git a/include/linux/isicom.h b/include/linux/isicom.h
index 7c6eae7f6ed7..45b3d48f0978 100644
--- a/include/linux/isicom.h
+++ b/include/linux/isicom.h
@@ -4,47 +4,12 @@
 /*#define               ISICOM_DEBUG*/
 /*#define               ISICOM_DEBUG_DTR_RTS*/
-/*
- *      Firmware Loader definitions ...
- */
- 
-#define         __MultiTech             ('M'<<8)
-#define         MIOCTL_LOAD_FIRMWARE    (__MultiTech | 0x01)
-#define         MIOCTL_READ_FIRMWARE    (__MultiTech | 0x02)
-#define         MIOCTL_XFER_CTRL        (__MultiTech | 0x03)
-#define         MIOCTL_RESET_CARD       (__MultiTech | 0x04)
-#define         DATA_SIZE       16
-typedef struct  {
-                unsigned short  exec_segment;
-                unsigned short  exec_addr;
-}       exec_record;
-typedef struct  {
-                int             board;          /* Board to load */
-                unsigned short  addr;
-                unsigned short  count;
-}       bin_header;
-typedef struct  {
-                int             board;          /* Board to load */
-                unsigned short  addr;
-                unsigned short  count;
-                unsigned short  segment;
-                unsigned char   bin_data[DATA_SIZE];
-}       bin_frame;
 #ifdef __KERNEL__
 #define         YES     1
 #define         NO      0
-#define         ISILOAD_MISC_MINOR      155     /* /dev/isctl */
+/*
-#define         ISILOAD_NAME            "ISILoad"
-/*      
 *  ISICOM Driver definitions ...
 *
 */
@@ -55,8 +20,8 @@ typedef	struct	{
 *      PCI definitions
 */
- #define        DEVID_COUNT     9
+#define         DEVID_COUNT     9
- #define        VENDOR_ID       0x10b5
+#define         VENDOR_ID       0x10b5
 /*
 *      These are now officially allocated numbers
@@ -66,9 +31,9 @@ typedef	struct	{
 #define         ISICOM_CMAJOR   113     /* callout */
 #define         ISICOM_MAGIC    (('M' << 8) | 'T')
-#define         WAKEUP_CHARS    256     /* hard coded for now   */ 
+#define         WAKEUP_CHARS    256     /* hard coded for now   */
-#define         TX_SIZE         254 
+#define         TX_SIZE         254
- 
 #define         BOARD_COUNT     4
 #define         PORT_COUNT      (BOARD_COUNT*16)
@@ -98,18 +63,15 @@ typedef	struct	{
 #define         ISICOM_INITIATE_XONXOFF 0x04
 #define         ISICOM_RESPOND_XONXOFF  0x08
-#define InterruptTheCard(base) (outw(0,(base)+0xc)) 
-#define ClearInterrupt(base) (inw((base)+0x0a)) 
 #define BOARD(line)  (((line) >> 4) & 0x3)
        /*      isi kill queue bitmap   */
-        
 #define         ISICOM_KILLTX           0x01
 #define         ISICOM_KILLRX           0x02
        /* isi_board status bitmap */
-        
 #define         FIRMWARE_LOADED         0x0001
 #define         BOARD_ACTIVE            0x0002
@@ -123,9 +85,8 @@ typedef	struct	{
 #define         ISI_RTS                 0x0200
-#define         ISI_TXOK                0x0001 
+#define         ISI_TXOK                0x0001
- 
 #endif  /*      __KERNEL__      */
 #endif  /*      ISICOM_H        */
diff --git a/include/linux/jffs2_fs_i.h b/include/linux/jffs2_fs_i.h
index ef85ab56302b..ad565bf9dcc1 100644
--- a/include/linux/jffs2_fs_i.h
+++ b/include/linux/jffs2_fs_i.h
@@ -8,11 +8,11 @@
 #include <asm/semaphore.h>
 struct jffs2_inode_info {
-        /* We need an internal semaphore similar to inode->i_sem.
+        /* We need an internal mutex similar to inode->i_mutex.
           Unfortunately, we can't used the existing one, because
           either the GC would deadlock, or we'd have to release it
           before letting GC proceed. Or we'd have to put ugliness
-           into the GC code so it didn't attempt to obtain the i_sem
+           into the GC code so it didn't attempt to obtain the i_mutex
           for the inode(s) which are already locked */
        struct semaphore sem;
diff --git a/include/linux/jiffies.h b/include/linux/jiffies.h
index 6acfdbba734b..99905e180532 100644
--- a/include/linux/jiffies.h
+++ b/include/linux/jiffies.h
@@ -1,21 +1,12 @@
 #ifndef _LINUX_JIFFIES_H
 #define _LINUX_JIFFIES_H
+#include <linux/calc64.h>
 #include <linux/kernel.h>
 #include <linux/types.h>
 #include <linux/time.h>
 #include <linux/timex.h>
 #include <asm/param.h>                  /* for HZ */
-#include <asm/div64.h>
-#ifndef div_long_long_rem
-#define div_long_long_rem(dividend,divisor,remainder) \
-({                                                      \
-        u64 result = dividend;                          \
-        *remainder = do_div(result,divisor);            \
-        result;                                         \
-})
-#endif
 /*
 * The following defines establish the engineering parameters of the PLL
@@ -373,8 +364,11 @@ jiffies_to_timeval(const unsigned long jiffies, struct timeval *value)
         * one divide.
         */
        u64 nsec = (u64)jiffies * TICK_NSEC;
-        value->tv_sec = div_long_long_rem(nsec, NSEC_PER_SEC, &value->tv_usec);
+        long tv_usec;
-        value->tv_usec /= NSEC_PER_USEC;
+        value->tv_sec = div_long_long_rem(nsec, NSEC_PER_SEC, &tv_usec);
+        tv_usec /= NSEC_PER_USEC;
+        value->tv_usec = tv_usec;
 }
 /*
diff --git a/include/linux/kbd_kern.h b/include/linux/kbd_kern.h
index 7428198111eb..45f625d7d0b2 100644
--- a/include/linux/kbd_kern.h
+++ b/include/linux/kbd_kern.h
@@ -151,7 +151,7 @@ extern unsigned int keymap_count;
 static inline void con_schedule_flip(struct tty_struct *t)
 {
-        schedule_work(&t->flip.work);
+        schedule_work(&t->buf.work);
 }
 #endif
diff --git a/include/linux/kernel.h b/include/linux/kernel.h
index b1e407a4fbda..b49affa0ac5a 100644
--- a/include/linux/kernel.h
+++ b/include/linux/kernel.h
@@ -47,6 +47,8 @@ extern int console_printk[];
 #define default_console_loglevel (console_printk[3])
 struct completion;
+struct pt_regs;
+struct user;
 /**
 * might_sleep - annotation for functions that can sleep
@@ -123,6 +125,8 @@ extern int __kernel_text_address(unsigned long addr);
 extern int kernel_text_address(unsigned long addr);
 extern int session_of_pgrp(int pgrp);
+extern void dump_thread(struct pt_regs *regs, struct user *dump);
 #ifdef CONFIG_PRINTK
 asmlinkage int vprintk(const char *fmt, va_list args)
        __attribute__ ((format (printf, 1, 0)));
@@ -181,6 +185,7 @@ extern enum system_states {
        SYSTEM_HALT,
        SYSTEM_POWER_OFF,
        SYSTEM_RESTART,
+        SYSTEM_SUSPEND_DISK,
 } system_state;
 #define TAINT_PROPRIETARY_MODULE        (1<<0)
@@ -212,6 +217,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]), \
@@ -222,6 +228,8 @@ 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"
+#define NIP6_SEQFMT "%04x%04x%04x%04x%04x%04x%04x%04x"
 #if defined(__LITTLE_ENDIAN)
 #define HIPQUAD(addr) \
@@ -286,6 +294,15 @@ extern void dump_stack(void);
        1; \
 })
+/*
+ * Check at compile time that 'function' is a certain type, or is a pointer
+ * to that type (needs to use typedef for the function type.)
+ */
+#define typecheck_fn(type,function) \
+({      typeof(type) __tmp = function; \
+        (void)__tmp; \
+})
 #endif /* __KERNEL__ */
 #define SI_LOAD_SHIFT   16
@@ -316,8 +333,6 @@ extern int randomize_va_space;
 #endif
 /* Trap pasters of __FUNCTION__ at compile-time */
-#if __GNUC__ > 2 || __GNUC_MINOR__ >= 95
 #define __FUNCTION__ (__func__)
-#endif
 #endif
diff --git a/include/linux/kexec.h b/include/linux/kexec.h
index c8468472aec0..a311f58c8a7c 100644
--- a/include/linux/kexec.h
+++ b/include/linux/kexec.h
@@ -41,7 +41,7 @@ typedef unsigned long kimage_entry_t;
 #define IND_DONE         0x4
 #define IND_SOURCE       0x8
-#define KEXEC_SEGMENT_MAX 8
+#define KEXEC_SEGMENT_MAX 16
 struct kexec_segment {
        void __user *buf;
        size_t bufsz;
@@ -119,12 +119,15 @@ extern struct kimage *kexec_image;
 #define KEXEC_ARCH_PPC64   (21 << 16)
 #define KEXEC_ARCH_IA_64   (50 << 16)
 #define KEXEC_ARCH_S390    (22 << 16)
+#define KEXEC_ARCH_SH      (42 << 16)
 #define KEXEC_FLAGS    (KEXEC_ON_CRASH)  /* List of defined/legal kexec flags */
 /* Location of a reserved region to hold the crash kernel.
 */
 extern struct resource crashk_res;
+typedef u32 note_buf_t[MAX_NOTE_BYTES/4];
+extern note_buf_t *crash_notes;
 #else /* !CONFIG_KEXEC */
 struct pt_regs;
diff --git a/include/linux/key.h b/include/linux/key.h
index 4d189e51bc6c..cbf464ad9589 100644
--- a/include/linux/key.h
+++ b/include/linux/key.h
@@ -177,6 +177,8 @@ struct key {
 /*
 * kernel managed key type definition
 */
+typedef int (*request_key_actor_t)(struct key *key, struct key *authkey, const char *op);
 struct key_type {
        /* name of the type */
        const char *name;
@@ -218,6 +220,16 @@ struct key_type {
         */
        long (*read)(const struct key *key, char __user *buffer, size_t buflen);
+        /* handle request_key() for this type instead of invoking
+         * /sbin/request-key (optional)
+         * - key is the key to instantiate
+         * - authkey is the authority to assume when instantiating this key
+         * - op is the operation to be done, usually "create"
+         * - the call must not return until the instantiation process has run
+         *   its course
+         */
+        request_key_actor_t request_key;
        /* internal fields */
        struct list_head        link;           /* link in types list */
 };
diff --git a/include/linux/keyctl.h b/include/linux/keyctl.h
index 8d7c59a29e09..3365945640c9 100644
--- a/include/linux/keyctl.h
+++ b/include/linux/keyctl.h
@@ -19,6 +19,7 @@
 #define KEY_SPEC_USER_KEYRING           -4      /* - key ID for UID-specific keyring */
 #define KEY_SPEC_USER_SESSION_KEYRING   -5      /* - key ID for UID-session keyring */
 #define KEY_SPEC_GROUP_KEYRING          -6      /* - key ID for GID-specific keyring */
+#define KEY_SPEC_REQKEY_AUTH_KEY        -7      /* - key ID for assumed request_key auth key */
 /* request-key default keyrings */
 #define KEY_REQKEY_DEFL_NO_CHANGE               -1
@@ -46,5 +47,7 @@
 #define KEYCTL_INSTANTIATE              12      /* instantiate a partially constructed key */
 #define KEYCTL_NEGATE                   13      /* negate a partially constructed key */
 #define KEYCTL_SET_REQKEY_KEYRING       14      /* set default request-key keyring */
+#define KEYCTL_SET_TIMEOUT              15      /* set key timeout */
+#define KEYCTL_ASSUME_AUTHORITY         16      /* assume request_key() authorisation */
 #endif /*  _LINUX_KEYCTL_H */
diff --git a/include/linux/kprobes.h b/include/linux/kprobes.h
index c03f2dc933de..669756bc20a2 100644
--- a/include/linux/kprobes.h
+++ b/include/linux/kprobes.h
@@ -68,6 +68,9 @@ struct kprobe {
        /* list of kprobes for multi-handler support */
        struct list_head list;
+        /* Indicates that the corresponding module has been ref counted */
+        unsigned int mod_refcounted;
        /*count the number of times this probe was temporarily disarmed */
        unsigned long nmissed;
@@ -149,11 +152,10 @@ struct kretprobe_instance {
 };
 extern spinlock_t kretprobe_lock;
+extern struct semaphore kprobe_mutex;
 extern int arch_prepare_kprobe(struct kprobe *p);
-extern void arch_copy_kprobe(struct kprobe *p);
 extern void arch_arm_kprobe(struct kprobe *p);
 extern void arch_disarm_kprobe(struct kprobe *p);
-extern void arch_remove_kprobe(struct kprobe *p);
 extern int arch_init_kprobes(void);
 extern void show_registers(struct pt_regs *regs);
 extern kprobe_opcode_t *get_insn_slot(void);
diff --git a/include/linux/ktime.h b/include/linux/ktime.h
new file mode 100644
index 000000000000..1bd6552cc341
--- /dev/null
+++ b/include/linux/ktime.h
@@ -0,0 +1,284 @@
+/*
+ *  include/linux/ktime.h
+ *
+ *  ktime_t - nanosecond-resolution time format.
+ *
+ *   Copyright(C) 2005, Thomas Gleixner <tglx@linutronix.de>
+ *   Copyright(C) 2005, Red Hat, Inc., Ingo Molnar
+ *
+ *  data type definitions, declarations, prototypes and macros.
+ *
+ *  Started by: Thomas Gleixner and Ingo Molnar
+ *
+ *  For licencing details see kernel-base/COPYING
+ */
+#ifndef _LINUX_KTIME_H
+#define _LINUX_KTIME_H
+#include <linux/time.h>
+#include <linux/jiffies.h>
+/*
+ * ktime_t:
+ *
+ * On 64-bit CPUs a single 64-bit variable is used to store the hrtimers
+ * internal representation of time values in scalar nanoseconds. The
+ * design plays out best on 64-bit CPUs, where most conversions are
+ * NOPs and most arithmetic ktime_t operations are plain arithmetic
+ * operations.
+ *
+ * On 32-bit CPUs an optimized representation of the timespec structure
+ * is used to avoid expensive conversions from and to timespecs. The
+ * endian-aware order of the tv struct members is choosen to allow
+ * mathematical operations on the tv64 member of the union too, which
+ * for certain operations produces better code.
+ *
+ * For architectures with efficient support for 64/32-bit conversions the
+ * plain scalar nanosecond based representation can be selected by the
+ * config switch CONFIG_KTIME_SCALAR.
+ */
+typedef union {
+        s64     tv64;
+#if BITS_PER_LONG != 64 && !defined(CONFIG_KTIME_SCALAR)
+        struct {
+# ifdef __BIG_ENDIAN
+        s32     sec, nsec;
+# else
+        s32     nsec, sec;
+# endif
+        } tv;
+#endif
+} ktime_t;
+#define KTIME_MAX                       (~((u64)1 << 63))
+/*
+ * ktime_t definitions when using the 64-bit scalar representation:
+ */
+#if (BITS_PER_LONG == 64) || defined(CONFIG_KTIME_SCALAR)
+/* Define a ktime_t variable and initialize it to zero: */
+#define DEFINE_KTIME(kt)                ktime_t kt = { .tv64 = 0 }
+/**
+ * ktime_set - Set a ktime_t variable from a seconds/nanoseconds value
+ *
+ * @secs:       seconds to set
+ * @nsecs:      nanoseconds to set
+ *
+ * Return the ktime_t representation of the value
+ */
+static inline ktime_t ktime_set(const long secs, const unsigned long nsecs)
+{
+        return (ktime_t) { .tv64 = (s64)secs * NSEC_PER_SEC + (s64)nsecs };
+}
+/* Subtract two ktime_t variables. rem = lhs -rhs: */
+#define ktime_sub(lhs, rhs) \
+                ({ (ktime_t){ .tv64 = (lhs).tv64 - (rhs).tv64 }; })
+/* Add two ktime_t variables. res = lhs + rhs: */
+#define ktime_add(lhs, rhs) \
+                ({ (ktime_t){ .tv64 = (lhs).tv64 + (rhs).tv64 }; })
+/*
+ * Add a ktime_t variable and a scalar nanosecond value.
+ * res = kt + nsval:
+ */
+#define ktime_add_ns(kt, nsval) \
+                ({ (ktime_t){ .tv64 = (kt).tv64 + (nsval) }; })
+/* convert a timespec to ktime_t format: */
+#define timespec_to_ktime(ts)           ktime_set((ts).tv_sec, (ts).tv_nsec)
+/* convert a timeval to ktime_t format: */
+#define timeval_to_ktime(tv)            ktime_set((tv).tv_sec, (tv).tv_usec * 1000)
+/* Map the ktime_t to timespec conversion to ns_to_timespec function */
+#define ktime_to_timespec(kt)           ns_to_timespec((kt).tv64)
+/* Map the ktime_t to timeval conversion to ns_to_timeval function */
+#define ktime_to_timeval(kt)            ns_to_timeval((kt).tv64)
+/* Map the ktime_t to clock_t conversion to the inline in jiffies.h: */
+#define ktime_to_clock_t(kt)            nsec_to_clock_t((kt).tv64)
+/* Convert ktime_t to nanoseconds - NOP in the scalar storage format: */
+#define ktime_to_ns(kt)                 ((kt).tv64)
+#else
+/*
+ * Helper macros/inlines to get the ktime_t math right in the timespec
+ * representation. The macros are sometimes ugly - their actual use is
+ * pretty okay-ish, given the circumstances. We do all this for
+ * performance reasons. The pure scalar nsec_t based code was nice and
+ * simple, but created too many 64-bit / 32-bit conversions and divisions.
+ *
+ * Be especially aware that negative values are represented in a way
+ * that the tv.sec field is negative and the tv.nsec field is greater
+ * or equal to zero but less than nanoseconds per second. This is the
+ * same representation which is used by timespecs.
+ *
+ *   tv.sec < 0 and 0 >= tv.nsec < NSEC_PER_SEC
+ */
+/* Define a ktime_t variable and initialize it to zero: */
+#define DEFINE_KTIME(kt)                ktime_t kt = { .tv64 = 0 }
+/* Set a ktime_t variable to a value in sec/nsec representation: */
+static inline ktime_t ktime_set(const long secs, const unsigned long nsecs)
+{
+        return (ktime_t) { .tv = { .sec = secs, .nsec = nsecs } };
+}
+/**
+ * ktime_sub - subtract two ktime_t variables
+ *
+ * @lhs:        minuend
+ * @rhs:        subtrahend
+ *
+ * Returns the remainder of the substraction
+ */
+static inline ktime_t ktime_sub(const ktime_t lhs, const ktime_t rhs)
+{
+        ktime_t res;
+        res.tv64 = lhs.tv64 - rhs.tv64;
+        if (res.tv.nsec < 0)
+                res.tv.nsec += NSEC_PER_SEC;
+        return res;
+}
+/**
+ * ktime_add - add two ktime_t variables
+ *
+ * @add1:       addend1
+ * @add2:       addend2
+ *
+ * Returns the sum of addend1 and addend2
+ */
+static inline ktime_t ktime_add(const ktime_t add1, const ktime_t add2)
+{
+        ktime_t res;
+        res.tv64 = add1.tv64 + add2.tv64;
+        /*
+         * performance trick: the (u32) -NSEC gives 0x00000000Fxxxxxxx
+         * so we subtract NSEC_PER_SEC and add 1 to the upper 32 bit.
+         *
+         * it's equivalent to:
+         *   tv.nsec -= NSEC_PER_SEC
+         *   tv.sec ++;
+         */
+        if (res.tv.nsec >= NSEC_PER_SEC)
+                res.tv64 += (u32)-NSEC_PER_SEC;
+        return res;
+}
+/**
+ * ktime_add_ns - Add a scalar nanoseconds value to a ktime_t variable
+ *
+ * @kt:         addend
+ * @nsec:       the scalar nsec value to add
+ *
+ * Returns the sum of kt and nsec in ktime_t format
+ */
+extern ktime_t ktime_add_ns(const ktime_t kt, u64 nsec);
+/**
+ * timespec_to_ktime - convert a timespec to ktime_t format
+ *
+ * @ts:         the timespec variable to convert
+ *
+ * Returns a ktime_t variable with the converted timespec value
+ */
+static inline ktime_t timespec_to_ktime(const struct timespec ts)
+{
+        return (ktime_t) { .tv = { .sec = (s32)ts.tv_sec,
+                                   .nsec = (s32)ts.tv_nsec } };
+}
+/**
+ * timeval_to_ktime - convert a timeval to ktime_t format
+ *
+ * @tv:         the timeval variable to convert
+ *
+ * Returns a ktime_t variable with the converted timeval value
+ */
+static inline ktime_t timeval_to_ktime(const struct timeval tv)
+{
+        return (ktime_t) { .tv = { .sec = (s32)tv.tv_sec,
+                                   .nsec = (s32)tv.tv_usec * 1000 } };
+}
+/**
+ * ktime_to_timespec - convert a ktime_t variable to timespec format
+ *
+ * @kt:         the ktime_t variable to convert
+ *
+ * Returns the timespec representation of the ktime value
+ */
+static inline struct timespec ktime_to_timespec(const ktime_t kt)
+{
+        return (struct timespec) { .tv_sec = (time_t) kt.tv.sec,
+                                   .tv_nsec = (long) kt.tv.nsec };
+}
+/**
+ * ktime_to_timeval - convert a ktime_t variable to timeval format
+ *
+ * @kt:         the ktime_t variable to convert
+ *
+ * Returns the timeval representation of the ktime value
+ */
+static inline struct timeval ktime_to_timeval(const ktime_t kt)
+{
+        return (struct timeval) {
+                .tv_sec = (time_t) kt.tv.sec,
+                .tv_usec = (suseconds_t) (kt.tv.nsec / NSEC_PER_USEC) };
+}
+/**
+ * ktime_to_clock_t - convert a ktime_t variable to clock_t format
+ * @kt:         the ktime_t variable to convert
+ *
+ * Returns a clock_t variable with the converted value
+ */
+static inline clock_t ktime_to_clock_t(const ktime_t kt)
+{
+        return nsec_to_clock_t( (u64) kt.tv.sec * NSEC_PER_SEC + kt.tv.nsec);
+}
+/**
+ * ktime_to_ns - convert a ktime_t variable to scalar nanoseconds
+ * @kt:         the ktime_t variable to convert
+ *
+ * Returns the scalar nanoseconds representation of kt
+ */
+static inline u64 ktime_to_ns(const ktime_t kt)
+{
+        return (u64) kt.tv.sec * NSEC_PER_SEC + kt.tv.nsec;
+}
+#endif
+/*
+ * The resolution of the clocks. The resolution value is returned in
+ * the clock_getres() system call to give application programmers an
+ * idea of the (in)accuracy of timers. Timer values are rounded up to
+ * this resolution values.
+ */
+#define KTIME_REALTIME_RES      (ktime_t){ .tv64 = TICK_NSEC }
+#define KTIME_MONOTONIC_RES     (ktime_t){ .tv64 = TICK_NSEC }
+/* Get the monotonic time in timespec format: */
+extern void ktime_get_ts(struct timespec *ts);
+/* Get the real (wall-) time in timespec format: */
+#define ktime_get_real_ts(ts)   getnstimeofday(ts)
+#endif
diff --git a/include/linux/libata.h b/include/linux/libata.h
index a43c95f8f968..9e5db2949c58 100644
--- a/include/linux/libata.h
+++ b/include/linux/libata.h
@@ -126,16 +126,19 @@ enum {
        ATA_FLAG_SUSPENDED      = (1 << 12), /* port is suspended */
+        ATA_FLAG_PIO_LBA48      = (1 << 13), /* Host DMA engine is LBA28 only */
+        ATA_FLAG_IRQ_MASK       = (1 << 14), /* Mask IRQ in PIO xfers */
        ATA_QCFLAG_ACTIVE       = (1 << 1), /* cmd not yet ack'd to scsi lyer */
        ATA_QCFLAG_SG           = (1 << 3), /* have s/g table? */
        ATA_QCFLAG_SINGLE       = (1 << 4), /* no s/g, just a single buffer */
        ATA_QCFLAG_DMAMAP       = ATA_QCFLAG_SG | ATA_QCFLAG_SINGLE,
        /* various lengths of time */
-        ATA_TMOUT_EDD           = 5 * HZ,       /* hueristic */
+        ATA_TMOUT_EDD           = 5 * HZ,       /* heuristic */
        ATA_TMOUT_PIO           = 30 * HZ,
-        ATA_TMOUT_BOOT          = 30 * HZ,      /* hueristic */
+        ATA_TMOUT_BOOT          = 30 * HZ,      /* heuristic */
-        ATA_TMOUT_BOOT_QUICK    = 7 * HZ,       /* hueristic */
+        ATA_TMOUT_BOOT_QUICK    = 7 * HZ,       /* heuristic */
        ATA_TMOUT_CDB           = 30 * HZ,
        ATA_TMOUT_CDB_QUICK     = 5 * HZ,
        ATA_TMOUT_INTERNAL      = 30 * HZ,
@@ -499,6 +502,8 @@ extern int ata_scsi_slave_config(struct scsi_device *sdev);
 /*
 * Timing helpers
 */
+extern unsigned int ata_pio_need_iordy(const struct ata_device *);
 extern int ata_timing_compute(struct ata_device *, unsigned short,
                              struct ata_timing *, int, int);
 extern void ata_timing_merge(const struct ata_timing *,
diff --git a/include/linux/list.h b/include/linux/list.h
index 8e3388284530..945daa1f13dd 100644
--- a/include/linux/list.h
+++ b/include/linux/list.h
@@ -436,6 +436,20 @@ static inline void list_splice_init(struct list_head *list,
             pos = n, n = list_entry(n->member.next, typeof(*n), member))
 /**
+ * list_for_each_entry_safe_reverse - iterate backwards over list of given type safe against
+ *                                    removal of list entry
+ * @pos:        the type * to use as a loop counter.
+ * @n:          another type * to use as temporary storage
+ * @head:       the head for your list.
+ * @member:     the name of the list_struct within the struct.
+ */
+#define list_for_each_entry_safe_reverse(pos, n, head, member)          \
+        for (pos = list_entry((head)->prev, typeof(*pos), member),      \
+                n = list_entry(pos->member.prev, typeof(*pos), member); \
+             &pos->member != (head);                                    \
+             pos = n, n = list_entry(n->member.prev, typeof(*n), member))
+/**
 * list_for_each_rcu    -       iterate over an rcu-protected list
 * @pos:        the &struct list_head to use as a loop counter.
 * @head:       the head for your list.
diff --git a/include/linux/loop.h b/include/linux/loop.h
index 40f63c9879d2..f96506782ebe 100644
--- a/include/linux/loop.h
+++ b/include/linux/loop.h
@@ -58,9 +58,9 @@ struct loop_device {
        struct bio              *lo_bio;
        struct bio              *lo_biotail;
        int                     lo_state;
-        struct semaphore        lo_sem;
+        struct completion       lo_done;
+        struct completion       lo_bh_done;
        struct semaphore        lo_ctl_mutex;
-        struct semaphore        lo_bh_mutex;
        int                     lo_pending;
        request_queue_t         *lo_queue;
diff --git a/include/linux/memory.h b/include/linux/memory.h
index dc4081b6f161..e251dc43d0f5 100644
--- a/include/linux/memory.h
+++ b/include/linux/memory.h
@@ -70,21 +70,15 @@ static inline void unregister_memory_notifier(struct notifier_block *nb)
 {
 }
 #else
-extern int register_memory(struct memory_block *, struct mem_section *section, struct node *);
 extern int register_new_memory(struct mem_section *);
 extern int unregister_memory_section(struct mem_section *);
 extern int memory_dev_init(void);
-extern int register_memory_notifier(struct notifier_block *nb);
+extern int remove_memory_block(unsigned long, struct mem_section *, int);
-extern void unregister_memory_notifier(struct notifier_block *nb);
 #define CONFIG_MEM_BLOCK_SIZE   (PAGES_PER_SECTION<<PAGE_SHIFT)
-extern int invalidate_phys_mapping(unsigned long, unsigned long);
 struct notifier_block;
-extern int register_memory_notifier(struct notifier_block *nb);
-extern void unregister_memory_notifier(struct notifier_block *nb);
 #endif /* CONFIG_MEMORY_HOTPLUG */
 #define hotplug_memory_notifier(fn, pri) {                      \
diff --git a/include/linux/mempolicy.h b/include/linux/mempolicy.h
index ed00b278cb93..bbd2221923c3 100644
--- a/include/linux/mempolicy.h
+++ b/include/linux/mempolicy.h
@@ -22,6 +22,9 @@
 /* Flags for mbind */
 #define MPOL_MF_STRICT  (1<<0)  /* Verify existing pages in the mapping */
+#define MPOL_MF_MOVE    (1<<1)  /* Move pages owned by this process to conform to mapping */
+#define MPOL_MF_MOVE_ALL (1<<2) /* Move every page to conform to mapping */
+#define MPOL_MF_INTERNAL (1<<3) /* Internal flags start here */
 #ifdef __KERNEL__
@@ -65,6 +68,7 @@ struct mempolicy {
                nodemask_t       nodes;         /* interleave */
                /* undefined for default */
        } v;
+        nodemask_t cpuset_mems_allowed; /* mempolicy relative to these nodes */
 };
 /*
@@ -128,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);
@@ -141,15 +141,25 @@ void mpol_free_shared_policy(struct shared_policy *p);
 struct mempolicy *mpol_shared_policy_lookup(struct shared_policy *sp,
                                            unsigned long idx);
-struct mempolicy *get_vma_policy(struct task_struct *task,
-                        struct vm_area_struct *vma, unsigned long addr);
 extern void numa_default_policy(void);
 extern void numa_policy_init(void);
-extern void numa_policy_rebind(const nodemask_t *old, const nodemask_t *new);
+extern void mpol_rebind_policy(struct mempolicy *pol, const nodemask_t *new);
+extern void mpol_rebind_task(struct task_struct *tsk,
+                                        const nodemask_t *new);
+extern void mpol_rebind_mm(struct mm_struct *mm, nodemask_t *new);
+#define set_cpuset_being_rebound(x) (cpuset_being_rebound = (x))
+#ifdef CONFIG_CPUSET
+#define current_cpuset_is_being_rebound() \
+                                (cpuset_being_rebound == current->cpuset)
+#else
+#define current_cpuset_is_being_rebound() 0
+#endif
 extern struct mempolicy default_policy;
 extern struct zonelist *huge_zonelist(struct vm_area_struct *vma,
                unsigned long addr);
+extern unsigned slab_node(struct mempolicy *policy);
 extern int policy_zone;
@@ -159,6 +169,11 @@ static inline void check_highest_zone(int k)
                policy_zone = k;
 }
+int do_migrate_pages(struct mm_struct *mm,
+        const nodemask_t *from_nodes, const nodemask_t *to_nodes, int flags);
+extern void *cpuset_being_rebound;      /* Trigger mpol_copy vma rebind */
 #else
 struct mempolicy {};
@@ -193,7 +208,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)
 {
 }
@@ -218,17 +234,35 @@ static inline void numa_default_policy(void)
 {
 }
-static inline void numa_policy_rebind(const nodemask_t *old,
+static inline void mpol_rebind_policy(struct mempolicy *pol,
+                                        const nodemask_t *new)
+{
+}
+static inline void mpol_rebind_task(struct task_struct *tsk,
                                        const nodemask_t *new)
 {
 }
+static inline void mpol_rebind_mm(struct mm_struct *mm, nodemask_t *new)
+{
+}
+#define set_cpuset_being_rebound(x) do {} while (0)
 static inline struct zonelist *huge_zonelist(struct vm_area_struct *vma,
                unsigned long addr)
 {
        return NODE_DATA(0)->node_zonelists + gfp_zone(GFP_HIGHUSER);
 }
+static inline int do_migrate_pages(struct mm_struct *mm,
+                        const nodemask_t *from_nodes,
+                        const nodemask_t *to_nodes, int flags)
+{
+        return 0;
+}
 static inline void check_highest_zone(int k)
 {
 }
diff --git a/include/linux/mm.h b/include/linux/mm.h
index bc01fff3aa01..85854b867463 100644
--- a/include/linux/mm.h
+++ b/include/linux/mm.h
@@ -3,6 +3,7 @@
 #include <linux/sched.h>
 #include <linux/errno.h>
+#include <linux/capability.h>
 #ifdef __KERNEL__
@@ -13,6 +14,7 @@
 #include <linux/rbtree.h>
 #include <linux/prio_tree.h>
 #include <linux/fs.h>
+#include <linux/mutex.h>
 struct mempolicy;
 struct anon_vma;
@@ -223,24 +225,27 @@ struct page {
                                         * & limit reverse map searches.
                                         */
        union {
-                unsigned long private;  /* Mapping-private opaque data:
+            struct {
-                                         * usually used for buffer_heads
+                unsigned long private;          /* Mapping-private opaque data:
-                                         * if PagePrivate set; used for
+                                                 * usually used for buffer_heads
-                                         * swp_entry_t if PageSwapCache
+                                                 * if PagePrivate set; used for
-                                         * When page is free, this indicates
+                                                 * swp_entry_t if PageSwapCache.
-                                         * order in the buddy system.
+                                                 * When page is free, this
-                                         */
+                                                 * indicates order in the buddy
+                                                 * system.
+                                                 */
+                struct address_space *mapping;  /* If low bit clear, points to
+                                                 * inode address_space, or NULL.
+                                                 * If page mapped as anonymous
+                                                 * memory, low bit is set, and
+                                                 * it points to anon_vma object:
+                                                 * see PAGE_MAPPING_ANON below.
+                                                 */
+            };
 #if NR_CPUS >= CONFIG_SPLIT_PTLOCK_CPUS
-                spinlock_t ptl;
+            spinlock_t ptl;
 #endif
-        } u;
+        };
-        struct address_space *mapping;  /* If low bit clear, points to
-                                         * inode address_space, or NULL.
-                                         * If page mapped as anonymous
-                                         * memory, low bit is set, and
-                                         * it points to anon_vma object:
-                                         * see PAGE_MAPPING_ANON below.
-                                         */
        pgoff_t index;                  /* Our offset within mapping. */
        struct list_head lru;           /* Pageout list, eg. active_list
                                         * protected by zone->lru_lock !
@@ -261,8 +266,8 @@ struct page {
 #endif /* WANT_PAGE_VIRTUAL */
 };
-#define page_private(page)              ((page)->u.private)
+#define page_private(page)              ((page)->private)
-#define set_page_private(page, v)       ((page)->u.private = (v))
+#define set_page_private(page, v)       ((page)->private = (v))
 /*
 * FIXME: take this include out, include page-flags.h in
@@ -308,7 +313,7 @@ struct page {
 */
 #define get_page_testone(p)     atomic_inc_and_test(&(p)->_count)
-#define set_page_count(p,v)     atomic_set(&(p)->_count, v - 1)
+#define set_page_count(p,v)     atomic_set(&(p)->_count, (v) - 1)
 #define __put_page(p)           atomic_dec(&(p)->_count)
 extern void FASTCALL(__page_cache_release(struct page *));
@@ -507,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);
 }
@@ -815,7 +820,7 @@ static inline pmd_t *pmd_alloc(struct mm_struct *mm, pud_t *pud, unsigned long a
 * overflow into the next struct page (as it might with DEBUG_SPINLOCK).
 * When freeing, reset page->mapping so free_pages_check won't complain.
 */
-#define __pte_lockptr(page)     &((page)->u.ptl)
+#define __pte_lockptr(page)     &((page)->ptl)
 #define pte_lock_init(_page)    do {                                    \
        spin_lock_init(__pte_lockptr(_page));                           \
 } while (0)
@@ -1021,6 +1026,9 @@ static inline void vm_stat_account(struct mm_struct *mm,
 static inline void
 kernel_map_pages(struct page *page, int numpages, int enable)
 {
+        if (!PageHighMem(page) && !enable)
+                mutex_debug_check_no_locks_freed(page_address(page),
+                                                 numpages * PAGE_SIZE);
 }
 #endif
@@ -1036,5 +1044,12 @@ int in_gate_area_no_task(unsigned long addr);
 /* /proc/<pid>/oom_adj set to -17 protects from the oom-killer */
 #define OOM_DISABLE -17
+int drop_caches_sysctl_handler(struct ctl_table *, int, struct file *,
+                                        void __user *, size_t *, loff_t *);
+int shrink_slab(unsigned long scanned, gfp_t gfp_mask,
+                        unsigned long lru_pages);
+void drop_pagecache(void);
+void drop_slab(void);
 #endif /* __KERNEL__ */
 #endif /* _LINUX_MM_H */
diff --git a/include/linux/mm_inline.h b/include/linux/mm_inline.h
index 47762ca695a5..8ac854f7f190 100644
--- a/include/linux/mm_inline.h
+++ b/include/linux/mm_inline.h
@@ -38,3 +38,4 @@ del_page_from_lru(struct zone *zone, struct page *page)
                zone->nr_inactive--;
        }
 }
diff --git a/include/linux/mmc/card.h b/include/linux/mmc/card.h
index 18fc77f682de..30dd978c1ec8 100644
--- a/include/linux/mmc/card.h
+++ b/include/linux/mmc/card.h
@@ -30,7 +30,12 @@ struct mmc_csd {
        unsigned int            tacc_ns;
        unsigned int            max_dtr;
        unsigned int            read_blkbits;
+        unsigned int            write_blkbits;
        unsigned int            capacity;
+        unsigned int            read_partial:1,
+                                read_misalign:1,
+                                write_partial:1,
+                                write_misalign:1;
 };
 struct sd_scr {
diff --git a/include/linux/mmc/mmc.h b/include/linux/mmc/mmc.h
index aef6042f8f0b..ccd3e13de1e8 100644
--- a/include/linux/mmc/mmc.h
+++ b/include/linux/mmc/mmc.h
@@ -27,14 +27,15 @@ struct mmc_command {
 #define MMC_RSP_MASK    (3 << 0)
 #define MMC_RSP_CRC     (1 << 3)                /* expect valid crc */
 #define MMC_RSP_BUSY    (1 << 4)                /* card may send busy */
+#define MMC_RSP_OPCODE  (1 << 5)                /* response contains opcode */
 /*
 * These are the response types, and correspond to valid bit
 * patterns of the above flags.  One additional valid pattern
 * is all zeros, which means we don't expect a response.
 */
-#define MMC_RSP_R1      (MMC_RSP_SHORT|MMC_RSP_CRC)
+#define MMC_RSP_R1      (MMC_RSP_SHORT|MMC_RSP_CRC|MMC_RSP_OPCODE)
-#define MMC_RSP_R1B     (MMC_RSP_SHORT|MMC_RSP_CRC|MMC_RSP_BUSY)
+#define MMC_RSP_R1B     (MMC_RSP_SHORT|MMC_RSP_CRC|MMC_RSP_OPCODE|MMC_RSP_BUSY)
 #define MMC_RSP_R2      (MMC_RSP_LONG|MMC_RSP_CRC)
 #define MMC_RSP_R3      (MMC_RSP_SHORT)
 #define MMC_RSP_R6      (MMC_RSP_SHORT|MMC_RSP_CRC)
@@ -64,6 +65,7 @@ struct mmc_data {
 #define MMC_DATA_WRITE  (1 << 8)
 #define MMC_DATA_READ   (1 << 9)
 #define MMC_DATA_STREAM (1 << 10)
+#define MMC_DATA_MULTI  (1 << 11)
        unsigned int            bytes_xfered;
diff --git a/include/linux/mmzone.h b/include/linux/mmzone.h
index c34f4a2c62f8..93a849f742db 100644
--- a/include/linux/mmzone.h
+++ b/include/linux/mmzone.h
@@ -38,7 +38,7 @@ struct pglist_data;
 #if defined(CONFIG_SMP)
 struct zone_padding {
        char x[0];
-} ____cacheline_maxaligned_in_smp;
+} ____cacheline_internodealigned_in_smp;
 #define ZONE_PADDING(name)      struct zone_padding name;
 #else
 #define ZONE_PADDING(name)
@@ -98,7 +98,7 @@ struct per_cpu_pageset {
 /*
 * On machines where it is needed (eg PCs) we divide physical memory
- * into multiple physical zones. On a PC we have 4 zones:
+ * into multiple physical zones. On a 32bit PC we have 4 zones:
 *
 * ZONE_DMA       < 16 MB       ISA DMA capable memory
 * ZONE_DMA32        0 MB       Empty
@@ -149,15 +149,17 @@ struct zone {
        unsigned long           pages_scanned;     /* since last reclaim */
        int                     all_unreclaimable; /* All pages pinned */
-        /*
-         * Does the allocator try to reclaim pages from the zone as soon
-         * as it fails a watermark_ok() in __alloc_pages?
-         */
-        int                     reclaim_pages;
        /* A count of how many reclaimers are scanning this zone */
        atomic_t                reclaim_in_progress;
        /*
+         * timestamp (in jiffies) of the last zone reclaim that did not
+         * result in freeing of pages. This is used to avoid repeated scans
+         * if all memory in the zone is in use.
+         */
+        unsigned long           last_unsuccessful_zone_reclaim;
+        /*
         * prev_priority holds the scanning priority for this zone.  It is
         * defined as the scanning priority at which we achieved our reclaim
         * target at the previous try_to_free_pages() or balance_pgdat()
@@ -233,7 +235,7 @@ struct zone {
         * rarely used fields:
         */
        char                    *name;
-} ____cacheline_maxaligned_in_smp;
+} ____cacheline_internodealigned_in_smp;
 /*
@@ -437,6 +439,8 @@ int min_free_kbytes_sysctl_handler(struct ctl_table *, int, struct file *,
 extern int sysctl_lowmem_reserve_ratio[MAX_NR_ZONES-1];
 int lowmem_reserve_ratio_sysctl_handler(struct ctl_table *, int, struct file *,
                                        void __user *, size_t *, loff_t *);
+int percpu_pagelist_fraction_sysctl_handler(struct ctl_table *, int, struct file *,
+                                        void __user *, size_t *, loff_t *);
 #include <linux/topology.h>
 /* Returns the number of the current Node. */
diff --git a/include/linux/mount.h b/include/linux/mount.h
index dd4e83eba933..b7472ae91fa4 100644
--- a/include/linux/mount.h
+++ b/include/linux/mount.h
@@ -20,9 +20,12 @@
 #define MNT_NOSUID      0x01
 #define MNT_NODEV       0x02
 #define MNT_NOEXEC      0x04
-#define MNT_SHARED      0x10    /* if the vfsmount is a shared mount */
+#define MNT_NOATIME     0x08
-#define MNT_UNBINDABLE  0x20    /* if the vfsmount is a unbindable mount */
+#define MNT_NODIRATIME  0x10
-#define MNT_PNODE_MASK  0x30    /* propogation flag mask */
+#define MNT_SHARED      0x1000  /* if the vfsmount is a shared mount */
+#define MNT_UNBINDABLE  0x2000  /* if the vfsmount is a unbindable mount */
+#define MNT_PNODE_MASK  0x3000  /* propogation flag mask */
 struct vfsmount {
        struct list_head mnt_hash;
diff --git a/include/linux/msdos_fs.h b/include/linux/msdos_fs.h
index 941da5c016a0..e933e2a355ad 100644
--- a/include/linux/msdos_fs.h
+++ b/include/linux/msdos_fs.h
@@ -329,7 +329,8 @@ static inline void fatwchar_to16(__u8 *dst, const wchar_t *src, size_t len)
 extern void fat_cache_inval_inode(struct inode *inode);
 extern int fat_get_cluster(struct inode *inode, int cluster,
                           int *fclus, int *dclus);
-extern int fat_bmap(struct inode *inode, sector_t sector, sector_t *phys);
+extern int fat_bmap(struct inode *inode, sector_t sector, sector_t *phys,
+                    unsigned long *mapped_blocks);
 /* fat/dir.c */
 extern struct file_operations fat_dir_operations;
diff --git a/include/linux/mutex-debug.h b/include/linux/mutex-debug.h
new file mode 100644
index 000000000000..8b5769f00467
--- /dev/null
+++ b/include/linux/mutex-debug.h
@@ -0,0 +1,23 @@
+#ifndef __LINUX_MUTEX_DEBUG_H
+#define __LINUX_MUTEX_DEBUG_H
+#include <linux/linkage.h>
+/*
+ * Mutexes - debugging helpers:
+ */
+#define __DEBUG_MUTEX_INITIALIZER(lockname) \
+        , .held_list = LIST_HEAD_INIT(lockname.held_list), \
+          .name = #lockname , .magic = &lockname
+#define mutex_init(sem)         __mutex_init(sem, __FUNCTION__)
+extern void FASTCALL(mutex_destroy(struct mutex *lock));
+extern void mutex_debug_show_all_locks(void);
+extern void mutex_debug_show_held_locks(struct task_struct *filter);
+extern void mutex_debug_check_no_locks_held(struct task_struct *task);
+extern void mutex_debug_check_no_locks_freed(const void *from, unsigned long len);
+#endif
diff --git a/include/linux/mutex.h b/include/linux/mutex.h
new file mode 100644
index 000000000000..f1ac507fa20d
--- /dev/null
+++ b/include/linux/mutex.h
@@ -0,0 +1,120 @@
+/*
+ * Mutexes: blocking mutual exclusion locks
+ *
+ * started by Ingo Molnar:
+ *
+ *  Copyright (C) 2004, 2005, 2006 Red Hat, Inc., Ingo Molnar <mingo@redhat.com>
+ *
+ * This file contains the main data structure and API definitions.
+ */
+#ifndef __LINUX_MUTEX_H
+#define __LINUX_MUTEX_H
+#include <linux/list.h>
+#include <linux/spinlock_types.h>
+#include <linux/linkage.h>
+#include <asm/atomic.h>
+/*
+ * Simple, straightforward mutexes with strict semantics:
+ *
+ * - only one task can hold the mutex at a time
+ * - only the owner can unlock the mutex
+ * - multiple unlocks are not permitted
+ * - recursive locking is not permitted
+ * - a mutex object must be initialized via the API
+ * - a mutex object must not be initialized via memset or copying
+ * - task may not exit with mutex held
+ * - memory areas where held locks reside must not be freed
+ * - held mutexes must not be reinitialized
+ * - mutexes may not be used in irq contexts
+ *
+ * These semantics are fully enforced when DEBUG_MUTEXES is
+ * enabled. Furthermore, besides enforcing the above rules, the mutex
+ * debugging code also implements a number of additional features
+ * that make lock debugging easier and faster:
+ *
+ * - uses symbolic names of mutexes, whenever they are printed in debug output
+ * - point-of-acquire tracking, symbolic lookup of function names
+ * - list of all locks held in the system, printout of them
+ * - owner tracking
+ * - detects self-recursing locks and prints out all relevant info
+ * - detects multi-task circular deadlocks and prints out all affected
+ *   locks and tasks (and only those tasks)
+ */
+struct mutex {
+        /* 1: unlocked, 0: locked, negative: locked, possible waiters */
+        atomic_t                count;
+        spinlock_t              wait_lock;
+        struct list_head        wait_list;
+#ifdef CONFIG_DEBUG_MUTEXES
+        struct thread_info      *owner;
+        struct list_head        held_list;
+        unsigned long           acquire_ip;
+        const char              *name;
+        void                    *magic;
+#endif
+};
+/*
+ * This is the control structure for tasks blocked on mutex,
+ * which resides on the blocked task's kernel stack:
+ */
+struct mutex_waiter {
+        struct list_head        list;
+        struct task_struct      *task;
+#ifdef CONFIG_DEBUG_MUTEXES
+        struct mutex            *lock;
+        void                    *magic;
+#endif
+};
+#ifdef CONFIG_DEBUG_MUTEXES
+# include <linux/mutex-debug.h>
+#else
+# define __DEBUG_MUTEX_INITIALIZER(lockname)
+# define mutex_init(mutex)                      __mutex_init(mutex, NULL)
+# define mutex_destroy(mutex)                           do { } while (0)
+# define mutex_debug_show_all_locks()                   do { } while (0)
+# define mutex_debug_show_held_locks(p)                 do { } while (0)
+# define mutex_debug_check_no_locks_held(task)          do { } while (0)
+# define mutex_debug_check_no_locks_freed(from, len)    do { } while (0)
+#endif
+#define __MUTEX_INITIALIZER(lockname) \
+                { .count = ATOMIC_INIT(1) \
+                , .wait_lock = SPIN_LOCK_UNLOCKED \
+                , .wait_list = LIST_HEAD_INIT(lockname.wait_list) \
+                __DEBUG_MUTEX_INITIALIZER(lockname) }
+#define DEFINE_MUTEX(mutexname) \
+        struct mutex mutexname = __MUTEX_INITIALIZER(mutexname)
+extern void fastcall __mutex_init(struct mutex *lock, const char *name);
+/***
+ * mutex_is_locked - is the mutex locked
+ * @lock: the mutex to be queried
+ *
+ * Returns 1 if the mutex is locked, 0 if unlocked.
+ */
+static inline int fastcall mutex_is_locked(struct mutex *lock)
+{
+        return atomic_read(&lock->count) != 1;
+}
+/*
+ * See kernel/mutex.c for detailed documentation of these APIs.
+ * Also see Documentation/mutex-design.txt.
+ */
+extern void fastcall mutex_lock(struct mutex *lock);
+extern int fastcall mutex_lock_interruptible(struct mutex *lock);
+/*
+ * NOTE: mutex_trylock() follows the spin_trylock() convention,
+ *       not the down_trylock() convention!
+ */
+extern int fastcall mutex_trylock(struct mutex *lock);
+extern void fastcall mutex_unlock(struct mutex *lock);
+#endif
diff --git a/include/linux/namei.h b/include/linux/namei.h
index 455660eafba9..e6698013e4d0 100644
--- a/include/linux/namei.h
+++ b/include/linux/namei.h
@@ -56,10 +56,11 @@ enum {LAST_NORM, LAST_ROOT, LAST_DOT, LAST_DOTDOT, LAST_BIND};
 #define LOOKUP_ACCESS           (0x0400)
 extern int FASTCALL(__user_walk(const char __user *, unsigned, struct nameidata *));
+extern int FASTCALL(__user_walk_fd(int dfd, const char __user *, unsigned, struct nameidata *));
 #define user_path_walk(name,nd) \
-        __user_walk(name, LOOKUP_FOLLOW, nd)
+        __user_walk_fd(AT_FDCWD, name, LOOKUP_FOLLOW, nd)
 #define user_path_walk_link(name,nd) \
-        __user_walk(name, 0, nd)
+        __user_walk_fd(AT_FDCWD, name, 0, nd)
 extern int FASTCALL(path_lookup(const char *, unsigned, struct nameidata *));
 extern int FASTCALL(path_walk(const char *, struct nameidata *));
 extern int FASTCALL(link_path_walk(const char *, struct nameidata *));
@@ -67,14 +68,14 @@ extern void path_release(struct nameidata *);
 extern void path_release_on_umount(struct nameidata *);
 extern int __user_path_lookup_open(const char __user *, unsigned lookup_flags, struct nameidata *nd, int open_flags);
-extern int path_lookup_open(const char *, unsigned lookup_flags, struct nameidata *, int open_flags);
+extern int path_lookup_open(int dfd, const char *name, unsigned lookup_flags, struct nameidata *, int open_flags);
 extern struct file *lookup_instantiate_filp(struct nameidata *nd, struct dentry *dentry,
                int (*open)(struct inode *, struct file *));
 extern struct file *nameidata_to_filp(struct nameidata *nd, int flags);
 extern void release_open_intent(struct nameidata *);
 extern struct dentry * lookup_one_len(const char *, struct dentry *, int);
-extern struct dentry * lookup_hash(struct nameidata *);
+extern __deprecated_for_modules struct dentry * lookup_hash(struct nameidata *);
 extern int follow_down(struct vfsmount **, struct dentry **);
 extern int follow_up(struct vfsmount **, struct dentry **);
diff --git a/include/linux/ncp.h b/include/linux/ncp.h
index 99f77876b716..99f0adeeb3f3 100644
--- a/include/linux/ncp.h
+++ b/include/linux/ncp.h
@@ -20,29 +20,29 @@
 #define NCP_DEALLOC_SLOT_REQUEST (0x5555)
 struct ncp_request_header {
-        __u16 type __attribute__((packed));
+        __u16 type;
-        __u8 sequence __attribute__((packed));
+        __u8 sequence;
-        __u8 conn_low __attribute__((packed));
+        __u8 conn_low;
-        __u8 task __attribute__((packed));
+        __u8 task;
-        __u8 conn_high __attribute__((packed));
+        __u8 conn_high;
-        __u8 function __attribute__((packed));
+        __u8 function;
-        __u8 data[0] __attribute__((packed));
+        __u8 data[0];
-};
+} __attribute__((packed));
 #define NCP_REPLY                (0x3333)
 #define NCP_WATCHDOG             (0x3E3E)
 #define NCP_POSITIVE_ACK         (0x9999)
 struct ncp_reply_header {
-        __u16 type __attribute__((packed));
+        __u16 type;
-        __u8 sequence __attribute__((packed));
+        __u8 sequence;
-        __u8 conn_low __attribute__((packed));
+        __u8 conn_low;
-        __u8 task __attribute__((packed));
+        __u8 task;
-        __u8 conn_high __attribute__((packed));
+        __u8 conn_high;
-        __u8 completion_code __attribute__((packed));
+        __u8 completion_code;
-        __u8 connection_state __attribute__((packed));
+        __u8 connection_state;
-        __u8 data[0] __attribute__((packed));
+        __u8 data[0];
-};
+} __attribute__((packed));
 #define NCP_VOLNAME_LEN (16)
 #define NCP_NUMBER_OF_VOLUMES (256)
@@ -128,37 +128,37 @@ struct nw_nfs_info {
 };
 struct nw_info_struct {
-        __u32 spaceAlloc __attribute__((packed));
+        __u32 spaceAlloc;
-        __le32 attributes __attribute__((packed));
+        __le32 attributes;
-        __u16 flags __attribute__((packed));
+        __u16 flags;
-        __le32 dataStreamSize __attribute__((packed));
+        __le32 dataStreamSize;
-        __le32 totalStreamSize __attribute__((packed));
+        __le32 totalStreamSize;
-        __u16 numberOfStreams __attribute__((packed));
+        __u16 numberOfStreams;
-        __le16 creationTime __attribute__((packed));
+        __le16 creationTime;
-        __le16 creationDate __attribute__((packed));
+        __le16 creationDate;
-        __u32 creatorID __attribute__((packed));
+        __u32 creatorID;
-        __le16 modifyTime __attribute__((packed));
+        __le16 modifyTime;
-        __le16 modifyDate __attribute__((packed));
+        __le16 modifyDate;
-        __u32 modifierID __attribute__((packed));
+        __u32 modifierID;
-        __le16 lastAccessDate __attribute__((packed));
+        __le16 lastAccessDate;
-        __u16 archiveTime __attribute__((packed));
+        __u16 archiveTime;
-        __u16 archiveDate __attribute__((packed));
+        __u16 archiveDate;
-        __u32 archiverID __attribute__((packed));
+        __u32 archiverID;
-        __u16 inheritedRightsMask __attribute__((packed));
+        __u16 inheritedRightsMask;
-        __le32 dirEntNum __attribute__((packed));
+        __le32 dirEntNum;
-        __le32 DosDirNum __attribute__((packed));
+        __le32 DosDirNum;
-        __u32 volNumber __attribute__((packed));
+        __u32 volNumber;
-        __u32 EADataSize __attribute__((packed));
+        __u32 EADataSize;
-        __u32 EAKeyCount __attribute__((packed));
+        __u32 EAKeyCount;
-        __u32 EAKeySize __attribute__((packed));
+        __u32 EAKeySize;
-        __u32 NSCreator __attribute__((packed));
+        __u32 NSCreator;
-        __u8 nameLen __attribute__((packed));
+        __u8 nameLen;
-        __u8 entryName[256] __attribute__((packed));
+        __u8 entryName[256];
        /* libncp may depend on there being nothing after entryName */
 #ifdef __KERNEL__
        struct nw_nfs_info nfs;
 #endif
-};
+} __attribute__((packed));
 /* modify mask - use with MODIFY_DOS_INFO structure */
 #define DM_ATTRIBUTES             (cpu_to_le32(0x02))
@@ -176,26 +176,26 @@ struct nw_info_struct {
 #define DM_MAXIMUM_SPACE          (cpu_to_le32(0x2000))
 struct nw_modify_dos_info {
-        __le32 attributes __attribute__((packed));
+        __le32 attributes;
-        __le16 creationDate __attribute__((packed));
+        __le16 creationDate;
-        __le16 creationTime __attribute__((packed));
+        __le16 creationTime;
-        __u32 creatorID __attribute__((packed));
+        __u32 creatorID;
-        __le16 modifyDate __attribute__((packed));
+        __le16 modifyDate;
-        __le16 modifyTime __attribute__((packed));
+        __le16 modifyTime;
-        __u32 modifierID __attribute__((packed));
+        __u32 modifierID;
-        __u16 archiveDate __attribute__((packed));
+        __u16 archiveDate;
-        __u16 archiveTime __attribute__((packed));
+        __u16 archiveTime;
-        __u32 archiverID __attribute__((packed));
+        __u32 archiverID;
-        __le16 lastAccessDate __attribute__((packed));
+        __le16 lastAccessDate;
-        __u16 inheritanceGrantMask __attribute__((packed));
+        __u16 inheritanceGrantMask;
-        __u16 inheritanceRevokeMask __attribute__((packed));
+        __u16 inheritanceRevokeMask;
-        __u32 maximumSpace __attribute__((packed));
+        __u32 maximumSpace;
-};
+} __attribute__((packed));
 struct nw_search_sequence {
-        __u8 volNumber __attribute__((packed));
+        __u8 volNumber;
-        __u32 dirBase __attribute__((packed));
+        __u32 dirBase;
-        __u32 sequence __attribute__((packed));
+        __u32 sequence;
-};
+} __attribute__((packed));
 #endif                          /* _LINUX_NCP_H */
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.h b/include/linux/netfilter.h
index be365e70ee99..4cf6088625c1 100644
--- a/include/linux/netfilter.h
+++ b/include/linux/netfilter.h
@@ -168,6 +168,37 @@ void nf_log_packet(int pf,
                   const struct net_device *out,
                   struct nf_loginfo *li,
                   const char *fmt, ...);
+int nf_hook_slow(int pf, unsigned int hook, struct sk_buff **pskb,
+                 struct net_device *indev, struct net_device *outdev,
+                 int (*okfn)(struct sk_buff *), int thresh);
+/**
+ *      nf_hook_thresh - call a netfilter hook
+ *      
+ *      Returns 1 if the hook has allowed the packet to pass.  The function
+ *      okfn must be invoked by the caller in this case.  Any other return
+ *      value indicates the packet has been consumed by the hook.
+ */
+static inline int nf_hook_thresh(int pf, unsigned int hook,
+                                 struct sk_buff **pskb,
+                                 struct net_device *indev,
+                                 struct net_device *outdev,
+                                 int (*okfn)(struct sk_buff *), int thresh)
+{
+#ifndef CONFIG_NETFILTER_DEBUG
+        if (list_empty(&nf_hooks[pf][hook]))
+                return 1;
+#endif
+        return nf_hook_slow(pf, hook, pskb, indev, outdev, okfn, thresh);
+}
+static inline int nf_hook(int pf, unsigned int hook, struct sk_buff **pskb,
+                          struct net_device *indev, struct net_device *outdev,
+                          int (*okfn)(struct sk_buff *))
+{
+        return nf_hook_thresh(pf, hook, pskb, indev, outdev, okfn, INT_MIN);
+}
                   
 /* Activate hook; either okfn or kfree_skb called, unless a hook
   returns NF_STOLEN (in which case, it's up to the hook to deal with
@@ -188,35 +219,17 @@ void nf_log_packet(int pf,
 /* This is gross, but inline doesn't cut it for avoiding the function
   call in fast path: gcc doesn't inline (needs value tracking?). --RR */
-#ifdef CONFIG_NETFILTER_DEBUG
-#define NF_HOOK(pf, hook, skb, indev, outdev, okfn)                            \
+/* HX: It's slightly less gross now. */
-({int __ret;                                                                   \
-if ((__ret=nf_hook_slow(pf, hook, &(skb), indev, outdev, okfn, INT_MIN)) == 1) \
-        __ret = (okfn)(skb);                                                   \
-__ret;})
-#define NF_HOOK_THRESH(pf, hook, skb, indev, outdev, okfn, thresh)             \
-({int __ret;                                                                   \
-if ((__ret=nf_hook_slow(pf, hook, &(skb), indev, outdev, okfn, thresh)) == 1)  \
-        __ret = (okfn)(skb);                                                   \
-__ret;})
-#else
-#define NF_HOOK(pf, hook, skb, indev, outdev, okfn)                            \
-({int __ret;                                                                   \
-if (list_empty(&nf_hooks[pf][hook]) ||                                         \
-    (__ret=nf_hook_slow(pf, hook, &(skb), indev, outdev, okfn, INT_MIN)) == 1) \
-        __ret = (okfn)(skb);                                                   \
-__ret;})
 #define NF_HOOK_THRESH(pf, hook, skb, indev, outdev, okfn, thresh)             \
 ({int __ret;                                                                   \
-if (list_empty(&nf_hooks[pf][hook]) ||                                         \
+if ((__ret=nf_hook_thresh(pf, hook, &(skb), indev, outdev, okfn, thresh)) == 1)\
-    (__ret=nf_hook_slow(pf, hook, &(skb), indev, outdev, okfn, thresh)) == 1)  \
        __ret = (okfn)(skb);                                                   \
 __ret;})
-#endif
-int nf_hook_slow(int pf, unsigned int hook, struct sk_buff **pskb,
+#define NF_HOOK(pf, hook, skb, indev, outdev, okfn) \
-                 struct net_device *indev, struct net_device *outdev,
+        NF_HOOK_THRESH(pf, hook, skb, indev, outdev, okfn, INT_MIN)
-                 int (*okfn)(struct sk_buff *), int thresh);
 /* Call setsockopt() */
 int nf_setsockopt(struct sock *sk, int pf, int optval, char __user *opt, 
@@ -261,6 +274,20 @@ struct nf_queue_rerouter {
 extern int nf_register_queue_rerouter(int pf, struct nf_queue_rerouter *rer);
 extern int nf_unregister_queue_rerouter(int pf);
+#include <net/flow.h>
+extern void (*ip_nat_decode_session)(struct sk_buff *, struct flowi *);
+static inline void
+nf_nat_decode_session(struct sk_buff *skb, struct flowi *fl, int family)
+{
+#ifdef CONFIG_IP_NF_NAT_NEEDED
+        void (*decodefn)(struct sk_buff *, struct flowi *);
+        if (family == AF_INET && (decodefn = ip_nat_decode_session) != NULL)
+                decodefn(skb, fl);
+#endif
+}
 #ifdef CONFIG_PROC_FS
 #include <linux/proc_fs.h>
 extern struct proc_dir_entry *proc_net_netfilter;
@@ -268,7 +295,24 @@ extern struct proc_dir_entry *proc_net_netfilter;
 #else /* !CONFIG_NETFILTER */
 #define NF_HOOK(pf, hook, skb, indev, outdev, okfn) (okfn)(skb)
+static inline int nf_hook_thresh(int pf, unsigned int hook,
+                                 struct sk_buff **pskb,
+                                 struct net_device *indev,
+                                 struct net_device *outdev,
+                                 int (*okfn)(struct sk_buff *), int thresh)
+{
+        return okfn(*pskb);
+}
+static inline int nf_hook(int pf, unsigned int hook, struct sk_buff **pskb,
+                          struct net_device *indev, struct net_device *outdev,
+                          int (*okfn)(struct sk_buff *))
+{
+        return okfn(*pskb);
+}
 static inline void nf_ct_attach(struct sk_buff *new, struct sk_buff *skb) {}
+struct flowi;
+static inline void
+nf_nat_decode_session(struct sk_buff *skb, struct flowi *fl, int family) {}
 #endif /*CONFIG_NETFILTER*/
 #endif /*__KERNEL__*/
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..59ff6c430cf6
--- /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__(u_int64_t)-1)) & ~(__alignof__(u_int64_t)-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_nat_protocol.h b/include/linux/netfilter_ipv4/ip_nat_protocol.h
index ef63aa991a06..612a43614e7b 100644
--- a/include/linux/netfilter_ipv4/ip_nat_protocol.h
+++ b/include/linux/netfilter_ipv4/ip_nat_protocol.h
@@ -42,13 +42,6 @@ struct ip_nat_protocol
                            enum ip_nat_manip_type maniptype,
                            const struct ip_conntrack *conntrack);
-        unsigned int (*print)(char *buffer,
-                              const struct ip_conntrack_tuple *match,
-                              const struct ip_conntrack_tuple *mask);
-        unsigned int (*print_range)(char *buffer,
-                                    const struct ip_nat_range *range);
        int (*range_to_nfattr)(struct sk_buff *skb,
                               const struct ip_nat_range *range);
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_policy.h b/include/linux/netfilter_ipv4/ipt_policy.h
new file mode 100644
index 000000000000..7fd1bec453f1
--- /dev/null
+++ b/include/linux/netfilter_ipv4/ipt_policy.h
@@ -0,0 +1,52 @@
+#ifndef _IPT_POLICY_H
+#define _IPT_POLICY_H
+#define IPT_POLICY_MAX_ELEM     4
+enum ipt_policy_flags
+{
+        IPT_POLICY_MATCH_IN     = 0x1,
+        IPT_POLICY_MATCH_OUT    = 0x2,
+        IPT_POLICY_MATCH_NONE   = 0x4,
+        IPT_POLICY_MATCH_STRICT = 0x8,
+};
+enum ipt_policy_modes
+{
+        IPT_POLICY_MODE_TRANSPORT,
+        IPT_POLICY_MODE_TUNNEL
+};
+struct ipt_policy_spec
+{
+        u_int8_t        saddr:1,
+                        daddr:1,
+                        proto:1,
+                        mode:1,
+                        spi:1,
+                        reqid:1;
+};
+struct ipt_policy_elem
+{
+        u_int32_t       saddr;
+        u_int32_t       smask;
+        u_int32_t       daddr;
+        u_int32_t       dmask;
+        u_int32_t       spi;
+        u_int32_t       reqid;
+        u_int8_t        proto;
+        u_int8_t        mode;
+        struct ipt_policy_spec  match;
+        struct ipt_policy_spec  invert;
+};
+struct ipt_policy_info
+{
+        struct ipt_policy_elem pol[IPT_POLICY_MAX_ELEM];
+        u_int16_t flags;
+        u_int16_t len;
+};
+#endif /* _IPT_POLICY_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.h b/include/linux/netfilter_ipv6.h
index 53b2983f6278..14f2bd010884 100644
--- a/include/linux/netfilter_ipv6.h
+++ b/include/linux/netfilter_ipv6.h
@@ -72,7 +72,12 @@ enum nf_ip6_hook_priorities {
        NF_IP6_PRI_LAST = INT_MAX,
 };
+#ifdef CONFIG_NETFILTER
 extern int ipv6_netfilter_init(void);
 extern void ipv6_netfilter_fini(void);
+#else /* CONFIG_NETFILTER */
+static inline int ipv6_netfilter_init(void) { return 0; }
+static inline void ipv6_netfilter_fini(void) { return; }
+#endif /* CONFIG_NETFILTER */
 #endif /*__LINUX_IP6_NETFILTER_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_ah.h b/include/linux/netfilter_ipv6/ip6t_ah.h
index c4f0793a0a98..8531879eb464 100644
--- a/include/linux/netfilter_ipv6/ip6t_ah.h
+++ b/include/linux/netfilter_ipv6/ip6t_ah.h
@@ -18,13 +18,4 @@ struct ip6t_ah
 #define IP6T_AH_INV_LEN         0x02    /* Invert the sense of length. */
 #define IP6T_AH_INV_MASK        0x03    /* All possible flags. */
-#define MASK_HOPOPTS    128
-#define MASK_DSTOPTS    64
-#define MASK_ROUTING    32
-#define MASK_FRAGMENT   16
-#define MASK_AH         8
-#define MASK_ESP        4
-#define MASK_NONE       2
-#define MASK_PROTO      1
 #endif /*_IP6T_AH_H*/
diff --git a/include/linux/netfilter_ipv6/ip6t_esp.h b/include/linux/netfilter_ipv6/ip6t_esp.h
index 01142b98a231..a91b6abc8079 100644
--- a/include/linux/netfilter_ipv6/ip6t_esp.h
+++ b/include/linux/netfilter_ipv6/ip6t_esp.h
@@ -7,15 +7,6 @@ struct ip6t_esp
        u_int8_t  invflags;                     /* Inverse flags */
 };
-#define MASK_HOPOPTS    128
-#define MASK_DSTOPTS    64
-#define MASK_ROUTING    32
-#define MASK_FRAGMENT   16
-#define MASK_AH         8
-#define MASK_ESP        4
-#define MASK_NONE       2
-#define MASK_PROTO      1
 /* Values for "invflags" field in struct ip6t_esp. */
 #define IP6T_ESP_INV_SPI                0x01    /* Invert the sense of spi. */
 #define IP6T_ESP_INV_MASK       0x01    /* All possible flags. */
diff --git a/include/linux/netfilter_ipv6/ip6t_frag.h b/include/linux/netfilter_ipv6/ip6t_frag.h
index 449a57eca7dd..66070a0d6dfc 100644
--- a/include/linux/netfilter_ipv6/ip6t_frag.h
+++ b/include/linux/netfilter_ipv6/ip6t_frag.h
@@ -21,13 +21,4 @@ struct ip6t_frag
 #define IP6T_FRAG_INV_LEN       0x02    /* Invert the sense of length. */
 #define IP6T_FRAG_INV_MASK      0x03    /* All possible flags. */
-#define MASK_HOPOPTS    128
-#define MASK_DSTOPTS    64
-#define MASK_ROUTING    32
-#define MASK_FRAGMENT   16
-#define MASK_AH         8
-#define MASK_ESP        4
-#define MASK_NONE       2
-#define MASK_PROTO      1
 #endif /*_IP6T_FRAG_H*/
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_opts.h b/include/linux/netfilter_ipv6/ip6t_opts.h
index e259b6275bd2..a07e36380ae8 100644
--- a/include/linux/netfilter_ipv6/ip6t_opts.h
+++ b/include/linux/netfilter_ipv6/ip6t_opts.h
@@ -20,13 +20,4 @@ struct ip6t_opts
 #define IP6T_OPTS_INV_LEN       0x01    /* Invert the sense of length. */
 #define IP6T_OPTS_INV_MASK      0x01    /* All possible flags. */
-#define MASK_HOPOPTS    128
-#define MASK_DSTOPTS    64
-#define MASK_ROUTING    32
-#define MASK_FRAGMENT   16
-#define MASK_AH         8
-#define MASK_ESP        4
-#define MASK_NONE       2
-#define MASK_PROTO      1
 #endif /*_IP6T_OPTS_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/netfilter_ipv6/ip6t_policy.h b/include/linux/netfilter_ipv6/ip6t_policy.h
new file mode 100644
index 000000000000..5a93afcd2ff1
--- /dev/null
+++ b/include/linux/netfilter_ipv6/ip6t_policy.h
@@ -0,0 +1,52 @@
+#ifndef _IP6T_POLICY_H
+#define _IP6T_POLICY_H
+#define IP6T_POLICY_MAX_ELEM    4
+enum ip6t_policy_flags
+{
+        IP6T_POLICY_MATCH_IN            = 0x1,
+        IP6T_POLICY_MATCH_OUT           = 0x2,
+        IP6T_POLICY_MATCH_NONE          = 0x4,
+        IP6T_POLICY_MATCH_STRICT        = 0x8,
+};
+enum ip6t_policy_modes
+{
+        IP6T_POLICY_MODE_TRANSPORT,
+        IP6T_POLICY_MODE_TUNNEL
+};
+struct ip6t_policy_spec
+{
+        u_int8_t        saddr:1,
+                        daddr:1,
+                        proto:1,
+                        mode:1,
+                        spi:1,
+                        reqid:1;
+};
+struct ip6t_policy_elem
+{
+        struct in6_addr saddr;
+        struct in6_addr smask;
+        struct in6_addr daddr;
+        struct in6_addr dmask;
+        u_int32_t       spi;
+        u_int32_t       reqid;
+        u_int8_t        proto;
+        u_int8_t        mode;
+        struct ip6t_policy_spec match;
+        struct ip6t_policy_spec invert;
+};
+struct ip6t_policy_info
+{
+        struct ip6t_policy_elem pol[IP6T_POLICY_MAX_ELEM];
+        u_int16_t flags;
+        u_int16_t len;
+};
+#endif /* _IP6T_POLICY_H */
diff --git a/include/linux/netfilter_ipv6/ip6t_rt.h b/include/linux/netfilter_ipv6/ip6t_rt.h
index f1070fbf2757..52156023e8db 100644
--- a/include/linux/netfilter_ipv6/ip6t_rt.h
+++ b/include/linux/netfilter_ipv6/ip6t_rt.h
@@ -30,13 +30,4 @@ struct ip6t_rt
 #define IP6T_RT_INV_LEN         0x04    /* Invert the sense of length. */
 #define IP6T_RT_INV_MASK        0x07    /* All possible flags. */
-#define MASK_HOPOPTS    128
-#define MASK_DSTOPTS    64
-#define MASK_ROUTING    32
-#define MASK_FRAGMENT   16
-#define MASK_AH         8
-#define MASK_ESP        4
-#define MASK_NONE       2
-#define MASK_PROTO      1
 #endif /*_IP6T_RT_H*/
diff --git a/include/linux/nfsd/nfsd.h b/include/linux/nfsd/nfsd.h
index 51c231a1e5a6..ec7c2e872d72 100644
--- a/include/linux/nfsd/nfsd.h
+++ b/include/linux/nfsd/nfsd.h
@@ -124,7 +124,7 @@ int		nfsd_statfs(struct svc_rqst *, struct svc_fh *,
 int             nfsd_notify_change(struct inode *, struct iattr *);
 int             nfsd_permission(struct svc_export *, struct dentry *, int);
-void            nfsd_sync_dir(struct dentry *dp);
+int             nfsd_sync_dir(struct dentry *dp);
 #if defined(CONFIG_NFSD_V2_ACL) || defined(CONFIG_NFSD_V3_ACL)
 #ifdef CONFIG_NFSD_V2_ACL
diff --git a/include/linux/nfsd/nfsfh.h b/include/linux/nfsd/nfsfh.h
index bb842ea41033..0798b7781a6e 100644
--- a/include/linux/nfsd/nfsfh.h
+++ b/include/linux/nfsd/nfsfh.h
@@ -294,7 +294,7 @@ fill_post_wcc(struct svc_fh *fhp)
 /*
 * Lock a file handle/inode
 * NOTE: both fh_lock and fh_unlock are done "by hand" in
- * vfs.c:nfsd_rename as it needs to grab 2 i_sem's at once
+ * vfs.c:nfsd_rename as it needs to grab 2 i_mutex's at once
 * so, any changes here should be reflected there.
 */
 static inline void
@@ -317,7 +317,7 @@ fh_lock(struct svc_fh *fhp)
        }
        inode = dentry->d_inode;
-        down(&inode->i_sem);
+        mutex_lock(&inode->i_mutex);
        fill_pre_wcc(fhp);
        fhp->fh_locked = 1;
 }
@@ -333,7 +333,7 @@ fh_unlock(struct svc_fh *fhp)
        if (fhp->fh_locked) {
                fill_post_wcc(fhp);
-                up(&fhp->fh_dentry->d_inode->i_sem);
+                mutex_unlock(&fhp->fh_dentry->d_inode->i_mutex);
                fhp->fh_locked = 0;
        }
 }
diff --git a/include/linux/nfsd/xdr4.h b/include/linux/nfsd/xdr4.h
index 8903688890ce..77adba7d2281 100644
--- a/include/linux/nfsd/xdr4.h
+++ b/include/linux/nfsd/xdr4.h
@@ -145,8 +145,9 @@ struct nfsd4_lock {
                } ok;
                struct nfsd4_lock_denied        denied;
        } u;
+        /* The lk_replay_owner is the open owner in the open_to_lock_owner
-        struct nfs4_stateowner *lk_stateowner;
+         * case and the lock owner otherwise: */
+        struct nfs4_stateowner *lk_replay_owner;
 };
 #define lk_new_open_seqid       v.new.open_seqid
 #define lk_new_open_stateid     v.new.open_stateid
diff --git a/include/linux/pagevec.h b/include/linux/pagevec.h
index def32c5715be..8eb7fa76c1d0 100644
--- a/include/linux/pagevec.h
+++ b/include/linux/pagevec.h
@@ -5,6 +5,9 @@
 * pages.  A pagevec is a multipage container which is used for that.
 */
+#ifndef _LINUX_PAGEVEC_H
+#define _LINUX_PAGEVEC_H
 /* 14 pointers + two long's align the pagevec structure to a power of two */
 #define PAGEVEC_SIZE    14
@@ -83,3 +86,5 @@ static inline void pagevec_lru_add(struct pagevec *pvec)
        if (pagevec_count(pvec))
                __pagevec_lru_add(pvec);
 }
+#endif /* _LINUX_PAGEVEC_H */
diff --git a/include/linux/parport.h b/include/linux/parport.h
index f7ff0b0c4031..f67f838a3a1f 100644
--- a/include/linux/parport.h
+++ b/include/linux/parport.h
@@ -236,12 +236,14 @@ struct pardevice {
 /* IEEE1284 information */
-/* IEEE1284 phases */
+/* IEEE1284 phases. These are exposed to userland through ppdev IOCTL
+ * PP[GS]ETPHASE, so do not change existing values. */
 enum ieee1284_phase {
        IEEE1284_PH_FWD_DATA,
        IEEE1284_PH_FWD_IDLE,
        IEEE1284_PH_TERMINATE,
        IEEE1284_PH_NEGOTIATION,
+        IEEE1284_PH_HBUSY_DNA,
        IEEE1284_PH_REV_IDLE,
        IEEE1284_PH_HBUSY_DAVAIL,
        IEEE1284_PH_REV_DATA,
diff --git a/include/linux/pci.h b/include/linux/pci.h
index de690ca73d58..0a44072383ec 100644
--- a/include/linux/pci.h
+++ b/include/linux/pci.h
@@ -78,6 +78,23 @@ typedef int __bitwise pci_power_t;
 #define PCI_UNKNOWN     ((pci_power_t __force) 5)
 #define PCI_POWER_ERROR ((pci_power_t __force) -1)
+/** The pci_channel state describes connectivity between the CPU and
+ *  the pci device.  If some PCI bus between here and the pci device
+ *  has crashed or locked up, this info is reflected here.
+ */
+typedef unsigned int __bitwise pci_channel_state_t;
+enum pci_channel_state {
+        /* I/O channel is in normal state */
+        pci_channel_io_normal = (__force pci_channel_state_t) 1,
+        /* I/O to channel is blocked */
+        pci_channel_io_frozen = (__force pci_channel_state_t) 2,
+        /* PCI card is dead */
+        pci_channel_io_perm_failure = (__force pci_channel_state_t) 3,
+};
 /*
 * The pci_dev structure is used to describe PCI devices.
 */
@@ -98,6 +115,7 @@ struct pci_dev {
        unsigned int    class;          /* 3 bytes: (base,sub,prog-if) */
        u8              hdr_type;       /* PCI header type (`multi' flag masked out) */
        u8              rom_base_reg;   /* which config register controls the ROM */
+        u8              pin;            /* which interrupt pin this device uses */
        struct pci_driver *driver;      /* which driver has allocated this device */
        u64             dma_mask;       /* Mask of the bits of bus address this
@@ -110,6 +128,7 @@ struct pci_dev {
                                           this is D0-D3, D0 being fully functional,
                                           and D3 being off. */
+        pci_channel_state_t error_state;        /* current connectivity state */
        struct  device  dev;            /* Generic device interface */
        /* device is compatible with these IDs */
@@ -232,6 +251,54 @@ struct pci_dynids {
        unsigned int use_driver_data:1; /* pci_driver->driver_data is used */
 };
+/* ---------------------------------------------------------------- */
+/** PCI Error Recovery System (PCI-ERS).  If a PCI device driver provides
+ *  a set fof callbacks in struct pci_error_handlers, then that device driver
+ *  will be notified of PCI bus errors, and will be driven to recovery
+ *  when an error occurs.
+ */
+typedef unsigned int __bitwise pci_ers_result_t;
+enum pci_ers_result {
+        /* no result/none/not supported in device driver */
+        PCI_ERS_RESULT_NONE = (__force pci_ers_result_t) 1,
+        /* Device driver can recover without slot reset */
+        PCI_ERS_RESULT_CAN_RECOVER = (__force pci_ers_result_t) 2,
+        /* Device driver wants slot to be reset. */
+        PCI_ERS_RESULT_NEED_RESET = (__force pci_ers_result_t) 3,
+        /* Device has completely failed, is unrecoverable */
+        PCI_ERS_RESULT_DISCONNECT = (__force pci_ers_result_t) 4,
+        /* Device driver is fully recovered and operational */
+        PCI_ERS_RESULT_RECOVERED = (__force pci_ers_result_t) 5,
+};
+/* PCI bus error event callbacks */
+struct pci_error_handlers
+{
+        /* PCI bus error detected on this device */
+        pci_ers_result_t (*error_detected)(struct pci_dev *dev,
+                              enum pci_channel_state error);
+        /* MMIO has been re-enabled, but not DMA */
+        pci_ers_result_t (*mmio_enabled)(struct pci_dev *dev);
+        /* PCI Express link has been reset */
+        pci_ers_result_t (*link_reset)(struct pci_dev *dev);
+        /* PCI slot has been reset */
+        pci_ers_result_t (*slot_reset)(struct pci_dev *dev);
+        /* Device driver may resume normal operations */
+        void (*resume)(struct pci_dev *dev);
+};
+/* ---------------------------------------------------------------- */
 struct module;
 struct pci_driver {
        struct list_head node;
@@ -244,6 +311,7 @@ struct pci_driver {
        int  (*enable_wake) (struct pci_dev *dev, pci_power_t state, int enable);   /* Enable wake event */
        void (*shutdown) (struct pci_dev *dev);
+        struct pci_error_handlers *err_handler;
        struct device_driver    driver;
        struct pci_dynids dynids;
 };
@@ -448,6 +516,7 @@ int pci_scan_bridge(struct pci_bus *bus, struct pci_dev * dev, int max, int pass
 void pci_walk_bus(struct pci_bus *top, void (*cb)(struct pci_dev *, void *),
                  void *userdata);
+int pci_cfg_space_size(struct pci_dev *dev);
 /* kmem_cache style wrapper around pci_alloc_consistent() */
diff --git a/include/linux/pci_ids.h b/include/linux/pci_ids.h
index a213e999de31..ecc1fc1f0f04 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
@@ -377,6 +378,7 @@
 #define PCI_DEVICE_ID_NS_87560_USB      0x0012
 #define PCI_DEVICE_ID_NS_83815          0x0020
 #define PCI_DEVICE_ID_NS_83820          0x0022
+#define PCI_DEVICE_ID_NS_CS5535_ISA     0x002b
 #define PCI_DEVICE_ID_NS_CS5535_IDE     0x002d
 #define PCI_DEVICE_ID_NS_CS5535_AUDIO   0x002e
 #define PCI_DEVICE_ID_NS_CS5535_USB     0x002f
@@ -500,6 +502,14 @@
 #define PCI_DEVICE_ID_AMD_8111_AUDIO    0x746d
 #define PCI_DEVICE_ID_AMD_8151_0        0x7454
 #define PCI_DEVICE_ID_AMD_8131_APIC     0x7450
+#define PCI_DEVICE_ID_AMD_CS5536_ISA    0x2090
+#define PCI_DEVICE_ID_AMD_CS5536_FLASH  0x2091
+#define PCI_DEVICE_ID_AMD_CS5536_AUDIO  0x2093
+#define PCI_DEVICE_ID_AMD_CS5536_OHC    0x2094
+#define PCI_DEVICE_ID_AMD_CS5536_EHC    0x2095
+#define PCI_DEVICE_ID_AMD_CS5536_UDC    0x2096
+#define PCI_DEVICE_ID_AMD_CS5536_UOC    0x2097
+#define PCI_DEVICE_ID_AMD_CS5536_IDE    0x209A
 #define PCI_DEVICE_ID_AMD_CS5536_IDE    0x209A
@@ -1041,6 +1051,11 @@
 #define PCI_DEVICE_ID_NVIDIA_NVENET_6           0x00e6
 #define PCI_DEVICE_ID_NVIDIA_CK8S_AUDIO         0x00ea
 #define PCI_DEVICE_ID_NVIDIA_NFORCE3S_SATA2     0x00ee
+#define PCIE_DEVICE_ID_NVIDIA_GEFORCE_6800_ALT1 0x00f0
+#define PCIE_DEVICE_ID_NVIDIA_GEFORCE_6600_ALT1 0x00f1
+#define PCIE_DEVICE_ID_NVIDIA_GEFORCE_6600_ALT2 0x00f2
+#define PCIE_DEVICE_ID_NVIDIA_GEFORCE_6200_ALT1 0x00f3
+#define PCIE_DEVICE_ID_NVIDIA_GEFORCE_6800_GT   0x00f9
 #define PCI_DEVICE_ID_NVIDIA_GEFORCE_SDR        0x0100
 #define PCI_DEVICE_ID_NVIDIA_GEFORCE_DDR        0x0101
 #define PCI_DEVICE_ID_NVIDIA_QUADRO             0x0103
@@ -1583,6 +1598,23 @@
 #define PCI_SUBDEVICE_ID_CONNECT_TECH_BH8_485_2_6       0x0009
 #define PCI_SUBDEVICE_ID_CONNECT_TECH_BH081101V1        0x000A
 #define PCI_SUBDEVICE_ID_CONNECT_TECH_BH041101V1        0x000B
+#define PCI_SUBDEVICE_ID_CONNECT_TECH_BH2_20MHZ         0x000C
+#define PCI_SUBDEVICE_ID_CONNECT_TECH_BH2_PTM           0x000D
+#define PCI_SUBDEVICE_ID_CONNECT_TECH_NT960PCI          0x0100
+#define PCI_SUBDEVICE_ID_CONNECT_TECH_TITAN_2           0x0201
+#define PCI_SUBDEVICE_ID_CONNECT_TECH_TITAN_4           0x0202
+#define PCI_SUBDEVICE_ID_CONNECT_TECH_PCI_UART_2_232    0x0300
+#define PCI_SUBDEVICE_ID_CONNECT_TECH_PCI_UART_4_232    0x0301
+#define PCI_SUBDEVICE_ID_CONNECT_TECH_PCI_UART_8_232    0x0302
+#define PCI_SUBDEVICE_ID_CONNECT_TECH_PCI_UART_1_1      0x0310
+#define PCI_SUBDEVICE_ID_CONNECT_TECH_PCI_UART_2_2      0x0311
+#define PCI_SUBDEVICE_ID_CONNECT_TECH_PCI_UART_4_4      0x0312
+#define PCI_SUBDEVICE_ID_CONNECT_TECH_PCI_UART_2        0x0320
+#define PCI_SUBDEVICE_ID_CONNECT_TECH_PCI_UART_4        0x0321
+#define PCI_SUBDEVICE_ID_CONNECT_TECH_PCI_UART_8        0x0322
+#define PCI_SUBDEVICE_ID_CONNECT_TECH_PCI_UART_2_485    0x0330
+#define PCI_SUBDEVICE_ID_CONNECT_TECH_PCI_UART_4_485    0x0331
+#define PCI_SUBDEVICE_ID_CONNECT_TECH_PCI_UART_8_485    0x0332
 #define PCI_VENDOR_ID_NVIDIA_SGS        0x12d2
@@ -1960,6 +1992,7 @@
 #define PCI_VENDOR_ID_DCI               0x6666
 #define PCI_DEVICE_ID_DCI_PCCOM4        0x0001
 #define PCI_DEVICE_ID_DCI_PCCOM8        0x0002
+#define PCI_DEVICE_ID_DCI_PCCOM2        0x0004
 #define PCI_VENDOR_ID_INTEL             0x8086
 #define PCI_DEVICE_ID_INTEL_EESSC       0x0008
@@ -2121,6 +2154,9 @@
 #define PCI_DEVICE_ID_INTEL_IXP2800     0x9004
 #define PCI_DEVICE_ID_INTEL_S21152BB    0xb152
+#define PCI_VENDOR_ID_SCALEMP           0x8686
+#define PCI_DEVICE_ID_SCALEMP_VSMP_CTL  0x1010
 #define PCI_VENDOR_ID_COMPUTONE         0x8e0e
 #define PCI_DEVICE_ID_COMPUTONE_IP2EX   0x0291
 #define PCI_DEVICE_ID_COMPUTONE_PG      0x0302
diff --git a/include/linux/pci_regs.h b/include/linux/pci_regs.h
index e2a089b051ed..d27a78b71297 100644
--- a/include/linux/pci_regs.h
+++ b/include/linux/pci_regs.h
@@ -196,6 +196,7 @@
 #define  PCI_CAP_ID_MSI         0x05    /* Message Signalled Interrupts */
 #define  PCI_CAP_ID_CHSWP       0x06    /* CompactPCI HotSwap */
 #define  PCI_CAP_ID_PCIX        0x07    /* PCI-X */
+#define  PCI_CAP_ID_HT_IRQCONF  0x08    /* HyperTransport IRQ Configuration */
 #define  PCI_CAP_ID_SHPC        0x0C    /* PCI Standard Hot-Plug Controller */
 #define  PCI_CAP_ID_EXP         0x10    /* PCI Express */
 #define  PCI_CAP_ID_MSIX        0x11    /* MSI-X */
diff --git a/include/linux/percpu.h b/include/linux/percpu.h
index fb8d2d24e4bb..cb9039a21f2a 100644
--- a/include/linux/percpu.h
+++ b/include/linux/percpu.h
@@ -19,7 +19,6 @@
 struct percpu_data {
        void *ptrs[NR_CPUS];
-        void *blkp;
 };
 /* 
@@ -33,14 +32,14 @@ struct percpu_data {
        (__typeof__(ptr))__p->ptrs[(cpu)];      \
 })
-extern void *__alloc_percpu(size_t size, size_t align);
+extern void *__alloc_percpu(size_t size);
 extern void free_percpu(const void *);
 #else /* CONFIG_SMP */
 #define per_cpu_ptr(ptr, cpu) ({ (void)(cpu); (ptr); })
-static inline void *__alloc_percpu(size_t size, size_t align)
+static inline void *__alloc_percpu(size_t size)
 {
        void *ret = kmalloc(size, GFP_KERNEL);
        if (ret)
@@ -55,7 +54,6 @@ static inline void free_percpu(const void *ptr)
 #endif /* CONFIG_SMP */
 /* Simple wrapper for the common case: zeros memory. */
-#define alloc_percpu(type) \
+#define alloc_percpu(type)      ((type *)(__alloc_percpu(sizeof(type))))
-        ((type *)(__alloc_percpu(sizeof(type), __alignof__(type))))
 #endif /* __LINUX_PERCPU_H */
diff --git a/include/linux/pfkeyv2.h b/include/linux/pfkeyv2.h
index 6351c4055ace..bac0fb389cf1 100644
--- a/include/linux/pfkeyv2.h
+++ b/include/linux/pfkeyv2.h
@@ -104,7 +104,7 @@ struct sadb_prop {
 /* followed by:
        struct sadb_comb sadb_combs[(sadb_prop_len +
                sizeof(uint64_t) - sizeof(struct sadb_prop)) /
-                sizeof(strut sadb_comb)]; */
+                sizeof(struct sadb_comb)]; */
 struct sadb_comb {
        uint8_t         sadb_comb_auth;
diff --git a/include/linux/phy.h b/include/linux/phy.h
index 92a9696fdebe..331521a10a2d 100644
--- a/include/linux/phy.h
+++ b/include/linux/phy.h
@@ -53,6 +53,9 @@
 #define PHY_MAX_ADDR 32
+/* Used when trying to connect to a specific phy (mii bus id:phy device id) */
+#define PHY_ID_FMT "%x:%02x"
 /* The Bus class for PHYs.  Devices which provide access to
 * PHYs should register using this structure */
 struct mii_bus {
diff --git a/include/linux/pipe_fs_i.h b/include/linux/pipe_fs_i.h
index 1767073df26f..b12e59c75752 100644
--- a/include/linux/pipe_fs_i.h
+++ b/include/linux/pipe_fs_i.h
@@ -37,7 +37,7 @@ struct pipe_inode_info {
   memory allocation, whereas PIPE_BUF makes atomicity guarantees.  */
 #define PIPE_SIZE               PAGE_SIZE
-#define PIPE_SEM(inode)         (&(inode).i_sem)
+#define PIPE_MUTEX(inode)       (&(inode).i_mutex)
 #define PIPE_WAIT(inode)        (&(inode).i_pipe->wait)
 #define PIPE_READERS(inode)     ((inode).i_pipe->readers)
 #define PIPE_WRITERS(inode)     ((inode).i_pipe->writers)
diff --git a/include/linux/pmu.h b/include/linux/pmu.h
index 373bd3b9b330..217d3daf7336 100644
--- a/include/linux/pmu.h
+++ b/include/linux/pmu.h
@@ -140,7 +140,7 @@ extern int find_via_pmu(void);
 extern int pmu_request(struct adb_request *req,
                void (*done)(struct adb_request *), int nbytes, ...);
+extern int pmu_queue_request(struct adb_request *req);
 extern void pmu_poll(void);
 extern void pmu_poll_adb(void); /* For use by xmon */
 extern void pmu_wait_complete(struct adb_request *req);
@@ -160,12 +160,6 @@ extern void pmu_unlock(void);
 extern int pmu_present(void);
 extern int pmu_get_model(void);
-extern int pmu_i2c_combined_read(int bus, int addr, int subaddr,  u8* data, int len);
-extern int pmu_i2c_stdsub_write(int bus, int addr, int subaddr,  u8* data, int len);
-extern int pmu_i2c_simple_read(int bus, int addr,  u8* data, int len);
-extern int pmu_i2c_simple_write(int bus, int addr,  u8* data, int len);
 #ifdef CONFIG_PM
 /*
 * Stuff for putting the powerbook to sleep and waking it again.
diff --git a/include/linux/poll.h b/include/linux/poll.h
index f6da702088f4..8e8f6098508a 100644
--- a/include/linux/poll.h
+++ b/include/linux/poll.h
@@ -92,7 +92,11 @@ void zero_fd_set(unsigned long nr, unsigned long *fdset)
        memset(fdset, 0, FDS_BYTES(nr));
 }
-extern int do_select(int n, fd_set_bits *fds, long *timeout);
+#define MAX_INT64_SECONDS (((s64)(~((u64)0)>>1)/HZ)-1)
+extern int do_select(int n, fd_set_bits *fds, s64 *timeout);
+extern int do_sys_poll(struct pollfd __user * ufds, unsigned int nfds,
+                       s64 *timeout);
 #endif /* KERNEL */
diff --git a/include/linux/posix-timers.h b/include/linux/posix-timers.h
index f942e2bad8e3..54faf5236da0 100644
--- a/include/linux/posix-timers.h
+++ b/include/linux/posix-timers.h
@@ -42,7 +42,7 @@ struct k_itimer {
        timer_t it_id;                  /* timer id */
        int it_overrun;                 /* overrun on pending signal  */
        int it_overrun_last;            /* overrun on last delivered signal */
-        int it_requeue_pending;         /* waiting to requeue this timer */
+        int it_requeue_pending;         /* waiting to requeue this timer */
 #define REQUEUE_PENDING 1
        int it_sigev_notify;            /* notify word of sigevent struct */
        int it_sigev_signo;             /* signo word of sigevent struct */
@@ -51,10 +51,8 @@ struct k_itimer {
        struct sigqueue *sigq;          /* signal queue entry. */
        union {
                struct {
-                        struct timer_list timer;
+                        struct hrtimer timer;
-                        struct list_head abs_timer_entry; /* clock abs_timer_list */
+                        ktime_t interval;
-                        struct timespec wall_to_prev;   /* wall_to_monotonic used when set */
-                        unsigned long incr; /* interval in jiffies */
                } real;
                struct cpu_timer_list cpu;
                struct {
@@ -66,18 +64,14 @@ struct k_itimer {
        } it;
 };
-struct k_clock_abs {
-        struct list_head list;
-        spinlock_t lock;
-};
 struct k_clock {
-        int res;                /* in nano seconds */
+        int res;                /* in nanoseconds */
-        int (*clock_getres) (clockid_t which_clock, struct timespec *tp);
+        int (*clock_getres) (const clockid_t which_clock, struct timespec *tp);
-        struct k_clock_abs *abs_struct;
+        int (*clock_set) (const clockid_t which_clock, struct timespec * tp);
-        int (*clock_set) (clockid_t which_clock, struct timespec * tp);
+        int (*clock_get) (const clockid_t which_clock, struct timespec * tp);
-        int (*clock_get) (clockid_t which_clock, struct timespec * tp);
        int (*timer_create) (struct k_itimer *timer);
-        int (*nsleep) (clockid_t which_clock, int flags, struct timespec *);
+        int (*nsleep) (const clockid_t which_clock, int flags,
+                       struct timespec *, struct timespec __user *);
        int (*timer_set) (struct k_itimer * timr, int flags,
                          struct itimerspec * new_setting,
                          struct itimerspec * old_setting);
@@ -87,53 +81,35 @@ struct k_clock {
                           struct itimerspec * cur_setting);
 };
-void register_posix_clock(clockid_t clock_id, struct k_clock *new_clock);
+void register_posix_clock(const clockid_t clock_id, struct k_clock *new_clock);
-/* Error handlers for timer_create, nanosleep and settime */
+/* error handlers for timer_create, nanosleep and settime */
 int do_posix_clock_notimer_create(struct k_itimer *timer);
-int do_posix_clock_nonanosleep(clockid_t, int flags, struct timespec *);
+int do_posix_clock_nonanosleep(const clockid_t, int flags, struct timespec *,
-int do_posix_clock_nosettime(clockid_t, struct timespec *tp);
+                               struct timespec __user *);
+int do_posix_clock_nosettime(const clockid_t, struct timespec *tp);
 /* function to call to trigger timer event */
 int posix_timer_event(struct k_itimer *timr, int si_private);
-struct now_struct {
+int posix_cpu_clock_getres(const clockid_t which_clock, struct timespec *ts);
-        unsigned long jiffies;
+int posix_cpu_clock_get(const clockid_t which_clock, struct timespec *ts);
-};
+int posix_cpu_clock_set(const clockid_t which_clock, const struct timespec *ts);
+int posix_cpu_timer_create(struct k_itimer *timer);
-#define posix_get_now(now) (now)->jiffies = jiffies;
+int posix_cpu_nsleep(const clockid_t which_clock, int flags,
-#define posix_time_before(timer, now) \
+                     struct timespec *rqtp, struct timespec __user *rmtp);
-                      time_before((timer)->expires, (now)->jiffies)
+int posix_cpu_timer_set(struct k_itimer *timer, int flags,
+                        struct itimerspec *new, struct itimerspec *old);
-#define posix_bump_timer(timr, now)                                     \
+int posix_cpu_timer_del(struct k_itimer *timer);
-         do {                                                           \
+void posix_cpu_timer_get(struct k_itimer *timer, struct itimerspec *itp);
-              long delta, orun;                                         \
-              delta = now.jiffies - (timr)->it.real.timer.expires;      \
+void posix_cpu_timer_schedule(struct k_itimer *timer);
-              if (delta >= 0) {                                         \
-                   orun = 1 + (delta / (timr)->it.real.incr);           \
+void run_posix_cpu_timers(struct task_struct *task);
-                  (timr)->it.real.timer.expires +=                      \
+void posix_cpu_timers_exit(struct task_struct *task);
-                         orun * (timr)->it.real.incr;                   \
+void posix_cpu_timers_exit_group(struct task_struct *task);
-                  (timr)->it_overrun += orun;                           \
-              }                                                         \
+void set_process_cpu_timer(struct task_struct *task, unsigned int clock_idx,
-            }while (0)
+                           cputime_t *newval, cputime_t *oldval);
-int posix_cpu_clock_getres(clockid_t which_clock, struct timespec *);
-int posix_cpu_clock_get(clockid_t which_clock, struct timespec *);
-int posix_cpu_clock_set(clockid_t which_clock, const struct timespec *tp);
-int posix_cpu_timer_create(struct k_itimer *);
-int posix_cpu_nsleep(clockid_t, int, struct timespec *);
-int posix_cpu_timer_set(struct k_itimer *, int,
-                        struct itimerspec *, struct itimerspec *);
-int posix_cpu_timer_del(struct k_itimer *);
-void posix_cpu_timer_get(struct k_itimer *, struct itimerspec *);
-void posix_cpu_timer_schedule(struct k_itimer *);
-void run_posix_cpu_timers(struct task_struct *);
-void posix_cpu_timers_exit(struct task_struct *);
-void posix_cpu_timers_exit_group(struct task_struct *);
-void set_process_cpu_timer(struct task_struct *, unsigned int,
-                           cputime_t *, cputime_t *);
 #endif
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/ptrace.h b/include/linux/ptrace.h
index b2b3dba1298d..9d5cd106b344 100644
--- a/include/linux/ptrace.h
+++ b/include/linux/ptrace.h
@@ -20,8 +20,6 @@
 #define PTRACE_DETACH           0x11
 #define PTRACE_SYSCALL            24
-#define PTRACE_SYSEMU             31
-#define PTRACE_SYSEMU_SINGLESTEP  32
 /* 0x4200-0x4300 are reserved for architecture-independent additions.  */
 #define PTRACE_SETOPTIONS       0x4200
@@ -80,6 +78,8 @@
 extern long arch_ptrace(struct task_struct *child, long request, long addr, long data);
+extern struct task_struct *ptrace_get_task_struct(pid_t pid);
+extern int ptrace_traceme(void);
 extern int ptrace_readdata(struct task_struct *tsk, unsigned long src, char __user *dst, int len);
 extern int ptrace_writedata(struct task_struct *tsk, char __user *src, unsigned long dst, int len);
 extern int ptrace_attach(struct task_struct *tsk);
diff --git a/include/linux/radix-tree.h b/include/linux/radix-tree.h
index 36e5d269612f..c57ff2fcb30a 100644
--- a/include/linux/radix-tree.h
+++ b/include/linux/radix-tree.h
@@ -19,6 +19,7 @@
 #ifndef _LINUX_RADIX_TREE_H
 #define _LINUX_RADIX_TREE_H
+#include <linux/sched.h>
 #include <linux/preempt.h>
 #include <linux/types.h>
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/rcupdate.h b/include/linux/rcupdate.h
index a471f3bb713e..981f9aa43353 100644
--- a/include/linux/rcupdate.h
+++ b/include/linux/rcupdate.h
@@ -65,7 +65,11 @@ struct rcu_ctrlblk {
        long    cur;            /* Current batch number.                      */
        long    completed;      /* Number of the last completed batch         */
        int     next_pending;   /* Is the next batch already waiting?         */
-} ____cacheline_maxaligned_in_smp;
+        spinlock_t      lock    ____cacheline_internodealigned_in_smp;
+        cpumask_t       cpumask; /* CPUs that need to switch in order    */
+                                 /* for current batch to proceed.        */
+} ____cacheline_internodealigned_in_smp;
 /* Is batch a before batch b ? */
 static inline int rcu_batch_before(long a, long b)
@@ -125,36 +129,7 @@ static inline void rcu_bh_qsctr_inc(int cpu)
        rdp->passed_quiesc = 1;
 }
-static inline int __rcu_pending(struct rcu_ctrlblk *rcp,
+extern int rcu_pending(int cpu);
-                                                struct rcu_data *rdp)
-{
-        /* This cpu has pending rcu entries and the grace period
-         * for them has completed.
-         */
-        if (rdp->curlist && !rcu_batch_before(rcp->completed, rdp->batch))
-                return 1;
-        /* This cpu has no pending entries, but there are new entries */
-        if (!rdp->curlist && rdp->nxtlist)
-                return 1;
-        /* This cpu has finished callbacks to invoke */
-        if (rdp->donelist)
-                return 1;
-        /* The rcu core waits for a quiescent state from the cpu */
-        if (rdp->quiescbatch != rcp->cur || rdp->qs_pending)
-                return 1;
-        /* nothing to do */
-        return 0;
-}
-static inline int rcu_pending(int cpu)
-{
-        return __rcu_pending(&rcu_ctrlblk, &per_cpu(rcu_data, cpu)) ||
-                __rcu_pending(&rcu_bh_ctrlblk, &per_cpu(rcu_bh_data, cpu));
-}
 /**
 * rcu_read_lock - mark the beginning of an RCU read-side critical section.
diff --git a/include/linux/rcuref.h b/include/linux/rcuref.h
deleted file mode 100644
index e1adbba14b67..000000000000
--- a/include/linux/rcuref.h
+++ /dev/null
@@ -1,220 +0,0 @@
-/*
- * rcuref.h
- *
- * Reference counting for elements of lists/arrays protected by
- * RCU.
- *
- * 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.
- *
- * Copyright (C) IBM Corporation, 2005
- *
- * Author: Dipankar Sarma <dipankar@in.ibm.com>
- *         Ravikiran Thirumalai <kiran_th@gmail.com>
- *
- * See Documentation/RCU/rcuref.txt for detailed user guide.
- *
- */
-#ifndef _RCUREF_H_
-#define _RCUREF_H_
-#ifdef __KERNEL__
-#include <linux/types.h>
-#include <linux/interrupt.h>
-#include <linux/spinlock.h>
-#include <asm/atomic.h>
-/*
- * These APIs work on traditional atomic_t counters used in the
- * kernel for reference counting. Under special circumstances
- * where a lock-free get() operation races with a put() operation
- * these APIs can be used. See Documentation/RCU/rcuref.txt.
- */
-#ifdef __HAVE_ARCH_CMPXCHG
-/**
- * rcuref_inc - increment refcount for object.
- * @rcuref: reference counter in the object in question.
- *
- * This should be used only for objects where we use RCU and
- * use the rcuref_inc_lf() api to acquire a reference
- * in a lock-free reader-side critical section.
- */
-static inline void rcuref_inc(atomic_t *rcuref)
-{
-        atomic_inc(rcuref);
-}
-/**
- * rcuref_dec - decrement refcount for object.
- * @rcuref: reference counter in the object in question.
- *
- * This should be used only for objects where we use RCU and
- * use the rcuref_inc_lf() api to acquire a reference
- * in a lock-free reader-side critical section.
- */
-static inline void rcuref_dec(atomic_t *rcuref)
-{
-        atomic_dec(rcuref);
-}
-/**
- * rcuref_dec_and_test - decrement refcount for object and test
- * @rcuref: reference counter in the object.
- * @release: pointer to the function that will clean up the object
- *           when the last reference to the object is released.
- *           This pointer is required.
- *
- * Decrement the refcount, and if 0, return 1. Else return 0.
- *
- * This should be used only for objects where we use RCU and
- * use the rcuref_inc_lf() api to acquire a reference
- * in a lock-free reader-side critical section.
- */
-static inline int rcuref_dec_and_test(atomic_t *rcuref)
-{
-        return atomic_dec_and_test(rcuref);
-}
-/*
- * cmpxchg is needed on UP too, if deletions to the list/array can happen
- * in interrupt context.
- */
-/**
- * rcuref_inc_lf - Take reference to an object in a read-side
- * critical section protected by RCU.
- * @rcuref: reference counter in the object in question.
- *
- * Try and increment the refcount by 1.  The increment might fail if
- * the reference counter has been through a 1 to 0 transition and
- * is no longer part of the lock-free list.
- * Returns non-zero on successful increment and zero otherwise.
- */
-static inline int rcuref_inc_lf(atomic_t *rcuref)
-{
-        int c, old;
-        c = atomic_read(rcuref);
-        while (c && (old = cmpxchg(&rcuref->counter, c, c + 1)) != c)
-                c = old;
-        return c;
-}
-#else                           /* !__HAVE_ARCH_CMPXCHG */
-extern spinlock_t __rcuref_hash[];
-/*
- * Use a hash table of locks to protect the reference count
- * since cmpxchg is not available in this arch.
- */
-#ifdef  CONFIG_SMP
-#define RCUREF_HASH_SIZE        4
-#define RCUREF_HASH(k) \
-        (&__rcuref_hash[(((unsigned long)k)>>8) & (RCUREF_HASH_SIZE-1)])
-#else
-#define RCUREF_HASH_SIZE        1
-#define RCUREF_HASH(k)  &__rcuref_hash[0]
-#endif                          /* CONFIG_SMP */
-/**
- * rcuref_inc - increment refcount for object.
- * @rcuref: reference counter in the object in question.
- *
- * This should be used only for objects where we use RCU and
- * use the rcuref_inc_lf() api to acquire a reference in a lock-free
- * reader-side critical section.
- */
-static inline void rcuref_inc(atomic_t *rcuref)
-{
-        unsigned long flags;
-        spin_lock_irqsave(RCUREF_HASH(rcuref), flags);
-        rcuref->counter += 1;
-        spin_unlock_irqrestore(RCUREF_HASH(rcuref), flags);
-}
-/**
- * rcuref_dec - decrement refcount for object.
- * @rcuref: reference counter in the object in question.
- *
- * This should be used only for objects where we use RCU and
- * use the rcuref_inc_lf() api to acquire a reference in a lock-free
- * reader-side critical section.
- */
-static inline void rcuref_dec(atomic_t *rcuref)
-{
-        unsigned long flags;
-        spin_lock_irqsave(RCUREF_HASH(rcuref), flags);
-        rcuref->counter -= 1;
-        spin_unlock_irqrestore(RCUREF_HASH(rcuref), flags);
-}
-/**
- * rcuref_dec_and_test - decrement refcount for object and test
- * @rcuref: reference counter in the object.
- * @release: pointer to the function that will clean up the object
- *           when the last reference to the object is released.
- *           This pointer is required.
- *
- * Decrement the refcount, and if 0, return 1. Else return 0.
- *
- * This should be used only for objects where we use RCU and
- * use the rcuref_inc_lf() api to acquire a reference in a lock-free
- * reader-side critical section.
- */
-static inline int rcuref_dec_and_test(atomic_t *rcuref)
-{
-        unsigned long flags;
-        spin_lock_irqsave(RCUREF_HASH(rcuref), flags);
-        rcuref->counter--;
-        if (!rcuref->counter) {
-                spin_unlock_irqrestore(RCUREF_HASH(rcuref), flags);
-                return 1;
-        } else {
-                spin_unlock_irqrestore(RCUREF_HASH(rcuref), flags);
-                return 0;
-        }
-}
-/**
- * rcuref_inc_lf - Take reference to an object of a lock-free collection
- * by traversing a lock-free list/array.
- * @rcuref: reference counter in the object in question.
- *
- * Try and increment the refcount by 1.  The increment might fail if
- * the reference counter has been through a 1 to 0 transition and
- * object is no longer part of the lock-free list.
- * Returns non-zero on successful increment and zero otherwise.
- */
-static inline int rcuref_inc_lf(atomic_t *rcuref)
-{
-        int ret;
-        unsigned long flags;
-        spin_lock_irqsave(RCUREF_HASH(rcuref), flags);
-        if (rcuref->counter)
-                ret = rcuref->counter++;
-        else
-                ret = 0;
-        spin_unlock_irqrestore(RCUREF_HASH(rcuref), flags);
-        return ret;
-}
-#endif /* !__HAVE_ARCH_CMPXCHG */
-#endif /* __KERNEL__ */
-#endif /* _RCUREF_H_ */
diff --git a/include/linux/reboot.h b/include/linux/reboot.h
index 7ab2cdb83ef0..015297ff73fa 100644
--- a/include/linux/reboot.h
+++ b/include/linux/reboot.h
@@ -60,8 +60,7 @@ extern void machine_crash_shutdown(struct pt_regs *);
 */
 extern void kernel_restart_prepare(char *cmd);
-extern void kernel_halt_prepare(void);
+extern void kernel_shutdown_prepare(enum system_states state);
-extern void kernel_power_off_prepare(void);
 extern void kernel_restart(char *cmd);
 extern void kernel_halt(void);
diff --git a/include/linux/reiserfs_fs.h b/include/linux/reiserfs_fs.h
index 001ab82df051..e276c5ba2bb7 100644
--- a/include/linux/reiserfs_fs.h
+++ b/include/linux/reiserfs_fs.h
@@ -1857,7 +1857,7 @@ void padd_item(char *item, int total_length, int length);
 #define GET_BLOCK_CREATE 1      /* add anything you need to find block */
 #define GET_BLOCK_NO_HOLE 2     /* return -ENOENT for file holes */
 #define GET_BLOCK_READ_DIRECT 4 /* read the tail if indirect item not found */
-#define GET_BLOCK_NO_ISEM     8 /* i_sem is not held, don't preallocate */
+#define GET_BLOCK_NO_IMUX     8 /* i_mutex is not held, don't preallocate */
 #define GET_BLOCK_NO_DANGLE   16        /* don't leave any transactions running */
 int restart_transaction(struct reiserfs_transaction_handle *th,
diff --git a/include/linux/relayfs_fs.h b/include/linux/relayfs_fs.h
index fb7e80737325..7342e66247fb 100644
--- a/include/linux/relayfs_fs.h
+++ b/include/linux/relayfs_fs.h
@@ -65,20 +65,6 @@ struct rchan
 };
 /*
- * Relayfs inode
- */
-struct relayfs_inode_info
-{
-        struct inode vfs_inode;
-        struct rchan_buf *buf;
-};
-static inline struct relayfs_inode_info *RELAYFS_I(struct inode *inode)
-{
-        return container_of(inode, struct relayfs_inode_info, vfs_inode);
-}
-/*
 * Relay channel client callbacks
 */
 struct rchan_callbacks
@@ -124,6 +110,46 @@ struct rchan_callbacks
         */
        void (*buf_unmapped)(struct rchan_buf *buf,
                             struct file *filp);
+        /*
+         * create_buf_file - create file to represent a relayfs channel buffer
+         * @filename: the name of the file to create
+         * @parent: the parent of the file to create
+         * @mode: the mode of the file to create
+         * @buf: the channel buffer
+         * @is_global: outparam - set non-zero if the buffer should be global
+         *
+         * Called during relay_open(), once for each per-cpu buffer,
+         * to allow the client to create a file to be used to
+         * represent the corresponding channel buffer.  If the file is
+         * created outside of relayfs, the parent must also exist in
+         * that filesystem.
+         *
+         * The callback should return the dentry of the file created
+         * to represent the relay buffer.
+         *
+         * Setting the is_global outparam to a non-zero value will
+         * cause relay_open() to create a single global buffer rather
+         * than the default set of per-cpu buffers.
+         *
+         * See Documentation/filesystems/relayfs.txt for more info.
+         */
+        struct dentry *(*create_buf_file)(const char *filename,
+                                          struct dentry *parent,
+                                          int mode,
+                                          struct rchan_buf *buf,
+                                          int *is_global);
+        /*
+         * remove_buf_file - remove file representing a relayfs channel buffer
+         * @dentry: the dentry of the file to remove
+         *
+         * Called during relay_close(), once for each per-cpu buffer,
+         * to allow the client to remove a file used to represent a
+         * channel buffer.
+         *
+         * The callback should return 0 if successful, negative if not.
+         */
+        int (*remove_buf_file)(struct dentry *dentry);
 };
 /*
@@ -148,6 +174,12 @@ extern size_t relay_switch_subbuf(struct rchan_buf *buf,
 extern struct dentry *relayfs_create_dir(const char *name,
                                         struct dentry *parent);
 extern int relayfs_remove_dir(struct dentry *dentry);
+extern struct dentry *relayfs_create_file(const char *name,
+                                          struct dentry *parent,
+                                          int mode,
+                                          struct file_operations *fops,
+                                          void *data);
+extern int relayfs_remove_file(struct dentry *dentry);
 /**
 *      relay_write - write data into the channel
@@ -247,10 +279,9 @@ static inline void subbuf_start_reserve(struct rchan_buf *buf,
 }
 /*
- * exported relayfs file operations, fs/relayfs/inode.c
+ * exported relay file operations, fs/relayfs/inode.c
 */
+extern struct file_operations relay_file_operations;
-extern struct file_operations relayfs_file_operations;
 #endif /* _LINUX_RELAYFS_FS_H */
diff --git a/include/linux/rio_drv.h b/include/linux/rio_drv.h
index 3bd7cce19e26..f54772d0e7f8 100644
--- a/include/linux/rio_drv.h
+++ b/include/linux/rio_drv.h
@@ -21,6 +21,7 @@
 #include <linux/list.h>
 #include <linux/errno.h>
 #include <linux/device.h>
+#include <linux/string.h>
 #include <linux/rio.h>
 extern int __rio_local_read_config_32(struct rio_mport *port, u32 offset,
@@ -336,8 +337,8 @@ static inline void rio_init_dbell_res(struct resource *res, u16 start, u16 end)
 /**
 * RIO_DEVICE - macro used to describe a specific RIO device
- * @vid: the 16 bit RIO vendor ID
+ * @dev: the 16 bit RIO device ID
- * @did: the 16 bit RIO device ID
+ * @ven: the 16 bit RIO vendor ID
 *
 * This macro is used to create a struct rio_device_id that matches a
 * specific device.  The assembly vendor and assembly device fields
diff --git a/include/linux/rtc.h b/include/linux/rtc.h
index e1aaf1fac8e0..0b2ba67ff13c 100644
--- a/include/linux/rtc.h
+++ b/include/linux/rtc.h
@@ -11,6 +11,8 @@
 #ifndef _LINUX_RTC_H_
 #define _LINUX_RTC_H_
+#include <linux/interrupt.h>
 /*
 * The struct used to pass data via the following ioctl. Similar to the
 * struct tm in <time.h>, but it needs to be here so that the kernel 
@@ -102,6 +104,7 @@ int rtc_register(rtc_task_t *task);
 int rtc_unregister(rtc_task_t *task);
 int rtc_control(rtc_task_t *t, unsigned int cmd, unsigned long arg);
 void rtc_get_rtc_time(struct rtc_time *rtc_tm);
+irqreturn_t rtc_interrupt(int irq, void *dev_id, struct pt_regs *regs);
 #endif /* __KERNEL__ */
diff --git a/include/linux/sched.h b/include/linux/sched.h
index 7da33619d5d0..0cfcd1c7865e 100644
--- a/include/linux/sched.h
+++ b/include/linux/sched.h
@@ -34,6 +34,7 @@
 #include <linux/percpu.h>
 #include <linux/topology.h>
 #include <linux/seccomp.h>
+#include <linux/rcupdate.h>
 #include <linux/auxvec.h>       /* For AT_VECTOR_SIZE */
@@ -104,6 +105,7 @@ extern unsigned long nr_iowait(void);
 #include <linux/param.h>
 #include <linux/resource.h>
 #include <linux/timer.h>
+#include <linux/hrtimer.h>
 #include <asm/processor.h>
@@ -158,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;
@@ -350,8 +353,16 @@ struct sighand_struct {
        atomic_t                count;
        struct k_sigaction      action[_NSIG];
        spinlock_t              siglock;
+        struct rcu_head         rcu;
 };
+extern void sighand_free_cb(struct rcu_head *rhp);
+static inline void sighand_free(struct sighand_struct *sp)
+{
+        call_rcu(&sp->rcu, sighand_free_cb);
+}
 /*
 * NOTE! "signal_struct" does not have it's own
 * locking, because a shared signal_struct always
@@ -389,8 +400,8 @@ struct signal_struct {
        struct list_head posix_timers;
        /* ITIMER_REAL timer for the process */
-        struct timer_list real_timer;
+        struct hrtimer real_timer;
-        unsigned long it_real_value, it_real_incr;
+        ktime_t it_real_incr;
        /* ITIMER_PROF and ITIMER_VIRTUAL timers for the process */
        cputime_t it_prof_expires, it_virt_expires;
@@ -460,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
@@ -621,7 +632,14 @@ struct sched_domain {
 extern void partition_sched_domains(cpumask_t *partition1,
                                    cpumask_t *partition2);
-#endif /* CONFIG_SMP */
+/*
+ * Maximum cache size the migration-costs auto-tuning code will
+ * search from:
+ */
+extern unsigned int max_cache_size;
+#endif  /* CONFIG_SMP */
 struct io_context;                      /* See blkdev.h */
@@ -679,9 +697,12 @@ struct task_struct {
        int lock_depth;         /* BKL lock depth */
-#if defined(CONFIG_SMP) && defined(__ARCH_WANT_UNLOCKED_CTXSW)
+#if defined(CONFIG_SMP)
+        int last_waker_cpu;     /* CPU that last woke this task up */
+#if defined(__ARCH_WANT_UNLOCKED_CTXSW)
        int oncpu;
 #endif
+#endif
        int prio, static_prio;
        struct list_head run_list;
        prio_array_t *array;
@@ -762,6 +783,7 @@ struct task_struct {
        unsigned keep_capabilities:1;
        struct user_struct *user;
 #ifdef CONFIG_KEYS
+        struct key *request_key_auth;   /* assumed request_key authority */
        struct key *thread_keyring;     /* keyring private to this thread */
        unsigned char jit_keyring;      /* default keyring to attach requested keys to */
 #endif
@@ -787,6 +809,7 @@ struct task_struct {
        struct sighand_struct *sighand;
        sigset_t blocked, real_blocked;
+        sigset_t saved_sigmask;         /* To be restored with TIF_RESTORE_SIGMASK */
        struct sigpending pending;
        unsigned long sas_ss_sp;
@@ -807,6 +830,11 @@ struct task_struct {
 /* Protection of proc_dentry: nesting proc_lock, dcache_lock, write_lock_irq(&tasklist_lock); */
        spinlock_t proc_lock;
+#ifdef CONFIG_DEBUG_MUTEXES
+        /* mutex deadlock detection */
+        struct mutex_waiter *blocked_on;
+#endif
 /* journalling filesystem info */
        void *journal_info;
@@ -844,6 +872,7 @@ struct task_struct {
        int cpuset_mems_generation;
 #endif
        atomic_t fs_excl;       /* holding fs exclusive resources */
+        struct rcu_head rcu;
 };
 static inline pid_t process_group(struct task_struct *tsk)
@@ -867,8 +896,14 @@ static inline int pid_alive(struct task_struct *p)
 extern void free_task(struct task_struct *tsk);
 extern void __put_task_struct(struct task_struct *tsk);
 #define get_task_struct(tsk) do { atomic_inc(&(tsk)->usage); } while(0)
-#define put_task_struct(tsk) \
-do { if (atomic_dec_and_test(&(tsk)->usage)) __put_task_struct(tsk); } while(0)
+extern void __put_task_struct_cb(struct rcu_head *rhp);
+static inline void put_task_struct(struct task_struct *t)
+{
+        if (atomic_dec_and_test(&t->usage))
+                call_rcu(&t->rcu, __put_task_struct_cb);
+}
 /*
 * Per process flags
@@ -895,6 +930,7 @@ do { if (atomic_dec_and_test(&(tsk)->usage)) __put_task_struct(tsk); } while(0)
 #define PF_SYNCWRITE    0x00200000      /* I am doing a sync write */
 #define PF_BORROWED_MM  0x00400000      /* I am a kthread doing use_mm */
 #define PF_RANDOMIZE    0x00800000      /* randomize virtual address space */
+#define PF_SWAPWRITE    0x01000000      /* Allowed to write to swap */
 /*
 * Only the _current_ task can read/write to tsk->flags, but other
@@ -1088,21 +1124,6 @@ static inline int sas_ss_flags(unsigned long sp)
                : on_sig_stack(sp) ? SS_ONSTACK : 0);
 }
-#ifdef CONFIG_SECURITY
-/* code is in security.c */
-extern int capable(int cap);
-#else
-static inline int capable(int cap)
-{
-        if (cap_raised(current->cap_effective, cap)) {
-                current->flags |= PF_SUPERPRIV;
-                return 1;
-        }
-        return 0;
-}
-#endif
 /*
 * Routines for handling mm_structs
 */
@@ -1221,6 +1242,7 @@ static inline void task_unlock(struct task_struct *p)
 #ifndef __HAVE_THREAD_FUNCTIONS
 #define task_thread_info(task) (task)->thread_info
+#define task_stack_page(task) ((void*)((task)->thread_info))
 static inline void setup_thread_stack(struct task_struct *p, struct task_struct *org)
 {
@@ -1366,12 +1388,8 @@ static inline void arch_pick_mmap_layout(struct mm_struct *mm)
 extern long sched_setaffinity(pid_t pid, cpumask_t new_mask);
 extern long sched_getaffinity(pid_t pid, cpumask_t *mask);
-#ifdef CONFIG_MAGIC_SYSRQ
 extern void normalize_rt_tasks(void);
-#endif
 #ifdef CONFIG_PM
 /*
 * Check if a process has been frozen
diff --git a/include/linux/screen_info.h b/include/linux/screen_info.h
new file mode 100644
index 000000000000..6336987dae62
--- /dev/null
+++ b/include/linux/screen_info.h
@@ -0,0 +1,76 @@
+#ifndef _SCREEN_INFO_H
+#define _SCREEN_INFO_H
+#include <linux/types.h>
+/*
+ * These are set up by the setup-routine at boot-time:
+ */
+struct screen_info {
+        u8  orig_x;             /* 0x00 */
+        u8  orig_y;             /* 0x01 */
+        u16 dontuse1;           /* 0x02 -- EXT_MEM_K sits here */
+        u16 orig_video_page;    /* 0x04 */
+        u8  orig_video_mode;    /* 0x06 */
+        u8  orig_video_cols;    /* 0x07 */
+        u16 unused2;            /* 0x08 */
+        u16 orig_video_ega_bx;  /* 0x0a */
+        u16 unused3;            /* 0x0c */
+        u8  orig_video_lines;   /* 0x0e */
+        u8  orig_video_isVGA;   /* 0x0f */
+        u16 orig_video_points;  /* 0x10 */
+        /* VESA graphic mode -- linear frame buffer */
+        u16 lfb_width;          /* 0x12 */
+        u16 lfb_height;         /* 0x14 */
+        u16 lfb_depth;          /* 0x16 */
+        u32 lfb_base;           /* 0x18 */
+        u32 lfb_size;           /* 0x1c */
+        u16 dontuse2, dontuse3; /* 0x20 -- CL_MAGIC and CL_OFFSET here */
+        u16 lfb_linelength;     /* 0x24 */
+        u8  red_size;           /* 0x26 */
+        u8  red_pos;            /* 0x27 */
+        u8  green_size;         /* 0x28 */
+        u8  green_pos;          /* 0x29 */
+        u8  blue_size;          /* 0x2a */
+        u8  blue_pos;           /* 0x2b */
+        u8  rsvd_size;          /* 0x2c */
+        u8  rsvd_pos;           /* 0x2d */
+        u16 vesapm_seg;         /* 0x2e */
+        u16 vesapm_off;         /* 0x30 */
+        u16 pages;              /* 0x32 */
+        u16 vesa_attributes;    /* 0x34 */
+                                /* 0x36 -- 0x3f reserved for future expansion */
+};
+extern struct screen_info screen_info;
+#define ORIG_X                  (screen_info.orig_x)
+#define ORIG_Y                  (screen_info.orig_y)
+#define ORIG_VIDEO_MODE         (screen_info.orig_video_mode)
+#define ORIG_VIDEO_COLS         (screen_info.orig_video_cols)
+#define ORIG_VIDEO_EGA_BX       (screen_info.orig_video_ega_bx)
+#define ORIG_VIDEO_LINES        (screen_info.orig_video_lines)
+#define ORIG_VIDEO_ISVGA        (screen_info.orig_video_isVGA)
+#define ORIG_VIDEO_POINTS       (screen_info.orig_video_points)
+#define VIDEO_TYPE_MDA          0x10    /* Monochrome Text Display      */
+#define VIDEO_TYPE_CGA          0x11    /* CGA Display                  */
+#define VIDEO_TYPE_EGAM         0x20    /* EGA/VGA in Monochrome Mode   */
+#define VIDEO_TYPE_EGAC         0x21    /* EGA in Color Mode            */
+#define VIDEO_TYPE_VGAC         0x22    /* VGA+ in Color Mode           */
+#define VIDEO_TYPE_VLFB         0x23    /* VESA VGA in graphic mode     */
+#define VIDEO_TYPE_PICA_S3      0x30    /* ACER PICA-61 local S3 video  */
+#define VIDEO_TYPE_MIPS_G364    0x31    /* MIPS Magnum 4000 G364 video  */
+#define VIDEO_TYPE_SGI          0x33    /* Various SGI graphics hardware */
+#define VIDEO_TYPE_TGAC         0x40    /* DEC TGA */
+#define VIDEO_TYPE_SUN          0x50    /* Sun frame buffer. */
+#define VIDEO_TYPE_SUNPCI       0x51    /* Sun PCI based frame buffer. */
+#define VIDEO_TYPE_PMAC         0x60    /* PowerMacintosh frame buffer. */
+#endif /* _SCREEN_INFO_H */
diff --git a/include/linux/sdla.h b/include/linux/sdla.h
index 3b6afb8caa42..564acd3a71c1 100644
--- a/include/linux/sdla.h
+++ b/include/linux/sdla.h
@@ -293,46 +293,46 @@ void sdla(void *cfg_info, char *dev, struct frad_conf *conf, int quiet);
 #define SDLA_S508_INTEN                 0x10
 struct sdla_cmd {
-   char  opp_flag               __attribute__((packed));
+   char  opp_flag;
-   char  cmd                    __attribute__((packed));
+   char  cmd;
-   short length                 __attribute__((packed));
+   short length;
-   char  retval                 __attribute__((packed));
+   char  retval;
-   short dlci                   __attribute__((packed));
+   short dlci;
-   char  flags                  __attribute__((packed));
+   char  flags;
-   short rxlost_int             __attribute__((packed));
+   short rxlost_int;
-   long  rxlost_app             __attribute__((packed));
+   long  rxlost_app;
-   char  reserve[2]             __attribute__((packed));
+   char  reserve[2];
-   char  data[SDLA_MAX_DATA]    __attribute__((packed));        /* transfer data buffer */
+   char  data[SDLA_MAX_DATA];   /* transfer data buffer */
-};
+} __attribute__((packed));
 struct intr_info {
-   char  flags          __attribute__((packed));
+   char  flags;
-   short txlen          __attribute__((packed));
+   short txlen;
-   char  irq            __attribute__((packed));
+   char  irq;
-   char  flags2         __attribute__((packed));
+   char  flags2;
-   short timeout        __attribute__((packed));
+   short timeout;
-};
+} __attribute__((packed));
 /* found in the 508's control window at RXBUF_INFO */
 struct buf_info {
-   unsigned short rse_num       __attribute__((packed));
+   unsigned short rse_num;
-   unsigned long  rse_base      __attribute__((packed));
+   unsigned long  rse_base;
-   unsigned long  rse_next      __attribute__((packed));
+   unsigned long  rse_next;
-   unsigned long  buf_base      __attribute__((packed));
+   unsigned long  buf_base;
-   unsigned short reserved      __attribute__((packed));
+   unsigned short reserved;
-   unsigned long  buf_top       __attribute__((packed));
+   unsigned long  buf_top;
-};
+} __attribute__((packed));
 /* structure pointed to by rse_base in RXBUF_INFO struct */
 struct buf_entry {
-   char  opp_flag       __attribute__((packed));
+   char  opp_flag;
-   short length         __attribute__((packed));
+   short length;
-   short dlci           __attribute__((packed));
+   short dlci;
-   char  flags          __attribute__((packed));
+   char  flags;
-   short timestamp      __attribute__((packed));
+   short timestamp;
-   short reserved[2]    __attribute__((packed));
+   short reserved[2];
-   long  buf_addr       __attribute__((packed));
+   long  buf_addr;
-};
+} __attribute__((packed));
 #endif
diff --git a/include/linux/seccomp.h b/include/linux/seccomp.h
index dc89116bb1ca..cd2773b29a64 100644
--- a/include/linux/seccomp.h
+++ b/include/linux/seccomp.h
@@ -26,11 +26,7 @@ static inline int has_secure_computing(struct thread_info *ti)
 #else /* CONFIG_SECCOMP */
-#if (__GNUC__ > 2)
+typedef struct { } seccomp_t;
-  typedef struct { } seccomp_t;
-#else
-  typedef struct { int gcc_is_buggy; } seccomp_t;
-#endif
 #define secure_computing(x) do { } while (0)
 /* static inline to preserve typechecking */
diff --git a/include/linux/serial_core.h b/include/linux/serial_core.h
index e3710d7e260a..ec351005bf9d 100644
--- a/include/linux/serial_core.h
+++ b/include/linux/serial_core.h
@@ -67,6 +67,9 @@
 /* Parisc type numbers. */
 #define PORT_MUX        48
+/* Atmel AT91RM9200 SoC */
+#define PORT_AT91RM9200 49
 /* Macintosh Zilog type numbers */
 #define PORT_MAC_ZILOG  50      /* m68k : not yet implemented */
 #define PORT_PMAC_ZILOG 51
@@ -133,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;
@@ -281,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/signal.h b/include/linux/signal.h
index 5dd5f02c5c5f..b7d093520bb6 100644
--- a/include/linux/signal.h
+++ b/include/linux/signal.h
@@ -18,6 +18,19 @@
 #define SA_PROBE                SA_ONESHOT
 #define SA_SAMPLE_RANDOM        SA_RESTART
 #define SA_SHIRQ                0x04000000
+/*
+ * As above, these correspond to the IORESOURCE_IRQ_* defines in
+ * linux/ioport.h to select the interrupt line behaviour.  When
+ * requesting an interrupt without specifying a SA_TRIGGER, the
+ * setting should be assumed to be "as already configured", which
+ * may be as per machine or firmware initialisation.
+ */
+#define SA_TRIGGER_LOW          0x00000008
+#define SA_TRIGGER_HIGH         0x00000004
+#define SA_TRIGGER_FALLING      0x00000002
+#define SA_TRIGGER_RISING       0x00000001
+#define SA_TRIGGER_MASK (SA_TRIGGER_HIGH|SA_TRIGGER_LOW|\
+                                 SA_TRIGGER_RISING|SA_TRIGGER_FALLING)
 /*
 * Real Time signals may be queued.
@@ -81,6 +94,23 @@ static inline int sigfindinword(unsigned long word)
 #endif /* __HAVE_ARCH_SIG_BITOPS */
+static inline int sigisemptyset(sigset_t *set)
+{
+        extern void _NSIG_WORDS_is_unsupported_size(void);
+        switch (_NSIG_WORDS) {
+        case 4:
+                return (set->sig[3] | set->sig[2] |
+                        set->sig[1] | set->sig[0]) == 0;
+        case 2:
+                return (set->sig[1] | set->sig[0]) == 0;
+        case 1:
+                return set->sig[0] == 0;
+        default:
+                _NSIG_WORDS_is_unsupported_size();
+                return 0;
+        }
+}
 #define sigmask(sig)    (1UL << ((sig) - 1))
 #ifndef __HAVE_ARCH_SIG_SETOPS
diff --git a/include/linux/skbuff.h b/include/linux/skbuff.h
index 483cfc47ec34..ad7cc22bd424 100644
--- a/include/linux/skbuff.h
+++ b/include/linux/skbuff.h
@@ -251,7 +251,7 @@ struct sk_buff {
         * want to keep them across layers you have to do a skb_clone()
         * first. This is owned by whoever has the skb queued ATM.
         */
-        char                    cb[40];
+        char                    cb[48];
        unsigned int            len,
                                data_len,
@@ -926,7 +926,7 @@ static inline int skb_tailroom(const struct sk_buff *skb)
 *      Increase the headroom of an empty &sk_buff by reducing the tail
 *      room. This is only allowed for an empty buffer.
 */
-static inline void skb_reserve(struct sk_buff *skb, unsigned int len)
+static inline void skb_reserve(struct sk_buff *skb, int len)
 {
        skb->data += len;
        skb->tail += len;
diff --git a/include/linux/slab.h b/include/linux/slab.h
index d1ea4051b996..1fb77a9cc148 100644
--- a/include/linux/slab.h
+++ b/include/linux/slab.h
@@ -53,6 +53,8 @@ typedef struct kmem_cache kmem_cache_t;
 #define SLAB_CTOR_ATOMIC        0x002UL         /* tell constructor it can't sleep */
 #define SLAB_CTOR_VERIFY        0x004UL         /* tell constructor it's a verify call */
+#ifndef CONFIG_SLOB
 /* prototypes */
 extern void __init kmem_cache_init(void);
@@ -134,6 +136,39 @@ static inline void *kmalloc_node(size_t size, gfp_t flags, int node)
 extern int FASTCALL(kmem_cache_reap(int));
 extern int FASTCALL(kmem_ptr_validate(kmem_cache_t *cachep, void *ptr));
+#else /* CONFIG_SLOB */
+/* SLOB allocator routines */
+void kmem_cache_init(void);
+struct kmem_cache *kmem_find_general_cachep(size_t, gfp_t gfpflags);
+struct kmem_cache *kmem_cache_create(const char *c, size_t, size_t,
+        unsigned long,
+        void (*)(void *, struct kmem_cache *, unsigned long),
+        void (*)(void *, struct kmem_cache *, unsigned long));
+int kmem_cache_destroy(struct kmem_cache *c);
+void *kmem_cache_alloc(struct kmem_cache *c, gfp_t flags);
+void kmem_cache_free(struct kmem_cache *c, void *b);
+const char *kmem_cache_name(struct kmem_cache *);
+void *kmalloc(size_t size, gfp_t flags);
+void *kzalloc(size_t size, gfp_t flags);
+void kfree(const void *m);
+unsigned int ksize(const void *m);
+unsigned int kmem_cache_size(struct kmem_cache *c);
+static inline void *kcalloc(size_t n, size_t size, gfp_t flags)
+{
+        return kzalloc(n * size, flags);
+}
+#define kmem_cache_shrink(d) (0)
+#define kmem_cache_reap(a)
+#define kmem_ptr_validate(a, b) (0)
+#define kmem_cache_alloc_node(c, f, n) kmem_cache_alloc(c, f)
+#define kmalloc_node(s, f, n) kmalloc(s, f)
+#endif /* CONFIG_SLOB */
 /* System wide caches */
 extern kmem_cache_t     *vm_area_cachep;
 extern kmem_cache_t     *names_cachep;
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/spinlock_types_up.h b/include/linux/spinlock_types_up.h
index def2d173a8db..04135b0e198e 100644
--- a/include/linux/spinlock_types_up.h
+++ b/include/linux/spinlock_types_up.h
@@ -22,30 +22,16 @@ typedef struct {
 #else
-/*
- * All gcc 2.95 versions and early versions of 2.96 have a nasty bug
- * with empty initializers.
- */
-#if (__GNUC__ > 2)
 typedef struct { } raw_spinlock_t;
 #define __RAW_SPIN_LOCK_UNLOCKED { }
-#else
-typedef struct { int gcc_is_buggy; } raw_spinlock_t;
-#define __RAW_SPIN_LOCK_UNLOCKED (raw_spinlock_t) { 0 }
-#endif
 #endif
-#if (__GNUC__ > 2)
 typedef struct {
        /* no debug version on UP */
 } raw_rwlock_t;
 #define __RAW_RW_LOCK_UNLOCKED { }
-#else
-typedef struct { int gcc_is_buggy; } raw_rwlock_t;
-#define __RAW_RW_LOCK_UNLOCKED (raw_rwlock_t) { 0 }
-#endif
 #endif /* __LINUX_SPINLOCK_TYPES_UP_H */
diff --git a/include/linux/sunrpc/svc.h b/include/linux/sunrpc/svc.h
index e4086ec8b952..50cab2a09f28 100644
--- a/include/linux/sunrpc/svc.h
+++ b/include/linux/sunrpc/svc.h
@@ -246,6 +246,7 @@ struct svc_deferred_req {
        u32                     prot;   /* protocol (UDP or TCP) */
        struct sockaddr_in      addr;
        struct svc_sock         *svsk;  /* where reply must go */
+        u32                     daddr;  /* where reply must come from */
        struct cache_deferred_req handle;
        int                     argslen;
        u32                     args[0];
diff --git a/include/linux/swap.h b/include/linux/swap.h
index 556617bcf7ac..4a99e4a7fbf3 100644
--- a/include/linux/swap.h
+++ b/include/linux/swap.h
@@ -167,6 +167,7 @@ extern void FASTCALL(lru_cache_add_active(struct page *));
 extern void FASTCALL(activate_page(struct page *));
 extern void FASTCALL(mark_page_accessed(struct page *));
 extern void lru_add_drain(void);
+extern int lru_add_drain_all(void);
 extern int rotate_reclaimable_page(struct page *page);
 extern void swap_setup(void);
@@ -175,6 +176,29 @@ extern int try_to_free_pages(struct zone **, gfp_t);
 extern int shrink_all_memory(int);
 extern int vm_swappiness;
+#ifdef CONFIG_NUMA
+extern int zone_reclaim_mode;
+extern int zone_reclaim(struct zone *, gfp_t, unsigned int);
+#else
+#define zone_reclaim_mode 0
+static inline int zone_reclaim(struct zone *z, gfp_t mask, unsigned int order)
+{
+        return 0;
+}
+#endif
+#ifdef CONFIG_MIGRATION
+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
 /* linux/mm/shmem.c */
 extern int shmem_unuse(swp_entry_t entry, struct page *page);
@@ -192,7 +216,7 @@ extern int rw_swap_page_sync(int, swp_entry_t, struct page *);
 extern struct address_space swapper_space;
 #define total_swapcache_pages  swapper_space.nrpages
 extern void show_swap_cache_info(void);
-extern int add_to_swap(struct page *);
+extern int add_to_swap(struct page *, gfp_t);
 extern void __delete_from_swap_cache(struct page *);
 extern void delete_from_swap_cache(struct page *);
 extern int move_to_swap_cache(struct page *, swp_entry_t);
diff --git a/include/linux/synclink.h b/include/linux/synclink.h
index 763bd290f28d..1b7cd8d1a71b 100644
--- a/include/linux/synclink.h
+++ b/include/linux/synclink.h
@@ -1,7 +1,7 @@
 /*
 * SyncLink Multiprotocol Serial Adapter Driver
 *
- * $Id: synclink.h,v 3.6 2002/02/20 21:58:20 paulkf Exp $
+ * $Id: synclink.h,v 3.10 2005/11/08 19:50:54 paulkf Exp $
 *
 * Copyright (C) 1998-2000 by Microgate Corporation
 *
@@ -128,10 +128,14 @@
 #define MGSL_BUS_TYPE_EISA      2
 #define MGSL_BUS_TYPE_PCI       5
+#define MGSL_INTERFACE_MASK     0xf
 #define MGSL_INTERFACE_DISABLE  0
 #define MGSL_INTERFACE_RS232    1
 #define MGSL_INTERFACE_V35      2
 #define MGSL_INTERFACE_RS422    3
+#define MGSL_INTERFACE_RTS_EN   0x10
+#define MGSL_INTERFACE_LL       0x20
+#define MGSL_INTERFACE_RL       0x40
 typedef struct _MGSL_PARAMS
 {
@@ -163,6 +167,9 @@ typedef struct _MGSL_PARAMS
 #define SYNCLINK_DEVICE_ID 0x0010
 #define MGSCC_DEVICE_ID 0x0020
 #define SYNCLINK_SCA_DEVICE_ID 0x0030
+#define SYNCLINK_GT_DEVICE_ID 0x0070
+#define SYNCLINK_GT4_DEVICE_ID 0x0080
+#define SYNCLINK_AC_DEVICE_ID  0x0090
 #define MGSL_MAX_SERIAL_NUMBER 30
 /*
diff --git a/include/linux/syscalls.h b/include/linux/syscalls.h
index c7007b1db91d..e666d6070569 100644
--- a/include/linux/syscalls.h
+++ b/include/linux/syscalls.h
@@ -510,6 +510,28 @@ asmlinkage long sys_keyctl(int cmd, unsigned long arg2, unsigned long arg3,
 asmlinkage long sys_ioprio_set(int which, int who, int ioprio);
 asmlinkage long sys_ioprio_get(int which, int who);
 asmlinkage long sys_set_mempolicy(int mode, unsigned long __user *nmask,
-                                        unsigned long maxnode);
+                                unsigned long maxnode);
+asmlinkage long sys_migrate_pages(pid_t pid, unsigned long maxnode,
+                                const unsigned long __user *from,
+                                const unsigned long __user *to);
+asmlinkage long sys_mbind(unsigned long start, unsigned long len,
+                                unsigned long mode,
+                                unsigned long __user *nmask,
+                                unsigned long maxnode,
+                                unsigned flags);
+asmlinkage long sys_get_mempolicy(int __user *policy,
+                                unsigned long __user *nmask,
+                                unsigned long maxnode,
+                                unsigned long addr, unsigned long flags);
+asmlinkage long sys_inotify_init(void);
+asmlinkage long sys_inotify_add_watch(int fd, const char __user *path,
+                                        u32 mask);
+asmlinkage long sys_inotify_rm_watch(int fd, u32 wd);
+asmlinkage long sys_spu_run(int fd, __u32 __user *unpc,
+                                 __u32 __user *ustatus);
+asmlinkage long sys_spu_create(const char __user *name,
+                unsigned int flags, mode_t mode);
 #endif
diff --git a/include/linux/sysctl.h b/include/linux/sysctl.h
index a9b80fc7f0f3..8352a7ce5895 100644
--- a/include/linux/sysctl.h
+++ b/include/linux/sysctl.h
@@ -180,6 +180,9 @@ enum
        VM_VFS_CACHE_PRESSURE=26, /* dcache/icache reclaim pressure */
        VM_LEGACY_VA_LAYOUT=27, /* legacy/compatibility virtual address space layout */
        VM_SWAP_TOKEN_TIMEOUT=28, /* default time for token time out */
+        VM_DROP_PAGECACHE=29,   /* int: nuke lots of pagecache */
+        VM_PERCPU_PAGELIST_FRACTION=30,/* int: fraction of pages in each percpu_pagelist */
+        VM_ZONE_RECLAIM_MODE=31,/* reclaim local zone memory before going off node */
 };
diff --git a/include/linux/time.h b/include/linux/time.h
index 797ccd813bb0..614dd8465839 100644
--- a/include/linux/time.h
+++ b/include/linux/time.h
@@ -4,7 +4,7 @@
 #include <linux/types.h>
 #ifdef __KERNEL__
-#include <linux/seqlock.h>
+# include <linux/seqlock.h>
 #endif
 #ifndef _STRUCT_TIMESPEC
@@ -13,7 +13,7 @@ struct timespec {
        time_t  tv_sec;         /* seconds */
        long    tv_nsec;        /* nanoseconds */
 };
-#endif /* _STRUCT_TIMESPEC */
+#endif
 struct timeval {
        time_t          tv_sec;         /* seconds */
@@ -27,93 +27,103 @@ struct timezone {
 #ifdef __KERNEL__
-/* Parameters used to convert the timespec values */
+/* Parameters used to convert the timespec values: */
-#define MSEC_PER_SEC (1000L)
+#define MSEC_PER_SEC            1000L
-#define USEC_PER_SEC (1000000L)
+#define USEC_PER_SEC            1000000L
-#define NSEC_PER_SEC (1000000000L)
+#define NSEC_PER_SEC            1000000000L
-#define NSEC_PER_USEC (1000L)
+#define NSEC_PER_USEC           1000L
-static __inline__ int timespec_equal(struct timespec *a, struct timespec *b) 
+static __inline__ int timespec_equal(struct timespec *a, struct timespec *b)
-{ 
+{
        return (a->tv_sec == b->tv_sec) && (a->tv_nsec == b->tv_nsec);
-} 
+}
-/* Converts Gregorian date to seconds since 1970-01-01 00:00:00.
+extern unsigned long mktime(const unsigned int year, const unsigned int mon,
- * Assumes input in normal date format, i.e. 1980-12-31 23:59:59
+                            const unsigned int day, const unsigned int hour,
- * => year=1980, mon=12, day=31, hour=23, min=59, sec=59.
+                            const unsigned int min, const unsigned int sec);
- *
- * [For the Julian calendar (which was used in Russia before 1917,
+extern void set_normalized_timespec(struct timespec *ts, time_t sec, long nsec);
- * Britain & colonies before 1752, anywhere else before 1582,
- * and is still in use by some communities) leave out the
+/*
- * -year/100+year/400 terms, and add 10.]
+ * Returns true if the timespec is norm, false if denorm:
- *
- * This algorithm was first published by Gauss (I think).
- *
- * WARNING: this function will overflow on 2106-02-07 06:28:16 on
- * machines were long is 32-bit! (However, as time_t is signed, we
- * will already get problems at other places on 2038-01-19 03:14:08)
 */
-static inline unsigned long
+#define timespec_valid(ts) \
-mktime (unsigned int year, unsigned int mon,
+        (((ts)->tv_sec >= 0) && (((unsigned) (ts)->tv_nsec) < NSEC_PER_SEC))
-        unsigned int day, unsigned int hour,
-        unsigned int min, unsigned int sec)
+/*
-{
+ * 64-bit nanosec type. Large enough to span 292+ years in nanosecond
-        if (0 >= (int) (mon -= 2)) {    /* 1..12 -> 11,12,1..10 */
+ * resolution. Ought to be enough for a while.
-                mon += 12;              /* Puts Feb last since it has leap day */
+ */
-                year -= 1;
+typedef s64 nsec_t;
-        }
-        return (((
-                (unsigned long) (year/4 - year/100 + year/400 + 367*mon/12 + day) +
-                        year*365 - 719499
-            )*24 + hour /* now have hours */
-          )*60 + min /* now have minutes */
-        )*60 + sec; /* finally seconds */
-}
 extern struct timespec xtime;
 extern struct timespec wall_to_monotonic;
 extern seqlock_t xtime_lock;
 static inline unsigned long get_seconds(void)
-{ 
+{
        return xtime.tv_sec;
 }
 struct timespec current_kernel_time(void);
-#define CURRENT_TIME (current_kernel_time())
+#define CURRENT_TIME            (current_kernel_time())
-#define CURRENT_TIME_SEC ((struct timespec) { xtime.tv_sec, 0 })
+#define CURRENT_TIME_SEC        ((struct timespec) { xtime.tv_sec, 0 })
 extern void do_gettimeofday(struct timeval *tv);
 extern int do_settimeofday(struct timespec *tv);
 extern int do_sys_settimeofday(struct timespec *tv, struct timezone *tz);
-extern void clock_was_set(void); // call when ever the clock is set
+#define do_posix_clock_monotonic_gettime(ts) ktime_get_ts(ts)
-extern int do_posix_clock_monotonic_gettime(struct timespec *tp);
+extern long do_utimes(int dfd, char __user *filename, struct timeval *times);
-extern long do_utimes(char __user * filename, struct timeval * times);
 struct itimerval;
-extern int do_setitimer(int which, struct itimerval *value, struct itimerval *ovalue);
+extern int do_setitimer(int which, struct itimerval *value,
+                        struct itimerval *ovalue);
 extern int do_getitimer(int which, struct itimerval *value);
-extern void getnstimeofday (struct timespec *tv);
+extern void getnstimeofday(struct timespec *tv);
-extern void getnstimestamp(struct timespec *ts);
 extern struct timespec timespec_trunc(struct timespec t, unsigned gran);
-static inline void
+/**
-set_normalized_timespec (struct timespec *ts, time_t sec, long nsec)
+ * timespec_to_ns - Convert timespec to nanoseconds
+ * @ts:         pointer to the timespec variable to be converted
+ *
+ * Returns the scalar nanosecond representation of the timespec
+ * parameter.
+ */
+static inline nsec_t timespec_to_ns(const struct timespec *ts)
 {
-        while (nsec >= NSEC_PER_SEC) {
+        return ((nsec_t) ts->tv_sec * NSEC_PER_SEC) + ts->tv_nsec;
-                nsec -= NSEC_PER_SEC;
-                ++sec;
-        }
-        while (nsec < 0) {
-                nsec += NSEC_PER_SEC;
-                --sec;
-        }
-        ts->tv_sec = sec;
-        ts->tv_nsec = nsec;
 }
+/**
+ * timeval_to_ns - Convert timeval to nanoseconds
+ * @ts:         pointer to the timeval variable to be converted
+ *
+ * Returns the scalar nanosecond representation of the timeval
+ * parameter.
+ */
+static inline nsec_t timeval_to_ns(const struct timeval *tv)
+{
+        return ((nsec_t) tv->tv_sec * NSEC_PER_SEC) +
+                tv->tv_usec * NSEC_PER_USEC;
+}
+/**
+ * ns_to_timespec - Convert nanoseconds to timespec
+ * @nsec:       the nanoseconds value to be converted
+ *
+ * Returns the timespec representation of the nsec parameter.
+ */
+extern struct timespec ns_to_timespec(const nsec_t nsec);
+/**
+ * ns_to_timeval - Convert nanoseconds to timeval
+ * @nsec:       the nanoseconds value to be converted
+ *
+ * Returns the timeval representation of the nsec parameter.
+ */
+extern struct timeval ns_to_timeval(const nsec_t nsec);
 #endif /* __KERNEL__ */
 #define NFDBITS                 __NFDBITS
@@ -126,49 +136,41 @@ set_normalized_timespec (struct timespec *ts, time_t sec, long nsec)
 /*
 * Names of the interval timers, and structure
- * defining a timer setting.
+ * defining a timer setting:
 */
-#define ITIMER_REAL     0
+#define ITIMER_REAL             0
-#define ITIMER_VIRTUAL  1
+#define ITIMER_VIRTUAL          1
-#define ITIMER_PROF     2
+#define ITIMER_PROF             2
-struct  itimerspec {
+struct itimerspec {
-        struct  timespec it_interval;    /* timer period */
+        struct timespec it_interval;    /* timer period */
-        struct  timespec it_value;       /* timer expiration */
+        struct timespec it_value;       /* timer expiration */
 };
-struct  itimerval {
+struct itimerval {
-        struct  timeval it_interval;    /* timer interval */
+        struct timeval it_interval;     /* timer interval */
-        struct  timeval it_value;       /* current value */
+        struct timeval it_value;        /* current value */
 };
 /*
- * The IDs of the various system clocks (for POSIX.1b interval timers).
+ * The IDs of the various system clocks (for POSIX.1b interval timers):
 */
-#define CLOCK_REALTIME            0
+#define CLOCK_REALTIME                  0
-#define CLOCK_MONOTONIC   1
+#define CLOCK_MONOTONIC                 1
-#define CLOCK_PROCESS_CPUTIME_ID 2
+#define CLOCK_PROCESS_CPUTIME_ID        2
-#define CLOCK_THREAD_CPUTIME_ID  3
+#define CLOCK_THREAD_CPUTIME_ID         3
-#define CLOCK_REALTIME_HR        4
-#define CLOCK_MONOTONIC_HR        5
 /*
- * The IDs of various hardware clocks
+ * The IDs of various hardware clocks:
 */
+#define CLOCK_SGI_CYCLE                 10
+#define MAX_CLOCKS                      16
-#define CLOCK_SGI_CYCLE 10
+#define CLOCKS_MASK                     (CLOCK_REALTIME | CLOCK_MONOTONIC)
-#define MAX_CLOCKS 16
+#define CLOCKS_MONO                     CLOCK_MONOTONIC
-#define CLOCKS_MASK  (CLOCK_REALTIME | CLOCK_MONOTONIC | \
-                     CLOCK_REALTIME_HR | CLOCK_MONOTONIC_HR)
-#define CLOCKS_MONO (CLOCK_MONOTONIC & CLOCK_MONOTONIC_HR)
 /*
- * The various flags for setting POSIX.1b interval timers.
+ * The various flags for setting POSIX.1b interval timers:
 */
+#define TIMER_ABSTIME                   0x01
-#define TIMER_ABSTIME 0x01
 #endif
diff --git a/include/linux/timer.h b/include/linux/timer.h
index 72f3a7781106..9b9877fd2505 100644
--- a/include/linux/timer.h
+++ b/include/linux/timer.h
@@ -96,6 +96,6 @@ static inline void add_timer(struct timer_list *timer)
 extern void init_timers(void);
 extern void run_local_timers(void);
-extern void it_real_fn(unsigned long);
+extern int it_real_fn(void *);
 #endif
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..33a653913d94
--- /dev/null
+++ b/include/linux/tipc_config.h
@@ -0,0 +1,410 @@
+/*
+ * 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 (min, default, max, media default)
+ */
+#define TIPC_MIN_LINK_PRI       0
+#define TIPC_DEF_LINK_PRI       10
+#define TIPC_MAX_LINK_PRI       31
+#define TIPC_MEDIA_LINK_PRI     (TIPC_MAX_LINK_PRI + 1)
+/*
+ * 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/linux/topology.h b/include/linux/topology.h
index 3df1d474e5c5..e8eb0040ce3a 100644
--- a/include/linux/topology.h
+++ b/include/linux/topology.h
@@ -56,6 +56,14 @@
 #define REMOTE_DISTANCE         20
 #define node_distance(from,to)  ((from) == (to) ? LOCAL_DISTANCE : REMOTE_DISTANCE)
 #endif
+#ifndef RECLAIM_DISTANCE
+/*
+ * If the distance between nodes in a system is larger than RECLAIM_DISTANCE
+ * (in whatever arch specific measurement units returned by node_distance())
+ * then switch on zone reclaim on boot.
+ */
+#define RECLAIM_DISTANCE 20
+#endif
 #ifndef PENALTY_FOR_NODE_WITH_CPUS
 #define PENALTY_FOR_NODE_WITH_CPUS      (1)
 #endif
@@ -86,7 +94,6 @@
        .max_interval           = 2,                    \
        .busy_factor            = 8,                    \
        .imbalance_pct          = 110,                  \
-        .cache_hot_time         = 0,                    \
        .cache_nice_tries       = 0,                    \
        .per_cpu_gain           = 25,                   \
        .busy_idx               = 0,                    \
@@ -117,7 +124,6 @@
        .max_interval           = 4,                    \
        .busy_factor            = 64,                   \
        .imbalance_pct          = 125,                  \
-        .cache_hot_time         = (5*1000000/2),        \
        .cache_nice_tries       = 1,                    \
        .per_cpu_gain           = 100,                  \
        .busy_idx               = 2,                    \
diff --git a/include/linux/tty.h b/include/linux/tty.h
index 1267f88ece6e..3787102e4b12 100644
--- a/include/linux/tty.h
+++ b/include/linux/tty.h
@@ -23,6 +23,7 @@
 #include <linux/workqueue.h>
 #include <linux/tty_driver.h>
 #include <linux/tty_ldisc.h>
+#include <linux/screen_info.h>
 #include <asm/system.h>
@@ -37,77 +38,6 @@
 #define NR_LDISCS               16
 /*
- * These are set up by the setup-routine at boot-time:
- */
-struct screen_info {
-        u8  orig_x;             /* 0x00 */
-        u8  orig_y;             /* 0x01 */
-        u16 dontuse1;           /* 0x02 -- EXT_MEM_K sits here */
-        u16 orig_video_page;    /* 0x04 */
-        u8  orig_video_mode;    /* 0x06 */
-        u8  orig_video_cols;    /* 0x07 */
-        u16 unused2;            /* 0x08 */
-        u16 orig_video_ega_bx;  /* 0x0a */
-        u16 unused3;            /* 0x0c */
-        u8  orig_video_lines;   /* 0x0e */
-        u8  orig_video_isVGA;   /* 0x0f */
-        u16 orig_video_points;  /* 0x10 */
-        /* VESA graphic mode -- linear frame buffer */
-        u16 lfb_width;          /* 0x12 */
-        u16 lfb_height;         /* 0x14 */
-        u16 lfb_depth;          /* 0x16 */
-        u32 lfb_base;           /* 0x18 */
-        u32 lfb_size;           /* 0x1c */
-        u16 dontuse2, dontuse3; /* 0x20 -- CL_MAGIC and CL_OFFSET here */
-        u16 lfb_linelength;     /* 0x24 */
-        u8  red_size;           /* 0x26 */
-        u8  red_pos;            /* 0x27 */
-        u8  green_size;         /* 0x28 */
-        u8  green_pos;          /* 0x29 */
-        u8  blue_size;          /* 0x2a */
-        u8  blue_pos;           /* 0x2b */
-        u8  rsvd_size;          /* 0x2c */
-        u8  rsvd_pos;           /* 0x2d */
-        u16 vesapm_seg;         /* 0x2e */
-        u16 vesapm_off;         /* 0x30 */
-        u16 pages;              /* 0x32 */
-        u16 vesa_attributes;    /* 0x34 */
-        u32  capabilities;      /* 0x36 */
-                                /* 0x3a -- 0x3f reserved for future expansion */
-};
-extern struct screen_info screen_info;
-#define ORIG_X                  (screen_info.orig_x)
-#define ORIG_Y                  (screen_info.orig_y)
-#define ORIG_VIDEO_MODE         (screen_info.orig_video_mode)
-#define ORIG_VIDEO_COLS         (screen_info.orig_video_cols)
-#define ORIG_VIDEO_EGA_BX       (screen_info.orig_video_ega_bx)
-#define ORIG_VIDEO_LINES        (screen_info.orig_video_lines)
-#define ORIG_VIDEO_ISVGA        (screen_info.orig_video_isVGA)
-#define ORIG_VIDEO_POINTS       (screen_info.orig_video_points)
-#define VIDEO_TYPE_MDA          0x10    /* Monochrome Text Display      */
-#define VIDEO_TYPE_CGA          0x11    /* CGA Display                  */
-#define VIDEO_TYPE_EGAM         0x20    /* EGA/VGA in Monochrome Mode   */
-#define VIDEO_TYPE_EGAC         0x21    /* EGA in Color Mode            */
-#define VIDEO_TYPE_VGAC         0x22    /* VGA+ in Color Mode           */
-#define VIDEO_TYPE_VLFB         0x23    /* VESA VGA in graphic mode     */
-#define VIDEO_TYPE_PICA_S3      0x30    /* ACER PICA-61 local S3 video  */
-#define VIDEO_TYPE_MIPS_G364    0x31    /* MIPS Magnum 4000 G364 video  */
-#define VIDEO_TYPE_SGI          0x33    /* Various SGI graphics hardware */
-#define VIDEO_TYPE_TGAC         0x40    /* DEC TGA */
-#define VIDEO_TYPE_SUN          0x50    /* Sun frame buffer. */
-#define VIDEO_TYPE_SUNPCI       0x51    /* Sun PCI based frame buffer. */
-#define VIDEO_TYPE_PMAC         0x60    /* PowerMacintosh frame buffer. */
-/*
 * This character is the same as _POSIX_VDISABLE: it cannot be used as
 * a c_cc[] character, but indicates that a particular special character
 * isn't in use (eg VINTR has no character etc)
@@ -121,16 +51,22 @@ extern struct screen_info screen_info;
 */
 #define TTY_FLIPBUF_SIZE 512
-struct tty_flip_buffer {
+struct tty_buffer {
+        struct tty_buffer *next;
+        char *char_buf_ptr;
+        unsigned char *flag_buf_ptr;
+        int used;
+        int size;
+        /* Data points here */
+        unsigned long data[0];
+};
+struct tty_bufhead {
        struct work_struct              work;
        struct semaphore pty_sem;
-        char            *char_buf_ptr;
+        struct tty_buffer *head;        /* Queue head */
-        unsigned char   *flag_buf_ptr;
+        struct tty_buffer *tail;        /* Active buffer */
-        int             count;
+        struct tty_buffer *free;        /* Free queue head */
-        int             buf_num;
-        unsigned char   char_buf[2*TTY_FLIPBUF_SIZE];
-        char            flag_buf[2*TTY_FLIPBUF_SIZE];
-        unsigned char   slop[4]; /* N.B. bug overwrites buffer by 1 */
 };
 /*
 * The pty uses char_buf and flag_buf as a contiguous buffer
@@ -256,10 +192,11 @@ struct tty_struct {
        unsigned char stopped:1, hw_stopped:1, flow_stopped:1, packet:1;
        unsigned char low_latency:1, warned:1;
        unsigned char ctrl_status;
+        unsigned int receive_room;      /* Bytes free for queue */
        struct tty_struct *link;
        struct fasync_struct *fasync;
-        struct tty_flip_buffer flip;
+        struct tty_bufhead buf;
        int max_flip_cnt;
        int alt_speed;          /* For magic substitution of 38400 bps */
        wait_queue_head_t write_wait;
diff --git a/include/linux/tty_flip.h b/include/linux/tty_flip.h
index abe9bfcf226c..be1400e82482 100644
--- a/include/linux/tty_flip.h
+++ b/include/linux/tty_flip.h
@@ -1,25 +1,33 @@
 #ifndef _LINUX_TTY_FLIP_H
 #define _LINUX_TTY_FLIP_H
+extern int tty_buffer_request_room(struct tty_struct *tty, size_t size);
+extern int tty_insert_flip_string(struct tty_struct *tty, unsigned char *chars, size_t size);
+extern int tty_insert_flip_string_flags(struct tty_struct *tty, unsigned char *chars, char *flags, size_t size);
+extern int tty_prepare_flip_string(struct tty_struct *tty, unsigned char **chars, size_t size);
+extern int tty_prepare_flip_string_flags(struct tty_struct *tty, unsigned char **chars, char **flags, size_t size);
 #ifdef INCLUDE_INLINE_FUNCS
 #define _INLINE_ extern
 #else
 #define _INLINE_ static __inline__
 #endif
-_INLINE_ void tty_insert_flip_char(struct tty_struct *tty,
+_INLINE_ int tty_insert_flip_char(struct tty_struct *tty,
                                   unsigned char ch, char flag)
 {
-        if (tty->flip.count < TTY_FLIPBUF_SIZE) {
+        struct tty_buffer *tb = tty->buf.tail;
-                tty->flip.count++;
+        if (tb && tb->used < tb->size) {
-                *tty->flip.flag_buf_ptr++ = flag;
+                tb->flag_buf_ptr[tb->used] = flag;
-                *tty->flip.char_buf_ptr++ = ch;
+                tb->char_buf_ptr[tb->used++] = ch;
+                return 1;
        }
+        return tty_insert_flip_string_flags(tty, &ch, &flag, 1);
 }
 _INLINE_ void tty_schedule_flip(struct tty_struct *tty)
 {
-        schedule_delayed_work(&tty->flip.work, 1);
+        schedule_delayed_work(&tty->buf.work, 1);
 }
 #undef _INLINE_
diff --git a/include/linux/tty_ldisc.h b/include/linux/tty_ldisc.h
index 6066afde5ce4..83c6e6c10ebb 100644
--- a/include/linux/tty_ldisc.h
+++ b/include/linux/tty_ldisc.h
@@ -81,14 +81,6 @@
 *      pointer of flag bytes which indicate whether a character was
 *      received with a parity error, etc.
 * 
- * int  (*receive_room)(struct tty_struct *);
- *
- *      This function is called by the low-level tty driver to
- *      determine how many characters the line discpline can accept.
- *      The low-level driver must not send more characters than was
- *      indicated by receive_room, or the line discpline may drop
- *      those characters.
- * 
 * void (*write_wakeup)(struct tty_struct *);
 *
 *      This function is called by the low-level tty driver to signal
@@ -136,7 +128,6 @@ struct tty_ldisc {
         */
        void    (*receive_buf)(struct tty_struct *, const unsigned char *cp,
                               char *fp, int count);
-        int     (*receive_room)(struct tty_struct *);
        void    (*write_wakeup)(struct tty_struct *);
        struct  module *owner;
diff --git a/include/linux/video_decoder.h b/include/linux/video_decoder.h
index 0e9e48b83e3b..121e26da2c18 100644
--- a/include/linux/video_decoder.h
+++ b/include/linux/video_decoder.h
@@ -1,6 +1,8 @@
 #ifndef _LINUX_VIDEO_DECODER_H
 #define _LINUX_VIDEO_DECODER_H
+#define HAVE_VIDEO_DECODER 1
 struct video_decoder_capability { /* this name is too long */
        __u32   flags;
 #define VIDEO_DECODER_PAL       1       /* can decode PAL signal */
diff --git a/include/linux/videodev2.h b/include/linux/videodev2.h
index 1cded681eb6d..ce40675324bd 100644
--- a/include/linux/videodev2.h
+++ b/include/linux/videodev2.h
@@ -642,6 +642,12 @@ typedef __u64 v4l2_std_id;
 #define V4L2_STD_ATSC_8_VSB     ((v4l2_std_id)0x01000000)
 #define V4L2_STD_ATSC_16_VSB    ((v4l2_std_id)0x02000000)
+/* some merged standards */
+#define V4L2_STD_MN     (V4L2_STD_PAL_M|V4L2_STD_PAL_N|V4L2_STD_PAL_Nc|V4L2_STD_NTSC)
+#define V4L2_STD_B      (V4L2_STD_PAL_B|V4L2_STD_PAL_B1|V4L2_STD_SECAM_B)
+#define V4L2_STD_GH     (V4L2_STD_PAL_G|V4L2_STD_PAL_H|V4L2_STD_SECAM_G|V4L2_STD_SECAM_H)
+#define V4L2_STD_DK     (V4L2_STD_PAL_DK|V4L2_STD_SECAM_DK)
 /* some common needed stuff */
 #define V4L2_STD_PAL_BG         (V4L2_STD_PAL_B         |\
                                 V4L2_STD_PAL_B1        |\
@@ -662,7 +668,8 @@ typedef __u64 v4l2_std_id;
                                 V4L2_STD_SECAM_G       |\
                                 V4L2_STD_SECAM_H       |\
                                 V4L2_STD_SECAM_DK      |\
-                                 V4L2_STD_SECAM_L)
+                                 V4L2_STD_SECAM_L       |\
+                                 V4L2_STD_SECAM_LC)
 #define V4L2_STD_525_60         (V4L2_STD_PAL_M         |\
                                 V4L2_STD_PAL_60        |\
@@ -888,7 +895,6 @@ struct v4l2_audio
 /*  Flags for the 'mode' field */
 #define V4L2_AUDMODE_AVL                0x00001
-#define V4L2_AUDMODE_32BITS             0x00002
 struct v4l2_audioout
 {
@@ -1110,7 +1116,6 @@ int v4l2_prio_check(struct v4l2_prio_state *global, enum v4l2_priority *local);
 /* names for fancy debug output */
 extern char *v4l2_field_names[];
 extern char *v4l2_type_names[];
-extern char *v4l2_ioctl_names[];
 /*  Compatibility layer interface  --  v4l1-compat module */
 typedef int (*v4l2_kioctl)(struct inode *inode, struct file *file,
@@ -1118,6 +1123,11 @@ typedef int (*v4l2_kioctl)(struct inode *inode, struct file *file,
 int v4l_compat_translate_ioctl(struct inode *inode, struct file *file,
                               int cmd, void *arg, v4l2_kioctl driver_ioctl);
+/* 32 Bits compatibility layer for 64 bits processors */
+extern long v4l_compat_ioctl32(struct file *file, unsigned int cmd,
+                                unsigned long arg);
 #endif /* __KERNEL__ */
 #endif /* __LINUX_VIDEODEV2_H */
diff --git a/include/linux/wavefront.h b/include/linux/wavefront.h
index 61bd0fd35240..51ab3c933acd 100644
--- a/include/linux/wavefront.h
+++ b/include/linux/wavefront.h
@@ -434,22 +434,22 @@ typedef struct wf_multisample {
 } wavefront_multisample;
 typedef struct wf_alias {
-    INT16 OriginalSample __attribute__ ((packed));
+    INT16 OriginalSample;
-    struct wf_sample_offset sampleStartOffset __attribute__ ((packed));
+    struct wf_sample_offset sampleStartOffset;
-    struct wf_sample_offset loopStartOffset __attribute__ ((packed));
+    struct wf_sample_offset loopStartOffset;
-    struct wf_sample_offset sampleEndOffset __attribute__ ((packed));
+    struct wf_sample_offset sampleEndOffset;
-    struct wf_sample_offset loopEndOffset __attribute__ ((packed));
+    struct wf_sample_offset loopEndOffset;
-    INT16  FrequencyBias __attribute__ ((packed));
+    INT16  FrequencyBias;
-    UCHAR8 SampleResolution:2  __attribute__ ((packed));
+    UCHAR8 SampleResolution:2;
-    UCHAR8 Unused1:1  __attribute__ ((packed));
+    UCHAR8 Unused1:1;
-    UCHAR8 Loop:1 __attribute__ ((packed));
+    UCHAR8 Loop:1;
-    UCHAR8 Bidirectional:1  __attribute__ ((packed));
+    UCHAR8 Bidirectional:1;
-    UCHAR8 Unused2:1 __attribute__ ((packed));
+    UCHAR8 Unused2:1;
-    UCHAR8 Reverse:1 __attribute__ ((packed));
+    UCHAR8 Reverse:1;
-    UCHAR8 Unused3:1 __attribute__ ((packed)); 
+    UCHAR8 Unused3:1;
    
    /* This structure is meant to be padded only to 16 bits on their
       original. Of course, whoever wrote their documentation didn't
@@ -460,8 +460,8 @@ typedef struct wf_alias {
       standard 16->32 bit issues.
    */
-    UCHAR8 sixteen_bit_padding __attribute__ ((packed));
+    UCHAR8 sixteen_bit_padding;
-} wavefront_alias;
+} __attribute__((packed)) wavefront_alias;
 typedef struct wf_drum {
    UCHAR8 PatchNumber;
diff --git a/include/linux/workqueue.h b/include/linux/workqueue.h
index ac39d04d027c..86b111300231 100644
--- a/include/linux/workqueue.h
+++ b/include/linux/workqueue.h
@@ -65,6 +65,7 @@ extern int FASTCALL(schedule_work(struct work_struct *work));
 extern int FASTCALL(schedule_delayed_work(struct work_struct *work, unsigned long delay));
 extern int schedule_delayed_work_on(int cpu, struct work_struct *work, unsigned long delay);
+extern int schedule_on_each_cpu(void (*func)(void *info), void *info);
 extern void flush_scheduled_work(void);
 extern int current_is_keventd(void);
 extern int keventd_up(void);
diff --git a/include/linux/writeback.h b/include/linux/writeback.h
index b096159086e8..beaef5c7a0ea 100644
--- a/include/linux/writeback.h
+++ b/include/linux/writeback.h
@@ -103,7 +103,9 @@ void balance_dirty_pages_ratelimited(struct address_space *mapping);
 int pdflush_operation(void (*fn)(unsigned long), unsigned long arg0);
 int do_writepages(struct address_space *mapping, struct writeback_control *wbc);
 int sync_page_range(struct inode *inode, struct address_space *mapping,
-                        loff_t pos, size_t count);
+                        loff_t pos, loff_t count);
+int sync_page_range_nolock(struct inode *inode, struct address_space *mapping,
+                           loff_t pos, loff_t count);
 /* pdflush.c */
 extern int nr_pdflush_threads;  /* Global so it can be exported to sysctl
diff --git a/include/linux/xattr.h b/include/linux/xattr.h
index 23f9c61d9546..cda8a96e2fa0 100644
--- a/include/linux/xattr.h
+++ b/include/linux/xattr.h
@@ -13,7 +13,22 @@
 #define XATTR_CREATE    0x1     /* set value, fail if attr already exists */
 #define XATTR_REPLACE   0x2     /* set value, fail if attr does not exist */
+/* Namespaces */
+#define XATTR_OS2_PREFIX "os2."
+#define XATTR_OS2_PREFIX_LEN (sizeof (XATTR_OS2_PREFIX) - 1)
 #define XATTR_SECURITY_PREFIX   "security."
+#define XATTR_SECURITY_PREFIX_LEN (sizeof (XATTR_SECURITY_PREFIX) - 1)
+#define XATTR_SYSTEM_PREFIX "system."
+#define XATTR_SYSTEM_PREFIX_LEN (sizeof (XATTR_SYSTEM_PREFIX) - 1)
+#define XATTR_TRUSTED_PREFIX "trusted."
+#define XATTR_TRUSTED_PREFIX_LEN (sizeof (XATTR_TRUSTED_PREFIX) - 1)
+#define XATTR_USER_PREFIX "user."
+#define XATTR_USER_PREFIX_LEN (sizeof (XATTR_USER_PREFIX) - 1)
 struct xattr_handler {
        char *prefix;
@@ -25,6 +40,10 @@ struct xattr_handler {
                   size_t size, int flags);
 };
+ssize_t vfs_getxattr(struct dentry *, char *, void *, size_t);
+int vfs_setxattr(struct dentry *, char *, void *, size_t, int);
+int vfs_removexattr(struct dentry *, char *);
 ssize_t generic_getxattr(struct dentry *dentry, const char *name, void *buffer, size_t size);
 ssize_t generic_listxattr(struct dentry *dentry, char *buffer, size_t buffer_size);
 int generic_setxattr(struct dentry *dentry, const char *name, const void *value, size_t size, int flags);
diff --git a/include/linux/zlib.h b/include/linux/zlib.h
index 74f7b78c22d2..4fa32f0d4df8 100644
--- a/include/linux/zlib.h
+++ b/include/linux/zlib.h
@@ -442,9 +442,11 @@ extern int deflateInit2 (z_streamp strm,
   not perform any compression: this will be done by deflate().
 */
                            
+#if 0
 extern int zlib_deflateSetDictionary (z_streamp strm,
                                                     const Byte *dictionary,
                                                     uInt  dictLength);
+#endif
 /*
     Initializes the compression dictionary from the given byte sequence
   without producing any compressed output. This function must be called
@@ -478,7 +480,10 @@ extern int zlib_deflateSetDictionary (z_streamp strm,
   perform any compression: this will be done by deflate().
 */
+#if 0
 extern int zlib_deflateCopy (z_streamp dest, z_streamp source);
+#endif
 /*
     Sets the destination stream as a complete copy of the source stream.
@@ -511,7 +516,9 @@ static inline unsigned long deflateBound(unsigned long s)
        return s + ((s + 7) >> 3) + ((s + 63) >> 6) + 11;
 }
+#if 0
 extern int zlib_deflateParams (z_streamp strm, int level, int strategy);
+#endif
 /*
     Dynamically update the compression level and compression strategy.  The
   interpretation of level and strategy is as in deflateInit2.  This can be
@@ -571,7 +578,9 @@ extern int zlib_inflateSetDictionary (z_streamp strm,
   inflate().
 */
+#if 0
 extern int zlib_inflateSync (z_streamp strm);
+#endif
 /* 
    Skips invalid compressed data until a full flush point (see above the
  description of deflate with Z_FULL_FLUSH) can be found, or until all
@@ -636,7 +645,9 @@ extern int zlib_inflateInit2_ (z_streamp strm, int  windowBits,
 #endif
 extern const char  * zlib_zError           (int err);
+#if 0
 extern int           zlib_inflateSyncPoint (z_streamp z);
+#endif
 extern const uLong * zlib_get_crc_table    (void);
 #endif /* _ZLIB_H */