Merge with rsync://rsync.kernel.org/pub/scm/linux/kernel/git/torvalds/linux-2.6.git

32 files changed, 709 insertions, 268 deletions

diff --git a/include/linux/arcfb.h b/include/linux/arcfb.h
new file mode 100644
index 000000000000..721e7654daeb
--- /dev/null
+++ b/include/linux/arcfb.h
@@ -0,0 +1,8 @@
+#ifndef __LINUX_ARCFB_H__
+#define __LINUX_ARCFB_H__
+
+#define FBIO_WAITEVENT          _IO('F', 0x88)
+#define FBIO_GETCONTROL2        _IOR('F', 0x89, size_t)
+
+#endif
+
diff --git a/include/linux/auto_fs4.h b/include/linux/auto_fs4.h
index a1657fb99516..9343c89d843c 100644
--- a/include/linux/auto_fs4.h
+++ b/include/linux/auto_fs4.h
@@ -23,7 +23,7 @@
 #define AUTOFS_MIN_PROTO_VERSION        3
 #define AUTOFS_MAX_PROTO_VERSION        4
 
-#define AUTOFS_PROTO_SUBVERSION         6
+#define AUTOFS_PROTO_SUBVERSION         7
 
 /* Mask for expire behaviour */
 #define AUTOFS_EXP_IMMEDIATE            1
diff --git a/include/linux/fb.h b/include/linux/fb.h
index b468bf496547..bc24beeed971 100644
--- a/include/linux/fb.h
+++ b/include/linux/fb.h
@@ -524,11 +524,11 @@ struct fb_pixmap {
         u32 offset;             /* current offset to buffer             */
         u32 buf_align;          /* byte alignment of each bitmap        */
         u32 scan_align;         /* alignment per scanline               */
-        u32 access_align;       /* alignment per read/write             */
+        u32 access_align;       /* alignment per read/write (bits)      */
         u32 flags;              /* see FB_PIXMAP_*                      */
         /* access methods */
-        void (*outbuf)(struct fb_info *info, u8 *addr, u8 *src, unsigned int size);
-        u8   (*inbuf) (struct fb_info *info, u8 *addr);
+        void (*writeio)(struct fb_info *info, void __iomem *dst, void *src, unsigned int size);
+        void (*readio) (struct fb_info *info, void *dst, void __iomem *src, unsigned int size);
 };
 
 
@@ -816,18 +816,9 @@ extern int unregister_framebuffer(struct fb_info *fb_info);
 extern int fb_prepare_logo(struct fb_info *fb_info);
 extern int fb_show_logo(struct fb_info *fb_info);
 extern char* fb_get_buffer_offset(struct fb_info *info, struct fb_pixmap *buf, u32 size);
-extern void fb_iomove_buf_unaligned(struct fb_info *info, struct fb_pixmap *buf,
-                                u8 *dst, u32 d_pitch, u8 *src, u32 idx,
+extern void fb_pad_unaligned_buffer(u8 *dst, u32 d_pitch, u8 *src, u32 idx,
                                 u32 height, u32 shift_high, u32 shift_low, u32 mod);
-extern void fb_iomove_buf_aligned(struct fb_info *info, struct fb_pixmap *buf,
-                                u8 *dst, u32 d_pitch, u8 *src, u32 s_pitch,
-                                u32 height);
-extern void fb_sysmove_buf_unaligned(struct fb_info *info, struct fb_pixmap *buf,
-                                u8 *dst, u32 d_pitch, u8 *src, u32 idx,
-                                u32 height, u32 shift_high, u32 shift_low, u32 mod);
-extern void fb_sysmove_buf_aligned(struct fb_info *info, struct fb_pixmap *buf,
-                                u8 *dst, u32 d_pitch, u8 *src, u32 s_pitch,
-                                u32 height);
+extern void fb_pad_aligned_buffer(u8 *dst, u32 d_pitch, u8 *src, u32 s_pitch, u32 height);
 extern void fb_set_suspend(struct fb_info *info, int state);
 extern int fb_get_color_depth(struct fb_var_screeninfo *var);
 extern int fb_get_options(char *name, char **option);
diff --git a/include/linux/font.h b/include/linux/font.h
index fc2d690c9d5f..8fc80a7d78ac 100644
--- a/include/linux/font.h
+++ b/include/linux/font.h
@@ -25,19 +25,23 @@ struct font_desc {
 #define VGA8x16_IDX     1
 #define PEARL8x8_IDX    2
 #define VGA6x11_IDX     3
-#define SUN8x16_IDX     4
-#define SUN12x22_IDX    5
-#define ACORN8x8_IDX    6
-#define MINI4x6_IDX     7
+#define FONT7x14_IDX    4
+#define FONT10x18_IDX   5
+#define SUN8x16_IDX     6
+#define SUN12x22_IDX    7
+#define ACORN8x8_IDX    8
+#define MINI4x6_IDX     9
 
 extern struct font_desc font_vga_8x8,
-                                font_vga_8x16,
-                                font_pearl_8x8,
-                                font_vga_6x11,
-                                font_sun_8x16,
-                                font_sun_12x22,
-                                font_acorn_8x8,
-                                font_mini_4x6;
+                        font_vga_8x16,
+                        font_pearl_8x8,
+                        font_vga_6x11,
+                        font_7x14,
+                        font_10x18,
+                        font_sun_8x16,
+                        font_sun_12x22,
+                        font_acorn_8x8,
+                        font_mini_4x6;
 
 /* Find a font with a specific name */
 
diff --git a/include/linux/fsl_devices.h b/include/linux/fsl_devices.h
index faaff4c64559..70f54af87b9f 100644
--- a/include/linux/fsl_devices.h
+++ b/include/linux/fsl_devices.h
@@ -51,6 +51,7 @@ struct gianfar_platform_data {
 
         /* board specific information */
         u32 board_flags;
+        u32 phy_flags;
         u32 phyid;
         u32 interruptPHY;
         u8 mac_addr[6];
@@ -61,9 +62,14 @@ struct gianfar_platform_data {
 #define FSL_GIANFAR_DEV_HAS_COALESCE            0x00000002
 #define FSL_GIANFAR_DEV_HAS_RMON                0x00000004
 #define FSL_GIANFAR_DEV_HAS_MULTI_INTR          0x00000008
+#define FSL_GIANFAR_DEV_HAS_CSUM                0x00000010
+#define FSL_GIANFAR_DEV_HAS_VLAN                0x00000020
+#define FSL_GIANFAR_DEV_HAS_EXTENDED_HASH       0x00000040
+#define FSL_GIANFAR_DEV_HAS_PADDING             0x00000080
 
 /* Flags in gianfar_platform_data */
-#define FSL_GIANFAR_BRD_HAS_PHY_INTR    0x00000001      /* if not set use a timer */
+#define FSL_GIANFAR_BRD_HAS_PHY_INTR    0x00000001 /* set or use a timer */
+#define FSL_GIANFAR_BRD_IS_REDUCED      0x00000002 /* Set if RGMII, RMII */
 
 struct fsl_i2c_platform_data {
         /* device specific information */
diff --git a/include/linux/genalloc.h b/include/linux/genalloc.h
new file mode 100644
index 000000000000..7fd0576a4454
--- /dev/null
+++ b/include/linux/genalloc.h
@@ -0,0 +1,40 @@
+/*
+ * Basic general purpose allocator for managing special purpose memory
+ * not managed by the regular kmalloc/kfree interface.
+ * Uses for this includes on-device special memory, uncached memory
+ * etc.
+ *
+ * This code is based on the buddy allocator found in the sym53c8xx_2
+ * driver, adapted for general purpose use.
+ *
+ * This source code is licensed under the GNU General Public License,
+ * Version 2.  See the file COPYING for more details.
+ */
+
+#include <linux/spinlock.h>
+
+#define ALLOC_MIN_SHIFT         5 /* 32 bytes minimum */
+/*
+ *  Link between free memory chunks of a given size.
+ */
+struct gen_pool_link {
+        struct gen_pool_link *next;
+};
+
+/*
+ *  Memory pool descriptor.
+ */
+struct gen_pool {
+        spinlock_t lock;
+        unsigned long (*get_new_chunk)(struct gen_pool *);
+        struct gen_pool *next;
+        struct gen_pool_link *h;
+        unsigned long private;
+        int max_chunk_shift;
+};
+
+unsigned long gen_pool_alloc(struct gen_pool *poolp, int size);
+void gen_pool_free(struct gen_pool *mp, unsigned long ptr, int size);
+struct gen_pool *gen_pool_create(int nr_chunks, int max_chunk_shift,
+                                 unsigned long (*fp)(struct gen_pool *),
+                                 unsigned long data);
diff --git a/include/linux/gfp.h b/include/linux/gfp.h
index af7407e8cfc5..8d6bf608b199 100644
--- a/include/linux/gfp.h
+++ b/include/linux/gfp.h
@@ -39,6 +39,7 @@ struct vm_area_struct;
 #define __GFP_COMP      0x4000u /* Add compound page metadata */
 #define __GFP_ZERO      0x8000u /* Return zeroed page on success */
 #define __GFP_NOMEMALLOC 0x10000u /* Don't use emergency reserves */
+#define __GFP_NORECLAIM  0x20000u /* No realy zone reclaim during allocation */
 
 #define __GFP_BITS_SHIFT 20     /* Room for 20 __GFP_FOO bits */
 #define __GFP_BITS_MASK ((1 << __GFP_BITS_SHIFT) - 1)
@@ -47,7 +48,7 @@ struct vm_area_struct;
 #define GFP_LEVEL_MASK (__GFP_WAIT|__GFP_HIGH|__GFP_IO|__GFP_FS| \
                         __GFP_COLD|__GFP_NOWARN|__GFP_REPEAT| \
                         __GFP_NOFAIL|__GFP_NORETRY|__GFP_NO_GROW|__GFP_COMP| \
-                        __GFP_NOMEMALLOC)
+                        __GFP_NOMEMALLOC|__GFP_NORECLAIM)
 
 #define GFP_ATOMIC      (__GFP_HIGH)
 #define GFP_NOIO        (__GFP_WAIT)
@@ -132,5 +133,10 @@ extern void FASTCALL(free_cold_page(struct page *page));
 #define free_page(addr) free_pages((addr),0)
 
 void page_alloc_init(void);
+#ifdef CONFIG_NUMA
+void drain_remote_pages(void);
+#else
+static inline void drain_remote_pages(void) { };
+#endif
 
 #endif /* __LINUX_GFP_H */
diff --git a/include/linux/hugetlb.h b/include/linux/hugetlb.h
index 6af1ae4a8211..f529d1442815 100644
--- a/include/linux/hugetlb.h
+++ b/include/linux/hugetlb.h
@@ -4,6 +4,7 @@
 #ifdef CONFIG_HUGETLB_PAGE
 
 #include <linux/mempolicy.h>
+#include <asm/tlbflush.h>
 
 struct ctl_table;
 
@@ -22,12 +23,6 @@ int hugetlb_report_meminfo(char *);
 int hugetlb_report_node_meminfo(int, char *);
 int is_hugepage_mem_enough(size_t);
 unsigned long hugetlb_total_pages(void);
-struct page *follow_huge_addr(struct mm_struct *mm, unsigned long address,
-                              int write);
-struct page *follow_huge_pmd(struct mm_struct *mm, unsigned long address,
-                                pmd_t *pmd, int write);
-int is_aligned_hugepage_range(unsigned long addr, unsigned long len);
-int pmd_huge(pmd_t pmd);
 struct page *alloc_huge_page(void);
 void free_huge_page(struct page *);
 
@@ -35,6 +30,17 @@ extern unsigned long max_huge_pages;
 extern const unsigned long hugetlb_zero, hugetlb_infinity;
 extern int sysctl_hugetlb_shm_group;
 
+/* arch callbacks */
+
+pte_t *huge_pte_alloc(struct mm_struct *mm, unsigned long addr);
+pte_t *huge_pte_offset(struct mm_struct *mm, unsigned long addr);
+struct page *follow_huge_addr(struct mm_struct *mm, unsigned long address,
+                              int write);
+struct page *follow_huge_pmd(struct mm_struct *mm, unsigned long address,
+                                pmd_t *pmd, int write);
+int is_aligned_hugepage_range(unsigned long addr, unsigned long len);
+int pmd_huge(pmd_t pmd);
+
 #ifndef ARCH_HAS_HUGEPAGE_ONLY_RANGE
 #define is_hugepage_only_range(mm, addr, len)   0
 #define hugetlb_free_pgd_range(tlb, addr, end, floor, ceiling) \
@@ -48,6 +54,28 @@ extern int sysctl_hugetlb_shm_group;
 int prepare_hugepage_range(unsigned long addr, unsigned long len);
 #endif
 
+#ifndef ARCH_HAS_SETCLEAR_HUGE_PTE
+#define set_huge_pte_at(mm, addr, ptep, pte)    set_pte_at(mm, addr, ptep, pte)
+#define huge_ptep_get_and_clear(mm, addr, ptep) ptep_get_and_clear(mm, addr, ptep)
+#else
+void set_huge_pte_at(struct mm_struct *mm, unsigned long addr,
+                     pte_t *ptep, pte_t pte);
+pte_t huge_ptep_get_and_clear(struct mm_struct *mm, unsigned long addr,
+                              pte_t *ptep);
+#endif
+
+#ifndef ARCH_HAS_HUGETLB_PREFAULT_HOOK
+#define hugetlb_prefault_arch_hook(mm)          do { } while (0)
+#else
+void hugetlb_prefault_arch_hook(struct mm_struct *mm);
+#endif
+
+#ifndef ARCH_HAS_HUGETLB_CLEAN_STALE_PGTABLE
+#define hugetlb_clean_stale_pgtable(pte)        BUG()
+#else
+void hugetlb_clean_stale_pgtable(pte_t *pte);
+#endif
+
 #else /* !CONFIG_HUGETLB_PAGE */
 
 static inline int is_vm_hugetlb_page(struct vm_area_struct *vma)
diff --git a/include/linux/ioc4.h b/include/linux/ioc4.h
new file mode 100644
index 000000000000..3dd18b785ebd
--- /dev/null
+++ b/include/linux/ioc4.h
@@ -0,0 +1,179 @@
+/*
+ * 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 Silicon Graphics, Inc.  All Rights Reserved.
+ */
+
+#ifndef _LINUX_IOC4_H
+#define _LINUX_IOC4_H
+
+#include <linux/interrupt.h>
+
+/***************
+ * Definitions *
+ ***************/
+
+/* Miscellaneous values inherent to hardware */
+
+#define IOC4_EXTINT_COUNT_DIVISOR 520   /* PCI clocks per COUNT tick */
+
+/***********************************
+ * Structures needed by subdrivers *
+ ***********************************/
+
+/* This structure fully describes the IOC4 miscellaneous registers which
+ * appear at bar[0]+0x00000 through bar[0]+0x0005c.  The corresponding
+ * PCI resource is managed by the main IOC4 driver because it contains
+ * registers of interest to many different IOC4 subdrivers.
+ */
+struct ioc4_misc_regs {
+        /* Miscellaneous IOC4 registers */
+        union ioc4_pci_err_addr_l {
+                uint32_t raw;
+                struct {
+                        uint32_t valid:1;       /* Address captured */
+                        uint32_t master_id:4;   /* Unit causing error
+                                                 * 0/1: Serial port 0 TX/RX
+                                                 * 2/3: Serial port 1 TX/RX
+                                                 * 4/5: Serial port 2 TX/RX
+                                                 * 6/7: Serial port 3 TX/RX
+                                                 * 8: ATA/ATAPI
+                                                 * 9-15: Undefined
+                                                 */
+                        uint32_t mul_err:1;     /* Multiple errors occurred */
+                        uint32_t addr:26;       /* Bits 31-6 of error addr */
+                } fields;
+        } pci_err_addr_l;
+        uint32_t pci_err_addr_h;        /* Bits 63-32 of error addr */
+        union ioc4_sio_int {
+                uint32_t raw;
+                struct {
+                        uint8_t tx_mt:1;        /* TX ring buffer empty */
+                        uint8_t rx_full:1;      /* RX ring buffer full */
+                        uint8_t rx_high:1;      /* RX high-water exceeded */
+                        uint8_t rx_timer:1;     /* RX timer has triggered */
+                        uint8_t delta_dcd:1;    /* DELTA_DCD seen */
+                        uint8_t delta_cts:1;    /* DELTA_CTS seen */
+                        uint8_t intr_pass:1;    /* Interrupt pass-through */
+                        uint8_t tx_explicit:1;  /* TX, MCW, or delay complete */
+                } fields[4];
+        } sio_ir;               /* Serial interrupt state */
+        union ioc4_other_int {
+                uint32_t raw;
+                struct {
+                        uint32_t ata_int:1;     /* ATA port passthru */
+                        uint32_t ata_memerr:1;  /* ATA halted by mem error */
+                        uint32_t memerr:4;      /* Serial halted by mem err */
+                        uint32_t kbd_int:1;     /* kbd/mouse intr asserted */
+                        uint32_t reserved:16;   /* zero */
+                        uint32_t rt_int:1;      /* INT_OUT section latch */
+                        uint32_t gen_int:8;     /* Intr. from generic pins */
+                } fields;
+        } other_ir;             /* Other interrupt state */
+        union ioc4_sio_int sio_ies;     /* Serial interrupt enable set */
+        union ioc4_other_int other_ies; /* Other interrupt enable set */
+        union ioc4_sio_int sio_iec;     /* Serial interrupt enable clear */
+        union ioc4_other_int other_iec; /* Other interrupt enable clear */
+        union ioc4_sio_cr {
+                uint32_t raw;
+                struct {
+                        uint32_t cmd_pulse:4;   /* Bytebus strobe width */
+                        uint32_t arb_diag:3;    /* PCI bus requester */
+                        uint32_t sio_diag_idle:1;       /* Active ser req? */
+                        uint32_t ata_diag_idle:1;       /* Active ATA req? */
+                        uint32_t ata_diag_active:1;     /* ATA req is winner */
+                        uint32_t reserved:22;   /* zero */
+                } fields;
+        } sio_cr;
+        uint32_t unused1;
+        union ioc4_int_out {
+                uint32_t raw;
+                struct {
+                        uint32_t count:16;      /* Period control */
+                        uint32_t mode:3;        /* Output signal shape */
+                        uint32_t reserved:11;   /* zero */
+                        uint32_t diag:1;        /* Timebase control */
+                        uint32_t int_out:1;     /* Current value */
+                } fields;
+        } int_out;              /* External interrupt output control */
+        uint32_t unused2;
+        union ioc4_gpcr {
+                uint32_t raw;
+                struct {
+                        uint32_t dir:8; /* Pin direction */
+                        uint32_t edge:8;        /* Edge/level mode */
+                        uint32_t reserved1:4;   /* zero */
+                        uint32_t int_out_en:1;  /* INT_OUT enable */
+                        uint32_t reserved2:11;  /* zero */
+                } fields;
+        } gpcr_s;               /* Generic PIO control set */
+        union ioc4_gpcr gpcr_c; /* Generic PIO control clear */
+        union ioc4_gpdr {
+                uint32_t raw;
+                struct {
+                        uint32_t gen_pin:8;     /* State of pins */
+                        uint32_t reserved:24;
+                } fields;
+        } gpdr;                 /* Generic PIO data */
+        uint32_t unused3;
+        union ioc4_gppr {
+                uint32_t raw;
+                struct {
+                        uint32_t gen_pin:1;     /* Single pin state */
+                        uint32_t reserved:31;
+                } fields;
+        } gppr[8];              /* Generic PIO pins */
+};
+
+/* Masks for GPCR DIR pins */
+#define IOC4_GPCR_DIR_0 0x01    /* External interrupt output */
+#define IOC4_GPCR_DIR_1 0x02    /* External interrupt input */
+#define IOC4_GPCR_DIR_2 0x04
+#define IOC4_GPCR_DIR_3 0x08    /* Keyboard/mouse presence */
+#define IOC4_GPCR_DIR_4 0x10    /* Ser. port 0 xcvr select (0=232, 1=422) */
+#define IOC4_GPCR_DIR_5 0x20    /* Ser. port 1 xcvr select (0=232, 1=422) */
+#define IOC4_GPCR_DIR_6 0x40    /* Ser. port 2 xcvr select (0=232, 1=422) */
+#define IOC4_GPCR_DIR_7 0x80    /* Ser. port 3 xcvr select (0=232, 1=422) */
+
+/* Masks for GPCR EDGE pins */
+#define IOC4_GPCR_EDGE_0 0x01
+#define IOC4_GPCR_EDGE_1 0x02   /* External interrupt input */
+#define IOC4_GPCR_EDGE_2 0x04
+#define IOC4_GPCR_EDGE_3 0x08
+#define IOC4_GPCR_EDGE_4 0x10
+#define IOC4_GPCR_EDGE_5 0x20
+#define IOC4_GPCR_EDGE_6 0x40
+#define IOC4_GPCR_EDGE_7 0x80
+
+/* One of these per IOC4 */
+struct ioc4_driver_data {
+        struct list_head idd_list;
+        unsigned long idd_bar0;
+        struct pci_dev *idd_pdev;
+        const struct pci_device_id *idd_pci_id;
+        struct __iomem ioc4_misc_regs *idd_misc_regs;
+        unsigned long count_period;
+        void *idd_serial_data;
+};
+
+/* One per submodule */
+struct ioc4_submodule {
+        struct list_head is_list;
+        char *is_name;
+        struct module *is_owner;
+        int (*is_probe) (struct ioc4_driver_data *);
+        int (*is_remove) (struct ioc4_driver_data *);
+};
+
+#define IOC4_NUM_CARDS          8       /* max cards per partition */
+
+/**********************************
+ * Functions needed by submodules *
+ **********************************/
+
+extern int ioc4_register_submodule(struct ioc4_submodule *);
+extern void ioc4_unregister_submodule(struct ioc4_submodule *);
+
+#endif                          /* _LINUX_IOC4_H */
diff --git a/include/linux/ioc4_common.h b/include/linux/ioc4_common.h
deleted file mode 100644
index b03bcc46df55..000000000000
--- a/include/linux/ioc4_common.h
+++ /dev/null
@@ -1,21 +0,0 @@
-/*
- * 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 Silicon Graphics, Inc.  All Rights Reserved.
- */
-
-#ifndef _LINUX_IOC4_COMMON_H
-#define _LINUX_IOC4_COMMON_H
-
-/* prototypes */
-
-int ioc4_serial_init(void);
-
-int ioc4_serial_attach_one(struct pci_dev *pdev, const struct
-                                pci_device_id *pci_id);
-int ioc4_ide_attach_one(struct pci_dev *pdev, const struct
-                                pci_device_id *pci_id);
-
-#endif  /* _LINUX_IOC4_COMMON_H */
diff --git a/include/linux/irq.h b/include/linux/irq.h
index c3ff4d101667..7fc1022be9ee 100644
--- a/include/linux/irq.h
+++ b/include/linux/irq.h
@@ -47,6 +47,10 @@ struct hw_interrupt_type {
         void (*ack)(unsigned int irq);
         void (*end)(unsigned int irq);
         void (*set_affinity)(unsigned int irq, cpumask_t dest);
+        /* Currently used only by UML, might disappear one day.*/
+#ifdef CONFIG_IRQ_RELEASE_METHOD
+        void (*release)(unsigned int irq, void *dev_id);
+#endif
 };
 
 typedef struct hw_interrupt_type  hw_irq_controller;
diff --git a/include/linux/mm.h b/include/linux/mm.h
index 17518fe0b311..1813b162b0a8 100644
--- a/include/linux/mm.h
+++ b/include/linux/mm.h
@@ -691,6 +691,12 @@ extern void show_mem(void);
 extern void si_meminfo(struct sysinfo * val);
 extern void si_meminfo_node(struct sysinfo *val, int nid);
 
+#ifdef CONFIG_NUMA
+extern void setup_per_cpu_pageset(void);
+#else
+static inline void setup_per_cpu_pageset(void) {}
+#endif
+
 /* prio_tree.c */
 void vma_prio_tree_add(struct vm_area_struct *, struct vm_area_struct *old);
 void vma_prio_tree_insert(struct vm_area_struct *, struct prio_tree_root *);
diff --git a/include/linux/mmzone.h b/include/linux/mmzone.h
index e530c6c092f1..4733d35d8223 100644
--- a/include/linux/mmzone.h
+++ b/include/linux/mmzone.h
@@ -63,6 +63,12 @@ struct per_cpu_pageset {
 #endif
 } ____cacheline_aligned_in_smp;
 
+#ifdef CONFIG_NUMA
+#define zone_pcp(__z, __cpu) ((__z)->pageset[(__cpu)])
+#else
+#define zone_pcp(__z, __cpu) (&(__z)->pageset[(__cpu)])
+#endif
+
 #define ZONE_DMA                0
 #define ZONE_NORMAL             1
 #define ZONE_HIGHMEM            2
@@ -122,8 +128,11 @@ struct zone {
          */
         unsigned long           lowmem_reserve[MAX_NR_ZONES];
 
+#ifdef CONFIG_NUMA
+        struct per_cpu_pageset  *pageset[NR_CPUS];
+#else
         struct per_cpu_pageset  pageset[NR_CPUS];
-
+#endif
         /*
          * free areas of different sizes
          */
@@ -145,6 +154,14 @@ struct zone {
         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;
+
+        /*
          * 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()
@@ -381,7 +398,7 @@ int lowmem_reserve_ratio_sysctl_handler(struct ctl_table *, int, struct file *,
 
 #include <linux/topology.h>
 /* Returns the number of the current Node. */
-#define numa_node_id()          (cpu_to_node(_smp_processor_id()))
+#define numa_node_id()          (cpu_to_node(raw_smp_processor_id()))
 
 #ifndef CONFIG_DISCONTIGMEM
 
diff --git a/include/linux/netfilter_ipv4.h b/include/linux/netfilter_ipv4.h
index 9e5750079e09..3ebc36afae1a 100644
--- a/include/linux/netfilter_ipv4.h
+++ b/include/linux/netfilter_ipv4.h
@@ -75,12 +75,6 @@ enum nf_ip_hook_priorities {
 #define SO_ORIGINAL_DST 80
 
 #ifdef __KERNEL__
-#ifdef CONFIG_NETFILTER_DEBUG
-void nf_debug_ip_local_deliver(struct sk_buff *skb);
-void nf_debug_ip_loopback_xmit(struct sk_buff *newskb);
-void nf_debug_ip_finish_output2(struct sk_buff *skb);
-#endif /*CONFIG_NETFILTER_DEBUG*/
-
 extern int ip_route_me_harder(struct sk_buff **pskb);
 
 /* Call this before modifying an existing IP packet: ensures it is
diff --git a/include/linux/netfilter_ipv4/ip_conntrack_core.h b/include/linux/netfilter_ipv4/ip_conntrack_core.h
index d84be02cb4fc..694aec9b4784 100644
--- a/include/linux/netfilter_ipv4/ip_conntrack_core.h
+++ b/include/linux/netfilter_ipv4/ip_conntrack_core.h
@@ -1,7 +1,6 @@
 #ifndef _IP_CONNTRACK_CORE_H
 #define _IP_CONNTRACK_CORE_H
 #include <linux/netfilter.h>
-#include <linux/netfilter_ipv4/lockhelp.h>
 
 /* This header is used to share core functionality between the
    standalone connection tracking module, and the compatibility layer's use
@@ -47,6 +46,6 @@ static inline int ip_conntrack_confirm(struct sk_buff **pskb)
 
 extern struct list_head *ip_conntrack_hash;
 extern struct list_head ip_conntrack_expect_list;
-DECLARE_RWLOCK_EXTERN(ip_conntrack_lock);
+extern rwlock_t ip_conntrack_lock;
 #endif /* _IP_CONNTRACK_CORE_H */
 
diff --git a/include/linux/netfilter_ipv4/ip_nat.h b/include/linux/netfilter_ipv4/ip_nat.h
index 2b72b86176f0..e201ec6e9905 100644
--- a/include/linux/netfilter_ipv4/ip_nat.h
+++ b/include/linux/netfilter_ipv4/ip_nat.h
@@ -50,10 +50,9 @@ struct ip_nat_multi_range_compat
 
 #ifdef __KERNEL__
 #include <linux/list.h>
-#include <linux/netfilter_ipv4/lockhelp.h>
 
 /* Protects NAT hash tables, and NAT-private part of conntracks. */
-DECLARE_RWLOCK_EXTERN(ip_nat_lock);
+extern rwlock_t ip_nat_lock;
 
 /* The structure embedded in the conntrack structure. */
 struct ip_nat_info
diff --git a/include/linux/netfilter_ipv4/listhelp.h b/include/linux/netfilter_ipv4/listhelp.h
index f2ae7c5e57bb..360429f48737 100644
--- a/include/linux/netfilter_ipv4/listhelp.h
+++ b/include/linux/netfilter_ipv4/listhelp.h
@@ -2,7 +2,6 @@
 #define _LISTHELP_H
 #include <linux/config.h>
 #include <linux/list.h>
-#include <linux/netfilter_ipv4/lockhelp.h>
 
 /* Header to do more comprehensive job than linux/list.h; assume list
    is first entry in structure. */
diff --git a/include/linux/netfilter_ipv4/lockhelp.h b/include/linux/netfilter_ipv4/lockhelp.h
deleted file mode 100644
index a3288633ab46..000000000000
--- a/include/linux/netfilter_ipv4/lockhelp.h
+++ /dev/null
@@ -1,129 +0,0 @@
-#ifndef _LOCKHELP_H
-#define _LOCKHELP_H
-#include <linux/config.h>
-
-#include <linux/spinlock.h>
-#include <asm/atomic.h>
-#include <linux/interrupt.h>
-#include <linux/smp.h>
-
-/* Header to do help in lock debugging. */
-
-#ifdef CONFIG_NETFILTER_DEBUG
-struct spinlock_debug
-{
-        spinlock_t l;
-        atomic_t locked_by;
-};
-
-struct rwlock_debug
-{
-        rwlock_t l;
-        long read_locked_map;
-        long write_locked_map;
-};
-
-#define DECLARE_LOCK(l)                                                 \
-struct spinlock_debug l = { SPIN_LOCK_UNLOCKED, ATOMIC_INIT(-1) }
-#define DECLARE_LOCK_EXTERN(l)                  \
-extern struct spinlock_debug l
-#define DECLARE_RWLOCK(l)                               \
-struct rwlock_debug l = { RW_LOCK_UNLOCKED, 0, 0 }
-#define DECLARE_RWLOCK_EXTERN(l)                \
-extern struct rwlock_debug l
-
-#define MUST_BE_LOCKED(l)                                               \
-do { if (atomic_read(&(l)->locked_by) != smp_processor_id())            \
-        printk("ASSERT %s:%u %s unlocked\n", __FILE__, __LINE__, #l);   \
-} while(0)
-
-#define MUST_BE_UNLOCKED(l)                                             \
-do { if (atomic_read(&(l)->locked_by) == smp_processor_id())            \
-        printk("ASSERT %s:%u %s locked\n", __FILE__, __LINE__, #l);     \
-} while(0)
-
-/* Write locked OK as well. */
-#define MUST_BE_READ_LOCKED(l)                                              \
-do { if (!((l)->read_locked_map & (1UL << smp_processor_id()))              \
-         && !((l)->write_locked_map & (1UL << smp_processor_id())))         \
-        printk("ASSERT %s:%u %s not readlocked\n", __FILE__, __LINE__, #l); \
-} while(0)
-
-#define MUST_BE_WRITE_LOCKED(l)                                              \
-do { if (!((l)->write_locked_map & (1UL << smp_processor_id())))             \
-        printk("ASSERT %s:%u %s not writelocked\n", __FILE__, __LINE__, #l); \
-} while(0)
-
-#define MUST_BE_READ_WRITE_UNLOCKED(l)                                    \
-do { if ((l)->read_locked_map & (1UL << smp_processor_id()))              \
-        printk("ASSERT %s:%u %s readlocked\n", __FILE__, __LINE__, #l);   \
- else if ((l)->write_locked_map & (1UL << smp_processor_id()))            \
-         printk("ASSERT %s:%u %s writelocked\n", __FILE__, __LINE__, #l); \
-} while(0)
-
-#define LOCK_BH(lk)                                             \
-do {                                                            \
-        MUST_BE_UNLOCKED(lk);                                   \
-        spin_lock_bh(&(lk)->l);                                 \
-        atomic_set(&(lk)->locked_by, smp_processor_id());       \
-} while(0)
-
-#define UNLOCK_BH(lk)                           \
-do {                                            \
-        MUST_BE_LOCKED(lk);                     \
-        atomic_set(&(lk)->locked_by, -1);       \
-        spin_unlock_bh(&(lk)->l);               \
-} while(0)
-
-#define READ_LOCK(lk)                                           \
-do {                                                            \
-        MUST_BE_READ_WRITE_UNLOCKED(lk);                        \
-        read_lock_bh(&(lk)->l);                                 \
-        set_bit(smp_processor_id(), &(lk)->read_locked_map);    \
-} while(0)
-
-#define WRITE_LOCK(lk)                                                    \
-do {                                                                      \
-        MUST_BE_READ_WRITE_UNLOCKED(lk);                                  \
-        write_lock_bh(&(lk)->l);                                          \
-        set_bit(smp_processor_id(), &(lk)->write_locked_map);             \
-} while(0)
-
-#define READ_UNLOCK(lk)                                                 \
-do {                                                                    \
-        if (!((lk)->read_locked_map & (1UL << smp_processor_id())))     \
-                printk("ASSERT: %s:%u %s not readlocked\n",             \
-                       __FILE__, __LINE__, #lk);                        \
-        clear_bit(smp_processor_id(), &(lk)->read_locked_map);          \
-        read_unlock_bh(&(lk)->l);                                       \
-} while(0)
-
-#define WRITE_UNLOCK(lk)                                        \
-do {                                                            \
-        MUST_BE_WRITE_LOCKED(lk);                               \
-        clear_bit(smp_processor_id(), &(lk)->write_locked_map); \
-        write_unlock_bh(&(lk)->l);                              \
-} while(0)
-
-#else
-#define DECLARE_LOCK(l) spinlock_t l = SPIN_LOCK_UNLOCKED
-#define DECLARE_LOCK_EXTERN(l) extern spinlock_t l
-#define DECLARE_RWLOCK(l) rwlock_t l = RW_LOCK_UNLOCKED
-#define DECLARE_RWLOCK_EXTERN(l) extern rwlock_t l
-
-#define MUST_BE_LOCKED(l)
-#define MUST_BE_UNLOCKED(l)
-#define MUST_BE_READ_LOCKED(l)
-#define MUST_BE_WRITE_LOCKED(l)
-#define MUST_BE_READ_WRITE_UNLOCKED(l)
-
-#define LOCK_BH(l) spin_lock_bh(l)
-#define UNLOCK_BH(l) spin_unlock_bh(l)
-
-#define READ_LOCK(l) read_lock_bh(l)
-#define WRITE_LOCK(l) write_lock_bh(l)
-#define READ_UNLOCK(l) read_unlock_bh(l)
-#define WRITE_UNLOCK(l) write_unlock_bh(l)
-#endif /*CONFIG_NETFILTER_DEBUG*/
-
-#endif /* _LOCKHELP_H */
diff --git a/include/linux/netlink.h b/include/linux/netlink.h
index 561d4dc75836..3029cad63a01 100644
--- a/include/linux/netlink.h
+++ b/include/linux/netlink.h
@@ -147,7 +147,7 @@ struct netlink_callback
         int             (*dump)(struct sk_buff * skb, struct netlink_callback *cb);
         int             (*done)(struct netlink_callback *cb);
         int             family;
-        long            args[4];
+        long            args[5];
 };
 
 struct netlink_notify
diff --git a/include/linux/page-flags.h b/include/linux/page-flags.h
index 39ab8c6b5652..f5a6695d4d21 100644
--- a/include/linux/page-flags.h
+++ b/include/linux/page-flags.h
@@ -61,21 +61,20 @@
 #define PG_active                6
 #define PG_slab                  7      /* slab debug (Suparna wants this) */
 
-#define PG_highmem               8
-#define PG_checked               9      /* kill me in 2.5.<early>. */
-#define PG_arch_1               10
-#define PG_reserved             11
-
-#define PG_private              12      /* Has something at ->private */
-#define PG_writeback            13      /* Page is under writeback */
-#define PG_nosave               14      /* Used for system suspend/resume */
-#define PG_compound             15      /* Part of a compound page */
-
-#define PG_swapcache            16      /* Swap page: swp_entry_t in private */
-#define PG_mappedtodisk         17      /* Has blocks allocated on-disk */
-#define PG_reclaim              18      /* To be reclaimed asap */
-#define PG_nosave_free          19      /* Free, should not be written */
-#define PG_uncached             20      /* Page has been mapped as uncached */
+#define PG_checked               8      /* kill me in 2.5.<early>. */
+#define PG_arch_1                9
+#define PG_reserved             10
+#define PG_private              11      /* Has something at ->private */
+
+#define PG_writeback            12      /* Page is under writeback */
+#define PG_nosave               13      /* Used for system suspend/resume */
+#define PG_compound             14      /* Part of a compound page */
+#define PG_swapcache            15      /* Swap page: swp_entry_t in private */
+
+#define PG_mappedtodisk         16      /* Has blocks allocated on-disk */
+#define PG_reclaim              17      /* To be reclaimed asap */
+#define PG_nosave_free          18      /* Free, should not be written */
+#define PG_uncached             19      /* Page has been mapped as uncached */
 
 /*
  * Global page accounting.  One instance per CPU.  Only unsigned longs are
@@ -136,8 +135,8 @@ struct page_state {
 
 extern void get_page_state(struct page_state *ret);
 extern void get_full_page_state(struct page_state *ret);
-extern unsigned long __read_page_state(unsigned offset);
-extern void __mod_page_state(unsigned offset, unsigned long delta);
+extern unsigned long __read_page_state(unsigned long offset);
+extern void __mod_page_state(unsigned long offset, unsigned long delta);
 
 #define read_page_state(member) \
         __read_page_state(offsetof(struct page_state, member))
@@ -215,7 +214,7 @@ extern void __mod_page_state(unsigned offset, unsigned long delta);
 #define TestSetPageSlab(page)   test_and_set_bit(PG_slab, &(page)->flags)
 
 #ifdef CONFIG_HIGHMEM
-#define PageHighMem(page)       test_bit(PG_highmem, &(page)->flags)
+#define PageHighMem(page)       is_highmem(page_zone(page))
 #else
 #define PageHighMem(page)       0 /* needed to optimize away at compile time */
 #endif
diff --git a/include/linux/pagemap.h b/include/linux/pagemap.h
index 0422031161ba..d9a25647a295 100644
--- a/include/linux/pagemap.h
+++ b/include/linux/pagemap.h
@@ -52,12 +52,12 @@ void release_pages(struct page **pages, int nr, int cold);
 
 static inline struct page *page_cache_alloc(struct address_space *x)
 {
-        return alloc_pages(mapping_gfp_mask(x), 0);
+        return alloc_pages(mapping_gfp_mask(x)|__GFP_NORECLAIM, 0);
 }
 
 static inline struct page *page_cache_alloc_cold(struct address_space *x)
 {
-        return alloc_pages(mapping_gfp_mask(x)|__GFP_COLD, 0);
+        return alloc_pages(mapping_gfp_mask(x)|__GFP_COLD|__GFP_NORECLAIM, 0);
 }
 
 typedef int filler_t(void *, struct page *);
diff --git a/include/linux/pci_ids.h b/include/linux/pci_ids.h
index b8b4ebf9abf1..63e89e47b8e9 100644
--- a/include/linux/pci_ids.h
+++ b/include/linux/pci_ids.h
@@ -575,6 +575,7 @@
 #define PCI_DEVICE_ID_CT_65550          0x00e0
 #define PCI_DEVICE_ID_CT_65554          0x00e4
 #define PCI_DEVICE_ID_CT_65555          0x00e5
+#define PCI_DEVICE_ID_CT_69000          0x00c0
 
 #define PCI_VENDOR_ID_MIRO              0x1031
 #define PCI_DEVICE_ID_MIRO_36050        0x5601
diff --git a/include/linux/raid/bitmap.h b/include/linux/raid/bitmap.h
new file mode 100644
index 000000000000..e24b74b11150
--- /dev/null
+++ b/include/linux/raid/bitmap.h
@@ -0,0 +1,273 @@
+/*
+ * bitmap.h: Copyright (C) Peter T. Breuer (ptb@ot.uc3m.es) 2003
+ *
+ * additions: Copyright (C) 2003-2004, Paul Clements, SteelEye Technology, Inc.
+ */
+#ifndef BITMAP_H
+#define BITMAP_H 1
+
+#define BITMAP_MAJOR 3
+#define BITMAP_MINOR 38
+
+/*
+ * in-memory bitmap:
+ *
+ * Use 16 bit block counters to track pending writes to each "chunk".
+ * The 2 high order bits are special-purpose, the first is a flag indicating
+ * whether a resync is needed.  The second is a flag indicating whether a
+ * resync is active.
+ * This means that the counter is actually 14 bits:
+ *
+ * +--------+--------+------------------------------------------------+
+ * | resync | resync |               counter                          |
+ * | needed | active |                                                |
+ * |  (0-1) |  (0-1) |              (0-16383)                         |
+ * +--------+--------+------------------------------------------------+
+ *
+ * The "resync needed" bit is set when:
+ *    a '1' bit is read from storage at startup.
+ *    a write request fails on some drives
+ *    a resync is aborted on a chunk with 'resync active' set
+ * It is cleared (and resync-active set) when a resync starts across all drives
+ * of the chunk.
+ *
+ *
+ * The "resync active" bit is set when:
+ *    a resync is started on all drives, and resync_needed is set.
+ *       resync_needed will be cleared (as long as resync_active wasn't already set).
+ * It is cleared when a resync completes.
+ *
+ * The counter counts pending write requests, plus the on-disk bit.
+ * When the counter is '1' and the resync bits are clear, the on-disk
+ * bit can be cleared aswell, thus setting the counter to 0.
+ * When we set a bit, or in the counter (to start a write), if the fields is
+ * 0, we first set the disk bit and set the counter to 1.
+ *
+ * If the counter is 0, the on-disk bit is clear and the stipe is clean
+ * Anything that dirties the stipe pushes the counter to 2 (at least)
+ * and sets the on-disk bit (lazily).
+ * If a periodic sweep find the counter at 2, it is decremented to 1.
+ * If the sweep find the counter at 1, the on-disk bit is cleared and the
+ * counter goes to zero.
+ *
+ * Also, we'll hijack the "map" pointer itself and use it as two 16 bit block
+ * counters as a fallback when "page" memory cannot be allocated:
+ *
+ * Normal case (page memory allocated):
+ *
+ *     page pointer (32-bit)
+ *
+ *     [ ] ------+
+ *               |
+ *               +-------> [   ][   ]..[   ] (4096 byte page == 2048 counters)
+ *                          c1   c2    c2048
+ *
+ * Hijacked case (page memory allocation failed):
+ *
+ *     hijacked page pointer (32-bit)
+ *
+ *     [                  ][              ] (no page memory allocated)
+ *      counter #1 (16-bit) counter #2 (16-bit)
+ *
+ */
+
+#ifdef __KERNEL__
+
+#define PAGE_BITS (PAGE_SIZE << 3)
+#define PAGE_BIT_SHIFT (PAGE_SHIFT + 3)
+
+typedef __u16 bitmap_counter_t;
+#define COUNTER_BITS 16
+#define COUNTER_BIT_SHIFT 4
+#define COUNTER_BYTE_RATIO (COUNTER_BITS / 8)
+#define COUNTER_BYTE_SHIFT (COUNTER_BIT_SHIFT - 3)
+
+#define NEEDED_MASK ((bitmap_counter_t) (1 << (COUNTER_BITS - 1)))
+#define RESYNC_MASK ((bitmap_counter_t) (1 << (COUNTER_BITS - 2)))
+#define COUNTER_MAX ((bitmap_counter_t) RESYNC_MASK - 1)
+#define NEEDED(x) (((bitmap_counter_t) x) & NEEDED_MASK)
+#define RESYNC(x) (((bitmap_counter_t) x) & RESYNC_MASK)
+#define COUNTER(x) (((bitmap_counter_t) x) & COUNTER_MAX)
+
+/* how many counters per page? */
+#define PAGE_COUNTER_RATIO (PAGE_BITS / COUNTER_BITS)
+/* same, except a shift value for more efficient bitops */
+#define PAGE_COUNTER_SHIFT (PAGE_BIT_SHIFT - COUNTER_BIT_SHIFT)
+/* same, except a mask value for more efficient bitops */
+#define PAGE_COUNTER_MASK  (PAGE_COUNTER_RATIO - 1)
+
+#define BITMAP_BLOCK_SIZE 512
+#define BITMAP_BLOCK_SHIFT 9
+
+/* how many blocks per chunk? (this is variable) */
+#define CHUNK_BLOCK_RATIO(bitmap) ((bitmap)->chunksize >> BITMAP_BLOCK_SHIFT)
+#define CHUNK_BLOCK_SHIFT(bitmap) ((bitmap)->chunkshift - BITMAP_BLOCK_SHIFT)
+#define CHUNK_BLOCK_MASK(bitmap) (CHUNK_BLOCK_RATIO(bitmap) - 1)
+
+/* when hijacked, the counters and bits represent even larger "chunks" */
+/* there will be 1024 chunks represented by each counter in the page pointers */
+#define PAGEPTR_BLOCK_RATIO(bitmap) \
+                        (CHUNK_BLOCK_RATIO(bitmap) << PAGE_COUNTER_SHIFT >> 1)
+#define PAGEPTR_BLOCK_SHIFT(bitmap) \
+                        (CHUNK_BLOCK_SHIFT(bitmap) + PAGE_COUNTER_SHIFT - 1)
+#define PAGEPTR_BLOCK_MASK(bitmap) (PAGEPTR_BLOCK_RATIO(bitmap) - 1)
+
+/*
+ * on-disk bitmap:
+ *
+ * Use one bit per "chunk" (block set). We do the disk I/O on the bitmap
+ * file a page at a time. There's a superblock at the start of the file.
+ */
+
+/* map chunks (bits) to file pages - offset by the size of the superblock */
+#define CHUNK_BIT_OFFSET(chunk) ((chunk) + (sizeof(bitmap_super_t) << 3))
+
+#endif
+
+/*
+ * bitmap structures:
+ */
+
+#define BITMAP_MAGIC 0x6d746962
+
+/* use these for bitmap->flags and bitmap->sb->state bit-fields */
+enum bitmap_state {
+        BITMAP_ACTIVE = 0x001, /* the bitmap is in use */
+        BITMAP_STALE  = 0x002  /* the bitmap file is out of date or had -EIO */
+};
+
+/* the superblock at the front of the bitmap file -- little endian */
+typedef struct bitmap_super_s {
+        __u32 magic;        /*  0  BITMAP_MAGIC */
+        __u32 version;      /*  4  the bitmap major for now, could change... */
+        __u8  uuid[16];     /*  8  128 bit uuid - must match md device uuid */
+        __u64 events;       /* 24  event counter for the bitmap (1)*/
+        __u64 events_cleared;/*32  event counter when last bit cleared (2) */
+        __u64 sync_size;    /* 40  the size of the md device's sync range(3) */
+        __u32 state;        /* 48  bitmap state information */
+        __u32 chunksize;    /* 52  the bitmap chunk size in bytes */
+        __u32 daemon_sleep; /* 56  seconds between disk flushes */
+
+        __u8  pad[256 - 60]; /* set to zero */
+} bitmap_super_t;
+
+/* notes:
+ * (1) This event counter is updated before the eventcounter in the md superblock
+ *    When a bitmap is loaded, it is only accepted if this event counter is equal
+ *    to, or one greater than, the event counter in the superblock.
+ * (2) This event counter is updated when the other one is *if*and*only*if* the
+ *    array is not degraded.  As bits are not cleared when the array is degraded,
+ *    this represents the last time that any bits were cleared.
+ *    If a device is being added that has an event count with this value or
+ *    higher, it is accepted as conforming to the bitmap.
+ * (3)This is the number of sectors represented by the bitmap, and is the range that
+ *    resync happens across.  For raid1 and raid5/6 it is the size of individual
+ *    devices.  For raid10 it is the size of the array.
+ */
+
+#ifdef __KERNEL__
+
+/* the in-memory bitmap is represented by bitmap_pages */
+struct bitmap_page {
+        /*
+         * map points to the actual memory page
+         */
+        char *map;
+        /*
+         * in emergencies (when map cannot be alloced), hijack the map
+         * pointer and use it as two counters itself
+         */
+        unsigned int hijacked:1;
+        /*
+         * count of dirty bits on the page
+         */
+        unsigned int  count:31;
+};
+
+/* keep track of bitmap file pages that have pending writes on them */
+struct page_list {
+        struct list_head list;
+        struct page *page;
+};
+
+/* the main bitmap structure - one per mddev */
+struct bitmap {
+        struct bitmap_page *bp;
+        unsigned long pages; /* total number of pages in the bitmap */
+        unsigned long missing_pages; /* number of pages not yet allocated */
+
+        mddev_t *mddev; /* the md device that the bitmap is for */
+
+        int counter_bits; /* how many bits per block counter */
+
+        /* bitmap chunksize -- how much data does each bit represent? */
+        unsigned long chunksize;
+        unsigned long chunkshift; /* chunksize = 2^chunkshift (for bitops) */
+        unsigned long chunks; /* total number of data chunks for the array */
+
+        /* We hold a count on the chunk currently being synced, and drop
+         * it when the last block is started.  If the resync is aborted
+         * midway, we need to be able to drop that count, so we remember
+         * the counted chunk..
+         */
+        unsigned long syncchunk;
+
+        __u64   events_cleared;
+
+        /* bitmap spinlock */
+        spinlock_t lock;
+
+        long offset; /* offset from superblock if file is NULL */
+        struct file *file; /* backing disk file */
+        struct page *sb_page; /* cached copy of the bitmap file superblock */
+        struct page **filemap; /* list of cache pages for the file */
+        unsigned long *filemap_attr; /* attributes associated w/ filemap pages */
+        unsigned long file_pages; /* number of pages in the file */
+
+        unsigned long flags;
+
+        /*
+         * the bitmap daemon - periodically wakes up and sweeps the bitmap
+         * file, cleaning up bits and flushing out pages to disk as necessary
+         */
+        unsigned long daemon_lastrun; /* jiffies of last run */
+        unsigned long daemon_sleep; /* how many seconds between updates? */
+
+        /*
+         * bitmap_writeback_daemon waits for file-pages that have been written,
+         * as there is no way to get a call-back when a page write completes.
+         */
+        mdk_thread_t *writeback_daemon;
+        spinlock_t write_lock;
+        wait_queue_head_t write_wait;
+        struct list_head complete_pages;
+        mempool_t *write_pool;
+};
+
+/* the bitmap API */
+
+/* these are used only by md/bitmap */
+int  bitmap_create(mddev_t *mddev);
+void bitmap_destroy(mddev_t *mddev);
+int  bitmap_active(struct bitmap *bitmap);
+
+char *file_path(struct file *file, char *buf, int count);
+void bitmap_print_sb(struct bitmap *bitmap);
+int bitmap_update_sb(struct bitmap *bitmap);
+
+int  bitmap_setallbits(struct bitmap *bitmap);
+void bitmap_write_all(struct bitmap *bitmap);
+
+/* these are exported */
+int bitmap_startwrite(struct bitmap *bitmap, sector_t offset, unsigned long sectors);
+void bitmap_endwrite(struct bitmap *bitmap, sector_t offset, unsigned long sectors,
+                     int success);
+int bitmap_start_sync(struct bitmap *bitmap, sector_t offset, int *blocks);
+void bitmap_end_sync(struct bitmap *bitmap, sector_t offset, int *blocks, int aborted);
+void bitmap_close_sync(struct bitmap *bitmap);
+
+int bitmap_unplug(struct bitmap *bitmap);
+int bitmap_daemon_work(struct bitmap *bitmap);
+#endif
+
+#endif
diff --git a/include/linux/raid/md.h b/include/linux/raid/md.h
index a6a67d102bfa..ffa316ce4dc8 100644
--- a/include/linux/raid/md.h
+++ b/include/linux/raid/md.h
@@ -60,7 +60,14 @@
  */
 #define MD_MAJOR_VERSION                0
 #define MD_MINOR_VERSION                90
-#define MD_PATCHLEVEL_VERSION           1
+/*
+ * MD_PATCHLEVEL_VERSION indicates kernel functionality.
+ * >=1 means different superblock formats are selectable using SET_ARRAY_INFO
+ *     and major_version/minor_version accordingly
+ * >=2 means that Internal bitmaps are supported by setting MD_SB_BITMAP_PRESENT
+ *     in the super status byte
+ */
+#define MD_PATCHLEVEL_VERSION           2
 
 extern int register_md_personality (int p_num, mdk_personality_t *p);
 extern int unregister_md_personality (int p_num);
@@ -69,7 +76,7 @@ extern mdk_thread_t * md_register_thread (void (*run) (mddev_t *mddev),
 extern void md_unregister_thread (mdk_thread_t *thread);
 extern void md_wakeup_thread(mdk_thread_t *thread);
 extern void md_check_recovery(mddev_t *mddev);
-extern void md_write_start(mddev_t *mddev);
+extern void md_write_start(mddev_t *mddev, struct bio *bi);
 extern void md_write_end(mddev_t *mddev);
 extern void md_handle_safemode(mddev_t *mddev);
 extern void md_done_sync(mddev_t *mddev, int blocks, int ok);
@@ -78,6 +85,12 @@ extern void md_unplug_mddev(mddev_t *mddev);
 
 extern void md_print_devices (void);
 
+extern void md_super_write(mddev_t *mddev, mdk_rdev_t *rdev,
+                           sector_t sector, int size, struct page *page);
+extern int sync_page_io(struct block_device *bdev, sector_t sector, int size,
+                        struct page *page, int rw);
+
+
 #define MD_BUG(x...) { printk("md: bug in file %s, line %d\n", __FILE__, __LINE__); md_print_devices(); }
 
 #endif 
diff --git a/include/linux/raid/md_k.h b/include/linux/raid/md_k.h
index c9a0d4013be7..8c14ba565a45 100644
--- a/include/linux/raid/md_k.h
+++ b/include/linux/raid/md_k.h
@@ -15,6 +15,9 @@
 #ifndef _MD_K_H
 #define _MD_K_H
 
+/* and dm-bio-list.h is not under include/linux because.... ??? */
+#include "../../../drivers/md/dm-bio-list.h"
+
 #define MD_RESERVED       0UL
 #define LINEAR            1UL
 #define RAID0             2UL
@@ -180,6 +183,10 @@ struct mdk_rdev_s
 
         int desc_nr;                    /* descriptor index in the superblock */
         int raid_disk;                  /* role of device in array */
+        int saved_raid_disk;            /* role that device used to have in the
+                                         * array and could again if we did a partial
+                                         * resync from the bitmap
+                                         */
 
         atomic_t        nr_pending;     /* number of pending requests.
                                          * only maintained for arrays that
@@ -252,6 +259,11 @@ struct mddev_s
         atomic_t                        recovery_active; /* blocks scheduled, but not written */
         wait_queue_head_t               recovery_wait;
         sector_t                        recovery_cp;
+
+        spinlock_t                      write_lock;
+        wait_queue_head_t               sb_wait;        /* for waiting on superblock updates */
+        atomic_t                        pending_writes; /* number of active superblock writes */
+
         unsigned int                    safemode;       /* if set, update "clean" superblock
                                                          * when no writes pending.
                                                          */ 
@@ -260,6 +272,13 @@ struct mddev_s
         atomic_t                        writes_pending; 
         request_queue_t                 *queue; /* for plugging ... */
 
+        struct bitmap                   *bitmap; /* the bitmap for the device */
+        struct file                     *bitmap_file; /* the bitmap file */
+        long                            bitmap_offset; /* offset from superblock of
+                                                        * start of bitmap. May be
+                                                        * negative, but not '0'
+                                                        */
+
         struct list_head                all_mddevs;
 };
 
@@ -291,7 +310,7 @@ struct mdk_personality_s
         int (*hot_add_disk) (mddev_t *mddev, mdk_rdev_t *rdev);
         int (*hot_remove_disk) (mddev_t *mddev, int number);
         int (*spare_active) (mddev_t *mddev);
-        int (*sync_request)(mddev_t *mddev, sector_t sector_nr, int go_faster);
+        sector_t (*sync_request)(mddev_t *mddev, sector_t sector_nr, int *skipped, int go_faster);
         int (*resize) (mddev_t *mddev, sector_t sectors);
         int (*reshape) (mddev_t *mddev, int raid_disks);
         int (*reconfig) (mddev_t *mddev, int layout, int chunk_size);
@@ -334,6 +353,7 @@ typedef struct mdk_thread_s {
         unsigned long           flags;
         struct completion       *event;
         struct task_struct      *tsk;
+        unsigned long           timeout;
         const char              *name;
 } mdk_thread_t;
 
diff --git a/include/linux/raid/md_p.h b/include/linux/raid/md_p.h
index 8ba95d67329f..dc65cd435494 100644
--- a/include/linux/raid/md_p.h
+++ b/include/linux/raid/md_p.h
@@ -96,6 +96,7 @@ typedef struct mdp_device_descriptor_s {
 #define MD_SB_CLEAN             0
 #define MD_SB_ERRORS            1
 
+#define MD_SB_BITMAP_PRESENT    8 /* bitmap may be present nearby */
 typedef struct mdp_superblock_s {
         /*
          * Constant generic information
@@ -184,7 +185,7 @@ struct mdp_superblock_1 {
         /* constant array information - 128 bytes */
         __u32   magic;          /* MD_SB_MAGIC: 0xa92b4efc - little endian */
         __u32   major_version;  /* 1 */
-        __u32   feature_map;    /* 0 for now */
+        __u32   feature_map;    /* bit 0 set if 'bitmap_offset' is meaningful */
         __u32   pad0;           /* always set to 0 when writing */
 
         __u8    set_uuid[16];   /* user-space generated. */
@@ -197,7 +198,11 @@ struct mdp_superblock_1 {
 
         __u32   chunksize;      /* in 512byte sectors */
         __u32   raid_disks;
-        __u8    pad1[128-96];   /* set to 0 when written */
+        __u32   bitmap_offset;  /* sectors after start of superblock that bitmap starts
+                                 * NOTE: signed, so bitmap can be before superblock
+                                 * only meaningful of feature_map[0] is set.
+                                 */
+        __u8    pad1[128-100];  /* set to 0 when written */
 
         /* constant this-device information - 64 bytes */
         __u64   data_offset;    /* sector start of data, often 0 */
diff --git a/include/linux/raid/md_u.h b/include/linux/raid/md_u.h
index a2df5c2a42af..81da20ccec4d 100644
--- a/include/linux/raid/md_u.h
+++ b/include/linux/raid/md_u.h
@@ -23,6 +23,7 @@
 #define GET_DISK_INFO           _IOR (MD_MAJOR, 0x12, mdu_disk_info_t)
 #define PRINT_RAID_DEBUG        _IO (MD_MAJOR, 0x13)
 #define RAID_AUTORUN            _IO (MD_MAJOR, 0x14)
+#define GET_BITMAP_FILE         _IOR (MD_MAJOR, 0x15, mdu_bitmap_file_t)
 
 /* configuration */
 #define CLEAR_ARRAY             _IO (MD_MAJOR, 0x20)
@@ -36,6 +37,7 @@
 #define HOT_ADD_DISK            _IO (MD_MAJOR, 0x28)
 #define SET_DISK_FAULTY         _IO (MD_MAJOR, 0x29)
 #define HOT_GENERATE_ERROR      _IO (MD_MAJOR, 0x2a)
+#define SET_BITMAP_FILE         _IOW (MD_MAJOR, 0x2b, int)
 
 /* usage */
 #define RUN_ARRAY               _IOW (MD_MAJOR, 0x30, mdu_param_t)
@@ -106,6 +108,11 @@ typedef struct mdu_start_info_s {
 
 } mdu_start_info_t;
 
+typedef struct mdu_bitmap_file_s
+{
+        char pathname[4096];
+} mdu_bitmap_file_t;
+
 typedef struct mdu_param_s
 {
         int                     personality;    /* 1,2,3,4 */
diff --git a/include/linux/raid/raid1.h b/include/linux/raid/raid1.h
index abbfdd9afe1e..9d93cf12e890 100644
--- a/include/linux/raid/raid1.h
+++ b/include/linux/raid/raid1.h
@@ -36,12 +36,21 @@ struct r1_private_data_s {
         spinlock_t              device_lock;
 
         struct list_head        retry_list;
+        /* queue pending writes and submit them on unplug */
+        struct bio_list         pending_bio_list;
+        /* queue of writes that have been unplugged */
+        struct bio_list         flushing_bio_list;
+
         /* for use when syncing mirrors: */
 
         spinlock_t              resync_lock;
-        int nr_pending;
-        int barrier;
+        int                     nr_pending;
+        int                     barrier;
         sector_t                next_resync;
+        int                     fullsync;  /* set to 1 if a full sync is needed,
+                                            * (fresh device added).
+                                            * Cleared when a sync completes.
+                                            */
 
         wait_queue_head_t       wait_idle;
         wait_queue_head_t       wait_resume;
@@ -85,14 +94,17 @@ struct r1bio_s {
         int                     read_disk;
 
         struct list_head        retry_list;
+        struct bitmap_update    *bitmap_update;
         /*
          * if the IO is in WRITE direction, then multiple bios are used.
          * We choose the number when they are allocated.
          */
         struct bio              *bios[0];
+        /* DO NOT PUT ANY NEW FIELDS HERE - bios array is contiguously alloced*/
 };
 
 /* bits for r1bio.state */
 #define R1BIO_Uptodate  0
 #define R1BIO_IsSync    1
+#define R1BIO_Degraded  2
 #endif
diff --git a/include/linux/sched.h b/include/linux/sched.h
index 4dbb109022f3..b58afd97a180 100644
--- a/include/linux/sched.h
+++ b/include/linux/sched.h
@@ -201,8 +201,8 @@ extern unsigned long
 arch_get_unmapped_area_topdown(struct file *filp, unsigned long addr,
                           unsigned long len, unsigned long pgoff,
                           unsigned long flags);
-extern void arch_unmap_area(struct vm_area_struct *area);
-extern void arch_unmap_area_topdown(struct vm_area_struct *area);
+extern void arch_unmap_area(struct mm_struct *, unsigned long);
+extern void arch_unmap_area_topdown(struct mm_struct *, unsigned long);
 
 #define set_mm_counter(mm, member, value) (mm)->_##member = (value)
 #define get_mm_counter(mm, member) ((mm)->_##member)
@@ -218,9 +218,10 @@ struct mm_struct {
         unsigned long (*get_unmapped_area) (struct file *filp,
                                 unsigned long addr, unsigned long len,
                                 unsigned long pgoff, unsigned long flags);
-        void (*unmap_area) (struct vm_area_struct *area);
-        unsigned long mmap_base;                /* base of mmap area */
-        unsigned long free_area_cache;          /* first hole */
+        void (*unmap_area) (struct mm_struct *mm, unsigned long addr);
+        unsigned long mmap_base;                /* base of mmap area */
+        unsigned long cached_hole_size;         /* if non-zero, the largest hole below free_area_cache */
+        unsigned long free_area_cache;          /* first hole of size cached_hole_size or larger */
         pgd_t * pgd;
         atomic_t mm_users;                      /* How many users with user space? */
         atomic_t mm_count;                      /* How many references to "struct mm_struct" (users count as 1) */
diff --git a/include/linux/skbuff.h b/include/linux/skbuff.h
index cc04f5cd2286..d7c839a21842 100644
--- a/include/linux/skbuff.h
+++ b/include/linux/skbuff.h
@@ -193,7 +193,6 @@ struct skb_shared_info {
  *      @nfcache: Cache info
  *      @nfct: Associated connection, if any
  *      @nfctinfo: Relationship of this skb to the connection
- *      @nf_debug: Netfilter debugging
  *      @nf_bridge: Saved data about a bridged frame - see br_netfilter.c
  *      @private: Data which is private to the HIPPI implementation
  *      @tc_index: Traffic control index
@@ -264,9 +263,6 @@ struct sk_buff {
         __u32                   nfcache;
         __u32                   nfctinfo;
         struct nf_conntrack     *nfct;
-#ifdef CONFIG_NETFILTER_DEBUG
-        unsigned int            nf_debug;
-#endif
 #ifdef CONFIG_BRIDGE_NETFILTER
         struct nf_bridge_info   *nf_bridge;
 #endif
@@ -1219,15 +1215,6 @@ static inline void nf_reset(struct sk_buff *skb)
 {
         nf_conntrack_put(skb->nfct);
         skb->nfct = NULL;
-#ifdef CONFIG_NETFILTER_DEBUG
-        skb->nf_debug = 0;
-#endif
-}
-static inline void nf_reset_debug(struct sk_buff *skb)
-{
-#ifdef CONFIG_NETFILTER_DEBUG
-        skb->nf_debug = 0;
-#endif
 }
 
 #ifdef CONFIG_BRIDGE_NETFILTER
diff --git a/include/linux/smp.h b/include/linux/smp.h
index dcf1db3b35d3..9dfa3ee769ae 100644
--- a/include/linux/smp.h
+++ b/include/linux/smp.h
@@ -92,10 +92,7 @@ void smp_prepare_boot_cpu(void);
 /*
  *      These macros fold the SMP functionality into a single CPU system
  */
-
-#if !defined(__smp_processor_id) || !defined(CONFIG_PREEMPT)
-# define smp_processor_id()                     0
-#endif
+#define raw_smp_processor_id()                  0
 #define hard_smp_processor_id()                 0
 #define smp_call_function(func,info,retry,wait) ({ 0; })
 #define on_each_cpu(func,info,retry,wait)       ({ func(info); 0; })
@@ -106,30 +103,25 @@ static inline void smp_send_reschedule(int cpu) { }
 #endif /* !SMP */
 
 /*
- * DEBUG_PREEMPT support: check whether smp_processor_id() is being
- * used in a preemption-safe way.
+ * smp_processor_id(): get the current CPU ID.
  *
- * An architecture has to enable this debugging code explicitly.
- * It can do so by renaming the smp_processor_id() macro to
- * __smp_processor_id().  This should only be done after some minimal
- * testing, because usually there are a number of false positives
- * that an architecture will trigger.
+ * if DEBUG_PREEMPT is enabled the we check whether it is
+ * used in a preemption-safe way. (smp_processor_id() is safe
+ * if it's used in a preemption-off critical section, or in
+ * a thread that is bound to the current CPU.)
  *
- * To fix a false positive (i.e. smp_processor_id() use that the
- * debugging code reports but which use for some reason is legal),
- * change the smp_processor_id() reference to _smp_processor_id(),
- * which is the nondebug variant.  NOTE: don't use this to hack around
- * real bugs.
+ * NOTE: raw_smp_processor_id() is for internal use only
+ * (smp_processor_id() is the preferred variant), but in rare
+ * instances it might also be used to turn off false positives
+ * (i.e. smp_processor_id() use that the debugging code reports but
+ * which use for some reason is legal). Don't use this to hack around
+ * the warning message, as your code might not work under PREEMPT.
  */
-#ifdef __smp_processor_id
-# if defined(CONFIG_PREEMPT) && defined(CONFIG_DEBUG_PREEMPT)
-   extern unsigned int smp_processor_id(void);
-# else
-#  define smp_processor_id() __smp_processor_id()
-# endif
-# define _smp_processor_id() __smp_processor_id()
+#ifdef CONFIG_DEBUG_PREEMPT
+  extern unsigned int debug_smp_processor_id(void);
+# define smp_processor_id() debug_smp_processor_id()
 #else
-# define _smp_processor_id() smp_processor_id()
+# define smp_processor_id() raw_smp_processor_id()
 #endif
 
 #define get_cpu()               ({ preempt_disable(); smp_processor_id(); })
diff --git a/include/linux/swap.h b/include/linux/swap.h
index 3bbc41be9bd0..2343f999e6e1 100644
--- a/include/linux/swap.h
+++ b/include/linux/swap.h
@@ -172,7 +172,8 @@ extern int rotate_reclaimable_page(struct page *page);
 extern void swap_setup(void);
 
 /* linux/mm/vmscan.c */
-extern int try_to_free_pages(struct zone **, unsigned int, unsigned int);
+extern int try_to_free_pages(struct zone **, unsigned int);
+extern int zone_reclaim(struct zone *, unsigned int, unsigned int);
 extern int shrink_all_memory(int);
 extern int vm_swappiness;