170 files changed, 2103 insertions, 5400 deletions
diff --git a/include/asm-alpha/bitops.h b/include/asm-alpha/bitops.h
index 302201f1a097..3f88715e811e 100644
--- a/include/asm-alpha/bitops.h
+++ b/include/asm-alpha/bitops.h
@@ -261,7 +261,7 @@ static inline unsigned long ffz_b(unsigned long x)
 static inline unsigned long ffz(unsigned long word)
 {
-#if defined(__alpha_cix__) && defined(__alpha_fix__)
+#if defined(CONFIG_ALPHA_EV6) && defined(CONFIG_ALPHA_EV67)
        /* Whee.  EV67 can calculate it directly.  */
        return __kernel_cttz(~word);
 #else
@@ -281,7 +281,7 @@ static inline unsigned long ffz(unsigned long word)
 */
 static inline unsigned long __ffs(unsigned long word)
 {
-#if defined(__alpha_cix__) && defined(__alpha_fix__)
+#if defined(CONFIG_ALPHA_EV6) && defined(CONFIG_ALPHA_EV67)
        /* Whee.  EV67 can calculate it directly.  */
        return __kernel_cttz(word);
 #else
@@ -313,20 +313,20 @@ static inline int ffs(int word)
 /*
 * fls: find last bit set.
 */
-#if defined(__alpha_cix__) && defined(__alpha_fix__)
+#if defined(CONFIG_ALPHA_EV6) && defined(CONFIG_ALPHA_EV67)
 static inline int fls(int word)
 {
        return 64 - __kernel_ctlz(word & 0xffffffff);
 }
 #else
-#define fls     generic_fls
+#include <asm-generic/bitops/fls.h>
 #endif
-#define fls64   generic_fls64
+#include <asm-generic/bitops/fls64.h>
 /* Compute powers of two for the given integer.  */
 static inline long floor_log2(unsigned long word)
 {
-#if defined(__alpha_cix__) && defined(__alpha_fix__)
+#if defined(CONFIG_ALPHA_EV6) && defined(CONFIG_ALPHA_EV67)
        return 63 - __kernel_ctlz(word);
 #else
        long bit;
@@ -347,7 +347,7 @@ static inline long ceil_log2(unsigned long word)
 * of bits set) of a N-bit word
 */
-#if defined(__alpha_cix__) && defined(__alpha_fix__)
+#if defined(CONFIG_ALPHA_EV6) && defined(CONFIG_ALPHA_EV67)
 /* Whee.  EV67 can calculate it directly.  */
 static inline unsigned long hweight64(unsigned long w)
 {
@@ -358,112 +358,12 @@ static inline unsigned long hweight64(unsigned long w)
 #define hweight16(x)    (unsigned int) hweight64((x) & 0xfffful)
 #define hweight8(x)     (unsigned int) hweight64((x) & 0xfful)
 #else
-static inline unsigned long hweight64(unsigned long w)
+#include <asm-generic/bitops/hweight.h>
-{
-        unsigned long result;
-        for (result = 0; w ; w >>= 1)
-                result += (w & 1);
-        return result;
-}
-#define hweight32(x) generic_hweight32(x)
-#define hweight16(x) generic_hweight16(x)
-#define hweight8(x)  generic_hweight8(x)
 #endif
 #endif /* __KERNEL__ */
-/*
+#include <asm-generic/bitops/find.h>
- * Find next zero bit in a bitmap reasonably efficiently..
- */
-static inline unsigned long
-find_next_zero_bit(const void *addr, unsigned long size, unsigned long offset)
-{
-        const unsigned long *p = addr;
-        unsigned long result = offset & ~63UL;
-        unsigned long tmp;
-        p += offset >> 6;
-        if (offset >= size)
-                return size;
-        size -= result;
-        offset &= 63UL;
-        if (offset) {
-                tmp = *(p++);
-                tmp |= ~0UL >> (64-offset);
-                if (size < 64)
-                        goto found_first;
-                if (~tmp)
-                        goto found_middle;
-                size -= 64;
-                result += 64;
-        }
-        while (size & ~63UL) {
-                if (~(tmp = *(p++)))
-                        goto found_middle;
-                result += 64;
-                size -= 64;
-        }
-        if (!size)
-                return result;
-        tmp = *p;
- found_first:
-        tmp |= ~0UL << size;
-        if (tmp == ~0UL)        /* Are any bits zero? */
-                return result + size; /* Nope. */
- found_middle:
-        return result + ffz(tmp);
-}
-/*
- * Find next one bit in a bitmap reasonably efficiently.
- */
-static inline unsigned long
-find_next_bit(const void * addr, unsigned long size, unsigned long offset)
-{
-        const unsigned long *p = addr;
-        unsigned long result = offset & ~63UL;
-        unsigned long tmp;
-        p += offset >> 6;
-        if (offset >= size)
-                return size;
-        size -= result;
-        offset &= 63UL;
-        if (offset) {
-                tmp = *(p++);
-                tmp &= ~0UL << offset;
-                if (size < 64)
-                        goto found_first;
-                if (tmp)
-                        goto found_middle;
-                size -= 64;
-                result += 64;
-        }
-        while (size & ~63UL) {
-                if ((tmp = *(p++)))
-                        goto found_middle;
-                result += 64;
-                size -= 64;
-        }
-        if (!size)
-                return result;
-        tmp = *p;
- found_first:
-        tmp &= ~0UL >> (64 - size);
-        if (!tmp)
-                return result + size;
- found_middle:
-        return result + __ffs(tmp);
-}
-/*
- * The optimizer actually does good code for this case.
- */
-#define find_first_zero_bit(addr, size) \
-        find_next_zero_bit((addr), (size), 0)
-#define find_first_bit(addr, size) \
-        find_next_bit((addr), (size), 0)
 #ifdef __KERNEL__
@@ -487,21 +387,12 @@ sched_find_first_bit(unsigned long b[3])
        return __ffs(b0) + ofs;
 }
+#include <asm-generic/bitops/ext2-non-atomic.h>
-#define ext2_set_bit                 __test_and_set_bit
 #define ext2_set_bit_atomic(l,n,a)   test_and_set_bit(n,a)
-#define ext2_clear_bit               __test_and_clear_bit
 #define ext2_clear_bit_atomic(l,n,a) test_and_clear_bit(n,a)
-#define ext2_test_bit                test_bit
-#define ext2_find_first_zero_bit     find_first_zero_bit
+#include <asm-generic/bitops/minix.h>
-#define ext2_find_next_zero_bit      find_next_zero_bit
-/* Bitmap functions for the minix filesystem.  */
-#define minix_test_and_set_bit(nr,addr) __test_and_set_bit(nr,addr)
-#define minix_set_bit(nr,addr) __set_bit(nr,addr)
-#define minix_test_and_clear_bit(nr,addr) __test_and_clear_bit(nr,addr)
-#define minix_test_bit(nr,addr) test_bit(nr,addr)
-#define minix_find_first_zero_bit(addr,size) find_first_zero_bit(addr,size)
 #endif /* __KERNEL__ */
diff --git a/include/asm-alpha/fpu.h b/include/asm-alpha/fpu.h
index c203fc2fa5cd..ecb17a72acc3 100644
--- a/include/asm-alpha/fpu.h
+++ b/include/asm-alpha/fpu.h
@@ -130,7 +130,7 @@ rdfpcr(void)
 {
        unsigned long tmp, ret;
-#if defined(__alpha_cix__) || defined(__alpha_fix__)
+#if defined(CONFIG_ALPHA_EV6) || defined(CONFIG_ALPHA_EV67)
        __asm__ __volatile__ (
                "ftoit $f0,%0\n\t"
                "mf_fpcr $f0\n\t"
@@ -154,7 +154,7 @@ wrfpcr(unsigned long val)
 {
        unsigned long tmp;
-#if defined(__alpha_cix__) || defined(__alpha_fix__)
+#if defined(CONFIG_ALPHA_EV6) || defined(CONFIG_ALPHA_EV67)
        __asm__ __volatile__ (
                "ftoit $f0,%0\n\t"
                "itoft %1,$f0\n\t"
diff --git a/include/asm-alpha/mmzone.h b/include/asm-alpha/mmzone.h
index a011ef4cf3d3..192d80c875b0 100644
--- a/include/asm-alpha/mmzone.h
+++ b/include/asm-alpha/mmzone.h
@@ -59,9 +59,6 @@ PLAT_NODE_DATA_LOCALNR(unsigned long p, int n)
 #define kvaddr_to_nid(kaddr)    pa_to_nid(__pa(kaddr))
 #define node_start_pfn(nid)     (NODE_DATA(nid)->node_start_pfn)
-#define local_mapnr(kvaddr) \
-      ((__pa(kvaddr) >> PAGE_SHIFT) - node_start_pfn(kvaddr_to_nid(kvaddr)))
 /*
 * Given a kaddr, LOCAL_BASE_ADDR finds the owning node of the memory
 * and returns the kaddr corresponding to first physical page in the
@@ -86,8 +83,7 @@ PLAT_NODE_DATA_LOCALNR(unsigned long p, int n)
        pte_t pte;                                                           \
        unsigned long pfn;                                                   \
                                                                             \
-        pfn = ((unsigned long)((page)-page_zone(page)->zone_mem_map)) << 32; \
+        pfn = page_to_pfn(page) << 32; \
-        pfn += page_zone(page)->zone_start_pfn << 32;                        \
        pte_val(pte) = pfn | pgprot_val(pgprot);                             \
                                                                             \
        pte;                                                                 \
@@ -104,19 +100,8 @@ PLAT_NODE_DATA_LOCALNR(unsigned long p, int n)
        __xx;                                                           \
 })
-#define pfn_to_page(pfn)                                                \
-({                                                                      \
-        unsigned long kaddr = (unsigned long)__va((pfn) << PAGE_SHIFT); \
-        (NODE_DATA(kvaddr_to_nid(kaddr))->node_mem_map + local_mapnr(kaddr));   \
-})
-#define page_to_pfn(page)                                               \
-        ((page) - page_zone(page)->zone_mem_map +                       \
-         (page_zone(page)->zone_start_pfn))
 #define page_to_pa(page)                                                \
-        ((( (page) - page_zone(page)->zone_mem_map )                    \
+        (page_to_pfn(page) << PAGE_SHIFT)
-        + page_zone(page)->zone_start_pfn) << PAGE_SHIFT)
 #define pfn_to_nid(pfn)         pa_to_nid(((u64)(pfn) << PAGE_SHIFT))
 #define pfn_valid(pfn)                                                  \
diff --git a/include/asm-alpha/page.h b/include/asm-alpha/page.h
index fa0b41b164a7..61bcf70b5eac 100644
--- a/include/asm-alpha/page.h
+++ b/include/asm-alpha/page.h
@@ -85,8 +85,6 @@ typedef unsigned long pgprot_t;
 #define __pa(x)                 ((unsigned long) (x) - PAGE_OFFSET)
 #define __va(x)                 ((void *)((unsigned long) (x) + PAGE_OFFSET))
 #ifndef CONFIG_DISCONTIGMEM
-#define pfn_to_page(pfn)        (mem_map + (pfn))
-#define page_to_pfn(page)       ((unsigned long)((page) - mem_map))
 #define virt_to_page(kaddr)     pfn_to_page(__pa(kaddr) >> PAGE_SHIFT)
 #define pfn_valid(pfn)          ((pfn) < max_mapnr)
@@ -95,9 +93,9 @@ typedef unsigned long pgprot_t;
 #define VM_DATA_DEFAULT_FLAGS           (VM_READ | VM_WRITE | VM_EXEC | \
                                         VM_MAYREAD | VM_MAYWRITE | VM_MAYEXEC)
 #endif /* __KERNEL__ */
+#include <asm-generic/memory_model.h>
 #include <asm-generic/page.h>
 #endif /* _ALPHA_PAGE_H */
diff --git a/include/asm-arm/bitops.h b/include/asm-arm/bitops.h
index d02de721ecc1..0ac54b1a8bad 100644
--- a/include/asm-arm/bitops.h
+++ b/include/asm-arm/bitops.h
@@ -117,65 +117,7 @@ ____atomic_test_and_change_bit(unsigned int bit, volatile unsigned long *p)
        return res & mask;
 }
-/*
+#include <asm-generic/bitops/non-atomic.h>
- * Now the non-atomic variants.  We let the compiler handle all
- * optimisations for these.  These are all _native_ endian.
- */
-static inline void __set_bit(int nr, volatile unsigned long *p)
-{
-        p[nr >> 5] |= (1UL << (nr & 31));
-}
-static inline void __clear_bit(int nr, volatile unsigned long *p)
-{
-        p[nr >> 5] &= ~(1UL << (nr & 31));
-}
-static inline void __change_bit(int nr, volatile unsigned long *p)
-{
-        p[nr >> 5] ^= (1UL << (nr & 31));
-}
-static inline int __test_and_set_bit(int nr, volatile unsigned long *p)
-{
-        unsigned long oldval, mask = 1UL << (nr & 31);
-        p += nr >> 5;
-        oldval = *p;
-        *p = oldval | mask;
-        return oldval & mask;
-}
-static inline int __test_and_clear_bit(int nr, volatile unsigned long *p)
-{
-        unsigned long oldval, mask = 1UL << (nr & 31);
-        p += nr >> 5;
-        oldval = *p;
-        *p = oldval & ~mask;
-        return oldval & mask;
-}
-static inline int __test_and_change_bit(int nr, volatile unsigned long *p)
-{
-        unsigned long oldval, mask = 1UL << (nr & 31);
-        p += nr >> 5;
-        oldval = *p;
-        *p = oldval ^ mask;
-        return oldval & mask;
-}
-/*
- * This routine doesn't need to be atomic.
- */
-static inline int __test_bit(int nr, const volatile unsigned long * p)
-{
-        return (p[nr >> 5] >> (nr & 31)) & 1UL;
-}
 /*
 *  A note about Endian-ness.
@@ -261,7 +203,6 @@ extern int _find_next_bit_be(const unsigned long *p, int size, int offset);
 #define test_and_set_bit(nr,p)          ATOMIC_BITOP_LE(test_and_set_bit,nr,p)
 #define test_and_clear_bit(nr,p)        ATOMIC_BITOP_LE(test_and_clear_bit,nr,p)
 #define test_and_change_bit(nr,p)       ATOMIC_BITOP_LE(test_and_change_bit,nr,p)
-#define test_bit(nr,p)                  __test_bit(nr,p)
 #define find_first_zero_bit(p,sz)       _find_first_zero_bit_le(p,sz)
 #define find_next_zero_bit(p,sz,off)    _find_next_zero_bit_le(p,sz,off)
 #define find_first_bit(p,sz)            _find_first_bit_le(p,sz)
@@ -280,7 +221,6 @@ extern int _find_next_bit_be(const unsigned long *p, int size, int offset);
 #define test_and_set_bit(nr,p)          ATOMIC_BITOP_BE(test_and_set_bit,nr,p)
 #define test_and_clear_bit(nr,p)        ATOMIC_BITOP_BE(test_and_clear_bit,nr,p)
 #define test_and_change_bit(nr,p)       ATOMIC_BITOP_BE(test_and_change_bit,nr,p)
-#define test_bit(nr,p)                  __test_bit(nr,p)
 #define find_first_zero_bit(p,sz)       _find_first_zero_bit_be(p,sz)
 #define find_next_zero_bit(p,sz,off)    _find_next_zero_bit_be(p,sz,off)
 #define find_first_bit(p,sz)            _find_first_bit_be(p,sz)
@@ -292,57 +232,41 @@ extern int _find_next_bit_be(const unsigned long *p, int size, int offset);
 #if __LINUX_ARM_ARCH__ < 5
-/*
+#include <asm-generic/bitops/ffz.h>
- * ffz = Find First Zero in word. Undefined if no zero exists,
+#include <asm-generic/bitops/__ffs.h>
- * so code should check against ~0UL first..
+#include <asm-generic/bitops/fls.h>
- */
+#include <asm-generic/bitops/ffs.h>
-static inline unsigned long ffz(unsigned long word)
-{
-        int k;
-        word = ~word;
-        k = 31;
-        if (word & 0x0000ffff) { k -= 16; word <<= 16; }
-        if (word & 0x00ff0000) { k -= 8;  word <<= 8;  }
-        if (word & 0x0f000000) { k -= 4;  word <<= 4;  }
-        if (word & 0x30000000) { k -= 2;  word <<= 2;  }
-        if (word & 0x40000000) { k -= 1; }
-        return k;
-}
-/*
- * ffz = Find First Zero in word. Undefined if no zero exists,
- * so code should check against ~0UL first..
- */
-static inline unsigned long __ffs(unsigned long word)
-{
-        int k;
-        k = 31;
-        if (word & 0x0000ffff) { k -= 16; word <<= 16; }
-        if (word & 0x00ff0000) { k -= 8;  word <<= 8;  }
-        if (word & 0x0f000000) { k -= 4;  word <<= 4;  }
-        if (word & 0x30000000) { k -= 2;  word <<= 2;  }
-        if (word & 0x40000000) { k -= 1; }
-        return k;
-}
-/*
- * fls: find last bit set.
- */
-#define fls(x) generic_fls(x)
+#else
-#define fls64(x)   generic_fls64(x)
-/*
- * ffs: find first bit set. This is defined the same way as
- * the libc and compiler builtin ffs routines, therefore
- * differs in spirit from the above ffz (man ffs).
- */
-#define ffs(x) generic_ffs(x)
+static inline int constant_fls(int x)
+{
+        int r = 32;
-#else
+        if (!x)
+                return 0;
+        if (!(x & 0xffff0000u)) {
+                x <<= 16;
+                r -= 16;
+        }
+        if (!(x & 0xff000000u)) {
+                x <<= 8;
+                r -= 8;
+        }
+        if (!(x & 0xf0000000u)) {
+                x <<= 4;
+                r -= 4;
+        }
+        if (!(x & 0xc0000000u)) {
+                x <<= 2;
+                r -= 2;
+        }
+        if (!(x & 0x80000000u)) {
+                x <<= 1;
+                r -= 1;
+        }
+        return r;
+}
 /*
 * On ARMv5 and above those functions can be implemented around
@@ -350,39 +274,18 @@ static inline unsigned long __ffs(unsigned long word)
 */
 #define fls(x) \
-        ( __builtin_constant_p(x) ? generic_fls(x) : \
+        ( __builtin_constant_p(x) ? constant_fls(x) : \
          ({ int __r; asm("clz\t%0, %1" : "=r"(__r) : "r"(x) : "cc"); 32-__r; }) )
-#define fls64(x)   generic_fls64(x)
 #define ffs(x) ({ unsigned long __t = (x); fls(__t & -__t); })
 #define __ffs(x) (ffs(x) - 1)
 #define ffz(x) __ffs( ~(x) )
 #endif
-/*
+#include <asm-generic/bitops/fls64.h>
- * Find first bit set in a 168-bit bitmap, where the first
- * 128 bits are unlikely to be set.
- */
-static inline int sched_find_first_bit(const unsigned long *b)
-{
-        unsigned long v;
-        unsigned int off;
-        for (off = 0; v = b[off], off < 4; off++) {
-                if (unlikely(v))
-                        break;
-        }
-        return __ffs(v) + off * 32;
-}
-/*
- * hweightN: returns the hamming weight (i.e. the number
- * of bits set) of a N-bit word
- */
-#define hweight32(x) generic_hweight32(x)
+#include <asm-generic/bitops/sched.h>
-#define hweight16(x) generic_hweight16(x)
+#include <asm-generic/bitops/hweight.h>
-#define hweight8(x) generic_hweight8(x)
 /*
 * Ext2 is defined to use little-endian byte ordering.
@@ -397,7 +300,7 @@ static inline int sched_find_first_bit(const unsigned long *b)
 #define ext2_clear_bit_atomic(lock,nr,p)        \
                test_and_clear_bit(WORD_BITOFF_TO_LE(nr), (unsigned long *)(p))
 #define ext2_test_bit(nr,p)                     \
-                __test_bit(WORD_BITOFF_TO_LE(nr), (unsigned long *)(p))
+                test_bit(WORD_BITOFF_TO_LE(nr), (unsigned long *)(p))
 #define ext2_find_first_zero_bit(p,sz)          \
                _find_first_zero_bit_le(p,sz)
 #define ext2_find_next_zero_bit(p,sz,off)       \
@@ -410,7 +313,7 @@ static inline int sched_find_first_bit(const unsigned long *b)
 #define minix_set_bit(nr,p)                     \
                __set_bit(WORD_BITOFF_TO_LE(nr), (unsigned long *)(p))
 #define minix_test_bit(nr,p)                    \
-                __test_bit(WORD_BITOFF_TO_LE(nr), (unsigned long *)(p))
+                test_bit(WORD_BITOFF_TO_LE(nr), (unsigned long *)(p))
 #define minix_test_and_set_bit(nr,p)            \
                __test_and_set_bit(WORD_BITOFF_TO_LE(nr), (unsigned long *)(p))
 #define minix_test_and_clear_bit(nr,p)          \
diff --git a/include/asm-arm/memory.h b/include/asm-arm/memory.h
index b4e1146ab682..afa5c3ea077c 100644
--- a/include/asm-arm/memory.h
+++ b/include/asm-arm/memory.h
@@ -172,9 +172,7 @@ static inline __deprecated void *bus_to_virt(unsigned long x)
 *  virt_addr_valid(k)  indicates whether a virtual address is valid
 */
 #ifndef CONFIG_DISCONTIGMEM
+#define ARCH_PFN_OFFSET         (PHYS_PFN_OFFSET)
-#define page_to_pfn(page)       (((page) - mem_map) + PHYS_PFN_OFFSET)
-#define pfn_to_page(pfn)        ((mem_map + (pfn)) - PHYS_PFN_OFFSET)
 #define pfn_valid(pfn)          ((pfn) >= PHYS_PFN_OFFSET && (pfn) < (PHYS_PFN_OFFSET + max_mapnr))
 #define virt_to_page(kaddr)     (pfn_to_page(__pa(kaddr) >> PAGE_SHIFT))
@@ -189,13 +187,8 @@ static inline __deprecated void *bus_to_virt(unsigned long x)
 * around in memory.
 */
 #include <linux/numa.h>
+#define arch_pfn_to_nid(pfn)    (PFN_TO_NID(pfn))
-#define page_to_pfn(page)                                       \
+#define arch_local_page_offset(pfn, nid) (LOCAL_MAP_NR((pfn) << PAGE_OFFSET))
-        (( (page) - page_zone(page)->zone_mem_map)              \
-          + page_zone(page)->zone_start_pfn)
-#define pfn_to_page(pfn)                                        \
-        (PFN_TO_MAPBASE(pfn) + LOCAL_MAP_NR((pfn) << PAGE_SHIFT))
 #define pfn_valid(pfn)                                          \
        ({                                                      \
@@ -243,4 +236,6 @@ static inline __deprecated void *bus_to_virt(unsigned long x)
 #endif
+#include <asm-generic/memory_model.h>
 #endif
diff --git a/include/asm-arm/rtc.h b/include/asm-arm/rtc.h
index 370dfe77589d..1a5c9232a91e 100644
--- a/include/asm-arm/rtc.h
+++ b/include/asm-arm/rtc.h
@@ -25,9 +25,6 @@ struct rtc_ops {
        int             (*proc)(char *buf);
 };
-void rtc_time_to_tm(unsigned long, struct rtc_time *);
-int rtc_tm_to_time(struct rtc_time *, unsigned long *);
-int rtc_valid_tm(struct rtc_time *);
 void rtc_next_alarm_time(struct rtc_time *, struct rtc_time *, struct rtc_time *);
 void rtc_update(unsigned long, unsigned long);
 int register_rtc(struct rtc_ops *);
diff --git a/include/asm-arm26/bitops.h b/include/asm-arm26/bitops.h
index d87f8634e625..19a69573a654 100644
--- a/include/asm-arm26/bitops.h
+++ b/include/asm-arm26/bitops.h
@@ -117,65 +117,7 @@ ____atomic_test_and_change_bit(unsigned int bit, volatile unsigned long *p)
        return res & mask;
 }
-/*
+#include <asm-generic/bitops/non-atomic.h>
- * Now the non-atomic variants.  We let the compiler handle all
- * optimisations for these.  These are all _native_ endian.
- */
-static inline void __set_bit(int nr, volatile unsigned long *p)
-{
-        p[nr >> 5] |= (1UL << (nr & 31));
-}
-static inline void __clear_bit(int nr, volatile unsigned long *p)
-{
-        p[nr >> 5] &= ~(1UL << (nr & 31));
-}
-static inline void __change_bit(int nr, volatile unsigned long *p)
-{
-        p[nr >> 5] ^= (1UL << (nr & 31));
-}
-static inline int __test_and_set_bit(int nr, volatile unsigned long *p)
-{
-        unsigned long oldval, mask = 1UL << (nr & 31);
-        p += nr >> 5;
-        oldval = *p;
-        *p = oldval | mask;
-        return oldval & mask;
-}
-static inline int __test_and_clear_bit(int nr, volatile unsigned long *p)
-{
-        unsigned long oldval, mask = 1UL << (nr & 31);
-        p += nr >> 5;
-        oldval = *p;
-        *p = oldval & ~mask;
-        return oldval & mask;
-}
-static inline int __test_and_change_bit(int nr, volatile unsigned long *p)
-{
-        unsigned long oldval, mask = 1UL << (nr & 31);
-        p += nr >> 5;
-        oldval = *p;
-        *p = oldval ^ mask;
-        return oldval & mask;
-}
-/*
- * This routine doesn't need to be atomic.
- */
-static inline int __test_bit(int nr, const volatile unsigned long * p)
-{
-        return (p[nr >> 5] >> (nr & 31)) & 1UL;
-}
 /*
 * Little endian assembly bitops.  nr = 0 -> byte 0 bit 0.
@@ -211,7 +153,6 @@ extern int _find_next_bit_le(const unsigned long *p, int size, int offset);
 #define test_and_set_bit(nr,p)          ATOMIC_BITOP_LE(test_and_set_bit,nr,p)
 #define test_and_clear_bit(nr,p)        ATOMIC_BITOP_LE(test_and_clear_bit,nr,p)
 #define test_and_change_bit(nr,p)       ATOMIC_BITOP_LE(test_and_change_bit,nr,p)
-#define test_bit(nr,p)                  __test_bit(nr,p)
 #define find_first_zero_bit(p,sz)       _find_first_zero_bit_le(p,sz)
 #define find_next_zero_bit(p,sz,off)    _find_next_zero_bit_le(p,sz,off)
 #define find_first_bit(p,sz)            _find_first_bit_le(p,sz)
@@ -219,80 +160,13 @@ extern int _find_next_bit_le(const unsigned long *p, int size, int offset);
 #define WORD_BITOFF_TO_LE(x)            ((x))
-/*
+#include <asm-generic/bitops/ffz.h>
- * ffz = Find First Zero in word. Undefined if no zero exists,
+#include <asm-generic/bitops/__ffs.h>
- * so code should check against ~0UL first..
+#include <asm-generic/bitops/fls.h>
- */
+#include <asm-generic/bitops/fls64.h>
-static inline unsigned long ffz(unsigned long word)
+#include <asm-generic/bitops/ffs.h>
-{
+#include <asm-generic/bitops/sched.h>
-        int k;
+#include <asm-generic/bitops/hweight.h>
-        word = ~word;
-        k = 31;
-        if (word & 0x0000ffff) { k -= 16; word <<= 16; }
-        if (word & 0x00ff0000) { k -= 8;  word <<= 8;  }
-        if (word & 0x0f000000) { k -= 4;  word <<= 4;  }
-        if (word & 0x30000000) { k -= 2;  word <<= 2;  }
-        if (word & 0x40000000) { k -= 1; }
-        return k;
-}
-/*
- * ffz = Find First Zero in word. Undefined if no zero exists,
- * so code should check against ~0UL first..
- */
-static inline unsigned long __ffs(unsigned long word)
-{
-        int k;
-        k = 31;
-        if (word & 0x0000ffff) { k -= 16; word <<= 16; }
-        if (word & 0x00ff0000) { k -= 8;  word <<= 8;  }
-        if (word & 0x0f000000) { k -= 4;  word <<= 4;  }
-        if (word & 0x30000000) { k -= 2;  word <<= 2;  }
-        if (word & 0x40000000) { k -= 1; }
-        return k;
-}
-/*
- * fls: find last bit set.
- */
-#define fls(x) generic_fls(x)
-#define fls64(x)   generic_fls64(x)
-/*
- * ffs: find first bit set. This is defined the same way as
- * the libc and compiler builtin ffs routines, therefore
- * differs in spirit from the above ffz (man ffs).
- */
-#define ffs(x) generic_ffs(x)
-/*
- * Find first bit set in a 168-bit bitmap, where the first
- * 128 bits are unlikely to be set.
- */
-static inline int sched_find_first_bit(unsigned long *b)
-{
-        unsigned long v;
-        unsigned int off;
-        for (off = 0; v = b[off], off < 4; off++) {
-                if (unlikely(v))
-                        break;
-        }
-        return __ffs(v) + off * 32;
-}
-/*
- * hweightN: returns the hamming weight (i.e. the number
- * of bits set) of a N-bit word
- */
-#define hweight32(x) generic_hweight32(x)
-#define hweight16(x) generic_hweight16(x)
-#define hweight8(x) generic_hweight8(x)
 /*
 * Ext2 is defined to use little-endian byte ordering.
@@ -307,7 +181,7 @@ static inline int sched_find_first_bit(unsigned long *b)
 #define ext2_clear_bit_atomic(lock,nr,p)        \
                test_and_clear_bit(WORD_BITOFF_TO_LE(nr), (unsigned long *)(p))
 #define ext2_test_bit(nr,p)                     \
-                __test_bit(WORD_BITOFF_TO_LE(nr), (unsigned long *)(p))
+                test_bit(WORD_BITOFF_TO_LE(nr), (unsigned long *)(p))
 #define ext2_find_first_zero_bit(p,sz)          \
                _find_first_zero_bit_le(p,sz)
 #define ext2_find_next_zero_bit(p,sz,off)       \
@@ -320,7 +194,7 @@ static inline int sched_find_first_bit(unsigned long *b)
 #define minix_set_bit(nr,p)                     \
                __set_bit(WORD_BITOFF_TO_LE(nr), (unsigned long *)(p))
 #define minix_test_bit(nr,p)                    \
-                __test_bit(WORD_BITOFF_TO_LE(nr), (unsigned long *)(p))
+                test_bit(WORD_BITOFF_TO_LE(nr), (unsigned long *)(p))
 #define minix_test_and_set_bit(nr,p)            \
                __test_and_set_bit(WORD_BITOFF_TO_LE(nr), (unsigned long *)(p))
 #define minix_test_and_clear_bit(nr,p)          \
diff --git a/include/asm-arm26/memory.h b/include/asm-arm26/memory.h
index 20d78616f650..a65f10b80dfb 100644
--- a/include/asm-arm26/memory.h
+++ b/include/asm-arm26/memory.h
@@ -81,8 +81,7 @@ static inline void *phys_to_virt(unsigned long x)
 *  virt_to_page(k)     convert a _valid_ virtual address to struct page *
 *  virt_addr_valid(k)  indicates whether a virtual address is valid
 */
-#define page_to_pfn(page)       (((page) - mem_map) + PHYS_PFN_OFFSET)
+#define ARCH_PFN_OFFSET         (PHYS_PFN_OFFSET)
-#define pfn_to_page(pfn)        ((mem_map + (pfn)) - PHYS_PFN_OFFSET)
 #define pfn_valid(pfn)          ((pfn) >= PHYS_PFN_OFFSET && (pfn) < (PHYS_PFN_OFFSET + max_mapnr))
 #define virt_to_page(kaddr)     (pfn_to_page(__pa(kaddr) >> PAGE_SHIFT))
@@ -98,4 +97,5 @@ static inline void *phys_to_virt(unsigned long x)
 */
 #define page_to_bus(page)       (page_address(page))
+#include <asm-generic/memory_model.h>
 #endif
diff --git a/include/asm-cris/bitops.h b/include/asm-cris/bitops.h
index b7fef1572dc0..a569065113d9 100644
--- a/include/asm-cris/bitops.h
+++ b/include/asm-cris/bitops.h
@@ -39,8 +39,6 @@ struct __dummy { unsigned long a[100]; };
 #define set_bit(nr, addr)    (void)test_and_set_bit(nr, addr)
-#define __set_bit(nr, addr)    (void)__test_and_set_bit(nr, addr)
 /*
 * clear_bit - Clears a bit in memory
 * @nr: Bit to clear
@@ -54,8 +52,6 @@ struct __dummy { unsigned long a[100]; };
 #define clear_bit(nr, addr)  (void)test_and_clear_bit(nr, addr)
-#define __clear_bit(nr, addr)  (void)__test_and_clear_bit(nr, addr)
 /*
 * change_bit - Toggle a bit in memory
 * @nr: Bit to change
@@ -68,18 +64,6 @@ struct __dummy { unsigned long a[100]; };
 #define change_bit(nr, addr) (void)test_and_change_bit(nr, addr)
-/*
- * __change_bit - Toggle a bit in memory
- * @nr: the bit to change
- * @addr: the address to start counting from
- *
- * Unlike change_bit(), this function is non-atomic and may be reordered.
- * If it's called on the same region of memory simultaneously, the effect
- * may be that only one operation succeeds.
- */
-#define __change_bit(nr, addr) (void)__test_and_change_bit(nr, addr)
 /**
 * test_and_set_bit - Set a bit and return its old value
 * @nr: Bit to set
@@ -101,19 +85,6 @@ static inline int test_and_set_bit(int nr, volatile unsigned long *addr)
        retval = (mask & *adr) != 0;
        *adr |= mask;
        cris_atomic_restore(addr, flags);
-        local_irq_restore(flags);
-        return retval;
-}
-static inline int __test_and_set_bit(int nr, volatile unsigned long *addr)
-{
-        unsigned int mask, retval;
-        unsigned int *adr = (unsigned int *)addr;
-        
-        adr += nr >> 5;
-        mask = 1 << (nr & 0x1f);
-        retval = (mask & *adr) != 0;
-        *adr |= mask;
        return retval;
 }
@@ -148,27 +119,6 @@ static inline int test_and_clear_bit(int nr, volatile unsigned long *addr)
 }
 /**
- * __test_and_clear_bit - Clear a bit and return its old value
- * @nr: Bit to clear
- * @addr: Address to count from
- *
- * This operation is non-atomic and can be reordered.  
- * If two examples of this operation race, one can appear to succeed
- * but actually fail.  You must protect multiple accesses with a lock.
- */
-static inline int __test_and_clear_bit(int nr, volatile unsigned long *addr)
-{
-        unsigned int mask, retval;
-        unsigned int *adr = (unsigned int *)addr;
-        
-        adr += nr >> 5;
-        mask = 1 << (nr & 0x1f);
-        retval = (mask & *adr) != 0;
-        *adr &= ~mask;
-        return retval;
-}
-/**
 * test_and_change_bit - Change a bit and return its old value
 * @nr: Bit to change
 * @addr: Address to count from
@@ -191,42 +141,7 @@ static inline int test_and_change_bit(int nr, volatile unsigned long *addr)
        return retval;
 }
-/* WARNING: non atomic and it can be reordered! */
+#include <asm-generic/bitops/non-atomic.h>
-static inline int __test_and_change_bit(int nr, volatile unsigned long *addr)
-{
-        unsigned int mask, retval;
-        unsigned int *adr = (unsigned int *)addr;
-        adr += nr >> 5;
-        mask = 1 << (nr & 0x1f);
-        retval = (mask & *adr) != 0;
-        *adr ^= mask;
-        return retval;
-}
-/**
- * test_bit - Determine whether a bit is set
- * @nr: bit number to test
- * @addr: Address to start counting from
- *
- * This routine doesn't need to be atomic.
- */
-static inline int test_bit(int nr, const volatile unsigned long *addr)
-{
-        unsigned int mask;
-        unsigned int *adr = (unsigned int *)addr;
-        
-        adr += nr >> 5;
-        mask = 1 << (nr & 0x1f);
-        return ((mask & *adr) != 0);
-}
-/*
- * Find-bit routines..
- */
 /*
 * Since we define it "external", it collides with the built-in
@@ -235,152 +150,18 @@ static inline int test_bit(int nr, const volatile unsigned long *addr)
 */
 #define ffs kernel_ffs
-/*
+#include <asm-generic/bitops/fls.h>
- * fls: find last bit set.
+#include <asm-generic/bitops/fls64.h>
- */
+#include <asm-generic/bitops/hweight.h>
+#include <asm-generic/bitops/find.h>
-#define fls(x) generic_fls(x)
-#define fls64(x)   generic_fls64(x)
-/*
- * hweightN - returns the hamming weight of a N-bit word
- * @x: the word to weigh
- *
- * The Hamming Weight of a number is the total number of bits set in it.
- */
-#define hweight32(x) generic_hweight32(x)
+#include <asm-generic/bitops/ext2-non-atomic.h>
-#define hweight16(x) generic_hweight16(x)
-#define hweight8(x) generic_hweight8(x)
-/**
- * find_next_zero_bit - find the first zero bit in a memory region
- * @addr: The address to base the search on
- * @offset: The bitnumber to start searching at
- * @size: The maximum size to search
- */
-static inline int find_next_zero_bit (const unsigned long * addr, int size, int offset)
-{
-        unsigned long *p = ((unsigned long *) addr) + (offset >> 5);
-        unsigned long result = offset & ~31UL;
-        unsigned long tmp;
-        
-        if (offset >= size)
-                return size;
-        size -= result;
-        offset &= 31UL;
-        if (offset) {
-                tmp = *(p++);
-                tmp |= ~0UL >> (32-offset);
-                if (size < 32)
-                        goto found_first;
-                if (~tmp)
-                        goto found_middle;
-                size -= 32;
-                result += 32;
-        }
-        while (size & ~31UL) {
-                if (~(tmp = *(p++)))
-                        goto found_middle;
-                result += 32;
-                size -= 32;
-        }
-        if (!size)
-                return result;
-        tmp = *p;
-        
- found_first:
-        tmp |= ~0UL << size;
- found_middle:
-        return result + ffz(tmp);
-}
-/**
- * find_next_bit - find the first set bit in a memory region
- * @addr: The address to base the search on
- * @offset: The bitnumber to start searching at
- * @size: The maximum size to search
- */
-static __inline__ int find_next_bit(const unsigned long *addr, int size, int offset)
-{
-        unsigned long *p = ((unsigned long *) addr) + (offset >> 5);
-        unsigned long result = offset & ~31UL;
-        unsigned long tmp;
-        if (offset >= size)
-                return size;
-        size -= result;
-        offset &= 31UL;
-        if (offset) {
-                tmp = *(p++);
-                tmp &= (~0UL << offset);
-                if (size < 32)
-                        goto found_first;
-                if (tmp)
-                        goto found_middle;
-                size -= 32;
-                result += 32;
-        }
-        while (size & ~31UL) {
-                if ((tmp = *(p++)))
-                        goto found_middle;
-                result += 32;
-                size -= 32;
-        }
-        if (!size)
-                return result;
-        tmp = *p;
-found_first:
-        tmp &= (~0UL >> (32 - size));
-        if (tmp == 0UL)        /* Are any bits set? */
-                return result + size; /* Nope. */
-found_middle:
-        return result + __ffs(tmp);
-}
-/**
- * find_first_zero_bit - find the first zero bit in a memory region
- * @addr: The address to start the search at
- * @size: The maximum size to search
- *
- * Returns the bit-number of the first zero bit, not the number of the byte
- * containing a bit.
- */
-#define find_first_zero_bit(addr, size) \
-        find_next_zero_bit((addr), (size), 0)
-#define find_first_bit(addr, size) \
-        find_next_bit((addr), (size), 0)
-#define ext2_set_bit                 test_and_set_bit
 #define ext2_set_bit_atomic(l,n,a)   test_and_set_bit(n,a)
-#define ext2_clear_bit               test_and_clear_bit
 #define ext2_clear_bit_atomic(l,n,a) test_and_clear_bit(n,a)
-#define ext2_test_bit                test_bit
-#define ext2_find_first_zero_bit     find_first_zero_bit
-#define ext2_find_next_zero_bit      find_next_zero_bit
-/* Bitmap functions for the minix filesystem.  */
-#define minix_set_bit(nr,addr) test_and_set_bit(nr,addr)
-#define minix_clear_bit(nr,addr) test_and_clear_bit(nr,addr)
-#define minix_test_bit(nr,addr) test_bit(nr,addr)
-#define minix_find_first_zero_bit(addr,size) find_first_zero_bit(addr,size)
-static inline int sched_find_first_bit(const unsigned long *b)
+#include <asm-generic/bitops/minix.h>
-{
+#include <asm-generic/bitops/sched.h>
-        if (unlikely(b[0]))
-                return __ffs(b[0]);
-        if (unlikely(b[1]))
-                return __ffs(b[1]) + 32;
-        if (unlikely(b[2]))
-                return __ffs(b[2]) + 64;
-        if (unlikely(b[3]))
-                return __ffs(b[3]) + 96;
-        if (b[4])
-                return __ffs(b[4]) + 128;
-        return __ffs(b[5]) + 32 + 128;
-}
 #endif /* __KERNEL__ */
diff --git a/include/asm-cris/page.h b/include/asm-cris/page.h
index c99c478c482f..3787633e6209 100644
--- a/include/asm-cris/page.h
+++ b/include/asm-cris/page.h
@@ -43,8 +43,7 @@ typedef struct { unsigned long pgprot; } pgprot_t;
 /* On CRIS the PFN numbers doesn't start at 0 so we have to compensate */
 /* for that before indexing into the page table starting at mem_map    */
-#define pfn_to_page(pfn)        (mem_map + ((pfn) - (PAGE_OFFSET >> PAGE_SHIFT)))
+#define ARCH_PFN_OFFSET         (PAGE_OFFSET >> PAGE_SHIFT)
-#define page_to_pfn(page)       ((unsigned long)((page) - mem_map) + (PAGE_OFFSET >> PAGE_SHIFT))
 #define pfn_valid(pfn)          (((pfn) - (PAGE_OFFSET >> PAGE_SHIFT)) < max_mapnr)
 /* to index into the page map. our pages all start at physical addr PAGE_OFFSET so
@@ -77,6 +76,7 @@ typedef struct { unsigned long pgprot; } pgprot_t;
 #endif /* __KERNEL__ */
+#include <asm-generic/memory_model.h>
 #include <asm-generic/page.h>
 #endif /* _CRIS_PAGE_H */
diff --git a/include/asm-frv/bitops.h b/include/asm-frv/bitops.h
index f686b519878e..6344d06390b9 100644
--- a/include/asm-frv/bitops.h
+++ b/include/asm-frv/bitops.h
@@ -22,20 +22,7 @@
 #ifdef __KERNEL__
-/*
+#include <asm-generic/bitops/ffz.h>
- * ffz = Find First Zero in word. Undefined if no zero exists,
- * so code should check against ~0UL first..
- */
-static inline unsigned long ffz(unsigned long word)
-{
-        unsigned long result = 0;
-        while (word & 1) {
-                result++;
-                word >>= 1;
-        }
-        return result;
-}
 /*
 * clear_bit() doesn't provide any barrier for the compiler.
@@ -171,51 +158,9 @@ static inline int __test_bit(int nr, const volatile void * addr)
 __constant_test_bit((nr),(addr)) : \
 __test_bit((nr),(addr)))
-extern int find_next_bit(const unsigned long *addr, int size, int offset);
+#include <asm-generic/bitops/ffs.h>
+#include <asm-generic/bitops/__ffs.h>
-#define find_first_bit(addr, size) find_next_bit(addr, size, 0)
+#include <asm-generic/bitops/find.h>
-#define find_first_zero_bit(addr, size) \
-        find_next_zero_bit((addr), (size), 0)
-static inline int find_next_zero_bit(const void *addr, int size, int offset)
-{
-        const unsigned long *p = ((const unsigned long *) addr) + (offset >> 5);
-        unsigned long result = offset & ~31UL;
-        unsigned long tmp;
-        if (offset >= size)
-                return size;
-        size -= result;
-        offset &= 31UL;
-        if (offset) {
-                tmp = *(p++);
-                tmp |= ~0UL >> (32-offset);
-                if (size < 32)
-                        goto found_first;
-                if (~tmp)
-                        goto found_middle;
-                size -= 32;
-                result += 32;
-        }
-        while (size & ~31UL) {
-                if (~(tmp = *(p++)))
-                        goto found_middle;
-                result += 32;
-                size -= 32;
-        }
-        if (!size)
-                return result;
-        tmp = *p;
-found_first:
-        tmp |= ~0UL << size;
-found_middle:
-        return result + ffz(tmp);
-}
-#define ffs(x) generic_ffs(x)
-#define __ffs(x) (ffs(x) - 1)
 /*
 * fls: find last bit set.
@@ -228,114 +173,17 @@ found_middle:
                                                        \
        bit ? 33 - bit : bit;                           \
 })
-#define fls64(x)   generic_fls64(x)
-/*
+#include <asm-generic/bitops/fls64.h>
- * Every architecture must define this function. It's the fastest
+#include <asm-generic/bitops/sched.h>
- * way of searching a 140-bit bitmap where the first 100 bits are
+#include <asm-generic/bitops/hweight.h>
- * unlikely to be set. It's guaranteed that at least one of the 140
- * bits is cleared.
- */
-static inline int sched_find_first_bit(const unsigned long *b)
-{
-        if (unlikely(b[0]))
-                return __ffs(b[0]);
-        if (unlikely(b[1]))
-                return __ffs(b[1]) + 32;
-        if (unlikely(b[2]))
-                return __ffs(b[2]) + 64;
-        if (b[3])
-                return __ffs(b[3]) + 96;
-        return __ffs(b[4]) + 128;
-}
+#include <asm-generic/bitops/ext2-non-atomic.h>
-/*
+#define ext2_set_bit_atomic(lock,nr,addr)       test_and_set_bit  ((nr) ^ 0x18, (addr))
- * hweightN: returns the hamming weight (i.e. the number
+#define ext2_clear_bit_atomic(lock,nr,addr)     test_and_clear_bit((nr) ^ 0x18, (addr))
- * of bits set) of a N-bit word
- */
-#define hweight32(x) generic_hweight32(x)
-#define hweight16(x) generic_hweight16(x)
-#define hweight8(x) generic_hweight8(x)
-#define ext2_set_bit(nr, addr)          test_and_set_bit  ((nr) ^ 0x18, (addr))
-#define ext2_clear_bit(nr, addr)        test_and_clear_bit((nr) ^ 0x18, (addr))
-#define ext2_set_bit_atomic(lock,nr,addr)       ext2_set_bit((nr), addr)
-#define ext2_clear_bit_atomic(lock,nr,addr)     ext2_clear_bit((nr), addr)
-static inline int ext2_test_bit(int nr, const volatile void * addr)
-{
-        const volatile unsigned char *ADDR = (const unsigned char *) addr;
-        int mask;
-        ADDR += nr >> 3;
-        mask = 1 << (nr & 0x07);
-        return ((mask & *ADDR) != 0);
-}
-#define ext2_find_first_zero_bit(addr, size) \
-        ext2_find_next_zero_bit((addr), (size), 0)
-static inline unsigned long ext2_find_next_zero_bit(const void *addr,
-                                                    unsigned long size,
-                                                    unsigned long offset)
-{
-        const unsigned long *p = ((const unsigned long *) addr) + (offset >> 5);
-        unsigned long result = offset & ~31UL;
-        unsigned long tmp;
-        if (offset >= size)
-                return size;
-        size -= result;
-        offset &= 31UL;
-        if(offset) {
-                /* We hold the little endian value in tmp, but then the
-                 * shift is illegal. So we could keep a big endian value
-                 * in tmp, like this:
-                 *
-                 * tmp = __swab32(*(p++));
-                 * tmp |= ~0UL >> (32-offset);
-                 *
-                 * but this would decrease preformance, so we change the
-                 * shift:
-                 */
-                tmp = *(p++);
-                tmp |= __swab32(~0UL >> (32-offset));
-                if(size < 32)
-                        goto found_first;
-                if(~tmp)
-                        goto found_middle;
-                size -= 32;
-                result += 32;
-        }
-        while(size & ~31UL) {
-                if(~(tmp = *(p++)))
-                        goto found_middle;
-                result += 32;
-                size -= 32;
-        }
-        if(!size)
-                return result;
-        tmp = *p;
-found_first:
-        /* tmp is little endian, so we would have to swab the shift,
-         * see above. But then we have to swab tmp below for ffz, so
-         * we might as well do this here.
-         */
-        return result + ffz(__swab32(tmp) | (~0UL << size));
-found_middle:
-        return result + ffz(__swab32(tmp));
-}
-/* Bitmap functions for the minix filesystem.  */
+#include <asm-generic/bitops/minix-le.h>
-#define minix_test_and_set_bit(nr,addr)         ext2_set_bit(nr,addr)
-#define minix_set_bit(nr,addr)                  ext2_set_bit(nr,addr)
-#define minix_test_and_clear_bit(nr,addr)       ext2_clear_bit(nr,addr)
-#define minix_test_bit(nr,addr)                 ext2_test_bit(nr,addr)
-#define minix_find_first_zero_bit(addr,size)    ext2_find_first_zero_bit(addr,size)
 #endif /* __KERNEL__ */
diff --git a/include/asm-frv/futex.h b/include/asm-frv/futex.h
index fca9d90e32c9..08b3d1da3583 100644
--- a/include/asm-frv/futex.h
+++ b/include/asm-frv/futex.h
@@ -9,5 +9,11 @@
 extern int futex_atomic_op_inuser(int encoded_op, int __user *uaddr);
+static inline int
+futex_atomic_cmpxchg_inatomic(int __user *uaddr, int oldval, int newval)
+{
+        return -ENOSYS;
+}
 #endif
 #endif
diff --git a/include/asm-frv/page.h b/include/asm-frv/page.h
index b8221b611b5c..dc0f7e08a4c2 100644
--- a/include/asm-frv/page.h
+++ b/include/asm-frv/page.h
@@ -57,13 +57,9 @@ extern unsigned long min_low_pfn;
 extern unsigned long max_pfn;
 #ifdef CONFIG_MMU
-#define pfn_to_page(pfn)        (mem_map + (pfn))
-#define page_to_pfn(page)       ((unsigned long) ((page) - mem_map))
 #define pfn_valid(pfn)          ((pfn) < max_mapnr)
 #else
-#define pfn_to_page(pfn)        (&mem_map[(pfn) - (PAGE_OFFSET >> PAGE_SHIFT)])
+#define ARCH_PFN_OFFSET         (PAGE_OFFSET >> PAGE_SHIFT)
-#define page_to_pfn(page)       ((PAGE_OFFSET >> PAGE_SHIFT) + (unsigned long) ((page) - mem_map))
 #define pfn_valid(pfn)          ((pfn) >= min_low_pfn && (pfn) < max_low_pfn)
 #endif
@@ -87,6 +83,7 @@ extern unsigned long max_pfn;
 #define WANT_PAGE_VIRTUAL       1
 #endif
+#include <asm-generic/memory_model.h>
 #include <asm-generic/page.h>
 #endif /* _ASM_PAGE_H */
diff --git a/include/asm-generic/bitops.h b/include/asm-generic/bitops.h
index 0e6d9852008c..1f9d99193df8 100644
--- a/include/asm-generic/bitops.h
+++ b/include/asm-generic/bitops.h
@@ -5,77 +5,27 @@
 * For the benefit of those who are trying to port Linux to another
 * architecture, here are some C-language equivalents.  You should
 * recode these in the native assembly language, if at all possible.
- * To guarantee atomicity, these routines call cli() and sti() to
- * disable interrupts while they operate.  (You have to provide inline
- * routines to cli() and sti().)
- *
- * Also note, these routines assume that you have 32 bit longs.
- * You will have to change this if you are trying to port Linux to the
- * Alpha architecture or to a Cray.  :-)
 * 
 * C language equivalents written by Theodore Ts'o, 9/26/92
 */
-extern __inline__ int set_bit(int nr,long * addr)
+#include <asm-generic/bitops/atomic.h>
-{
+#include <asm-generic/bitops/non-atomic.h>
-        int     mask, retval;
+#include <asm-generic/bitops/__ffs.h>
+#include <asm-generic/bitops/ffz.h>
-        addr += nr >> 5;
+#include <asm-generic/bitops/fls.h>
-        mask = 1 << (nr & 0x1f);
+#include <asm-generic/bitops/fls64.h>
-        cli();
+#include <asm-generic/bitops/find.h>
-        retval = (mask & *addr) != 0;
-        *addr |= mask;
-        sti();
-        return retval;
-}
-extern __inline__ int clear_bit(int nr, long * addr)
-{
-        int     mask, retval;
-        addr += nr >> 5;
-        mask = 1 << (nr & 0x1f);
-        cli();
-        retval = (mask & *addr) != 0;
-        *addr &= ~mask;
-        sti();
-        return retval;
-}
-extern __inline__ int test_bit(int nr, const unsigned long * addr)
-{
-        int     mask;
-        addr += nr >> 5;
-        mask = 1 << (nr & 0x1f);
-        return ((mask & *addr) != 0);
-}
-/*
- * fls: find last bit set.
- */
-#define fls(x) generic_fls(x)
-#define fls64(x)   generic_fls64(x)
 #ifdef __KERNEL__
-/*
+#include <asm-generic/bitops/sched.h>
- * ffs: find first bit set. This is defined the same way as
+#include <asm-generic/bitops/ffs.h>
- * the libc and compiler builtin ffs routines, therefore
+#include <asm-generic/bitops/hweight.h>
- * differs in spirit from the above ffz (man ffs).
- */
-#define ffs(x) generic_ffs(x)
-/*
- * hweightN: returns the hamming weight (i.e. the number
- * of bits set) of a N-bit word
- */
-#define hweight32(x) generic_hweight32(x)
+#include <asm-generic/bitops/ext2-non-atomic.h>
-#define hweight16(x) generic_hweight16(x)
+#include <asm-generic/bitops/ext2-atomic.h>
-#define hweight8(x) generic_hweight8(x)
+#include <asm-generic/bitops/minix.h>
 #endif /* __KERNEL__ */
diff --git a/include/asm-generic/bitops/__ffs.h b/include/asm-generic/bitops/__ffs.h
new file mode 100644
index 000000000000..9a3274aecf83
--- /dev/null
+++ b/include/asm-generic/bitops/__ffs.h
@@ -0,0 +1,43 @@
+#ifndef _ASM_GENERIC_BITOPS___FFS_H_
+#define _ASM_GENERIC_BITOPS___FFS_H_
+#include <asm/types.h>
+/**
+ * __ffs - find first bit in word.
+ * @word: The word to search
+ *
+ * Undefined if no bit exists, so code should check against 0 first.
+ */
+static inline unsigned long __ffs(unsigned long word)
+{
+        int num = 0;
+#if BITS_PER_LONG == 64
+        if ((word & 0xffffffff) == 0) {
+                num += 32;
+                word >>= 32;
+        }
+#endif
+        if ((word & 0xffff) == 0) {
+                num += 16;
+                word >>= 16;
+        }
+        if ((word & 0xff) == 0) {
+                num += 8;
+                word >>= 8;
+        }
+        if ((word & 0xf) == 0) {
+                num += 4;
+                word >>= 4;
+        }
+        if ((word & 0x3) == 0) {
+                num += 2;
+                word >>= 2;
+        }
+        if ((word & 0x1) == 0)
+                num += 1;
+        return num;
+}
+#endif /* _ASM_GENERIC_BITOPS___FFS_H_ */
diff --git a/include/asm-generic/bitops/atomic.h b/include/asm-generic/bitops/atomic.h
new file mode 100644
index 000000000000..78339319ba02
--- /dev/null
+++ b/include/asm-generic/bitops/atomic.h
@@ -0,0 +1,191 @@
+#ifndef _ASM_GENERIC_BITOPS_ATOMIC_H_
+#define _ASM_GENERIC_BITOPS_ATOMIC_H_
+#include <asm/types.h>
+#define BITOP_MASK(nr)          (1UL << ((nr) % BITS_PER_LONG))
+#define BITOP_WORD(nr)          ((nr) / BITS_PER_LONG)
+#ifdef CONFIG_SMP
+#include <asm/spinlock.h>
+#include <asm/cache.h>          /* we use L1_CACHE_BYTES */
+/* Use an array of spinlocks for our atomic_ts.
+ * Hash function to index into a different SPINLOCK.
+ * Since "a" is usually an address, use one spinlock per cacheline.
+ */
+#  define ATOMIC_HASH_SIZE 4
+#  define ATOMIC_HASH(a) (&(__atomic_hash[ (((unsigned long) a)/L1_CACHE_BYTES) & (ATOMIC_HASH_SIZE-1) ]))
+extern raw_spinlock_t __atomic_hash[ATOMIC_HASH_SIZE] __lock_aligned;
+/* Can't use raw_spin_lock_irq because of #include problems, so
+ * this is the substitute */
+#define _atomic_spin_lock_irqsave(l,f) do {     \
+        raw_spinlock_t *s = ATOMIC_HASH(l);     \
+        local_irq_save(f);                      \
+        __raw_spin_lock(s);                     \
+} while(0)
+#define _atomic_spin_unlock_irqrestore(l,f) do {        \
+        raw_spinlock_t *s = ATOMIC_HASH(l);             \
+        __raw_spin_unlock(s);                           \
+        local_irq_restore(f);                           \
+} while(0)
+#else
+#  define _atomic_spin_lock_irqsave(l,f) do { local_irq_save(f); } while (0)
+#  define _atomic_spin_unlock_irqrestore(l,f) do { local_irq_restore(f); } while (0)
+#endif
+/*
+ * NMI events can occur at any time, including when interrupts have been
+ * disabled by *_irqsave().  So you can get NMI events occurring while a
+ * *_bit function is holding a spin lock.  If the NMI handler also wants
+ * to do bit manipulation (and they do) then you can get a deadlock
+ * between the original caller of *_bit() and the NMI handler.
+ *
+ * by Keith Owens
+ */
+/**
+ * set_bit - Atomically set a bit in memory
+ * @nr: the bit to set
+ * @addr: the address to start counting from
+ *
+ * This function is atomic and may not be reordered.  See __set_bit()
+ * if you do not require the atomic guarantees.
+ *
+ * Note: there are no guarantees that this function will not be reordered
+ * on non x86 architectures, so if you are writting portable code,
+ * make sure not to rely on its reordering guarantees.
+ *
+ * Note that @nr may be almost arbitrarily large; this function is not
+ * restricted to acting on a single-word quantity.
+ */
+static inline void set_bit(int nr, volatile unsigned long *addr)
+{
+        unsigned long mask = BITOP_MASK(nr);
+        unsigned long *p = ((unsigned long *)addr) + BITOP_WORD(nr);
+        unsigned long flags;
+        _atomic_spin_lock_irqsave(p, flags);
+        *p  |= mask;
+        _atomic_spin_unlock_irqrestore(p, flags);
+}
+/**
+ * clear_bit - Clears a bit in memory
+ * @nr: Bit to clear
+ * @addr: Address to start counting from
+ *
+ * clear_bit() is atomic and may not be reordered.  However, it does
+ * not contain a memory barrier, so if it is used for locking purposes,
+ * you should call smp_mb__before_clear_bit() and/or smp_mb__after_clear_bit()
+ * in order to ensure changes are visible on other processors.
+ */
+static inline void clear_bit(int nr, volatile unsigned long *addr)
+{
+        unsigned long mask = BITOP_MASK(nr);
+        unsigned long *p = ((unsigned long *)addr) + BITOP_WORD(nr);
+        unsigned long flags;
+        _atomic_spin_lock_irqsave(p, flags);
+        *p &= ~mask;
+        _atomic_spin_unlock_irqrestore(p, flags);
+}
+/**
+ * change_bit - Toggle a bit in memory
+ * @nr: Bit to change
+ * @addr: Address to start counting from
+ *
+ * change_bit() is atomic and may not be reordered. It may be
+ * reordered on other architectures than x86.
+ * Note that @nr may be almost arbitrarily large; this function is not
+ * restricted to acting on a single-word quantity.
+ */
+static inline void change_bit(int nr, volatile unsigned long *addr)
+{
+        unsigned long mask = BITOP_MASK(nr);
+        unsigned long *p = ((unsigned long *)addr) + BITOP_WORD(nr);
+        unsigned long flags;
+        _atomic_spin_lock_irqsave(p, flags);
+        *p ^= mask;
+        _atomic_spin_unlock_irqrestore(p, flags);
+}
+/**
+ * test_and_set_bit - Set a bit and return its old value
+ * @nr: Bit to set
+ * @addr: Address to count from
+ *
+ * This operation is atomic and cannot be reordered.
+ * It may be reordered on other architectures than x86.
+ * It also implies a memory barrier.
+ */
+static inline int test_and_set_bit(int nr, volatile unsigned long *addr)
+{
+        unsigned long mask = BITOP_MASK(nr);
+        unsigned long *p = ((unsigned long *)addr) + BITOP_WORD(nr);
+        unsigned long old;
+        unsigned long flags;
+        _atomic_spin_lock_irqsave(p, flags);
+        old = *p;
+        *p = old | mask;
+        _atomic_spin_unlock_irqrestore(p, flags);
+        return (old & mask) != 0;
+}
+/**
+ * test_and_clear_bit - Clear a bit and return its old value
+ * @nr: Bit to clear
+ * @addr: Address to count from
+ *
+ * This operation is atomic and cannot be reordered.
+ * It can be reorderdered on other architectures other than x86.
+ * It also implies a memory barrier.
+ */
+static inline int test_and_clear_bit(int nr, volatile unsigned long *addr)
+{
+        unsigned long mask = BITOP_MASK(nr);
+        unsigned long *p = ((unsigned long *)addr) + BITOP_WORD(nr);
+        unsigned long old;
+        unsigned long flags;
+        _atomic_spin_lock_irqsave(p, flags);
+        old = *p;
+        *p = old & ~mask;
+        _atomic_spin_unlock_irqrestore(p, flags);
+        return (old & mask) != 0;
+}
+/**
+ * test_and_change_bit - Change a bit and return its old value
+ * @nr: Bit to change
+ * @addr: Address to count from
+ *
+ * This operation is atomic and cannot be reordered.
+ * It also implies a memory barrier.
+ */
+static inline int test_and_change_bit(int nr, volatile unsigned long *addr)
+{
+        unsigned long mask = BITOP_MASK(nr);
+        unsigned long *p = ((unsigned long *)addr) + BITOP_WORD(nr);
+        unsigned long old;
+        unsigned long flags;
+        _atomic_spin_lock_irqsave(p, flags);
+        old = *p;
+        *p = old ^ mask;
+        _atomic_spin_unlock_irqrestore(p, flags);
+        return (old & mask) != 0;
+}
+#endif /* _ASM_GENERIC_BITOPS_ATOMIC_H */
diff --git a/include/asm-generic/bitops/ext2-atomic.h b/include/asm-generic/bitops/ext2-atomic.h
new file mode 100644
index 000000000000..ab1c875efb74
--- /dev/null
+++ b/include/asm-generic/bitops/ext2-atomic.h
@@ -0,0 +1,22 @@
+#ifndef _ASM_GENERIC_BITOPS_EXT2_ATOMIC_H_
+#define _ASM_GENERIC_BITOPS_EXT2_ATOMIC_H_
+#define ext2_set_bit_atomic(lock, nr, addr)             \
+        ({                                              \
+                int ret;                                \
+                spin_lock(lock);                        \
+                ret = ext2_set_bit((nr), (unsigned long *)(addr)); \
+                spin_unlock(lock);                      \
+                ret;                                    \
+        })
+#define ext2_clear_bit_atomic(lock, nr, addr)           \
+        ({                                              \
+                int ret;                                \
+                spin_lock(lock);                        \
+                ret = ext2_clear_bit((nr), (unsigned long *)(addr)); \
+                spin_unlock(lock);                      \
+                ret;                                    \
+        })
+#endif /* _ASM_GENERIC_BITOPS_EXT2_ATOMIC_H_ */
diff --git a/include/asm-generic/bitops/ext2-non-atomic.h b/include/asm-generic/bitops/ext2-non-atomic.h
new file mode 100644
index 000000000000..1697404afa05
--- /dev/null
+++ b/include/asm-generic/bitops/ext2-non-atomic.h
@@ -0,0 +1,18 @@
+#ifndef _ASM_GENERIC_BITOPS_EXT2_NON_ATOMIC_H_
+#define _ASM_GENERIC_BITOPS_EXT2_NON_ATOMIC_H_
+#include <asm-generic/bitops/le.h>
+#define ext2_set_bit(nr,addr)   \
+        generic___test_and_set_le_bit((nr),(unsigned long *)(addr))
+#define ext2_clear_bit(nr,addr) \
+        generic___test_and_clear_le_bit((nr),(unsigned long *)(addr))
+#define ext2_test_bit(nr,addr)  \
+        generic_test_le_bit((nr),(unsigned long *)(addr))
+#define ext2_find_first_zero_bit(addr, size) \
+        generic_find_first_zero_le_bit((unsigned long *)(addr), (size))
+#define ext2_find_next_zero_bit(addr, size, off) \
+        generic_find_next_zero_le_bit((unsigned long *)(addr), (size), (off))
+#endif /* _ASM_GENERIC_BITOPS_EXT2_NON_ATOMIC_H_ */
diff --git a/include/asm-generic/bitops/ffs.h b/include/asm-generic/bitops/ffs.h
new file mode 100644
index 000000000000..fbbb43af7dc0
--- /dev/null
+++ b/include/asm-generic/bitops/ffs.h
@@ -0,0 +1,41 @@
+#ifndef _ASM_GENERIC_BITOPS_FFS_H_
+#define _ASM_GENERIC_BITOPS_FFS_H_
+/**
+ * ffs - find first bit set
+ * @x: the word to search
+ *
+ * This is defined the same way as
+ * the libc and compiler builtin ffs routines, therefore
+ * differs in spirit from the above ffz (man ffs).
+ */
+static inline int ffs(int x)
+{
+        int r = 1;
+        if (!x)
+                return 0;
+        if (!(x & 0xffff)) {
+                x >>= 16;
+                r += 16;
+        }
+        if (!(x & 0xff)) {
+                x >>= 8;
+                r += 8;
+        }
+        if (!(x & 0xf)) {
+                x >>= 4;
+                r += 4;
+        }
+        if (!(x & 3)) {
+                x >>= 2;
+                r += 2;
+        }
+        if (!(x & 1)) {
+                x >>= 1;
+                r += 1;
+        }
+        return r;
+}
+#endif /* _ASM_GENERIC_BITOPS_FFS_H_ */
diff --git a/include/asm-generic/bitops/ffz.h b/include/asm-generic/bitops/ffz.h
new file mode 100644
index 000000000000..6744bd4cdf46
--- /dev/null
+++ b/include/asm-generic/bitops/ffz.h
@@ -0,0 +1,12 @@
+#ifndef _ASM_GENERIC_BITOPS_FFZ_H_
+#define _ASM_GENERIC_BITOPS_FFZ_H_
+/*
+ * ffz - find first zero in word.
+ * @word: The word to search
+ *
+ * Undefined if no zero exists, so code should check against ~0UL first.
+ */
+#define ffz(x)  __ffs(~(x))
+#endif /* _ASM_GENERIC_BITOPS_FFZ_H_ */
diff --git a/include/asm-generic/bitops/find.h b/include/asm-generic/bitops/find.h
new file mode 100644
index 000000000000..72a51e5a12ef
--- /dev/null
+++ b/include/asm-generic/bitops/find.h
@@ -0,0 +1,13 @@
+#ifndef _ASM_GENERIC_BITOPS_FIND_H_
+#define _ASM_GENERIC_BITOPS_FIND_H_
+extern unsigned long find_next_bit(const unsigned long *addr, unsigned long
+                size, unsigned long offset);
+extern unsigned long find_next_zero_bit(const unsigned long *addr, unsigned
+                long size, unsigned long offset);
+#define find_first_bit(addr, size) find_next_bit((addr), (size), 0)
+#define find_first_zero_bit(addr, size) find_next_zero_bit((addr), (size), 0)
+#endif /*_ASM_GENERIC_BITOPS_FIND_H_ */
diff --git a/include/asm-generic/bitops/fls.h b/include/asm-generic/bitops/fls.h
new file mode 100644
index 000000000000..850859bc5069
--- /dev/null
+++ b/include/asm-generic/bitops/fls.h
@@ -0,0 +1,41 @@
+#ifndef _ASM_GENERIC_BITOPS_FLS_H_
+#define _ASM_GENERIC_BITOPS_FLS_H_
+/**
+ * fls - find last (most-significant) bit set
+ * @x: the word to search
+ *
+ * This is defined the same way as ffs.
+ * Note fls(0) = 0, fls(1) = 1, fls(0x80000000) = 32.
+ */
+static inline int fls(int x)
+{
+        int r = 32;
+        if (!x)
+                return 0;
+        if (!(x & 0xffff0000u)) {
+                x <<= 16;
+                r -= 16;
+        }
+        if (!(x & 0xff000000u)) {
+                x <<= 8;
+                r -= 8;
+        }
+        if (!(x & 0xf0000000u)) {
+                x <<= 4;
+                r -= 4;
+        }
+        if (!(x & 0xc0000000u)) {
+                x <<= 2;
+                r -= 2;
+        }
+        if (!(x & 0x80000000u)) {
+                x <<= 1;
+                r -= 1;
+        }
+        return r;
+}
+#endif /* _ASM_GENERIC_BITOPS_FLS_H_ */
diff --git a/include/asm-generic/bitops/fls64.h b/include/asm-generic/bitops/fls64.h
new file mode 100644
index 000000000000..1b6b17ce2428
--- /dev/null
+++ b/include/asm-generic/bitops/fls64.h
@@ -0,0 +1,14 @@
+#ifndef _ASM_GENERIC_BITOPS_FLS64_H_
+#define _ASM_GENERIC_BITOPS_FLS64_H_
+#include <asm/types.h>
+static inline int fls64(__u64 x)
+{
+        __u32 h = x >> 32;
+        if (h)
+                return fls(h) + 32;
+        return fls(x);
+}
+#endif /* _ASM_GENERIC_BITOPS_FLS64_H_ */
diff --git a/include/asm-generic/bitops/hweight.h b/include/asm-generic/bitops/hweight.h
new file mode 100644
index 000000000000..fbbc383771da
--- /dev/null
+++ b/include/asm-generic/bitops/hweight.h
@@ -0,0 +1,11 @@
+#ifndef _ASM_GENERIC_BITOPS_HWEIGHT_H_
+#define _ASM_GENERIC_BITOPS_HWEIGHT_H_
+#include <asm/types.h>
+extern unsigned int hweight32(unsigned int w);
+extern unsigned int hweight16(unsigned int w);
+extern unsigned int hweight8(unsigned int w);
+extern unsigned long hweight64(__u64 w);
+#endif /* _ASM_GENERIC_BITOPS_HWEIGHT_H_ */
diff --git a/include/asm-generic/bitops/le.h b/include/asm-generic/bitops/le.h
new file mode 100644
index 000000000000..b9c7e5d2d2ad
--- /dev/null
+++ b/include/asm-generic/bitops/le.h
@@ -0,0 +1,53 @@
+#ifndef _ASM_GENERIC_BITOPS_LE_H_
+#define _ASM_GENERIC_BITOPS_LE_H_
+#include <asm/types.h>
+#include <asm/byteorder.h>
+#define BITOP_WORD(nr)          ((nr) / BITS_PER_LONG)
+#define BITOP_LE_SWIZZLE        ((BITS_PER_LONG-1) & ~0x7)
+#if defined(__LITTLE_ENDIAN)
+#define generic_test_le_bit(nr, addr) test_bit(nr, addr)
+#define generic___set_le_bit(nr, addr) __set_bit(nr, addr)
+#define generic___clear_le_bit(nr, addr) __clear_bit(nr, addr)
+#define generic_test_and_set_le_bit(nr, addr) test_and_set_bit(nr, addr)
+#define generic_test_and_clear_le_bit(nr, addr) test_and_clear_bit(nr, addr)
+#define generic___test_and_set_le_bit(nr, addr) __test_and_set_bit(nr, addr)
+#define generic___test_and_clear_le_bit(nr, addr) __test_and_clear_bit(nr, addr)
+#define generic_find_next_zero_le_bit(addr, size, offset) find_next_zero_bit(addr, size, offset)
+#elif defined(__BIG_ENDIAN)
+#define generic_test_le_bit(nr, addr) \
+        test_bit((nr) ^ BITOP_LE_SWIZZLE, (addr))
+#define generic___set_le_bit(nr, addr) \
+        __set_bit((nr) ^ BITOP_LE_SWIZZLE, (addr))
+#define generic___clear_le_bit(nr, addr) \
+        __clear_bit((nr) ^ BITOP_LE_SWIZZLE, (addr))
+#define generic_test_and_set_le_bit(nr, addr) \
+        test_and_set_bit((nr) ^ BITOP_LE_SWIZZLE, (addr))
+#define generic_test_and_clear_le_bit(nr, addr) \
+        test_and_clear_bit((nr) ^ BITOP_LE_SWIZZLE, (addr))
+#define generic___test_and_set_le_bit(nr, addr) \
+        __test_and_set_bit((nr) ^ BITOP_LE_SWIZZLE, (addr))
+#define generic___test_and_clear_le_bit(nr, addr) \
+        __test_and_clear_bit((nr) ^ BITOP_LE_SWIZZLE, (addr))
+extern unsigned long generic_find_next_zero_le_bit(const unsigned long *addr,
+                unsigned long size, unsigned long offset);
+#else
+#error "Please fix <asm/byteorder.h>"
+#endif
+#define generic_find_first_zero_le_bit(addr, size) \
+        generic_find_next_zero_le_bit((addr), (size), 0)
+#endif /* _ASM_GENERIC_BITOPS_LE_H_ */
diff --git a/include/asm-generic/bitops/minix-le.h b/include/asm-generic/bitops/minix-le.h
new file mode 100644
index 000000000000..4a981c1bb1ae
--- /dev/null
+++ b/include/asm-generic/bitops/minix-le.h
@@ -0,0 +1,17 @@
+#ifndef _ASM_GENERIC_BITOPS_MINIX_LE_H_
+#define _ASM_GENERIC_BITOPS_MINIX_LE_H_
+#include <asm-generic/bitops/le.h>
+#define minix_test_and_set_bit(nr,addr) \
+        generic___test_and_set_le_bit((nr),(unsigned long *)(addr))
+#define minix_set_bit(nr,addr)          \
+        generic___set_le_bit((nr),(unsigned long *)(addr))
+#define minix_test_and_clear_bit(nr,addr) \
+        generic___test_and_clear_le_bit((nr),(unsigned long *)(addr))
+#define minix_test_bit(nr,addr)         \
+        generic_test_le_bit((nr),(unsigned long *)(addr))
+#define minix_find_first_zero_bit(addr,size) \
+        generic_find_first_zero_le_bit((unsigned long *)(addr),(size))
+#endif /* _ASM_GENERIC_BITOPS_MINIX_LE_H_ */
diff --git a/include/asm-generic/bitops/minix.h b/include/asm-generic/bitops/minix.h
new file mode 100644
index 000000000000..91f42e87aa51
--- /dev/null
+++ b/include/asm-generic/bitops/minix.h
@@ -0,0 +1,15 @@
+#ifndef _ASM_GENERIC_BITOPS_MINIX_H_
+#define _ASM_GENERIC_BITOPS_MINIX_H_
+#define minix_test_and_set_bit(nr,addr) \
+        __test_and_set_bit((nr),(unsigned long *)(addr))
+#define minix_set_bit(nr,addr)          \
+        __set_bit((nr),(unsigned long *)(addr))
+#define minix_test_and_clear_bit(nr,addr) \
+        __test_and_clear_bit((nr),(unsigned long *)(addr))
+#define minix_test_bit(nr,addr)         \
+        test_bit((nr),(unsigned long *)(addr))
+#define minix_find_first_zero_bit(addr,size) \
+        find_first_zero_bit((unsigned long *)(addr),(size))
+#endif /* _ASM_GENERIC_BITOPS_MINIX_H_ */
diff --git a/include/asm-generic/bitops/non-atomic.h b/include/asm-generic/bitops/non-atomic.h
new file mode 100644
index 000000000000..46a825cf2ae1
--- /dev/null
+++ b/include/asm-generic/bitops/non-atomic.h
@@ -0,0 +1,111 @@
+#ifndef _ASM_GENERIC_BITOPS_NON_ATOMIC_H_
+#define _ASM_GENERIC_BITOPS_NON_ATOMIC_H_
+#include <asm/types.h>
+#define BITOP_MASK(nr)          (1UL << ((nr) % BITS_PER_LONG))
+#define BITOP_WORD(nr)          ((nr) / BITS_PER_LONG)
+/**
+ * __set_bit - Set a bit in memory
+ * @nr: the bit to set
+ * @addr: the address to start counting from
+ *
+ * Unlike set_bit(), this function is non-atomic and may be reordered.
+ * If it's called on the same region of memory simultaneously, the effect
+ * may be that only one operation succeeds.
+ */
+static inline void __set_bit(int nr, volatile unsigned long *addr)
+{
+        unsigned long mask = BITOP_MASK(nr);
+        unsigned long *p = ((unsigned long *)addr) + BITOP_WORD(nr);
+        *p  |= mask;
+}
+static inline void __clear_bit(int nr, volatile unsigned long *addr)
+{
+        unsigned long mask = BITOP_MASK(nr);
+        unsigned long *p = ((unsigned long *)addr) + BITOP_WORD(nr);
+        *p &= ~mask;
+}
+/**
+ * __change_bit - Toggle a bit in memory
+ * @nr: the bit to change
+ * @addr: the address to start counting from
+ *
+ * Unlike change_bit(), this function is non-atomic and may be reordered.
+ * If it's called on the same region of memory simultaneously, the effect
+ * may be that only one operation succeeds.
+ */
+static inline void __change_bit(int nr, volatile unsigned long *addr)
+{
+        unsigned long mask = BITOP_MASK(nr);
+        unsigned long *p = ((unsigned long *)addr) + BITOP_WORD(nr);
+        *p ^= mask;
+}
+/**
+ * __test_and_set_bit - Set a bit and return its old value
+ * @nr: Bit to set
+ * @addr: Address to count from
+ *
+ * This operation is non-atomic and can be reordered.
+ * If two examples of this operation race, one can appear to succeed
+ * but actually fail.  You must protect multiple accesses with a lock.
+ */
+static inline int __test_and_set_bit(int nr, volatile unsigned long *addr)
+{
+        unsigned long mask = BITOP_MASK(nr);
+        unsigned long *p = ((unsigned long *)addr) + BITOP_WORD(nr);
+        unsigned long old = *p;
+        *p = old | mask;
+        return (old & mask) != 0;
+}
+/**
+ * __test_and_clear_bit - Clear a bit and return its old value
+ * @nr: Bit to clear
+ * @addr: Address to count from
+ *
+ * This operation is non-atomic and can be reordered.
+ * If two examples of this operation race, one can appear to succeed
+ * but actually fail.  You must protect multiple accesses with a lock.
+ */
+static inline int __test_and_clear_bit(int nr, volatile unsigned long *addr)
+{
+        unsigned long mask = BITOP_MASK(nr);
+        unsigned long *p = ((unsigned long *)addr) + BITOP_WORD(nr);
+        unsigned long old = *p;
+        *p = old & ~mask;
+        return (old & mask) != 0;
+}
+/* WARNING: non atomic and it can be reordered! */
+static inline int __test_and_change_bit(int nr,
+                                            volatile unsigned long *addr)
+{
+        unsigned long mask = BITOP_MASK(nr);
+        unsigned long *p = ((unsigned long *)addr) + BITOP_WORD(nr);
+        unsigned long old = *p;
+        *p = old ^ mask;
+        return (old & mask) != 0;
+}
+/**
+ * test_bit - Determine whether a bit is set
+ * @nr: bit number to test
+ * @addr: Address to start counting from
+ */
+static inline int test_bit(int nr, const volatile unsigned long *addr)
+{
+        return 1UL & (addr[BITOP_WORD(nr)] >> (nr & (BITS_PER_LONG-1)));
+}
+#endif /* _ASM_GENERIC_BITOPS_NON_ATOMIC_H_ */
diff --git a/include/asm-generic/bitops/sched.h b/include/asm-generic/bitops/sched.h
new file mode 100644
index 000000000000..5ef93a4d009f
--- /dev/null
+++ b/include/asm-generic/bitops/sched.h
@@ -0,0 +1,36 @@
+#ifndef _ASM_GENERIC_BITOPS_SCHED_H_
+#define _ASM_GENERIC_BITOPS_SCHED_H_
+#include <linux/compiler.h>     /* unlikely() */
+#include <asm/types.h>
+/*
+ * Every architecture must define this function. It's the fastest
+ * way of searching a 140-bit bitmap where the first 100 bits are
+ * unlikely to be set. It's guaranteed that at least one of the 140
+ * bits is cleared.
+ */
+static inline int sched_find_first_bit(const unsigned long *b)
+{
+#if BITS_PER_LONG == 64
+        if (unlikely(b[0]))
+                return __ffs(b[0]);
+        if (unlikely(b[1]))
+                return __ffs(b[1]) + 64;
+        return __ffs(b[2]) + 128;
+#elif BITS_PER_LONG == 32
+        if (unlikely(b[0]))
+                return __ffs(b[0]);
+        if (unlikely(b[1]))
+                return __ffs(b[1]) + 32;
+        if (unlikely(b[2]))
+                return __ffs(b[2]) + 64;
+        if (b[3])
+                return __ffs(b[3]) + 96;
+        return __ffs(b[4]) + 128;
+#else
+#error BITS_PER_LONG not defined
+#endif
+}
+#endif /* _ASM_GENERIC_BITOPS_SCHED_H_ */
diff --git a/include/asm-generic/futex.h b/include/asm-generic/futex.h
index 3ae2c7347549..df893c160318 100644
--- a/include/asm-generic/futex.h
+++ b/include/asm-generic/futex.h
@@ -49,5 +49,11 @@ futex_atomic_op_inuser (int encoded_op, int __user *uaddr)
        return ret;
 }
+static inline int
+futex_atomic_cmpxchg_inatomic(int __user *uaddr, int oldval, int newval)
+{
+        return -ENOSYS;
+}
 #endif
 #endif
diff --git a/include/asm-generic/memory_model.h b/include/asm-generic/memory_model.h
new file mode 100644
index 000000000000..0cfb086dd373
--- /dev/null
+++ b/include/asm-generic/memory_model.h
@@ -0,0 +1,77 @@
+#ifndef __ASM_MEMORY_MODEL_H
+#define __ASM_MEMORY_MODEL_H
+#ifdef __KERNEL__
+#ifndef __ASSEMBLY__
+#if defined(CONFIG_FLATMEM)
+#ifndef ARCH_PFN_OFFSET
+#define ARCH_PFN_OFFSET         (0UL)
+#endif
+#elif defined(CONFIG_DISCONTIGMEM)
+#ifndef arch_pfn_to_nid
+#define arch_pfn_to_nid(pfn)    pfn_to_nid(pfn)
+#endif
+#ifndef arch_local_page_offset
+#define arch_local_page_offset(pfn, nid)        \
+        ((pfn) - NODE_DATA(nid)->node_start_pfn)
+#endif
+#endif /* CONFIG_DISCONTIGMEM */
+#ifdef CONFIG_OUT_OF_LINE_PFN_TO_PAGE
+struct page;
+/* this is useful when inlined pfn_to_page is too big */
+extern struct page *pfn_to_page(unsigned long pfn);
+extern unsigned long page_to_pfn(struct page *page);
+#else
+/*
+ * supports 3 memory models.
+ */
+#if defined(CONFIG_FLATMEM)
+#define pfn_to_page(pfn)        (mem_map + ((pfn) - ARCH_PFN_OFFSET))
+#define page_to_pfn(page)       ((unsigned long)((page) - mem_map) + \
+                                 ARCH_PFN_OFFSET)
+#elif defined(CONFIG_DISCONTIGMEM)
+#define pfn_to_page(pfn)                        \
+({      unsigned long __pfn = (pfn);            \
+        unsigned long __nid = arch_pfn_to_nid(pfn);  \
+        NODE_DATA(__nid)->node_mem_map + arch_local_page_offset(__pfn, __nid);\
+})
+#define page_to_pfn(pg)                                                 \
+({      struct page *__pg = (pg);                                       \
+        struct pglist_data *__pgdat = NODE_DATA(page_to_nid(__pg));     \
+        (unsigned long)(__pg - __pgdat->node_mem_map) +                 \
+         __pgdat->node_start_pfn;                                       \
+})
+#elif defined(CONFIG_SPARSEMEM)
+/*
+ * Note: section's mem_map is encorded to reflect its start_pfn.
+ * section[i].section_mem_map == mem_map's address - start_pfn;
+ */
+#define page_to_pfn(pg)                                 \
+({      struct page *__pg = (pg);                               \
+        int __sec = page_to_section(__pg);                      \
+        __pg - __section_mem_map_addr(__nr_to_section(__sec));  \
+})
+#define pfn_to_page(pfn)                                \
+({      unsigned long __pfn = (pfn);                    \
+        struct mem_section *__sec = __pfn_to_section(__pfn);    \
+        __section_mem_map_addr(__sec) + __pfn;          \
+})
+#endif /* CONFIG_FLATMEM/DISCONTIGMEM/SPARSEMEM */
+#endif /* CONFIG_OUT_OF_LINE_PFN_TO_PAGE */
+#endif /* __ASSEMBLY__ */
+#endif /* __KERNEL__ */
+#endif
diff --git a/include/asm-h8300/bitops.h b/include/asm-h8300/bitops.h
index ff7c2b721594..574f57b6c4d1 100644
--- a/include/asm-h8300/bitops.h
+++ b/include/asm-h8300/bitops.h
@@ -8,7 +8,6 @@
 #include <linux/config.h>
 #include <linux/compiler.h>
-#include <asm/byteorder.h>      /* swab32 */
 #include <asm/system.h>
 #ifdef __KERNEL__
@@ -177,10 +176,7 @@ H8300_GEN_TEST_BITOP(test_and_change_bit,"bnot")
 #undef H8300_GEN_TEST_BITOP_CONST_INT
 #undef H8300_GEN_TEST_BITOP
-#define find_first_zero_bit(addr, size) \
+#include <asm-generic/bitops/ffs.h>
-        find_next_zero_bit((addr), (size), 0)
-#define ffs(x) generic_ffs(x)
 static __inline__ unsigned long __ffs(unsigned long word)
 {
@@ -196,216 +192,16 @@ static __inline__ unsigned long __ffs(unsigned long word)
        return result;
 }
-static __inline__ int find_next_zero_bit (const unsigned long * addr, int size, int offset)
+#include <asm-generic/bitops/find.h>
-{
+#include <asm-generic/bitops/sched.h>
-        unsigned long *p = (unsigned long *)(((unsigned long)addr + (offset >> 3)) & ~3);
+#include <asm-generic/bitops/hweight.h>
-        unsigned long result = offset & ~31UL;
+#include <asm-generic/bitops/ext2-non-atomic.h>
-        unsigned long tmp;
+#include <asm-generic/bitops/ext2-atomic.h>
+#include <asm-generic/bitops/minix.h>
-        if (offset >= size)
-                return size;
-        size -= result;
-        offset &= 31UL;
-        if (offset) {
-                tmp = *(p++);
-                tmp |= ~0UL >> (32-offset);
-                if (size < 32)
-                        goto found_first;
-                if (~tmp)
-                        goto found_middle;
-                size -= 32;
-                result += 32;
-        }
-        while (size & ~31UL) {
-                if (~(tmp = *(p++)))
-                        goto found_middle;
-                result += 32;
-                size -= 32;
-        }
-        if (!size)
-                return result;
-        tmp = *p;
-found_first:
-        tmp |= ~0UL << size;
-found_middle:
-        return result + ffz(tmp);
-}
-static __inline__ unsigned long find_next_bit(const unsigned long *addr,
-        unsigned long size, unsigned long offset)
-{
-        unsigned long *p = (unsigned long *)(((unsigned long)addr + (offset >> 3)) & ~3);
-        unsigned int result = offset & ~31UL;
-        unsigned int tmp;
-        if (offset >= size)
-                return size;
-        size -= result;
-        offset &= 31UL;
-        if (offset) {
-                tmp = *(p++);
-                tmp &= ~0UL << offset;
-                if (size < 32)
-                        goto found_first;
-                if (tmp)
-                        goto found_middle;
-                size -= 32;
-                result += 32;
-        }
-        while (size >= 32) {
-                if ((tmp = *p++) != 0)
-                        goto found_middle;
-                result += 32;
-                size -= 32;
-        }
-        if (!size)
-                return result;
-        tmp = *p;
-found_first:
-        tmp &= ~0UL >> (32 - size);
-        if (tmp == 0UL)
-                return result + size;
-found_middle:
-        return result + __ffs(tmp);
-}
-#define find_first_bit(addr, size) find_next_bit(addr, size, 0)
-/*
- * Every architecture must define this function. It's the fastest
- * way of searching a 140-bit bitmap where the first 100 bits are
- * unlikely to be set. It's guaranteed that at least one of the 140
- * bits is cleared.
- */
-static inline int sched_find_first_bit(unsigned long *b)
-{
-        if (unlikely(b[0]))
-                return __ffs(b[0]);
-        if (unlikely(b[1]))
-                return __ffs(b[1]) + 32;
-        if (unlikely(b[2]))
-                return __ffs(b[2]) + 64;
-        if (b[3])
-                return __ffs(b[3]) + 96;
-        return __ffs(b[4]) + 128;
-}
-/*
- * hweightN: returns the hamming weight (i.e. the number
- * of bits set) of a N-bit word
- */
-#define hweight32(x) generic_hweight32(x)
-#define hweight16(x) generic_hweight16(x)
-#define hweight8(x) generic_hweight8(x)
-static __inline__ int ext2_set_bit(int nr, volatile void * addr)
-{
-        int             mask, retval;
-        unsigned long   flags;
-        volatile unsigned char  *ADDR = (unsigned char *) addr;
-        ADDR += nr >> 3;
-        mask = 1 << (nr & 0x07);
-        local_irq_save(flags);
-        retval = (mask & *ADDR) != 0;
-        *ADDR |= mask;
-        local_irq_restore(flags);
-        return retval;
-}
-#define ext2_set_bit_atomic(lock, nr, addr) ext2_set_bit(nr, addr)
-static __inline__ int ext2_clear_bit(int nr, volatile void * addr)
-{
-        int             mask, retval;
-        unsigned long   flags;
-        volatile unsigned char  *ADDR = (unsigned char *) addr;
-        ADDR += nr >> 3;
-        mask = 1 << (nr & 0x07);
-        local_irq_save(flags);
-        retval = (mask & *ADDR) != 0;
-        *ADDR &= ~mask;
-        local_irq_restore(flags);
-        return retval;
-}
-#define ext2_clear_bit_atomic(lock, nr, addr) ext2_set_bit(nr, addr)
-static __inline__ int ext2_test_bit(int nr, const volatile void * addr)
-{
-        int                     mask;
-        const volatile unsigned char    *ADDR = (const unsigned char *) addr;
-        ADDR += nr >> 3;
-        mask = 1 << (nr & 0x07);
-        return ((mask & *ADDR) != 0);
-}
-#define ext2_find_first_zero_bit(addr, size) \
-        ext2_find_next_zero_bit((addr), (size), 0)
-static __inline__ unsigned long ext2_find_next_zero_bit(void *addr, unsigned long size, unsigned long offset)
-{
-        unsigned long *p = ((unsigned long *) addr) + (offset >> 5);
-        unsigned long result = offset & ~31UL;
-        unsigned long tmp;
-        if (offset >= size)
-                return size;
-        size -= result;
-        offset &= 31UL;
-        if(offset) {
-                /* We hold the little endian value in tmp, but then the
-                 * shift is illegal. So we could keep a big endian value
-                 * in tmp, like this:
-                 *
-                 * tmp = __swab32(*(p++));
-                 * tmp |= ~0UL >> (32-offset);
-                 *
-                 * but this would decrease performance, so we change the
-                 * shift:
-                 */
-                tmp = *(p++);
-                tmp |= __swab32(~0UL >> (32-offset));
-                if(size < 32)
-                        goto found_first;
-                if(~tmp)
-                        goto found_middle;
-                size -= 32;
-                result += 32;
-        }
-        while(size & ~31UL) {
-                if(~(tmp = *(p++)))
-                        goto found_middle;
-                result += 32;
-                size -= 32;
-        }
-        if(!size)
-                return result;
-        tmp = *p;
-found_first:
-        /* tmp is little endian, so we would have to swab the shift,
-         * see above. But then we have to swab tmp below for ffz, so
-         * we might as well do this here.
-         */
-        return result + ffz(__swab32(tmp) | (~0UL << size));
-found_middle:
-        return result + ffz(__swab32(tmp));
-}
-/* Bitmap functions for the minix filesystem.  */
-#define minix_test_and_set_bit(nr,addr) test_and_set_bit(nr,addr)
-#define minix_set_bit(nr,addr) set_bit(nr,addr)
-#define minix_test_and_clear_bit(nr,addr) test_and_clear_bit(nr,addr)
-#define minix_test_bit(nr,addr) test_bit(nr,addr)
-#define minix_find_first_zero_bit(addr,size) find_first_zero_bit(addr,size)
 #endif /* __KERNEL__ */
-#define fls(x) generic_fls(x)
+#include <asm-generic/bitops/fls.h>
-#define fls64(x)   generic_fls64(x)
+#include <asm-generic/bitops/fls64.h>
 #endif /* _H8300_BITOPS_H */
diff --git a/include/asm-h8300/page.h b/include/asm-h8300/page.h
index cd35b1cc6cde..6472c9f88227 100644
--- a/include/asm-h8300/page.h
+++ b/include/asm-h8300/page.h
@@ -71,8 +71,7 @@ extern unsigned long memory_end;
 #define page_to_virt(page)      ((((page) - mem_map) << PAGE_SHIFT) + PAGE_OFFSET)
 #define pfn_valid(page)         (page < max_mapnr)
-#define pfn_to_page(pfn)        virt_to_page(pfn_to_virt(pfn))
+#define ARCH_PFN_OFFSET         (PAGE_OFFSET >> PAGE_SHIFT)
-#define page_to_pfn(page)       virt_to_pfn(page_to_virt(page))
 #define virt_addr_valid(kaddr)  (((void *)(kaddr) >= (void *)PAGE_OFFSET) && \
                                ((void *)(kaddr) < (void *)memory_end))
@@ -81,6 +80,7 @@ extern unsigned long memory_end;
 #endif /* __KERNEL__ */
+#include <asm-generic/memory_model.h>
 #include <asm-generic/page.h>
 #endif /* _H8300_PAGE_H */
diff --git a/include/asm-h8300/types.h b/include/asm-h8300/types.h
index bf91e0d4dde7..da2402b86540 100644
--- a/include/asm-h8300/types.h
+++ b/include/asm-h8300/types.h
@@ -58,6 +58,9 @@ typedef u32 dma_addr_t;
 #define HAVE_SECTOR_T
 typedef u64 sector_t;
+#define HAVE_BLKCNT_T
+typedef u64 blkcnt_t;
 #endif /* __KERNEL__ */
 #endif /* __ASSEMBLY__ */
diff --git a/include/asm-i386/bitops.h b/include/asm-i386/bitops.h
index 7d20b95edb3b..08deaeee6be9 100644
--- a/include/asm-i386/bitops.h
+++ b/include/asm-i386/bitops.h
@@ -362,28 +362,9 @@ static inline unsigned long ffz(unsigned long word)
        return word;
 }
-#define fls64(x)   generic_fls64(x)
 #ifdef __KERNEL__
-/*
+#include <asm-generic/bitops/sched.h>
- * Every architecture must define this function. It's the fastest
- * way of searching a 140-bit bitmap where the first 100 bits are
- * unlikely to be set. It's guaranteed that at least one of the 140
- * bits is cleared.
- */
-static inline int sched_find_first_bit(const unsigned long *b)
-{
-        if (unlikely(b[0]))
-                return __ffs(b[0]);
-        if (unlikely(b[1]))
-                return __ffs(b[1]) + 32;
-        if (unlikely(b[2]))
-                return __ffs(b[2]) + 64;
-        if (b[3])
-                return __ffs(b[3]) + 96;
-        return __ffs(b[4]) + 128;
-}
 /**
 * ffs - find first bit set
@@ -421,42 +402,22 @@ static inline int fls(int x)
        return r+1;
 }
-/**
+#include <asm-generic/bitops/hweight.h>
- * hweightN - returns the hamming weight of a N-bit word
- * @x: the word to weigh
- *
- * The Hamming Weight of a number is the total number of bits set in it.
- */
-#define hweight32(x) generic_hweight32(x)
-#define hweight16(x) generic_hweight16(x)
-#define hweight8(x) generic_hweight8(x)
 #endif /* __KERNEL__ */
+#include <asm-generic/bitops/fls64.h>
 #ifdef __KERNEL__
-#define ext2_set_bit(nr,addr) \
+#include <asm-generic/bitops/ext2-non-atomic.h>
-        __test_and_set_bit((nr),(unsigned long*)addr)
 #define ext2_set_bit_atomic(lock,nr,addr) \
        test_and_set_bit((nr),(unsigned long*)addr)
-#define ext2_clear_bit(nr, addr) \
-        __test_and_clear_bit((nr),(unsigned long*)addr)
 #define ext2_clear_bit_atomic(lock,nr, addr) \
                test_and_clear_bit((nr),(unsigned long*)addr)
-#define ext2_test_bit(nr, addr)      test_bit((nr),(unsigned long*)addr)
-#define ext2_find_first_zero_bit(addr, size) \
+#include <asm-generic/bitops/minix.h>
-        find_first_zero_bit((unsigned long*)addr, size)
-#define ext2_find_next_zero_bit(addr, size, off) \
-        find_next_zero_bit((unsigned long*)addr, size, off)
-/* Bitmap functions for the minix filesystem.  */
-#define minix_test_and_set_bit(nr,addr) __test_and_set_bit(nr,(void*)addr)
-#define minix_set_bit(nr,addr) __set_bit(nr,(void*)addr)
-#define minix_test_and_clear_bit(nr,addr) __test_and_clear_bit(nr,(void*)addr)
-#define minix_test_bit(nr,addr) test_bit(nr,(void*)addr)
-#define minix_find_first_zero_bit(addr,size) \
-        find_first_zero_bit((void*)addr,size)
 #endif /* __KERNEL__ */
diff --git a/include/asm-i386/futex.h b/include/asm-i386/futex.h
index 44b9db806474..7b8ceefd010f 100644
--- a/include/asm-i386/futex.h
+++ b/include/asm-i386/futex.h
@@ -104,5 +104,32 @@ futex_atomic_op_inuser (int encoded_op, int __user *uaddr)
        return ret;
 }
+static inline int
+futex_atomic_cmpxchg_inatomic(int __user *uaddr, int oldval, int newval)
+{
+        if (!access_ok(VERIFY_WRITE, uaddr, sizeof(int)))
+                return -EFAULT;
+        __asm__ __volatile__(
+                "1:     " LOCK_PREFIX "cmpxchgl %3, %1          \n"
+                "2:     .section .fixup, \"ax\"                 \n"
+                "3:     mov     %2, %0                          \n"
+                "       jmp     2b                              \n"
+                "       .previous                               \n"
+                "       .section __ex_table, \"a\"              \n"
+                "       .align  8                               \n"
+                "       .long   1b,3b                           \n"
+                "       .previous                               \n"
+                : "=a" (oldval), "=m" (*uaddr)
+                : "i" (-EFAULT), "r" (newval), "0" (oldval)
+                : "memory"
+        );
+        return oldval;
+}
 #endif
 #endif
diff --git a/include/asm-i386/kdebug.h b/include/asm-i386/kdebug.h
index 316138e89910..96d0828ce096 100644
--- a/include/asm-i386/kdebug.h
+++ b/include/asm-i386/kdebug.h
@@ -17,11 +17,9 @@ struct die_args {
        int signr;
 };
-/* Note - you should never unregister because that can race with NMIs.
+extern int register_die_notifier(struct notifier_block *);
-   If you really want to do it first unregister - then synchronize_sched - then free.
+extern int unregister_die_notifier(struct notifier_block *);
-  */
+extern struct atomic_notifier_head i386die_chain;
-int register_die_notifier(struct notifier_block *nb);
-extern struct notifier_block *i386die_chain;
 /* Grossly misnamed. */
@@ -51,7 +49,7 @@ static inline int notify_die(enum die_val val, const char *str,
                .trapnr = trap,
                .signr = sig
        };
-        return notifier_call_chain(&i386die_chain, val, &args);
+        return atomic_notifier_call_chain(&i386die_chain, val, &args);
 }
 #endif
diff --git a/include/asm-i386/kprobes.h b/include/asm-i386/kprobes.h
index a0d2d74a7dda..57d157c5cf89 100644
--- a/include/asm-i386/kprobes.h
+++ b/include/asm-i386/kprobes.h
@@ -34,6 +34,7 @@ struct pt_regs;
 typedef u8 kprobe_opcode_t;
 #define BREAKPOINT_INSTRUCTION  0xcc
+#define RELATIVEJUMP_INSTRUCTION 0xe9
 #define MAX_INSN_SIZE 16
 #define MAX_STACK_SIZE 64
 #define MIN_STACK_SIZE(ADDR) (((MAX_STACK_SIZE) < \
@@ -51,6 +52,11 @@ void kretprobe_trampoline(void);
 struct arch_specific_insn {
        /* copy of the original instruction */
        kprobe_opcode_t *insn;
+        /*
+         * If this flag is not 0, this kprobe can be boost when its
+         * post_handler and break_handler is not set.
+         */
+        int boostable;
 };
 struct prev_kprobe {
diff --git a/include/asm-i386/mmzone.h b/include/asm-i386/mmzone.h
index 74f595d80579..e33e9f9e4c66 100644
--- a/include/asm-i386/mmzone.h
+++ b/include/asm-i386/mmzone.h
@@ -70,8 +70,6 @@ static inline int pfn_to_nid(unsigned long pfn)
 #endif
 }
-#define node_localnr(pfn, nid)          ((pfn) - node_data[nid]->node_start_pfn)
 /*
 * Following are macros that each numa implmentation must define.
 */
@@ -86,21 +84,6 @@ static inline int pfn_to_nid(unsigned long pfn)
 /* XXX: FIXME -- wli */
 #define kern_addr_valid(kaddr)  (0)
-#define pfn_to_page(pfn)                                                \
-({                                                                      \
-        unsigned long __pfn = pfn;                                      \
-        int __node  = pfn_to_nid(__pfn);                                \
-        &NODE_DATA(__node)->node_mem_map[node_localnr(__pfn,__node)];   \
-})
-#define page_to_pfn(pg)                                                 \
-({                                                                      \
-        struct page *__page = pg;                                       \
-        struct zone *__zone = page_zone(__page);                        \
-        (unsigned long)(__page - __zone->zone_mem_map)                  \
-                + __zone->zone_start_pfn;                               \
-})
 #ifdef CONFIG_X86_NUMAQ            /* we have contiguous memory on NUMA-Q */
 #define pfn_valid(pfn)          ((pfn) < num_physpages)
 #else
diff --git a/include/asm-i386/page.h b/include/asm-i386/page.h
index 997ca5d17876..30f52a2263ba 100644
--- a/include/asm-i386/page.h
+++ b/include/asm-i386/page.h
@@ -126,8 +126,6 @@ extern int page_is_ram(unsigned long pagenr);
 #define __va(x)                 ((void *)((unsigned long)(x)+PAGE_OFFSET))
 #define pfn_to_kaddr(pfn)      __va((pfn) << PAGE_SHIFT)
 #ifdef CONFIG_FLATMEM
-#define pfn_to_page(pfn)        (mem_map + (pfn))
-#define page_to_pfn(page)       ((unsigned long)((page) - mem_map))
 #define pfn_valid(pfn)          ((pfn) < max_mapnr)
 #endif /* CONFIG_FLATMEM */
 #define virt_to_page(kaddr)     pfn_to_page(__pa(kaddr) >> PAGE_SHIFT)
@@ -141,6 +139,7 @@ extern int page_is_ram(unsigned long pagenr);
 #endif /* __KERNEL__ */
+#include <asm-generic/memory_model.h>
 #include <asm-generic/page.h>
 #endif /* _I386_PAGE_H */
diff --git a/include/asm-i386/processor.h b/include/asm-i386/processor.h
index feca5d961e2b..af4bfd012475 100644
--- a/include/asm-i386/processor.h
+++ b/include/asm-i386/processor.h
@@ -20,6 +20,7 @@
 #include <linux/config.h>
 #include <linux/threads.h>
 #include <asm/percpu.h>
+#include <linux/cpumask.h>
 /* flag for disabling the tsc */
 extern int tsc_disable;
@@ -67,6 +68,9 @@ struct cpuinfo_x86 {
        char    pad0;
        int     x86_power;
        unsigned long loops_per_jiffy;
+#ifdef CONFIG_SMP
+        cpumask_t llc_shared_map;       /* cpus sharing the last level cache */
+#endif
        unsigned char x86_max_cores;    /* cpuid returned max cores value */
        unsigned char booted_cores;     /* number of cores as seen by OS */
        unsigned char apicid;
@@ -103,6 +107,7 @@ extern struct cpuinfo_x86 cpu_data[];
 extern  int phys_proc_id[NR_CPUS];
 extern  int cpu_core_id[NR_CPUS];
+extern  int cpu_llc_id[NR_CPUS];
 extern char ignore_fpu_irq;
 extern void identify_cpu(struct cpuinfo_x86 *);
diff --git a/include/asm-i386/setup.h b/include/asm-i386/setup.h
index 826a8ca50ac8..ee941457b55d 100644
--- a/include/asm-i386/setup.h
+++ b/include/asm-i386/setup.h
@@ -6,9 +6,7 @@
 #ifndef _i386_SETUP_H
 #define _i386_SETUP_H
-#define PFN_UP(x)       (((x) + PAGE_SIZE-1) >> PAGE_SHIFT)
+#include <linux/pfn.h>
-#define PFN_DOWN(x)     ((x) >> PAGE_SHIFT)
-#define PFN_PHYS(x)     ((x) << PAGE_SHIFT)
 /*
 * Reserved space for vmalloc and iomap - defined in asm/page.h
diff --git a/include/asm-i386/stat.h b/include/asm-i386/stat.h
index b464f8020ec4..67eae78323ba 100644
--- a/include/asm-i386/stat.h
+++ b/include/asm-i386/stat.h
@@ -58,8 +58,7 @@ struct stat64 {
        long long       st_size;
        unsigned long   st_blksize;
-        unsigned long   st_blocks;      /* Number 512-byte blocks allocated. */
+        unsigned long long      st_blocks;      /* Number 512-byte blocks allocated. */
-        unsigned long   __pad4;         /* future possible st_blocks high bits */
        unsigned long   st_atime;
        unsigned long   st_atime_nsec;
diff --git a/include/asm-i386/topology.h b/include/asm-i386/topology.h
index aa958c6ee83e..b94e5eeef917 100644
--- a/include/asm-i386/topology.h
+++ b/include/asm-i386/topology.h
@@ -112,4 +112,6 @@ extern unsigned long node_remap_size[];
 #endif /* CONFIG_NUMA */
+extern cpumask_t cpu_coregroup_map(int cpu);
 #endif /* _ASM_I386_TOPOLOGY_H */
diff --git a/include/asm-i386/types.h b/include/asm-i386/types.h
index ced00fe8fe61..e50a08bd7ced 100644
--- a/include/asm-i386/types.h
+++ b/include/asm-i386/types.h
@@ -63,6 +63,11 @@ typedef u64 sector_t;
 #define HAVE_SECTOR_T
 #endif
+#ifdef CONFIG_LSF
+typedef u64 blkcnt_t;
+#define HAVE_BLKCNT_T
+#endif
 #endif /* __ASSEMBLY__ */
 #endif /* __KERNEL__ */
diff --git a/include/asm-i386/unistd.h b/include/asm-i386/unistd.h
index d8afd0e3b81a..014e3562895b 100644
--- a/include/asm-i386/unistd.h
+++ b/include/asm-i386/unistd.h
@@ -316,8 +316,10 @@
 #define __NR_pselect6           308
 #define __NR_ppoll              309
 #define __NR_unshare            310
+#define __NR_set_robust_list    311
+#define __NR_get_robust_list    312
-#define NR_syscalls 311
+#define NR_syscalls 313
 /*
 * user-visible error numbers are in the range -1 - -128: see
diff --git a/include/asm-ia64/bitops.h b/include/asm-ia64/bitops.h
index 36d0fb95ea89..90921e162793 100644
--- a/include/asm-ia64/bitops.h
+++ b/include/asm-ia64/bitops.h
@@ -5,8 +5,8 @@
 * Copyright (C) 1998-2003 Hewlett-Packard Co
 *      David Mosberger-Tang <davidm@hpl.hp.com>
 *
- * 02/06/02 find_next_bit() and find_first_bit() added from Erich Focht's ia64 O(1)
+ * 02/06/02 find_next_bit() and find_first_bit() added from Erich Focht's ia64
- *          scheduler patch
+ * O(1) scheduler patch
 */
 #include <linux/compiler.h>
@@ -25,9 +25,9 @@
 * restricted to acting on a single-word quantity.
 *
 * The address must be (at least) "long" aligned.
- * Note that there are driver (e.g., eepro100) which use these operations to operate on
+ * Note that there are driver (e.g., eepro100) which use these operations to
- * hw-defined data-structures, so we can't easily change these operations to force a
+ * operate on hw-defined data-structures, so we can't easily change these
- * bigger alignment.
+ * operations to force a bigger alignment.
 *
 * bit 0 is the LSB of addr; bit 32 is the LSB of (addr+1).
 */
@@ -284,8 +284,8 @@ test_bit (int nr, const volatile void *addr)
 * ffz - find the first zero bit in a long word
 * @x: The long word to find the bit in
 *
- * Returns the bit-number (0..63) of the first (least significant) zero bit.  Undefined if
+ * Returns the bit-number (0..63) of the first (least significant) zero bit.
- * no zero exists, so code should check against ~0UL first...
+ * Undefined if no zero exists, so code should check against ~0UL first...
 */
 static inline unsigned long
 ffz (unsigned long x)
@@ -345,13 +345,14 @@ fls (int t)
        x |= x >> 16;
        return ia64_popcnt(x);
 }
-#define fls64(x)   generic_fls64(x)
+#include <asm-generic/bitops/fls64.h>
 /*
- * ffs: find first bit set. This is defined the same way as the libc and compiler builtin
+ * ffs: find first bit set. This is defined the same way as the libc and
- * ffs routines, therefore differs in spirit from the above ffz (man ffs): it operates on
+ * compiler builtin ffs routines, therefore differs in spirit from the above
- * "int" values only and the result value is the bit number + 1.  ffs(0) is defined to
+ * ffz (man ffs): it operates on "int" values only and the result value is the
- * return zero.
+ * bit number + 1.  ffs(0) is defined to return zero.
 */
 #define ffs(x)  __builtin_ffs(x)
@@ -373,51 +374,17 @@ hweight64 (unsigned long x)
 #endif /* __KERNEL__ */
-extern int __find_next_zero_bit (const void *addr, unsigned long size,
+#include <asm-generic/bitops/find.h>
-                        unsigned long offset);
-extern int __find_next_bit(const void *addr, unsigned long size,
-                        unsigned long offset);
-#define find_next_zero_bit(addr, size, offset) \
-                        __find_next_zero_bit((addr), (size), (offset))
-#define find_next_bit(addr, size, offset) \
-                        __find_next_bit((addr), (size), (offset))
-/*
- * The optimizer actually does good code for this case..
- */
-#define find_first_zero_bit(addr, size) find_next_zero_bit((addr), (size), 0)
-#define find_first_bit(addr, size) find_next_bit((addr), (size), 0)
 #ifdef __KERNEL__
-#define __clear_bit(nr, addr)           clear_bit(nr, addr)
+#include <asm-generic/bitops/ext2-non-atomic.h>
-#define ext2_set_bit                    test_and_set_bit
 #define ext2_set_bit_atomic(l,n,a)      test_and_set_bit(n,a)
-#define ext2_clear_bit                  test_and_clear_bit
 #define ext2_clear_bit_atomic(l,n,a)    test_and_clear_bit(n,a)
-#define ext2_test_bit                   test_bit
-#define ext2_find_first_zero_bit        find_first_zero_bit
-#define ext2_find_next_zero_bit         find_next_zero_bit
-/* Bitmap functions for the minix filesystem.  */
-#define minix_test_and_set_bit(nr,addr)         test_and_set_bit(nr,addr)
-#define minix_set_bit(nr,addr)                  set_bit(nr,addr)
-#define minix_test_and_clear_bit(nr,addr)       test_and_clear_bit(nr,addr)
-#define minix_test_bit(nr,addr)                 test_bit(nr,addr)
-#define minix_find_first_zero_bit(addr,size)    find_first_zero_bit(addr,size)
-static inline int
+#include <asm-generic/bitops/minix.h>
-sched_find_first_bit (unsigned long *b)
+#include <asm-generic/bitops/sched.h>
-{
-        if (unlikely(b[0]))
-                return __ffs(b[0]);
-        if (unlikely(b[1]))
-                return 64 + __ffs(b[1]);
-        return __ffs(b[2]) + 128;
-}
 #endif /* __KERNEL__ */
diff --git a/include/asm-ia64/compat.h b/include/asm-ia64/compat.h
index c0b19106665c..40d01d80610d 100644
--- a/include/asm-ia64/compat.h
+++ b/include/asm-ia64/compat.h
@@ -189,6 +189,12 @@ compat_ptr (compat_uptr_t uptr)
        return (void __user *) (unsigned long) uptr;
 }
+static inline compat_uptr_t
+ptr_to_compat(void __user *uptr)
+{
+        return (u32)(unsigned long)uptr;
+}
 static __inline__ void __user *
 compat_alloc_user_space (long len)
 {
diff --git a/include/asm-ia64/dmi.h b/include/asm-ia64/dmi.h
new file mode 100644
index 000000000000..f3efaa229525
--- /dev/null
+++ b/include/asm-ia64/dmi.h
@@ -0,0 +1,6 @@
+#ifndef _ASM_DMI_H
+#define _ASM_DMI_H 1
+#include <asm/io.h>
+#endif
diff --git a/include/asm-ia64/io.h b/include/asm-ia64/io.h
index b64fdb985494..c2e3742108bb 100644
--- a/include/asm-ia64/io.h
+++ b/include/asm-ia64/io.h
@@ -88,8 +88,8 @@ phys_to_virt (unsigned long address)
 }
 #define ARCH_HAS_VALID_PHYS_ADDR_RANGE
-extern int valid_phys_addr_range (unsigned long addr, size_t *count); /* efi.c */
+extern int valid_phys_addr_range (unsigned long addr, size_t count); /* efi.c */
-extern int valid_mmap_phys_addr_range (unsigned long addr, size_t *count);
+extern int valid_mmap_phys_addr_range (unsigned long addr, size_t count);
 /*
 * The following two macros are deprecated and scheduled for removal.
@@ -416,24 +416,18 @@ __writeq (unsigned long val, volatile void __iomem *addr)
 # define outl_p         outl
 #endif
-/*
+extern void __iomem * ioremap(unsigned long offset, unsigned long size);
- * An "address" in IO memory space is not clearly either an integer or a pointer. We will
+extern void __iomem * ioremap_nocache (unsigned long offset, unsigned long size);
- * accept both, thus the casts.
- *
- * On ia-64, we access the physical I/O memory space through the uncached kernel region.
- */
-static inline void __iomem *
-ioremap (unsigned long offset, unsigned long size)
-{
-        return (void __iomem *) (__IA64_UNCACHED_OFFSET | (offset));
-}
 static inline void
 iounmap (volatile void __iomem *addr)
 {
 }
-#define ioremap_nocache(o,s)    ioremap(o,s)
+/* Use normal IO mappings for DMI */
+#define dmi_ioremap ioremap
+#define dmi_iounmap(x,l) iounmap(x)
+#define dmi_alloc(l) kmalloc(l, GFP_ATOMIC)
 # ifdef __KERNEL__
diff --git a/include/asm-ia64/kdebug.h b/include/asm-ia64/kdebug.h
index 8b01a083dde6..218c458ab60c 100644
--- a/include/asm-ia64/kdebug.h
+++ b/include/asm-ia64/kdebug.h
@@ -40,7 +40,7 @@ struct die_args {
 extern int register_die_notifier(struct notifier_block *);
 extern int unregister_die_notifier(struct notifier_block *);
-extern struct notifier_block *ia64die_chain;
+extern struct atomic_notifier_head ia64die_chain;
 enum die_val {
        DIE_BREAK = 1,
@@ -81,7 +81,7 @@ static inline int notify_die(enum die_val val, char *str, struct pt_regs *regs,
                .signr  = sig
        };
-        return notifier_call_chain(&ia64die_chain, val, &args);
+        return atomic_notifier_call_chain(&ia64die_chain, val, &args);
 }
 #endif
diff --git a/include/asm-ia64/page.h b/include/asm-ia64/page.h
index 6e9aa23250c4..2087825eefa4 100644
--- a/include/asm-ia64/page.h
+++ b/include/asm-ia64/page.h
@@ -106,17 +106,25 @@ extern int ia64_pfn_valid (unsigned long pfn);
 # define ia64_pfn_valid(pfn) 1
 #endif
+#ifdef CONFIG_VIRTUAL_MEM_MAP
+extern struct page *vmem_map;
+#ifdef CONFIG_DISCONTIGMEM
+# define page_to_pfn(page)      ((unsigned long) (page - vmem_map))
+# define pfn_to_page(pfn)       (vmem_map + (pfn))
+#endif
+#endif
+#if defined(CONFIG_FLATMEM) || defined(CONFIG_SPARSEMEM)
+/* FLATMEM always configures mem_map (mem_map = vmem_map if necessary) */
+#include <asm-generic/memory_model.h>
+#endif
 #ifdef CONFIG_FLATMEM
 # define pfn_valid(pfn)         (((pfn) < max_mapnr) && ia64_pfn_valid(pfn))
-# define page_to_pfn(page)      ((unsigned long) (page - mem_map))
-# define pfn_to_page(pfn)       (mem_map + (pfn))
 #elif defined(CONFIG_DISCONTIGMEM)
-extern struct page *vmem_map;
 extern unsigned long min_low_pfn;
 extern unsigned long max_low_pfn;
 # define pfn_valid(pfn)         (((pfn) >= min_low_pfn) && ((pfn) < max_low_pfn) && ia64_pfn_valid(pfn))
-# define page_to_pfn(page)      ((unsigned long) (page - vmem_map))
-# define pfn_to_page(pfn)       (vmem_map + (pfn))
 #endif
 #define page_to_phys(page)      (page_to_pfn(page) << PAGE_SHIFT)
diff --git a/include/asm-ia64/sn/sn_sal.h b/include/asm-ia64/sn/sn_sal.h
index 244449df7411..bf4cc867a698 100644
--- a/include/asm-ia64/sn/sn_sal.h
+++ b/include/asm-ia64/sn/sn_sal.h
@@ -159,7 +159,7 @@
 static inline u32
 sn_sal_rev(void)
 {
-        struct ia64_sal_systab *systab = efi.sal_systab;
+        struct ia64_sal_systab *systab = __va(efi.sal_systab);
        return (u32)(systab->sal_b_rev_major << 8 | systab->sal_b_rev_minor);
 }
diff --git a/include/asm-m32r/bitops.h b/include/asm-m32r/bitops.h
index abea2fdd8689..902a366101a5 100644
--- a/include/asm-m32r/bitops.h
+++ b/include/asm-m32r/bitops.h
@@ -63,25 +63,6 @@ static __inline__ void set_bit(int nr, volatile void * addr)
 }
 /**
- * __set_bit - Set a bit in memory
- * @nr: the bit to set
- * @addr: the address to start counting from
- *
- * Unlike set_bit(), this function is non-atomic and may be reordered.
- * If it's called on the same region of memory simultaneously, the effect
- * may be that only one operation succeeds.
- */
-static __inline__ void __set_bit(int nr, volatile void * addr)
-{
-        __u32 mask;
-        volatile __u32 *a = addr;
-        a += (nr >> 5);
-        mask = (1 << (nr & 0x1F));
-        *a |= mask;
-}
-/**
 * clear_bit - Clears a bit in memory
 * @nr: Bit to clear
 * @addr: Address to start counting from
@@ -118,39 +99,10 @@ static __inline__ void clear_bit(int nr, volatile void * addr)
        local_irq_restore(flags);
 }
-static __inline__ void __clear_bit(int nr, volatile unsigned long * addr)
-{
-        unsigned long mask;
-        volatile unsigned long *a = addr;
-        a += (nr >> 5);
-        mask = (1 << (nr & 0x1F));
-        *a &= ~mask;
-}
 #define smp_mb__before_clear_bit()      barrier()
 #define smp_mb__after_clear_bit()       barrier()
 /**
- * __change_bit - Toggle a bit in memory
- * @nr: the bit to set
- * @addr: the address to start counting from
- *
- * Unlike change_bit(), this function is non-atomic and may be reordered.
- * If it's called on the same region of memory simultaneously, the effect
- * may be that only one operation succeeds.
- */
-static __inline__ void __change_bit(int nr, volatile void * addr)
-{
-        __u32 mask;
-        volatile __u32 *a = addr;
-        a += (nr >> 5);
-        mask = (1 << (nr & 0x1F));
-        *a ^= mask;
-}
-/**
 * change_bit - Toggle a bit in memory
 * @nr: Bit to clear
 * @addr: Address to start counting from
@@ -221,28 +173,6 @@ static __inline__ int test_and_set_bit(int nr, volatile void * addr)
 }
 /**
- * __test_and_set_bit - Set a bit and return its old value
- * @nr: Bit to set
- * @addr: Address to count from
- *
- * This operation is non-atomic and can be reordered.
- * If two examples of this operation race, one can appear to succeed
- * but actually fail.  You must protect multiple accesses with a lock.
- */
-static __inline__ int __test_and_set_bit(int nr, volatile void * addr)
-{
-        __u32 mask, oldbit;
-        volatile __u32 *a = addr;
-        a += (nr >> 5);
-        mask = (1 << (nr & 0x1F));
-        oldbit = (*a & mask);
-        *a |= mask;
-        return (oldbit != 0);
-}
-/**
 * test_and_clear_bit - Clear a bit and return its old value
 * @nr: Bit to set
 * @addr: Address to count from
@@ -280,42 +210,6 @@ static __inline__ int test_and_clear_bit(int nr, volatile void * addr)
 }
 /**
- * __test_and_clear_bit - Clear a bit and return its old value
- * @nr: Bit to set
- * @addr: Address to count from
- *
- * This operation is non-atomic and can be reordered.
- * If two examples of this operation race, one can appear to succeed
- * but actually fail.  You must protect multiple accesses with a lock.
- */
-static __inline__ int __test_and_clear_bit(int nr, volatile void * addr)
-{
-        __u32 mask, oldbit;
-        volatile __u32 *a = addr;
-        a += (nr >> 5);
-        mask = (1 << (nr & 0x1F));
-        oldbit = (*a & mask);
-        *a &= ~mask;
-        return (oldbit != 0);
-}
-/* WARNING: non atomic and it can be reordered! */
-static __inline__ int __test_and_change_bit(int nr, volatile void * addr)
-{
-        __u32 mask, oldbit;
-        volatile __u32 *a = addr;
-        a += (nr >> 5);
-        mask = (1 << (nr & 0x1F));
-        oldbit = (*a & mask);
-        *a ^= mask;
-        return (oldbit != 0);
-}
-/**
 * test_and_change_bit - Change a bit and return its old value
 * @nr: Bit to set
 * @addr: Address to count from
@@ -350,353 +244,26 @@ static __inline__ int test_and_change_bit(int nr, volatile void * addr)
        return (oldbit != 0);
 }
-/**
+#include <asm-generic/bitops/non-atomic.h>
- * test_bit - Determine whether a bit is set
+#include <asm-generic/bitops/ffz.h>
- * @nr: bit number to test
+#include <asm-generic/bitops/__ffs.h>
- * @addr: Address to start counting from
+#include <asm-generic/bitops/fls.h>
- */
+#include <asm-generic/bitops/fls64.h>
-static __inline__ int test_bit(int nr, const volatile void * addr)
-{
-        __u32 mask;
-        const volatile __u32 *a = addr;
-        a += (nr >> 5);
-        mask = (1 << (nr & 0x1F));
-        return ((*a & mask) != 0);
-}
-/**
- * ffz - find first zero in word.
- * @word: The word to search
- *
- * Undefined if no zero exists, so code should check against ~0UL first.
- */
-static __inline__ unsigned long ffz(unsigned long word)
-{
-        int k;
-        word = ~word;
-        k = 0;
-        if (!(word & 0x0000ffff)) { k += 16; word >>= 16; }
-        if (!(word & 0x000000ff)) { k += 8; word >>= 8; }
-        if (!(word & 0x0000000f)) { k += 4; word >>= 4; }
-        if (!(word & 0x00000003)) { k += 2; word >>= 2; }
-        if (!(word & 0x00000001)) { k += 1; }
-        return k;
-}
-/**
- * find_first_zero_bit - find the first zero bit in a memory region
- * @addr: The address to start the search at
- * @size: The maximum size to search
- *
- * Returns the bit-number of the first zero bit, not the number of the byte
- * containing a bit.
- */
-#define find_first_zero_bit(addr, size) \
-        find_next_zero_bit((addr), (size), 0)
-/**
- * find_next_zero_bit - find the first zero bit in a memory region
- * @addr: The address to base the search on
- * @offset: The bitnumber to start searching at
- * @size: The maximum size to search
- */
-static __inline__ int find_next_zero_bit(const unsigned long *addr,
-                                         int size, int offset)
-{
-        const unsigned long *p = addr + (offset >> 5);
-        unsigned long result = offset & ~31UL;
-        unsigned long tmp;
-        if (offset >= size)
-                return size;
-        size -= result;
-        offset &= 31UL;
-        if (offset) {
-                tmp = *(p++);
-                tmp |= ~0UL >> (32-offset);
-                if (size < 32)
-                        goto found_first;
-                if (~tmp)
-                        goto found_middle;
-                size -= 32;
-                result += 32;
-        }
-        while (size & ~31UL) {
-                if (~(tmp = *(p++)))
-                        goto found_middle;
-                result += 32;
-                size -= 32;
-        }
-        if (!size)
-                return result;
-        tmp = *p;
-found_first:
-        tmp |= ~0UL << size;
-found_middle:
-        return result + ffz(tmp);
-}
-/**
- * __ffs - find first bit in word.
- * @word: The word to search
- *
- * Undefined if no bit exists, so code should check against 0 first.
- */
-static __inline__ unsigned long __ffs(unsigned long word)
-{
-        int k = 0;
-        if (!(word & 0x0000ffff)) { k += 16; word >>= 16; }
-        if (!(word & 0x000000ff)) { k += 8; word >>= 8; }
-        if (!(word & 0x0000000f)) { k += 4; word >>= 4; }
-        if (!(word & 0x00000003)) { k += 2; word >>= 2; }
-        if (!(word & 0x00000001)) { k += 1;}
-        return k;
-}
-/*
- * fls: find last bit set.
- */
-#define fls(x) generic_fls(x)
-#define fls64(x)   generic_fls64(x)
 #ifdef __KERNEL__
-/*
+#include <asm-generic/bitops/sched.h>
- * Every architecture must define this function. It's the fastest
+#include <asm-generic/bitops/find.h>
- * way of searching a 140-bit bitmap where the first 100 bits are
+#include <asm-generic/bitops/ffs.h>
- * unlikely to be set. It's guaranteed that at least one of the 140
+#include <asm-generic/bitops/hweight.h>
- * bits is cleared.
- */
-static inline int sched_find_first_bit(unsigned long *b)
-{
-        if (unlikely(b[0]))
-                return __ffs(b[0]);
-        if (unlikely(b[1]))
-                return __ffs(b[1]) + 32;
-        if (unlikely(b[2]))
-                return __ffs(b[2]) + 64;
-        if (b[3])
-                return __ffs(b[3]) + 96;
-        return __ffs(b[4]) + 128;
-}
-/**
- * find_next_bit - find the first set bit in a memory region
- * @addr: The address to base the search on
- * @offset: The bitnumber to start searching at
- * @size: The maximum size to search
- */
-static inline unsigned long find_next_bit(const unsigned long *addr,
-        unsigned long size, unsigned long offset)
-{
-        unsigned int *p = ((unsigned int *) addr) + (offset >> 5);
-        unsigned int result = offset & ~31UL;
-        unsigned int tmp;
-        if (offset >= size)
-                return size;
-        size -= result;
-        offset &= 31UL;
-        if (offset) {
-                tmp = *p++;
-                tmp &= ~0UL << offset;
-                if (size < 32)
-                        goto found_first;
-                if (tmp)
-                        goto found_middle;
-                size -= 32;
-                result += 32;
-        }
-        while (size >= 32) {
-                if ((tmp = *p++) != 0)
-                        goto found_middle;
-                result += 32;
-                size -= 32;
-        }
-        if (!size)
-                return result;
-        tmp = *p;
-found_first:
-        tmp &= ~0UL >> (32 - size);
-        if (tmp == 0UL)        /* Are any bits set? */
-                return result + size; /* Nope. */
-found_middle:
-        return result + __ffs(tmp);
-}
-/**
- * find_first_bit - find the first set bit in a memory region
- * @addr: The address to start the search at
- * @size: The maximum size to search
- *
- * Returns the bit-number of the first set bit, not the number of the byte
- * containing a bit.
- */
-#define find_first_bit(addr, size) \
-        find_next_bit((addr), (size), 0)
-/**
- * ffs - find first bit set
- * @x: the word to search
- *
- * This is defined the same way as
- * the libc and compiler builtin ffs routines, therefore
- * differs in spirit from the above ffz (man ffs).
- */
-#define ffs(x)  generic_ffs(x)
-/**
- * hweightN - returns the hamming weight of a N-bit word
- * @x: the word to weigh
- *
- * The Hamming Weight of a number is the total number of bits set in it.
- */
-#define hweight32(x)    generic_hweight32(x)
-#define hweight16(x)    generic_hweight16(x)
-#define hweight8(x)     generic_hweight8(x)
 #endif /* __KERNEL__ */
 #ifdef __KERNEL__
-/*
+#include <asm-generic/bitops/ext2-non-atomic.h>
- * ext2_XXXX function
+#include <asm-generic/bitops/ext2-atomic.h>
- * orig: include/asm-sh/bitops.h
+#include <asm-generic/bitops/minix.h>
- */
-#ifdef __LITTLE_ENDIAN__
-#define ext2_set_bit                    test_and_set_bit
-#define ext2_clear_bit                  __test_and_clear_bit
-#define ext2_test_bit                   test_bit
-#define ext2_find_first_zero_bit        find_first_zero_bit
-#define ext2_find_next_zero_bit         find_next_zero_bit
-#else
-static inline int ext2_set_bit(int nr, volatile void * addr)
-{
-        __u8 mask, oldbit;
-        volatile __u8 *a = addr;
-        a += (nr >> 3);
-        mask = (1 << (nr & 0x07));
-        oldbit = (*a & mask);
-        *a |= mask;
-        return (oldbit != 0);
-}
-static inline int ext2_clear_bit(int nr, volatile void * addr)
-{
-        __u8 mask, oldbit;
-        volatile __u8 *a = addr;
-        a += (nr >> 3);
-        mask = (1 << (nr & 0x07));
-        oldbit = (*a & mask);
-        *a &= ~mask;
-        return (oldbit != 0);
-}
-static inline int ext2_test_bit(int nr, const volatile void * addr)
-{
-        __u32 mask;
-        const volatile __u8 *a = addr;
-        a += (nr >> 3);
-        mask = (1 << (nr & 0x07));
-        return ((mask & *a) != 0);
-}
-#define ext2_find_first_zero_bit(addr, size) \
-        ext2_find_next_zero_bit((addr), (size), 0)
-static inline unsigned long ext2_find_next_zero_bit(void *addr,
-        unsigned long size, unsigned long offset)
-{
-        unsigned long *p = ((unsigned long *) addr) + (offset >> 5);
-        unsigned long result = offset & ~31UL;
-        unsigned long tmp;
-        if (offset >= size)
-                return size;
-        size -= result;
-        offset &= 31UL;
-        if(offset) {
-                /* We hold the little endian value in tmp, but then the
-                 * shift is illegal. So we could keep a big endian value
-                 * in tmp, like this:
-                 *
-                 * tmp = __swab32(*(p++));
-                 * tmp |= ~0UL >> (32-offset);
-                 *
-                 * but this would decrease preformance, so we change the
-                 * shift:
-                 */
-                tmp = *(p++);
-                tmp |= __swab32(~0UL >> (32-offset));
-                if(size < 32)
-                        goto found_first;
-                if(~tmp)
-                        goto found_middle;
-                size -= 32;
-                result += 32;
-        }
-        while(size & ~31UL) {
-                if(~(tmp = *(p++)))
-                        goto found_middle;
-                result += 32;
-                size -= 32;
-        }
-        if(!size)
-                return result;
-        tmp = *p;
-found_first:
-        /* tmp is little endian, so we would have to swab the shift,
-         * see above. But then we have to swab tmp below for ffz, so
-         * we might as well do this here.
-         */
-        return result + ffz(__swab32(tmp) | (~0UL << size));
-found_middle:
-        return result + ffz(__swab32(tmp));
-}
-#endif
-#define ext2_set_bit_atomic(lock, nr, addr)             \
-        ({                                              \
-                int ret;                                \
-                spin_lock(lock);                        \
-                ret = ext2_set_bit((nr), (addr));       \
-                spin_unlock(lock);                      \
-                ret;                                    \
-        })
-#define ext2_clear_bit_atomic(lock, nr, addr)           \
-        ({                                              \
-                int ret;                                \
-                spin_lock(lock);                        \
-                ret = ext2_clear_bit((nr), (addr));     \
-                spin_unlock(lock);                      \
-                ret;                                    \
-        })
-/* Bitmap functions for the minix filesystem.  */
-#define minix_test_and_set_bit(nr,addr)         __test_and_set_bit(nr,addr)
-#define minix_set_bit(nr,addr)                  __set_bit(nr,addr)
-#define minix_test_and_clear_bit(nr,addr)       __test_and_clear_bit(nr,addr)
-#define minix_test_bit(nr,addr) test_bit(nr,addr)
-#define minix_find_first_zero_bit(addr,size)    find_first_zero_bit(addr,size)
 #endif /* __KERNEL__ */
diff --git a/include/asm-m32r/mmzone.h b/include/asm-m32r/mmzone.h
index adc7970a77ec..9f3b5accda88 100644
--- a/include/asm-m32r/mmzone.h
+++ b/include/asm-m32r/mmzone.h
@@ -21,20 +21,6 @@ extern struct pglist_data *node_data[];
        __pgdat->node_start_pfn + __pgdat->node_spanned_pages - 1;      \
 })
-#define pfn_to_page(pfn)                                                \
-({                                                                      \
-        unsigned long __pfn = pfn;                                      \
-        int __node  = pfn_to_nid(__pfn);                                \
-        &NODE_DATA(__node)->node_mem_map[node_localnr(__pfn,__node)];   \
-})
-#define page_to_pfn(pg)                                                 \
-({                                                                      \
-        struct page *__page = pg;                                       \
-        struct zone *__zone = page_zone(__page);                        \
-        (unsigned long)(__page - __zone->zone_mem_map)                  \
-                + __zone->zone_start_pfn;                               \
-})
 #define pmd_page(pmd)           (pfn_to_page(pmd_val(pmd) >> PAGE_SHIFT))
 /*
 * pfn_valid should be made as fast as possible, and the current definition
diff --git a/include/asm-m32r/page.h b/include/asm-m32r/page.h
index 4ab578876361..9ddbc087dbc5 100644
--- a/include/asm-m32r/page.h
+++ b/include/asm-m32r/page.h
@@ -76,9 +76,7 @@ typedef struct { unsigned long pgprot; } pgprot_t;
 #ifndef CONFIG_DISCONTIGMEM
 #define PFN_BASE                (CONFIG_MEMORY_START >> PAGE_SHIFT)
-#define pfn_to_page(pfn)        (mem_map + ((pfn) - PFN_BASE))
+#define ARCH_PFN_OFFSET         PFN_BASE
-#define page_to_pfn(page)       \
-        ((unsigned long)((page) - mem_map) + PFN_BASE)
 #define pfn_valid(pfn)          (((pfn) - PFN_BASE) < max_mapnr)
 #endif  /* !CONFIG_DISCONTIGMEM */
@@ -92,6 +90,7 @@ typedef struct { unsigned long pgprot; } pgprot_t;
 #endif /* __KERNEL__ */
+#include <asm-generic/memory_model.h>
 #include <asm-generic/page.h>
 #endif /* _ASM_M32R_PAGE_H */
diff --git a/include/asm-m32r/setup.h b/include/asm-m32r/setup.h
index 5f028dc26a9b..52f4fa29abfc 100644
--- a/include/asm-m32r/setup.h
+++ b/include/asm-m32r/setup.h
@@ -24,10 +24,6 @@
 #define RAMDISK_PROMPT_FLAG             (0x8000)
 #define RAMDISK_LOAD_FLAG               (0x4000)
-#define PFN_UP(x)       (((x) + PAGE_SIZE-1) >> PAGE_SHIFT)
-#define PFN_DOWN(x)     ((x) >> PAGE_SHIFT)
-#define PFN_PHYS(x)     ((x) << PAGE_SHIFT)
 extern unsigned long memory_start;
 extern unsigned long memory_end;
diff --git a/include/asm-m68k/bitops.h b/include/asm-m68k/bitops.h
index 13f4c0048463..1a61fdb56aaf 100644
--- a/include/asm-m68k/bitops.h
+++ b/include/asm-m68k/bitops.h
@@ -310,36 +310,10 @@ static inline int fls(int x)
        return 32 - cnt;
 }
-#define fls64(x)   generic_fls64(x)
-/*
+#include <asm-generic/bitops/fls64.h>
- * Every architecture must define this function. It's the fastest
+#include <asm-generic/bitops/sched.h>
- * way of searching a 140-bit bitmap where the first 100 bits are
+#include <asm-generic/bitops/hweight.h>
- * unlikely to be set. It's guaranteed that at least one of the 140
- * bits is cleared.
- */
-static inline int sched_find_first_bit(const unsigned long *b)
-{
-        if (unlikely(b[0]))
-                return __ffs(b[0]);
-        if (unlikely(b[1]))
-                return __ffs(b[1]) + 32;
-        if (unlikely(b[2]))
-                return __ffs(b[2]) + 64;
-        if (b[3])
-                return __ffs(b[3]) + 96;
-        return __ffs(b[4]) + 128;
-}
-/*
- * hweightN: returns the hamming weight (i.e. the number
- * of bits set) of a N-bit word
- */
-#define hweight32(x) generic_hweight32(x)
-#define hweight16(x) generic_hweight16(x)
-#define hweight8(x) generic_hweight8(x)
 /* Bitmap functions for the minix filesystem */
@@ -365,9 +339,9 @@ static inline int minix_find_first_zero_bit(const void *vaddr, unsigned size)
        return ((p - addr) << 4) + (res ^ 31);
 }
-#define minix_test_and_set_bit(nr, addr)        test_and_set_bit((nr) ^ 16, (unsigned long *)(addr))
+#define minix_test_and_set_bit(nr, addr)        __test_and_set_bit((nr) ^ 16, (unsigned long *)(addr))
-#define minix_set_bit(nr,addr)                  set_bit((nr) ^ 16, (unsigned long *)(addr))
+#define minix_set_bit(nr,addr)                  __set_bit((nr) ^ 16, (unsigned long *)(addr))
-#define minix_test_and_clear_bit(nr, addr)      test_and_clear_bit((nr) ^ 16, (unsigned long *)(addr))
+#define minix_test_and_clear_bit(nr, addr)      __test_and_clear_bit((nr) ^ 16, (unsigned long *)(addr))
 static inline int minix_test_bit(int nr, const void *vaddr)
 {
@@ -377,9 +351,9 @@ static inline int minix_test_bit(int nr, const void *vaddr)
 /* Bitmap functions for the ext2 filesystem. */
-#define ext2_set_bit(nr, addr)                  test_and_set_bit((nr) ^ 24, (unsigned long *)(addr))
+#define ext2_set_bit(nr, addr)                  __test_and_set_bit((nr) ^ 24, (unsigned long *)(addr))
 #define ext2_set_bit_atomic(lock, nr, addr)     test_and_set_bit((nr) ^ 24, (unsigned long *)(addr))
-#define ext2_clear_bit(nr, addr)                test_and_clear_bit((nr) ^ 24, (unsigned long *)(addr))
+#define ext2_clear_bit(nr, addr)                __test_and_clear_bit((nr) ^ 24, (unsigned long *)(addr))
 #define ext2_clear_bit_atomic(lock, nr, addr)   test_and_clear_bit((nr) ^ 24, (unsigned long *)(addr))
 static inline int ext2_test_bit(int nr, const void *vaddr)
diff --git a/include/asm-m68k/stat.h b/include/asm-m68k/stat.h
index c4c402a45e21..dd38bc2e9f98 100644
--- a/include/asm-m68k/stat.h
+++ b/include/asm-m68k/stat.h
@@ -60,8 +60,7 @@ struct stat64 {
        long long       st_size;
        unsigned long   st_blksize;
-        unsigned long   __pad4;         /* future possible st_blocks high bits */
+        unsigned long long      st_blocks;      /* Number 512-byte blocks allocated. */
-        unsigned long   st_blocks;      /* Number 512-byte blocks allocated. */
        unsigned long   st_atime;
        unsigned long   st_atime_nsec;
diff --git a/include/asm-m68knommu/bitops.h b/include/asm-m68knommu/bitops.h
index 25d8a3cfef90..0b68ccd327f7 100644
--- a/include/asm-m68knommu/bitops.h
+++ b/include/asm-m68knommu/bitops.h
@@ -12,104 +12,10 @@
 #ifdef __KERNEL__
-/*
+#include <asm-generic/bitops/ffs.h>
- *      Generic ffs().
+#include <asm-generic/bitops/__ffs.h>
- */
+#include <asm-generic/bitops/sched.h>
-static inline int ffs(int x)
+#include <asm-generic/bitops/ffz.h>
-{
-        int r = 1;
-        if (!x)
-                return 0;
-        if (!(x & 0xffff)) {
-                x >>= 16;
-                r += 16;
-        }
-        if (!(x & 0xff)) {
-                x >>= 8;
-                r += 8;
-        }
-        if (!(x & 0xf)) {
-                x >>= 4;
-                r += 4;
-        }
-        if (!(x & 3)) {
-                x >>= 2;
-                r += 2;
-        }
-        if (!(x & 1)) {
-                x >>= 1;
-                r += 1;
-        }
-        return r;
-}
-/*
- *      Generic __ffs().
- */
-static inline int __ffs(int x)
-{
-        int r = 0;
-        if (!x)
-                return 0;
-        if (!(x & 0xffff)) {
-                x >>= 16;
-                r += 16;
-        }
-        if (!(x & 0xff)) {
-                x >>= 8;
-                r += 8;
-        }
-        if (!(x & 0xf)) {
-                x >>= 4;
-                r += 4;
-        }
-        if (!(x & 3)) {
-                x >>= 2;
-                r += 2;
-        }
-        if (!(x & 1)) {
-                x >>= 1;
-                r += 1;
-        }
-        return r;
-}
-/*
- * Every architecture must define this function. It's the fastest
- * way of searching a 140-bit bitmap where the first 100 bits are
- * unlikely to be set. It's guaranteed that at least one of the 140
- * bits is cleared.
- */
-static inline int sched_find_first_bit(unsigned long *b)
-{
-        if (unlikely(b[0]))
-                return __ffs(b[0]);
-        if (unlikely(b[1]))
-                return __ffs(b[1]) + 32;
-        if (unlikely(b[2]))
-                return __ffs(b[2]) + 64;
-        if (b[3])
-                return __ffs(b[3]) + 96;
-        return __ffs(b[4]) + 128;
-}
-/*
- * ffz = Find First Zero in word. Undefined if no zero exists,
- * so code should check against ~0UL first..
- */
-static __inline__ unsigned long ffz(unsigned long word)
-{
-        unsigned long result = 0;
-        while(word & 1) {
-                result++;
-                word >>= 1;
-        }
-        return result;
-}
 static __inline__ void set_bit(int nr, volatile unsigned long * addr)
 {
@@ -254,98 +160,8 @@ static __inline__ int __test_bit(int nr, const volatile unsigned long * addr)
 __constant_test_bit((nr),(addr)) : \
 __test_bit((nr),(addr)))
-#define find_first_zero_bit(addr, size) \
+#include <asm-generic/bitops/find.h>
-        find_next_zero_bit((addr), (size), 0)
+#include <asm-generic/bitops/hweight.h>
-#define find_first_bit(addr, size) \
-        find_next_bit((addr), (size), 0)
-static __inline__ int find_next_zero_bit (const void * addr, int size, int offset)
-{
-        unsigned long *p = ((unsigned long *) addr) + (offset >> 5);
-        unsigned long result = offset & ~31UL;
-        unsigned long tmp;
-        if (offset >= size)
-                return size;
-        size -= result;
-        offset &= 31UL;
-        if (offset) {
-                tmp = *(p++);
-                tmp |= ~0UL >> (32-offset);
-                if (size < 32)
-                        goto found_first;
-                if (~tmp)
-                        goto found_middle;
-                size -= 32;
-                result += 32;
-        }
-        while (size & ~31UL) {
-                if (~(tmp = *(p++)))
-                        goto found_middle;
-                result += 32;
-                size -= 32;
-        }
-        if (!size)
-                return result;
-        tmp = *p;
-found_first:
-        tmp |= ~0UL << size;
-found_middle:
-        return result + ffz(tmp);
-}
-/*
- * Find next one bit in a bitmap reasonably efficiently.
- */
-static __inline__ unsigned long find_next_bit(const unsigned long *addr,
-        unsigned long size, unsigned long offset)
-{
-        unsigned int *p = ((unsigned int *) addr) + (offset >> 5);
-        unsigned int result = offset & ~31UL;
-        unsigned int tmp;
-        if (offset >= size)
-                return size;
-        size -= result;
-        offset &= 31UL;
-        if (offset) {
-                tmp = *p++;
-                tmp &= ~0UL << offset;
-                if (size < 32)
-                        goto found_first;
-                if (tmp)
-                        goto found_middle;
-                size -= 32;
-                result += 32;
-        }
-        while (size >= 32) {
-                if ((tmp = *p++) != 0)
-                        goto found_middle;
-                result += 32;
-                size -= 32;
-        }
-        if (!size)
-                return result;
-        tmp = *p;
-found_first:
-        tmp &= ~0UL >> (32 - size);
-        if (tmp == 0UL)        /* Are any bits set? */
-                return result + size; /* Nope. */
-found_middle:
-        return result + __ffs(tmp);
-}
-/*
- * hweightN: returns the hamming weight (i.e. the number
- * of bits set) of a N-bit word
- */
-#define hweight32(x) generic_hweight32(x)
-#define hweight16(x) generic_hweight16(x)
-#define hweight8(x) generic_hweight8(x)
 static __inline__ int ext2_set_bit(int nr, volatile void * addr)
 {
@@ -475,30 +291,11 @@ found_middle:
        return result + ffz(__swab32(tmp));
 }
-/* Bitmap functions for the minix filesystem.  */
+#include <asm-generic/bitops/minix.h>
-#define minix_test_and_set_bit(nr,addr) test_and_set_bit(nr,addr)
-#define minix_set_bit(nr,addr) set_bit(nr,addr)
-#define minix_test_and_clear_bit(nr,addr) test_and_clear_bit(nr,addr)
-#define minix_test_bit(nr,addr) test_bit(nr,addr)
-#define minix_find_first_zero_bit(addr,size) find_first_zero_bit(addr,size)
-/**
- * hweightN - returns the hamming weight of a N-bit word
- * @x: the word to weigh
- *
- * The Hamming Weight of a number is the total number of bits set in it.
- */
-#define hweight32(x) generic_hweight32(x)
-#define hweight16(x) generic_hweight16(x)
-#define hweight8(x) generic_hweight8(x)
 #endif /* __KERNEL__ */
-/*
+#include <asm-generic/bitops/fls.h>
- * fls: find last bit set.
+#include <asm-generic/bitops/fls64.h>
- */
-#define fls(x) generic_fls(x)
-#define fls64(x)   generic_fls64(x)
 #endif /* _M68KNOMMU_BITOPS_H */
diff --git a/include/asm-mips/bitops.h b/include/asm-mips/bitops.h
index 8e802059fe67..a1728f8c0705 100644
--- a/include/asm-mips/bitops.h
+++ b/include/asm-mips/bitops.h
@@ -105,22 +105,6 @@ static inline void set_bit(unsigned long nr, volatile unsigned long *addr)
 }
 /*
- * __set_bit - Set a bit in memory
- * @nr: the bit to set
- * @addr: the address to start counting from
- *
- * Unlike set_bit(), this function is non-atomic and may be reordered.
- * If it's called on the same region of memory simultaneously, the effect
- * may be that only one operation succeeds.
- */
-static inline void __set_bit(unsigned long nr, volatile unsigned long * addr)
-{
-        unsigned long * m = ((unsigned long *) addr) + (nr >> SZLONG_LOG);
-        *m |= 1UL << (nr & SZLONG_MASK);
-}
-/*
 * clear_bit - Clears a bit in memory
 * @nr: Bit to clear
 * @addr: Address to start counting from
@@ -169,22 +153,6 @@ static inline void clear_bit(unsigned long nr, volatile unsigned long *addr)
 }
 /*
- * __clear_bit - Clears a bit in memory
- * @nr: Bit to clear
- * @addr: Address to start counting from
- *
- * Unlike clear_bit(), this function is non-atomic and may be reordered.
- * If it's called on the same region of memory simultaneously, the effect
- * may be that only one operation succeeds.
- */
-static inline void __clear_bit(unsigned long nr, volatile unsigned long * addr)
-{
-        unsigned long * m = ((unsigned long *) addr) + (nr >> SZLONG_LOG);
-        *m &= ~(1UL << (nr & SZLONG_MASK));
-}
-/*
 * change_bit - Toggle a bit in memory
 * @nr: Bit to change
 * @addr: Address to start counting from
@@ -235,22 +203,6 @@ static inline void change_bit(unsigned long nr, volatile unsigned long *addr)
 }
 /*
- * __change_bit - Toggle a bit in memory
- * @nr: the bit to change
- * @addr: the address to start counting from
- *
- * Unlike change_bit(), this function is non-atomic and may be reordered.
- * If it's called on the same region of memory simultaneously, the effect
- * may be that only one operation succeeds.
- */
-static inline void __change_bit(unsigned long nr, volatile unsigned long * addr)
-{
-        unsigned long * m = ((unsigned long *) addr) + (nr >> SZLONG_LOG);
-        *m ^= 1UL << (nr & SZLONG_MASK);
-}
-/*
 * test_and_set_bit - Set a bit and return its old value
 * @nr: Bit to set
 * @addr: Address to count from
@@ -321,30 +273,6 @@ static inline int test_and_set_bit(unsigned long nr,
 }
 /*
- * __test_and_set_bit - Set a bit and return its old value
- * @nr: Bit to set
- * @addr: Address to count from
- *
- * This operation is non-atomic and can be reordered.
- * If two examples of this operation race, one can appear to succeed
- * but actually fail.  You must protect multiple accesses with a lock.
- */
-static inline int __test_and_set_bit(unsigned long nr,
-        volatile unsigned long *addr)
-{
-        volatile unsigned long *a = addr;
-        unsigned long mask;
-        int retval;
-        a += nr >> SZLONG_LOG;
-        mask = 1UL << (nr & SZLONG_MASK);
-        retval = (mask & *a) != 0;
-        *a |= mask;
-        return retval;
-}
-/*
 * test_and_clear_bit - Clear a bit and return its old value
 * @nr: Bit to clear
 * @addr: Address to count from
@@ -417,30 +345,6 @@ static inline int test_and_clear_bit(unsigned long nr,
 }
 /*
- * __test_and_clear_bit - Clear a bit and return its old value
- * @nr: Bit to clear
- * @addr: Address to count from
- *
- * This operation is non-atomic and can be reordered.
- * If two examples of this operation race, one can appear to succeed
- * but actually fail.  You must protect multiple accesses with a lock.
- */
-static inline int __test_and_clear_bit(unsigned long nr,
-        volatile unsigned long * addr)
-{
-        volatile unsigned long *a = addr;
-        unsigned long mask;
-        int retval;
-        a += (nr >> SZLONG_LOG);
-        mask = 1UL << (nr & SZLONG_MASK);
-        retval = ((mask & *a) != 0);
-        *a &= ~mask;
-        return retval;
-}
-/*
 * test_and_change_bit - Change a bit and return its old value
 * @nr: Bit to change
 * @addr: Address to count from
@@ -509,43 +413,11 @@ static inline int test_and_change_bit(unsigned long nr,
        }
 }
-/*
- * __test_and_change_bit - Change a bit and return its old value
- * @nr: Bit to change
- * @addr: Address to count from
- *
- * This operation is non-atomic and can be reordered.
- * If two examples of this operation race, one can appear to succeed
- * but actually fail.  You must protect multiple accesses with a lock.
- */
-static inline int __test_and_change_bit(unsigned long nr,
-        volatile unsigned long *addr)
-{
-        volatile unsigned long *a = addr;
-        unsigned long mask;
-        int retval;
-        a += (nr >> SZLONG_LOG);
-        mask = 1UL << (nr & SZLONG_MASK);
-        retval = ((mask & *a) != 0);
-        *a ^= mask;
-        return retval;
-}
 #undef __bi_flags
 #undef __bi_local_irq_save
 #undef __bi_local_irq_restore
-/*
+#include <asm-generic/bitops/non-atomic.h>
- * test_bit - Determine whether a bit is set
- * @nr: bit number to test
- * @addr: Address to start counting from
- */
-static inline int test_bit(unsigned long nr, const volatile unsigned long *addr)
-{
-        return 1UL & (addr[nr >> SZLONG_LOG] >> (nr & SZLONG_MASK));
-}
 /*
 * Return the bit position (0..63) of the most significant 1 bit in a word
@@ -580,6 +452,8 @@ static inline int __ilog2(unsigned long x)
        return 63 - lz;
 }
+#if defined(CONFIG_CPU_MIPS32) || defined(CONFIG_CPU_MIPS64)
 /*
 * __ffs - find first bit in word.
 * @word: The word to search
@@ -589,31 +463,7 @@ static inline int __ilog2(unsigned long x)
 */
 static inline unsigned long __ffs(unsigned long word)
 {
-#if defined(CONFIG_CPU_MIPS32) || defined(CONFIG_CPU_MIPS64)
        return __ilog2(word & -word);
-#else
-        int b = 0, s;
-#ifdef CONFIG_32BIT
-        s = 16; if (word << 16 != 0) s = 0; b += s; word >>= s;
-        s =  8; if (word << 24 != 0) s = 0; b += s; word >>= s;
-        s =  4; if (word << 28 != 0) s = 0; b += s; word >>= s;
-        s =  2; if (word << 30 != 0) s = 0; b += s; word >>= s;
-        s =  1; if (word << 31 != 0) s = 0; b += s;
-        return b;
-#endif
-#ifdef CONFIG_64BIT
-        s = 32; if (word << 32 != 0) s = 0; b += s; word >>= s;
-        s = 16; if (word << 48 != 0) s = 0; b += s; word >>= s;
-        s =  8; if (word << 56 != 0) s = 0; b += s; word >>= s;
-        s =  4; if (word << 60 != 0) s = 0; b += s; word >>= s;
-        s =  2; if (word << 62 != 0) s = 0; b += s; word >>= s;
-        s =  1; if (word << 63 != 0) s = 0; b += s;
-        return b;
-#endif
-#endif
 }
 /*
@@ -652,321 +502,38 @@ static inline unsigned long ffz(unsigned long word)
 */
 static inline unsigned long fls(unsigned long word)
 {
-#ifdef CONFIG_32BIT
 #ifdef CONFIG_CPU_MIPS32
        __asm__ ("clz %0, %1" : "=r" (word) : "r" (word));
        return 32 - word;
-#else
-        {
-        int r = 32, s;
-        if (word == 0)
-                return 0;
-        s = 16; if ((word & 0xffff0000)) s = 0; r -= s; word <<= s;
-        s = 8;  if ((word & 0xff000000)) s = 0; r -= s; word <<= s;
-        s = 4;  if ((word & 0xf0000000)) s = 0; r -= s; word <<= s;
-        s = 2;  if ((word & 0xc0000000)) s = 0; r -= s; word <<= s;
-        s = 1;  if ((word & 0x80000000)) s = 0; r -= s;
-        return r;
-        }
 #endif
-#endif /* CONFIG_32BIT */
-#ifdef CONFIG_64BIT
 #ifdef CONFIG_CPU_MIPS64
        __asm__ ("dclz %0, %1" : "=r" (word) : "r" (word));
        return 64 - word;
-#else
-        {
-        int r = 64, s;
-        if (word == 0)
-                return 0;
-        s = 32; if ((word & 0xffffffff00000000UL)) s = 0; r -= s; word <<= s;
-        s = 16; if ((word & 0xffff000000000000UL)) s = 0; r -= s; word <<= s;
-        s = 8;  if ((word & 0xff00000000000000UL)) s = 0; r -= s; word <<= s;
-        s = 4;  if ((word & 0xf000000000000000UL)) s = 0; r -= s; word <<= s;
-        s = 2;  if ((word & 0xc000000000000000UL)) s = 0; r -= s; word <<= s;
-        s = 1;  if ((word & 0x8000000000000000UL)) s = 0; r -= s;
-        return r;
-        }
 #endif
-#endif /* CONFIG_64BIT */
 }
-#define fls64(x)   generic_fls64(x)
+#else
-/*
- * find_next_zero_bit - find the first zero bit in a memory region
- * @addr: The address to base the search on
- * @offset: The bitnumber to start searching at
- * @size: The maximum size to search
- */
-static inline unsigned long find_next_zero_bit(const unsigned long *addr,
-        unsigned long size, unsigned long offset)
-{
-        const unsigned long *p = addr + (offset >> SZLONG_LOG);
-        unsigned long result = offset & ~SZLONG_MASK;
-        unsigned long tmp;
-        if (offset >= size)
-                return size;
-        size -= result;
-        offset &= SZLONG_MASK;
-        if (offset) {
-                tmp = *(p++);
-                tmp |= ~0UL >> (_MIPS_SZLONG-offset);
-                if (size < _MIPS_SZLONG)
-                        goto found_first;
-                if (~tmp)
-                        goto found_middle;
-                size -= _MIPS_SZLONG;
-                result += _MIPS_SZLONG;
-        }
-        while (size & ~SZLONG_MASK) {
-                if (~(tmp = *(p++)))
-                        goto found_middle;
-                result += _MIPS_SZLONG;
-                size -= _MIPS_SZLONG;
-        }
-        if (!size)
-                return result;
-        tmp = *p;
-found_first:
-        tmp |= ~0UL << size;
-        if (tmp == ~0UL)                /* Are any bits zero? */
-                return result + size;   /* Nope. */
-found_middle:
-        return result + ffz(tmp);
-}
-#define find_first_zero_bit(addr, size) \
+#include <asm-generic/bitops/__ffs.h>
-        find_next_zero_bit((addr), (size), 0)
+#include <asm-generic/bitops/ffs.h>
+#include <asm-generic/bitops/ffz.h>
+#include <asm-generic/bitops/fls.h>
-/*
+#endif /*defined(CONFIG_CPU_MIPS32) || defined(CONFIG_CPU_MIPS64) */
- * find_next_bit - find the next set bit in a memory region
- * @addr: The address to base the search on
- * @offset: The bitnumber to start searching at
- * @size: The maximum size to search
- */
-static inline unsigned long find_next_bit(const unsigned long *addr,
-        unsigned long size, unsigned long offset)
-{
-        const unsigned long *p = addr + (offset >> SZLONG_LOG);
-        unsigned long result = offset & ~SZLONG_MASK;
-        unsigned long tmp;
-        if (offset >= size)
-                return size;
-        size -= result;
-        offset &= SZLONG_MASK;
-        if (offset) {
-                tmp = *(p++);
-                tmp &= ~0UL << offset;
-                if (size < _MIPS_SZLONG)
-                        goto found_first;
-                if (tmp)
-                        goto found_middle;
-                size -= _MIPS_SZLONG;
-                result += _MIPS_SZLONG;
-        }
-        while (size & ~SZLONG_MASK) {
-                if ((tmp = *(p++)))
-                        goto found_middle;
-                result += _MIPS_SZLONG;
-                size -= _MIPS_SZLONG;
-        }
-        if (!size)
-                return result;
-        tmp = *p;
-found_first:
-        tmp &= ~0UL >> (_MIPS_SZLONG - size);
-        if (tmp == 0UL)                 /* Are any bits set? */
-                return result + size;   /* Nope. */
-found_middle:
-        return result + __ffs(tmp);
-}
-/*
+#include <asm-generic/bitops/fls64.h>
- * find_first_bit - find the first set bit in a memory region
+#include <asm-generic/bitops/find.h>
- * @addr: The address to start the search at
- * @size: The maximum size to search
- *
- * Returns the bit-number of the first set bit, not the number of the byte
- * containing a bit.
- */
-#define find_first_bit(addr, size) \
-        find_next_bit((addr), (size), 0)
 #ifdef __KERNEL__
-/*
+#include <asm-generic/bitops/sched.h>
- * Every architecture must define this function. It's the fastest
+#include <asm-generic/bitops/hweight.h>
- * way of searching a 140-bit bitmap where the first 100 bits are
+#include <asm-generic/bitops/ext2-non-atomic.h>
- * unlikely to be set. It's guaranteed that at least one of the 140
+#include <asm-generic/bitops/ext2-atomic.h>
- * bits is cleared.
+#include <asm-generic/bitops/minix.h>
- */
-static inline int sched_find_first_bit(const unsigned long *b)
-{
-#ifdef CONFIG_32BIT
-        if (unlikely(b[0]))
-                return __ffs(b[0]);
-        if (unlikely(b[1]))
-                return __ffs(b[1]) + 32;
-        if (unlikely(b[2]))
-                return __ffs(b[2]) + 64;
-        if (b[3])
-                return __ffs(b[3]) + 96;
-        return __ffs(b[4]) + 128;
-#endif
-#ifdef CONFIG_64BIT
-        if (unlikely(b[0]))
-                return __ffs(b[0]);
-        if (unlikely(b[1]))
-                return __ffs(b[1]) + 64;
-        return __ffs(b[2]) + 128;
-#endif
-}
-/*
- * hweightN - returns the hamming weight of a N-bit word
- * @x: the word to weigh
- *
- * The Hamming Weight of a number is the total number of bits set in it.
- */
-#define hweight64(x)    generic_hweight64(x)
-#define hweight32(x)    generic_hweight32(x)
-#define hweight16(x)    generic_hweight16(x)
-#define hweight8(x)     generic_hweight8(x)
-static inline int __test_and_set_le_bit(unsigned long nr, unsigned long *addr)
-{
-        unsigned char   *ADDR = (unsigned char *) addr;
-        int             mask, retval;
-        ADDR += nr >> 3;
-        mask = 1 << (nr & 0x07);
-        retval = (mask & *ADDR) != 0;
-        *ADDR |= mask;
-        return retval;
-}
-static inline int __test_and_clear_le_bit(unsigned long nr, unsigned long *addr)
-{
-        unsigned char   *ADDR = (unsigned char *) addr;
-        int             mask, retval;
-        ADDR += nr >> 3;
-        mask = 1 << (nr & 0x07);
-        retval = (mask & *ADDR) != 0;
-        *ADDR &= ~mask;
-        return retval;
-}
-static inline int test_le_bit(unsigned long nr, const unsigned long * addr)
-{
-        const unsigned char     *ADDR = (const unsigned char *) addr;
-        int                     mask;
-        ADDR += nr >> 3;
-        mask = 1 << (nr & 0x07);
-        return ((mask & *ADDR) != 0);
-}
-static inline unsigned long find_next_zero_le_bit(unsigned long *addr,
-        unsigned long size, unsigned long offset)
-{
-        unsigned long *p = ((unsigned long *) addr) + (offset >> SZLONG_LOG);
-        unsigned long result = offset & ~SZLONG_MASK;
-        unsigned long tmp;
-        if (offset >= size)
-                return size;
-        size -= result;
-        offset &= SZLONG_MASK;
-        if (offset) {
-                tmp = cpu_to_lelongp(p++);
-                tmp |= ~0UL >> (_MIPS_SZLONG-offset); /* bug or feature ? */
-                if (size < _MIPS_SZLONG)
-                        goto found_first;
-                if (~tmp)
-                        goto found_middle;
-                size -= _MIPS_SZLONG;
-                result += _MIPS_SZLONG;
-        }
-        while (size & ~SZLONG_MASK) {
-                if (~(tmp = cpu_to_lelongp(p++)))
-                        goto found_middle;
-                result += _MIPS_SZLONG;
-                size -= _MIPS_SZLONG;
-        }
-        if (!size)
-                return result;
-        tmp = cpu_to_lelongp(p);
-found_first:
-        tmp |= ~0UL << size;
-        if (tmp == ~0UL)                /* Are any bits zero? */
-                return result + size;   /* Nope. */
-found_middle:
-        return result + ffz(tmp);
-}
-#define find_first_zero_le_bit(addr, size) \
-        find_next_zero_le_bit((addr), (size), 0)
-#define ext2_set_bit(nr,addr) \
-        __test_and_set_le_bit((nr),(unsigned long*)addr)
-#define ext2_clear_bit(nr, addr) \
-        __test_and_clear_le_bit((nr),(unsigned long*)addr)
- #define ext2_set_bit_atomic(lock, nr, addr)            \
-({                                                      \
-        int ret;                                        \
-        spin_lock(lock);                                \
-        ret = ext2_set_bit((nr), (addr));               \
-        spin_unlock(lock);                              \
-        ret;                                            \
-})
-#define ext2_clear_bit_atomic(lock, nr, addr)           \
-({                                                      \
-        int ret;                                        \
-        spin_lock(lock);                                \
-        ret = ext2_clear_bit((nr), (addr));             \
-        spin_unlock(lock);                              \
-        ret;                                            \
-})
-#define ext2_test_bit(nr, addr) test_le_bit((nr),(unsigned long*)addr)
-#define ext2_find_first_zero_bit(addr, size) \
-        find_first_zero_le_bit((unsigned long*)addr, size)
-#define ext2_find_next_zero_bit(addr, size, off) \
-        find_next_zero_le_bit((unsigned long*)addr, size, off)
-/*
- * Bitmap functions for the minix filesystem.
- *
- * FIXME: These assume that Minix uses the native byte/bitorder.
- * This limits the Minix filesystem's value for data exchange very much.
- */
-#define minix_test_and_set_bit(nr,addr) test_and_set_bit(nr,addr)
-#define minix_set_bit(nr,addr) set_bit(nr,addr)
-#define minix_test_and_clear_bit(nr,addr) test_and_clear_bit(nr,addr)
-#define minix_test_bit(nr,addr) test_bit(nr,addr)
-#define minix_find_first_zero_bit(addr,size) find_first_zero_bit(addr,size)
 #endif /* __KERNEL__ */
diff --git a/include/asm-mips/compat.h b/include/asm-mips/compat.h
index 0012bd804d2d..986511db54a6 100644
--- a/include/asm-mips/compat.h
+++ b/include/asm-mips/compat.h
@@ -133,6 +133,11 @@ static inline void __user *compat_ptr(compat_uptr_t uptr)
        return (void __user *)(long)uptr;
 }
+static inline compat_uptr_t ptr_to_compat(void __user *uptr)
+{
+        return (u32)(unsigned long)uptr;
+}
 static inline void __user *compat_alloc_user_space(long len)
 {
        struct pt_regs *regs = (struct pt_regs *)
diff --git a/include/asm-mips/futex.h b/include/asm-mips/futex.h
index 2454c44a8f54..a554089991f2 100644
--- a/include/asm-mips/futex.h
+++ b/include/asm-mips/futex.h
@@ -99,5 +99,11 @@ futex_atomic_op_inuser (int encoded_op, int __user *uaddr)
        return ret;
 }
+static inline int
+futex_atomic_cmpxchg_inatomic(int __user *uaddr, int oldval, int newval)
+{
+        return -ENOSYS;
+}
 #endif
 #endif
diff --git a/include/asm-mips/mmzone.h b/include/asm-mips/mmzone.h
index 011caebac369..7bde4432092b 100644
--- a/include/asm-mips/mmzone.h
+++ b/include/asm-mips/mmzone.h
@@ -22,20 +22,6 @@
                       NODE_DATA(__n)->node_spanned_pages) : 0);\
 })
-#define pfn_to_page(pfn)                                        \
-({                                                              \
-        unsigned long __pfn = (pfn);                            \
-        pg_data_t *__pg = NODE_DATA(pfn_to_nid(__pfn));         \
-        __pg->node_mem_map + (__pfn - __pg->node_start_pfn);    \
-})
-#define page_to_pfn(p)                                          \
-({                                                              \
-        struct page *__p = (p);                                 \
-        struct zone *__z = page_zone(__p);                      \
-        ((__p - __z->zone_mem_map) + __z->zone_start_pfn);      \
-})
 /* XXX: FIXME -- wli */
 #define kern_addr_valid(addr)   (0)
diff --git a/include/asm-mips/page.h b/include/asm-mips/page.h
index ee25a779bf49..a1eab136ff6c 100644
--- a/include/asm-mips/page.h
+++ b/include/asm-mips/page.h
@@ -140,8 +140,6 @@ typedef struct { unsigned long pgprot; } pgprot_t;
 #define pfn_to_kaddr(pfn)       __va((pfn) << PAGE_SHIFT)
 #ifndef CONFIG_NEED_MULTIPLE_NODES
-#define pfn_to_page(pfn)        (mem_map + (pfn))
-#define page_to_pfn(page)       ((unsigned long)((page) - mem_map))
 #define pfn_valid(pfn)          ((pfn) < max_mapnr)
 #endif
@@ -160,6 +158,7 @@ typedef struct { unsigned long pgprot; } pgprot_t;
 #define WANT_PAGE_VIRTUAL
 #endif
+#include <asm-generic/memory_model.h>
 #include <asm-generic/page.h>
 #endif /* _ASM_PAGE_H */
diff --git a/include/asm-mips/time.h b/include/asm-mips/time.h
index 9cc3564cc2c9..d897c8bb554d 100644
--- a/include/asm-mips/time.h
+++ b/include/asm-mips/time.h
@@ -26,14 +26,14 @@ extern spinlock_t rtc_lock;
 /*
 * RTC ops.  By default, they point to no-RTC functions.
- *      rtc_get_time - mktime(year, mon, day, hour, min, sec) in seconds.
+ *      rtc_mips_get_time - mktime(year, mon, day, hour, min, sec) in seconds.
- *      rtc_set_time - reverse the above translation and set time to RTC.
+ *      rtc_mips_set_time - reverse the above translation and set time to RTC.
- *      rtc_set_mmss - similar to rtc_set_time, but only min and sec need
+ *      rtc_mips_set_mmss - similar to rtc_set_time, but only min and sec need
 *                      to be set.  Used by RTC sync-up.
 */
-extern unsigned long (*rtc_get_time)(void);
+extern unsigned long (*rtc_mips_get_time)(void);
-extern int (*rtc_set_time)(unsigned long);
+extern int (*rtc_mips_set_time)(unsigned long);
-extern int (*rtc_set_mmss)(unsigned long);
+extern int (*rtc_mips_set_mmss)(unsigned long);
 /*
 * Timer interrupt functions.
diff --git a/include/asm-mips/types.h b/include/asm-mips/types.h
index 421b3aea14cc..cd2813d8e136 100644
--- a/include/asm-mips/types.h
+++ b/include/asm-mips/types.h
@@ -99,6 +99,11 @@ typedef u64 sector_t;
 #define HAVE_SECTOR_T
 #endif
+#ifdef CONFIG_LSF
+typedef u64 blkcnt_t;
+#define HAVE_BLKCNT_T
+#endif
 #endif /* __ASSEMBLY__ */
 #endif /* __KERNEL__ */
diff --git a/include/asm-parisc/bitops.h b/include/asm-parisc/bitops.h
index 15d8c2b51584..900561922c4c 100644
--- a/include/asm-parisc/bitops.h
+++ b/include/asm-parisc/bitops.h
@@ -35,13 +35,6 @@ static __inline__ void set_bit(int nr, volatile unsigned long * addr)
        _atomic_spin_unlock_irqrestore(addr, flags);
 }
-static __inline__ void __set_bit(unsigned long nr, volatile unsigned long * addr)
-{
-        unsigned long *m = (unsigned long *) addr + (nr >> SHIFT_PER_LONG);
-        *m |= 1UL << CHOP_SHIFTCOUNT(nr);
-}
 static __inline__ void clear_bit(int nr, volatile unsigned long * addr)
 {
        unsigned long mask = ~(1UL << CHOP_SHIFTCOUNT(nr));
@@ -53,13 +46,6 @@ static __inline__ void clear_bit(int nr, volatile unsigned long * addr)
        _atomic_spin_unlock_irqrestore(addr, flags);
 }
-static __inline__ void __clear_bit(unsigned long nr, volatile unsigned long * addr)
-{
-        unsigned long *m = (unsigned long *) addr + (nr >> SHIFT_PER_LONG);
-        *m &= ~(1UL << CHOP_SHIFTCOUNT(nr));
-}
 static __inline__ void change_bit(int nr, volatile unsigned long * addr)
 {
        unsigned long mask = 1UL << CHOP_SHIFTCOUNT(nr);
@@ -71,13 +57,6 @@ static __inline__ void change_bit(int nr, volatile unsigned long * addr)
        _atomic_spin_unlock_irqrestore(addr, flags);
 }
-static __inline__ void __change_bit(unsigned long nr, volatile unsigned long * addr)
-{
-        unsigned long *m = (unsigned long *) addr + (nr >> SHIFT_PER_LONG);
-        *m ^= 1UL << CHOP_SHIFTCOUNT(nr);
-}
 static __inline__ int test_and_set_bit(int nr, volatile unsigned long * addr)
 {
        unsigned long mask = 1UL << CHOP_SHIFTCOUNT(nr);
@@ -93,18 +72,6 @@ static __inline__ int test_and_set_bit(int nr, volatile unsigned long * addr)
        return (oldbit & mask) ? 1 : 0;
 }
-static __inline__ int __test_and_set_bit(int nr, volatile unsigned long * address)
-{
-        unsigned long mask = 1UL << CHOP_SHIFTCOUNT(nr);
-        unsigned long oldbit;
-        unsigned long *addr = (unsigned long *)address + (nr >> SHIFT_PER_LONG);
-        oldbit = *addr;
-        *addr = oldbit | mask;
-        return (oldbit & mask) ? 1 : 0;
-}
 static __inline__ int test_and_clear_bit(int nr, volatile unsigned long * addr)
 {
        unsigned long mask = 1UL << CHOP_SHIFTCOUNT(nr);
@@ -120,18 +87,6 @@ static __inline__ int test_and_clear_bit(int nr, volatile unsigned long * addr)
        return (oldbit & mask) ? 1 : 0;
 }
-static __inline__ int __test_and_clear_bit(int nr, volatile unsigned long * address)
-{
-        unsigned long mask = 1UL << CHOP_SHIFTCOUNT(nr);
-        unsigned long *addr = (unsigned long *)address + (nr >> SHIFT_PER_LONG);
-        unsigned long oldbit;
-        oldbit = *addr;
-        *addr = oldbit & ~mask;
-        return (oldbit & mask) ? 1 : 0;
-}
 static __inline__ int test_and_change_bit(int nr, volatile unsigned long * addr)
 {
        unsigned long mask = 1UL << CHOP_SHIFTCOUNT(nr);
@@ -147,25 +102,7 @@ static __inline__ int test_and_change_bit(int nr, volatile unsigned long * addr)
        return (oldbit & mask) ? 1 : 0;
 }
-static __inline__ int __test_and_change_bit(int nr, volatile unsigned long * address)
+#include <asm-generic/bitops/non-atomic.h>
-{
-        unsigned long mask = 1UL << CHOP_SHIFTCOUNT(nr);
-        unsigned long *addr = (unsigned long *)address + (nr >> SHIFT_PER_LONG);
-        unsigned long oldbit;
-        oldbit = *addr;
-        *addr = oldbit ^ mask;
-        return (oldbit & mask) ? 1 : 0;
-}
-static __inline__ int test_bit(int nr, const volatile unsigned long *address)
-{
-        unsigned long mask = 1UL << CHOP_SHIFTCOUNT(nr);
-        const unsigned long *addr = (const unsigned long *)address + (nr >> SHIFT_PER_LONG);
-        
-        return !!(*addr & mask);
-}
 #ifdef __KERNEL__
@@ -219,8 +156,7 @@ static __inline__ unsigned long __ffs(unsigned long x)
        return ret;
 }
-/* Undefined if no bit is zero. */
+#include <asm-generic/bitops/ffz.h>
-#define ffz(x)  __ffs(~x)
 /*
 * ffs: find first bit set. returns 1 to BITS_PER_LONG or 0 (if none set)
@@ -263,155 +199,22 @@ static __inline__ int fls(int x)
        return ret;
 }
-#define fls64(x)   generic_fls64(x)
-/*
+#include <asm-generic/bitops/fls64.h>
- * hweightN: returns the hamming weight (i.e. the number
+#include <asm-generic/bitops/hweight.h>
- * of bits set) of a N-bit word
+#include <asm-generic/bitops/sched.h>
- */
-#define hweight64(x) generic_hweight64(x)
-#define hweight32(x) generic_hweight32(x)
-#define hweight16(x) generic_hweight16(x)
-#define hweight8(x) generic_hweight8(x)
-/*
- * Every architecture must define this function. It's the fastest
- * way of searching a 140-bit bitmap where the first 100 bits are
- * unlikely to be set. It's guaranteed that at least one of the 140
- * bits is cleared.
- */
-static inline int sched_find_first_bit(const unsigned long *b)
-{
-#ifdef __LP64__
-        if (unlikely(b[0]))
-                return __ffs(b[0]);
-        if (unlikely(b[1]))
-                return __ffs(b[1]) + 64;
-        return __ffs(b[2]) + 128;
-#else
-        if (unlikely(b[0]))
-                return __ffs(b[0]);
-        if (unlikely(b[1]))
-                return __ffs(b[1]) + 32;
-        if (unlikely(b[2]))
-                return __ffs(b[2]) + 64;
-        if (b[3])
-                return __ffs(b[3]) + 96;
-        return __ffs(b[4]) + 128;
-#endif
-}
 #endif /* __KERNEL__ */
-/*
+#include <asm-generic/bitops/find.h>
- * This implementation of find_{first,next}_zero_bit was stolen from
- * Linus' asm-alpha/bitops.h.
- */
-#define find_first_zero_bit(addr, size) \
-        find_next_zero_bit((addr), (size), 0)
-static __inline__ unsigned long find_next_zero_bit(const void * addr, unsigned long size, unsigned long offset)
-{
-        const unsigned long * p = ((unsigned long *) addr) + (offset >> SHIFT_PER_LONG);
-        unsigned long result = offset & ~(BITS_PER_LONG-1);
-        unsigned long tmp;
-        if (offset >= size)
-                return size;
-        size -= result;
-        offset &= (BITS_PER_LONG-1);
-        if (offset) {
-                tmp = *(p++);
-                tmp |= ~0UL >> (BITS_PER_LONG-offset);
-                if (size < BITS_PER_LONG)
-                        goto found_first;
-                if (~tmp)
-                        goto found_middle;
-                size -= BITS_PER_LONG;
-                result += BITS_PER_LONG;
-        }
-        while (size & ~(BITS_PER_LONG -1)) {
-                if (~(tmp = *(p++)))
-                        goto found_middle;
-                result += BITS_PER_LONG;
-                size -= BITS_PER_LONG;
-        }
-        if (!size)
-                return result;
-        tmp = *p;
-found_first:
-        tmp |= ~0UL << size;
-found_middle:
-        return result + ffz(tmp);
-}
-static __inline__ unsigned long find_next_bit(const unsigned long *addr, unsigned long size, unsigned long offset)
-{
-        const unsigned long *p = addr + (offset >> SHIFT_PER_LONG);
-        unsigned long result = offset & ~(BITS_PER_LONG-1);
-        unsigned long tmp;
-        if (offset >= size)
-                return size;
-        size -= result;
-        offset &= (BITS_PER_LONG-1);
-        if (offset) {
-                tmp = *(p++);
-                tmp &= (~0UL << offset);
-                if (size < BITS_PER_LONG)
-                        goto found_first;
-                if (tmp)
-                        goto found_middle;
-                size -= BITS_PER_LONG;
-                result += BITS_PER_LONG;
-        }
-        while (size & ~(BITS_PER_LONG-1)) {
-                if ((tmp = *(p++)))
-                        goto found_middle;
-                result += BITS_PER_LONG;
-                size -= BITS_PER_LONG;
-        }
-        if (!size)
-                return result;
-        tmp = *p;
-found_first:
-        tmp &= (~0UL >> (BITS_PER_LONG - size));
-        if (tmp == 0UL)        /* Are any bits set? */
-                return result + size; /* Nope. */
-found_middle:
-        return result + __ffs(tmp);
-}
-/**
- * find_first_bit - find the first set bit in a memory region
- * @addr: The address to start the search at
- * @size: The maximum size to search
- *
- * Returns the bit-number of the first set bit, not the number of the byte
- * containing a bit.
- */
-#define find_first_bit(addr, size) \
-        find_next_bit((addr), (size), 0)
-#define _EXT2_HAVE_ASM_BITOPS_
 #ifdef __KERNEL__
-/*
- * test_and_{set,clear}_bit guarantee atomicity without
+#include <asm-generic/bitops/ext2-non-atomic.h>
- * disabling interrupts.
- */
 /* '3' is bits per byte */
 #define LE_BYTE_ADDR ((sizeof(unsigned long) - 1) << 3)
-#define ext2_test_bit(nr, addr) \
-                        test_bit((nr)   ^ LE_BYTE_ADDR, (unsigned long *)addr)
-#define ext2_set_bit(nr, addr)  \
-                __test_and_set_bit((nr) ^ LE_BYTE_ADDR, (unsigned long *)addr)
-#define ext2_clear_bit(nr, addr) \
-                __test_and_clear_bit((nr) ^ LE_BYTE_ADDR, (unsigned long *)addr)
 #define ext2_set_bit_atomic(l,nr,addr) \
                test_and_set_bit((nr)   ^ LE_BYTE_ADDR, (unsigned long *)addr)
 #define ext2_clear_bit_atomic(l,nr,addr) \
@@ -419,77 +222,6 @@ found_middle:
 #endif  /* __KERNEL__ */
+#include <asm-generic/bitops/minix-le.h>
-#define ext2_find_first_zero_bit(addr, size) \
-        ext2_find_next_zero_bit((addr), (size), 0)
-/* include/linux/byteorder does not support "unsigned long" type */
-static inline unsigned long ext2_swabp(unsigned long * x)
-{
-#ifdef __LP64__
-        return (unsigned long) __swab64p((u64 *) x);
-#else
-        return (unsigned long) __swab32p((u32 *) x);
-#endif
-}
-/* include/linux/byteorder doesn't support "unsigned long" type */
-static inline unsigned long ext2_swab(unsigned long y)
-{
-#ifdef __LP64__
-        return (unsigned long) __swab64((u64) y);
-#else
-        return (unsigned long) __swab32((u32) y);
-#endif
-}
-static __inline__ unsigned long ext2_find_next_zero_bit(void *addr, unsigned long size, unsigned long offset)
-{
-        unsigned long *p = (unsigned long *) addr + (offset >> SHIFT_PER_LONG);
-        unsigned long result = offset & ~(BITS_PER_LONG - 1);
-        unsigned long tmp;
-        if (offset >= size)
-                return size;
-        size -= result;
-        offset &= (BITS_PER_LONG - 1UL);
-        if (offset) {
-                tmp = ext2_swabp(p++);
-                tmp |= (~0UL >> (BITS_PER_LONG - offset));
-                if (size < BITS_PER_LONG)
-                        goto found_first;
-                if (~tmp)
-                        goto found_middle;
-                size -= BITS_PER_LONG;
-                result += BITS_PER_LONG;
-        }
-        while (size & ~(BITS_PER_LONG - 1)) {
-                if (~(tmp = *(p++)))
-                        goto found_middle_swap;
-                result += BITS_PER_LONG;
-                size -= BITS_PER_LONG;
-        }
-        if (!size)
-                return result;
-        tmp = ext2_swabp(p);
-found_first:
-        tmp |= ~0UL << size;
-        if (tmp == ~0UL)        /* Are any bits zero? */
-                return result + size; /* Nope. Skip ffz */
-found_middle:
-        return result + ffz(tmp);
-found_middle_swap:
-        return result + ffz(ext2_swab(tmp));
-}
-/* Bitmap functions for the minix filesystem.  */
-#define minix_test_and_set_bit(nr,addr) ext2_set_bit(nr,addr)
-#define minix_set_bit(nr,addr) ((void)ext2_set_bit(nr,addr))
-#define minix_test_and_clear_bit(nr,addr) ext2_clear_bit(nr,addr)
-#define minix_test_bit(nr,addr) ext2_test_bit(nr,addr)
-#define minix_find_first_zero_bit(addr,size) ext2_find_first_zero_bit(addr,size)
 #endif /* _PARISC_BITOPS_H */
diff --git a/include/asm-parisc/compat.h b/include/asm-parisc/compat.h
index 38b918feead9..289624d8b2d4 100644
--- a/include/asm-parisc/compat.h
+++ b/include/asm-parisc/compat.h
@@ -138,6 +138,11 @@ static inline void __user *compat_ptr(compat_uptr_t uptr)
        return (void __user *)(unsigned long)uptr;
 }
+static inline compat_uptr_t ptr_to_compat(void __user *uptr)
+{
+        return (u32)(unsigned long)uptr;
+}
 static __inline__ void __user *compat_alloc_user_space(long len)
 {
        struct pt_regs *regs = &current->thread.regs;
diff --git a/include/asm-parisc/mmzone.h b/include/asm-parisc/mmzone.h
index ae039f4fd711..ceb9b73199d1 100644
--- a/include/asm-parisc/mmzone.h
+++ b/include/asm-parisc/mmzone.h
@@ -25,23 +25,6 @@ extern struct node_map_data node_data[];
        pg_data_t *__pgdat = NODE_DATA(nid);                            \
        __pgdat->node_start_pfn + __pgdat->node_spanned_pages;          \
 })
-#define node_localnr(pfn, nid)          ((pfn) - node_start_pfn(nid))
-#define pfn_to_page(pfn)                                                \
-({                                                                      \
-        unsigned long __pfn = (pfn);                                    \
-        int __node  = pfn_to_nid(__pfn);                                \
-        &NODE_DATA(__node)->node_mem_map[node_localnr(__pfn,__node)];   \
-})
-#define page_to_pfn(pg)                                                 \
-({                                                                      \
-        struct page *__page = pg;                                       \
-        struct zone *__zone = page_zone(__page);                        \
-        BUG_ON(__zone == NULL);                                         \
-        (unsigned long)(__page - __zone->zone_mem_map)                  \
-                + __zone->zone_start_pfn;                               \
-})
 /* We have these possible memory map layouts:
 * Astro: 0-3.75, 67.75-68, 4-64
diff --git a/include/asm-parisc/page.h b/include/asm-parisc/page.h
index 4a6752b0afed..9f303c0c3cd7 100644
--- a/include/asm-parisc/page.h
+++ b/include/asm-parisc/page.h
@@ -130,8 +130,6 @@ extern int npmem_ranges;
 #define __va(x)                 ((void *)((unsigned long)(x)+PAGE_OFFSET))
 #ifndef CONFIG_DISCONTIGMEM
-#define pfn_to_page(pfn)        (mem_map + (pfn))
-#define page_to_pfn(page)       ((unsigned long)((page) - mem_map))
 #define pfn_valid(pfn)          ((pfn) < max_mapnr)
 #endif /* CONFIG_DISCONTIGMEM */
@@ -152,6 +150,7 @@ extern int npmem_ranges;
 #endif /* __KERNEL__ */
+#include <asm-generic/memory_model.h>
 #include <asm-generic/page.h>
 #endif /* _PARISC_PAGE_H */
diff --git a/include/asm-powerpc/bitops.h b/include/asm-powerpc/bitops.h
index bf6941a810b8..d1c2a4405660 100644
--- a/include/asm-powerpc/bitops.h
+++ b/include/asm-powerpc/bitops.h
@@ -184,72 +184,7 @@ static __inline__ void set_bits(unsigned long mask, unsigned long *addr)
        : "cc");
 }
-/* Non-atomic versions */
+#include <asm-generic/bitops/non-atomic.h>
-static __inline__ int test_bit(unsigned long nr,
-                               __const__ volatile unsigned long *addr)
-{
-        return 1UL & (addr[BITOP_WORD(nr)] >> (nr & (BITS_PER_LONG-1)));
-}
-static __inline__ void __set_bit(unsigned long nr,
-                                 volatile unsigned long *addr)
-{
-        unsigned long mask = BITOP_MASK(nr);
-        unsigned long *p = ((unsigned long *)addr) + BITOP_WORD(nr);
-        *p  |= mask;
-}
-static __inline__ void __clear_bit(unsigned long nr,
-                                   volatile unsigned long *addr)
-{
-        unsigned long mask = BITOP_MASK(nr);
-        unsigned long *p = ((unsigned long *)addr) + BITOP_WORD(nr);
-        *p &= ~mask;
-}
-static __inline__ void __change_bit(unsigned long nr,
-                                    volatile unsigned long *addr)
-{
-        unsigned long mask = BITOP_MASK(nr);
-        unsigned long *p = ((unsigned long *)addr) + BITOP_WORD(nr);
-        *p ^= mask;
-}
-static __inline__ int __test_and_set_bit(unsigned long nr,
-                                         volatile unsigned long *addr)
-{
-        unsigned long mask = BITOP_MASK(nr);
-        unsigned long *p = ((unsigned long *)addr) + BITOP_WORD(nr);
-        unsigned long old = *p;
-        *p = old | mask;
-        return (old & mask) != 0;
-}
-static __inline__ int __test_and_clear_bit(unsigned long nr,
-                                           volatile unsigned long *addr)
-{
-        unsigned long mask = BITOP_MASK(nr);
-        unsigned long *p = ((unsigned long *)addr) + BITOP_WORD(nr);
-        unsigned long old = *p;
-        *p = old & ~mask;
-        return (old & mask) != 0;
-}
-static __inline__ int __test_and_change_bit(unsigned long nr,
-                                            volatile unsigned long *addr)
-{
-        unsigned long mask = BITOP_MASK(nr);
-        unsigned long *p = ((unsigned long *)addr) + BITOP_WORD(nr);
-        unsigned long old = *p;
-        *p = old ^ mask;
-        return (old & mask) != 0;
-}
 /*
 * Return the zero-based bit position (LE, not IBM bit numbering) of
@@ -310,16 +245,9 @@ static __inline__ int fls(unsigned int x)
        asm ("cntlzw %0,%1" : "=r" (lz) : "r" (x));
        return 32 - lz;
 }
-#define fls64(x)   generic_fls64(x)
+#include <asm-generic/bitops/fls64.h>
-/*
+#include <asm-generic/bitops/hweight.h>
- * hweightN: returns the hamming weight (i.e. the number
- * of bits set) of a N-bit word
- */
-#define hweight64(x) generic_hweight64(x)
-#define hweight32(x) generic_hweight32(x)
-#define hweight16(x) generic_hweight16(x)
-#define hweight8(x) generic_hweight8(x)
 #define find_first_zero_bit(addr, size) find_next_zero_bit((addr), (size), 0)
 unsigned long find_next_zero_bit(const unsigned long *addr,
@@ -397,32 +325,7 @@ unsigned long find_next_zero_le_bit(const unsigned long *addr,
 #define minix_find_first_zero_bit(addr,size) \
        find_first_zero_le_bit((unsigned long *)addr, size)
-/*
+#include <asm-generic/bitops/sched.h>
- * Every architecture must define this function. It's the fastest
- * way of searching a 140-bit bitmap where the first 100 bits are
- * unlikely to be set. It's guaranteed that at least one of the 140
- * bits is cleared.
- */
-static inline int sched_find_first_bit(const unsigned long *b)
-{
-#ifdef CONFIG_PPC64
-        if (unlikely(b[0]))
-                return __ffs(b[0]);
-        if (unlikely(b[1]))
-                return __ffs(b[1]) + 64;
-        return __ffs(b[2]) + 128;
-#else
-        if (unlikely(b[0]))
-                return __ffs(b[0]);
-        if (unlikely(b[1]))
-                return __ffs(b[1]) + 32;
-        if (unlikely(b[2]))
-                return __ffs(b[2]) + 64;
-        if (b[3])
-                return __ffs(b[3]) + 96;
-        return __ffs(b[4]) + 128;
-#endif
-}
 #endif /* __KERNEL__ */
diff --git a/include/asm-powerpc/futex.h b/include/asm-powerpc/futex.h
index 39e85f320a76..f1b3c00bc1ce 100644
--- a/include/asm-powerpc/futex.h
+++ b/include/asm-powerpc/futex.h
@@ -81,5 +81,11 @@ static inline int futex_atomic_op_inuser (int encoded_op, int __user *uaddr)
        return ret;
 }
+static inline int
+futex_atomic_cmpxchg_inatomic(int __user *uaddr, int oldval, int newval)
+{
+        return -ENOSYS;
+}
 #endif /* __KERNEL__ */
 #endif /* _ASM_POWERPC_FUTEX_H */
diff --git a/include/asm-powerpc/kdebug.h b/include/asm-powerpc/kdebug.h
index 7c16265568e0..c01786ab5fa6 100644
--- a/include/asm-powerpc/kdebug.h
+++ b/include/asm-powerpc/kdebug.h
@@ -16,13 +16,9 @@ struct die_args {
        int signr;
 };
-/*
+extern int register_die_notifier(struct notifier_block *);
-   Note - you should never unregister because that can race with NMIs.
+extern int unregister_die_notifier(struct notifier_block *);
-   If you really want to do it first unregister - then synchronize_sched -
+extern struct atomic_notifier_head powerpc_die_chain;
-   then free.
- */
-int register_die_notifier(struct notifier_block *nb);
-extern struct notifier_block *powerpc_die_chain;
 /* Grossly misnamed. */
 enum die_val {
@@ -37,7 +33,7 @@ enum die_val {
 static inline int notify_die(enum die_val val,char *str,struct pt_regs *regs,long err,int trap, int sig)
 {
        struct die_args args = { .regs=regs, .str=str, .err=err, .trapnr=trap,.signr=sig };
-        return notifier_call_chain(&powerpc_die_chain, val, &args);
+        return atomic_notifier_call_chain(&powerpc_die_chain, val, &args);
 }
 #endif /* __KERNEL__ */
diff --git a/include/asm-powerpc/page.h b/include/asm-powerpc/page.h
index 0b82df483f7f..2fbecebe1c92 100644
--- a/include/asm-powerpc/page.h
+++ b/include/asm-powerpc/page.h
@@ -69,8 +69,6 @@
 #endif
 #ifdef CONFIG_FLATMEM
-#define pfn_to_page(pfn)        (mem_map + (pfn))
-#define page_to_pfn(page)       ((unsigned long)((page) - mem_map))
 #define pfn_valid(pfn)          ((pfn) < max_mapnr)
 #endif
@@ -200,6 +198,7 @@ extern void copy_user_page(void *to, void *from, unsigned long vaddr,
                struct page *p);
 extern int page_is_ram(unsigned long pfn);
+#include <asm-generic/memory_model.h>
 #endif /* __ASSEMBLY__ */
 #endif /* __KERNEL__ */
diff --git a/include/asm-powerpc/types.h b/include/asm-powerpc/types.h
index ec3c2ee8bf86..baabba96e313 100644
--- a/include/asm-powerpc/types.h
+++ b/include/asm-powerpc/types.h
@@ -103,6 +103,11 @@ typedef u64 sector_t;
 #define HAVE_SECTOR_T
 #endif
+#ifdef CONFIG_LSF
+typedef u64 blkcnt_t;
+#define HAVE_BLKCNT_T
+#endif
 #endif /* __ASSEMBLY__ */
 #endif /* __KERNEL__ */
diff --git a/include/asm-ppc/page.h b/include/asm-ppc/page.h
index 538e0c8ab243..a70ba2ee552d 100644
--- a/include/asm-ppc/page.h
+++ b/include/asm-ppc/page.h
@@ -149,8 +149,7 @@ extern int page_is_ram(unsigned long pfn);
 #define __pa(x) ___pa((unsigned long)(x))
 #define __va(x) ((void *)(___va((unsigned long)(x))))
-#define pfn_to_page(pfn)        (mem_map + ((pfn) - PPC_PGSTART))
+#define ARCH_PFN_OFFSET         (PPC_PGSTART)
-#define page_to_pfn(page)       ((unsigned long)((page) - mem_map) + PPC_PGSTART)
 #define virt_to_page(kaddr)     pfn_to_page(__pa(kaddr) >> PAGE_SHIFT)
 #define page_to_virt(page)      __va(page_to_pfn(page) << PAGE_SHIFT)
@@ -175,5 +174,6 @@ extern __inline__ int get_order(unsigned long size)
 /* We do define AT_SYSINFO_EHDR but don't use the gate mecanism */
 #define __HAVE_ARCH_GATE_AREA           1
+#include <asm-generic/memory_model.h>
 #endif /* __KERNEL__ */
 #endif /* _PPC_PAGE_H */
diff --git a/include/asm-s390/bitops.h b/include/asm-s390/bitops.h
index 3628899f48bb..ca092ffb7a95 100644
--- a/include/asm-s390/bitops.h
+++ b/include/asm-s390/bitops.h
@@ -828,35 +828,12 @@ static inline int sched_find_first_bit(unsigned long *b)
        return find_first_bit(b, 140);
 }
-/*
+#include <asm-generic/bitops/ffs.h>
- * ffs: find first bit set. This is defined the same way as
- * the libc and compiler builtin ffs routines, therefore
- * differs in spirit from the above ffz (man ffs).
- */
-#define ffs(x) generic_ffs(x)
-/*
+#include <asm-generic/bitops/fls.h>
- * fls: find last bit set.
+#include <asm-generic/bitops/fls64.h>
- */
-#define fls(x) generic_fls(x)
-#define fls64(x)   generic_fls64(x)
-/*
- * hweightN: returns the hamming weight (i.e. the number
- * of bits set) of a N-bit word
- */
-#define hweight64(x)                                            \
-({                                                              \
-        unsigned long __x = (x);                                \
-        unsigned int __w;                                       \
-        __w = generic_hweight32((unsigned int) __x);            \
-        __w += generic_hweight32((unsigned int) (__x>>32));     \
-        __w;                                                    \
-})
-#define hweight32(x) generic_hweight32(x)
-#define hweight16(x) generic_hweight16(x)
-#define hweight8(x) generic_hweight8(x)
+#include <asm-generic/bitops/hweight.h>
 #ifdef __KERNEL__
@@ -871,11 +848,11 @@ static inline int sched_find_first_bit(unsigned long *b)
 */
 #define ext2_set_bit(nr, addr)       \
-        test_and_set_bit((nr)^(__BITOPS_WORDSIZE - 8), (unsigned long *)addr)
+        __test_and_set_bit((nr)^(__BITOPS_WORDSIZE - 8), (unsigned long *)addr)
 #define ext2_set_bit_atomic(lock, nr, addr)       \
        test_and_set_bit((nr)^(__BITOPS_WORDSIZE - 8), (unsigned long *)addr)
 #define ext2_clear_bit(nr, addr)     \
-        test_and_clear_bit((nr)^(__BITOPS_WORDSIZE - 8), (unsigned long *)addr)
+        __test_and_clear_bit((nr)^(__BITOPS_WORDSIZE - 8), (unsigned long *)addr)
 #define ext2_clear_bit_atomic(lock, nr, addr)     \
        test_and_clear_bit((nr)^(__BITOPS_WORDSIZE - 8), (unsigned long *)addr)
 #define ext2_test_bit(nr, addr)      \
@@ -1011,18 +988,7 @@ ext2_find_next_zero_bit(void *vaddr, unsigned long size, unsigned long offset)
        return offset + ext2_find_first_zero_bit(p, size);
 }
-/* Bitmap functions for the minix filesystem.  */
+#include <asm-generic/bitops/minix.h>
-/* FIXME !!! */
-#define minix_test_and_set_bit(nr,addr) \
-        test_and_set_bit(nr,(unsigned long *)addr)
-#define minix_set_bit(nr,addr) \
-        set_bit(nr,(unsigned long *)addr)
-#define minix_test_and_clear_bit(nr,addr) \
-        test_and_clear_bit(nr,(unsigned long *)addr)
-#define minix_test_bit(nr,addr) \
-        test_bit(nr,(unsigned long *)addr)
-#define minix_find_first_zero_bit(addr,size) \
-        find_first_zero_bit(addr,size)
 #endif /* __KERNEL__ */
diff --git a/include/asm-s390/compat.h b/include/asm-s390/compat.h
index a007715f4aea..356a0b183539 100644
--- a/include/asm-s390/compat.h
+++ b/include/asm-s390/compat.h
@@ -128,6 +128,11 @@ static inline void __user *compat_ptr(compat_uptr_t uptr)
        return (void __user *)(unsigned long)(uptr & 0x7fffffffUL);
 }
+static inline compat_uptr_t ptr_to_compat(void __user *uptr)
+{
+        return (u32)(unsigned long)uptr;
+}
 static inline void __user *compat_alloc_user_space(long len)
 {
        unsigned long stack;
diff --git a/include/asm-s390/page.h b/include/asm-s390/page.h
index 2430c561e021..3b1138ac7e79 100644
--- a/include/asm-s390/page.h
+++ b/include/asm-s390/page.h
@@ -181,8 +181,6 @@ page_get_storage_key(unsigned long addr)
 #define PAGE_OFFSET             0x0UL
 #define __pa(x)                 (unsigned long)(x)
 #define __va(x)                 (void *)(unsigned long)(x)
-#define pfn_to_page(pfn)        (mem_map + (pfn))
-#define page_to_pfn(page)       ((unsigned long)((page) - mem_map))
 #define virt_to_page(kaddr)     pfn_to_page(__pa(kaddr) >> PAGE_SHIFT)
 #define pfn_valid(pfn)          ((pfn) < max_mapnr)
@@ -193,6 +191,7 @@ page_get_storage_key(unsigned long addr)
 #endif /* __KERNEL__ */
+#include <asm-generic/memory_model.h>
 #include <asm-generic/page.h>
 #endif /* _S390_PAGE_H */
diff --git a/include/asm-s390/types.h b/include/asm-s390/types.h
index d0be3e477013..5738ad63537c 100644
--- a/include/asm-s390/types.h
+++ b/include/asm-s390/types.h
@@ -93,6 +93,11 @@ typedef u64 sector_t;
 #define HAVE_SECTOR_T
 #endif
+#ifdef CONFIG_LSF
+typedef u64 blkcnt_t;
+#define HAVE_BLKCNT_T
+#endif
 #endif /* ! __s390x__   */
 #endif /* __ASSEMBLY__  */
 #endif /* __KERNEL__    */
diff --git a/include/asm-sh/bitops.h b/include/asm-sh/bitops.h
index 1c5260860045..e34f82508568 100644
--- a/include/asm-sh/bitops.h
+++ b/include/asm-sh/bitops.h
@@ -19,16 +19,6 @@ static __inline__ void set_bit(int nr, volatile void * addr)
        local_irq_restore(flags);
 }
-static __inline__ void __set_bit(int nr, volatile void * addr)
-{
-        int     mask;
-        volatile unsigned int *a = addr;
-        a += nr >> 5;
-        mask = 1 << (nr & 0x1f);
-        *a |= mask;
-}
 /*
 * clear_bit() doesn't provide any barrier for the compiler.
 */
@@ -47,16 +37,6 @@ static __inline__ void clear_bit(int nr, volatile void * addr)
        local_irq_restore(flags);
 }
-static __inline__ void __clear_bit(int nr, volatile void * addr)
-{
-        int     mask;
-        volatile unsigned int *a = addr;
-        a += nr >> 5;
-        mask = 1 << (nr & 0x1f);
-        *a &= ~mask;
-}
 static __inline__ void change_bit(int nr, volatile void * addr)
 {
        int     mask;
@@ -70,16 +50,6 @@ static __inline__ void change_bit(int nr, volatile void * addr)
        local_irq_restore(flags);
 }
-static __inline__ void __change_bit(int nr, volatile void * addr)
-{
-        int     mask;
-        volatile unsigned int *a = addr;
-        a += nr >> 5;
-        mask = 1 << (nr & 0x1f);
-        *a ^= mask;
-}
 static __inline__ int test_and_set_bit(int nr, volatile void * addr)
 {
        int     mask, retval;
@@ -96,19 +66,6 @@ static __inline__ int test_and_set_bit(int nr, volatile void * addr)
        return retval;
 }
-static __inline__ int __test_and_set_bit(int nr, volatile void * addr)
-{
-        int     mask, retval;
-        volatile unsigned int *a = addr;
-        a += nr >> 5;
-        mask = 1 << (nr & 0x1f);
-        retval = (mask & *a) != 0;
-        *a |= mask;
-        return retval;
-}
 static __inline__ int test_and_clear_bit(int nr, volatile void * addr)
 {
        int     mask, retval;
@@ -125,19 +82,6 @@ static __inline__ int test_and_clear_bit(int nr, volatile void * addr)
        return retval;
 }
-static __inline__ int __test_and_clear_bit(int nr, volatile void * addr)
-{
-        int     mask, retval;
-        volatile unsigned int *a = addr;
-        a += nr >> 5;
-        mask = 1 << (nr & 0x1f);
-        retval = (mask & *a) != 0;
-        *a &= ~mask;
-        return retval;
-}
 static __inline__ int test_and_change_bit(int nr, volatile void * addr)
 {
        int     mask, retval;
@@ -154,23 +98,7 @@ static __inline__ int test_and_change_bit(int nr, volatile void * addr)
        return retval;
 }
-static __inline__ int __test_and_change_bit(int nr, volatile void * addr)
+#include <asm-generic/bitops/non-atomic.h>
-{
-        int     mask, retval;
-        volatile unsigned int *a = addr;
-        a += nr >> 5;
-        mask = 1 << (nr & 0x1f);
-        retval = (mask & *a) != 0;
-        *a ^= mask;
-        return retval;
-}
-static __inline__ int test_bit(int nr, const volatile void *addr)
-{
-        return 1UL & (((const volatile unsigned int *) addr)[nr >> 5] >> (nr & 31));
-}
 static __inline__ unsigned long ffz(unsigned long word)
 {
@@ -206,271 +134,15 @@ static __inline__ unsigned long __ffs(unsigned long word)
        return result;
 }
-/**
+#include <asm-generic/bitops/find.h>
- * find_next_bit - find the next set bit in a memory region
+#include <asm-generic/bitops/ffs.h>
- * @addr: The address to base the search on
+#include <asm-generic/bitops/hweight.h>
- * @offset: The bitnumber to start searching at
+#include <asm-generic/bitops/sched.h>
- * @size: The maximum size to search
+#include <asm-generic/bitops/ext2-non-atomic.h>
- */
+#include <asm-generic/bitops/ext2-atomic.h>
-static __inline__ unsigned long find_next_bit(const unsigned long *addr,
+#include <asm-generic/bitops/minix.h>
-        unsigned long size, unsigned long offset)
+#include <asm-generic/bitops/fls.h>
-{
+#include <asm-generic/bitops/fls64.h>
-        unsigned int *p = ((unsigned int *) addr) + (offset >> 5);
-        unsigned int result = offset & ~31UL;
-        unsigned int tmp;
-        if (offset >= size)
-                return size;
-        size -= result;
-        offset &= 31UL;
-        if (offset) {
-                tmp = *p++;
-                tmp &= ~0UL << offset;
-                if (size < 32)
-                        goto found_first;
-                if (tmp)
-                        goto found_middle;
-                size -= 32;
-                result += 32;
-        }
-        while (size >= 32) {
-                if ((tmp = *p++) != 0)
-                        goto found_middle;
-                result += 32;
-                size -= 32;
-        }
-        if (!size)
-                return result;
-        tmp = *p;
-found_first:
-        tmp &= ~0UL >> (32 - size);
-        if (tmp == 0UL)        /* Are any bits set? */
-                return result + size; /* Nope. */
-found_middle:
-        return result + __ffs(tmp);
-}
-/**
- * find_first_bit - find the first set bit in a memory region
- * @addr: The address to start the search at
- * @size: The maximum size to search
- *
- * Returns the bit-number of the first set bit, not the number of the byte
- * containing a bit.
- */
-#define find_first_bit(addr, size) \
-        find_next_bit((addr), (size), 0)
-static __inline__ int find_next_zero_bit(const unsigned long *addr, int size, int offset)
-{
-        const unsigned long *p = ((unsigned long *) addr) + (offset >> 5);
-        unsigned long result = offset & ~31UL;
-        unsigned long tmp;
-        if (offset >= size)
-                return size;
-        size -= result;
-        offset &= 31UL;
-        if (offset) {
-                tmp = *(p++);
-                tmp |= ~0UL >> (32-offset);
-                if (size < 32)
-                        goto found_first;
-                if (~tmp)
-                        goto found_middle;
-                size -= 32;
-                result += 32;
-        }
-        while (size & ~31UL) {
-                if (~(tmp = *(p++)))
-                        goto found_middle;
-                result += 32;
-                size -= 32;
-        }
-        if (!size)
-                return result;
-        tmp = *p;
-found_first:
-        tmp |= ~0UL << size;
-found_middle:
-        return result + ffz(tmp);
-}
-#define find_first_zero_bit(addr, size) \
-        find_next_zero_bit((addr), (size), 0)
-/*
- * ffs: find first bit set. This is defined the same way as
- * the libc and compiler builtin ffs routines, therefore
- * differs in spirit from the above ffz (man ffs).
- */
-#define ffs(x) generic_ffs(x)
-/*
- * hweightN: returns the hamming weight (i.e. the number
- * of bits set) of a N-bit word
- */
-#define hweight32(x) generic_hweight32(x)
-#define hweight16(x) generic_hweight16(x)
-#define hweight8(x) generic_hweight8(x)
-/*
- * Every architecture must define this function. It's the fastest
- * way of searching a 140-bit bitmap where the first 100 bits are
- * unlikely to be set. It's guaranteed that at least one of the 140
- * bits is cleared.
- */
-static inline int sched_find_first_bit(const unsigned long *b)
-{
-        if (unlikely(b[0]))
-                return __ffs(b[0]);
-        if (unlikely(b[1]))
-                return __ffs(b[1]) + 32;
-        if (unlikely(b[2]))
-                return __ffs(b[2]) + 64;
-        if (b[3])
-                return __ffs(b[3]) + 96;
-        return __ffs(b[4]) + 128;
-}
-#ifdef __LITTLE_ENDIAN__
-#define ext2_set_bit(nr, addr) test_and_set_bit((nr), (addr))
-#define ext2_clear_bit(nr, addr) test_and_clear_bit((nr), (addr))
-#define ext2_test_bit(nr, addr) test_bit((nr), (addr))
-#define ext2_find_first_zero_bit(addr, size) find_first_zero_bit((addr), (size))
-#define ext2_find_next_zero_bit(addr, size, offset) \
-                find_next_zero_bit((unsigned long *)(addr), (size), (offset))
-#else
-static __inline__ int ext2_set_bit(int nr, volatile void * addr)
-{
-        int             mask, retval;
-        unsigned long   flags;
-        volatile unsigned char  *ADDR = (unsigned char *) addr;
-        ADDR += nr >> 3;
-        mask = 1 << (nr & 0x07);
-        local_irq_save(flags);
-        retval = (mask & *ADDR) != 0;
-        *ADDR |= mask;
-        local_irq_restore(flags);
-        return retval;
-}
-static __inline__ int ext2_clear_bit(int nr, volatile void * addr)
-{
-        int             mask, retval;
-        unsigned long   flags;
-        volatile unsigned char  *ADDR = (unsigned char *) addr;
-        ADDR += nr >> 3;
-        mask = 1 << (nr & 0x07);
-        local_irq_save(flags);
-        retval = (mask & *ADDR) != 0;
-        *ADDR &= ~mask;
-        local_irq_restore(flags);
-        return retval;
-}
-static __inline__ int ext2_test_bit(int nr, const volatile void * addr)
-{
-        int                     mask;
-        const volatile unsigned char    *ADDR = (const unsigned char *) addr;
-        ADDR += nr >> 3;
-        mask = 1 << (nr & 0x07);
-        return ((mask & *ADDR) != 0);
-}
-#define ext2_find_first_zero_bit(addr, size) \
-        ext2_find_next_zero_bit((addr), (size), 0)
-static __inline__ unsigned long ext2_find_next_zero_bit(void *addr, unsigned long size, unsigned long offset)
-{
-        unsigned long *p = ((unsigned long *) addr) + (offset >> 5);
-        unsigned long result = offset & ~31UL;
-        unsigned long tmp;
-        if (offset >= size)
-                return size;
-        size -= result;
-        offset &= 31UL;
-        if(offset) {
-                /* We hold the little endian value in tmp, but then the
-                 * shift is illegal. So we could keep a big endian value
-                 * in tmp, like this:
-                 *
-                 * tmp = __swab32(*(p++));
-                 * tmp |= ~0UL >> (32-offset);
-                 *
-                 * but this would decrease preformance, so we change the
-                 * shift:
-                 */
-                tmp = *(p++);
-                tmp |= __swab32(~0UL >> (32-offset));
-                if(size < 32)
-                        goto found_first;
-                if(~tmp)
-                        goto found_middle;
-                size -= 32;
-                result += 32;
-        }
-        while(size & ~31UL) {
-                if(~(tmp = *(p++)))
-                        goto found_middle;
-                result += 32;
-                size -= 32;
-        }
-        if(!size)
-                return result;
-        tmp = *p;
-found_first:
-        /* tmp is little endian, so we would have to swab the shift,
-         * see above. But then we have to swab tmp below for ffz, so
-         * we might as well do this here.
-         */
-        return result + ffz(__swab32(tmp) | (~0UL << size));
-found_middle:
-        return result + ffz(__swab32(tmp));
-}
-#endif
-#define ext2_set_bit_atomic(lock, nr, addr)             \
-        ({                                              \
-                int ret;                                \
-                spin_lock(lock);                        \
-                ret = ext2_set_bit((nr), (addr));       \
-                spin_unlock(lock);                      \
-                ret;                                    \
-        })
-#define ext2_clear_bit_atomic(lock, nr, addr)           \
-        ({                                              \
-                int ret;                                \
-                spin_lock(lock);                        \
-                ret = ext2_clear_bit((nr), (addr));     \
-                spin_unlock(lock);                      \
-                ret;                                    \
-        })
-/* Bitmap functions for the minix filesystem.  */
-#define minix_test_and_set_bit(nr,addr) test_and_set_bit(nr,addr)
-#define minix_set_bit(nr,addr) set_bit(nr,addr)
-#define minix_test_and_clear_bit(nr,addr) test_and_clear_bit(nr,addr)
-#define minix_test_bit(nr,addr) test_bit(nr,addr)
-#define minix_find_first_zero_bit(addr,size) find_first_zero_bit(addr,size)
-/*
- * fls: find last bit set.
- */
-#define fls(x) generic_fls(x)
-#define fls64(x)   generic_fls64(x)
 #endif /* __KERNEL__ */
diff --git a/include/asm-sh/page.h b/include/asm-sh/page.h
index 972c3f655b2a..9c89287c3e56 100644
--- a/include/asm-sh/page.h
+++ b/include/asm-sh/page.h
@@ -105,9 +105,7 @@ typedef struct { unsigned long pgprot; } pgprot_t;
 /* PFN start number, because of __MEMORY_START */
 #define PFN_START               (__MEMORY_START >> PAGE_SHIFT)
+#define ARCH_PFN_OFFSET         (FPN_START)
-#define pfn_to_page(pfn)        (mem_map + (pfn) - PFN_START)
-#define page_to_pfn(page)       ((unsigned long)((page) - mem_map) + PFN_START)
 #define virt_to_page(kaddr)     pfn_to_page(__pa(kaddr) >> PAGE_SHIFT)
 #define pfn_valid(pfn)          (((pfn) - PFN_START) < max_mapnr)
 #define virt_addr_valid(kaddr)  pfn_valid(__pa(kaddr) >> PAGE_SHIFT)
@@ -117,6 +115,7 @@ typedef struct { unsigned long pgprot; } pgprot_t;
 #endif /* __KERNEL__ */
+#include <asm-generic/memory_model.h>
 #include <asm-generic/page.h>
 #endif /* __ASM_SH_PAGE_H */
diff --git a/include/asm-sh/stat.h b/include/asm-sh/stat.h
index 914e3fcbbd37..6c41a60657f1 100644
--- a/include/asm-sh/stat.h
+++ b/include/asm-sh/stat.h
@@ -60,13 +60,7 @@ struct stat64 {
        long long       st_size;
        unsigned long   st_blksize;
-#if defined(__BIG_ENDIAN__)
+        unsigned long long      st_blocks;      /* Number 512-byte blocks allocated. */
-        unsigned long   __pad4;         /* Future possible st_blocks hi bits */
-        unsigned long   st_blocks;      /* Number 512-byte blocks allocated. */
-#else /* Must be little */
-        unsigned long   st_blocks;      /* Number 512-byte blocks allocated. */
-        unsigned long   __pad4;         /* Future possible st_blocks hi bits */
-#endif
        unsigned long   st_atime;
        unsigned long   st_atime_nsec;
diff --git a/include/asm-sh/thread_info.h b/include/asm-sh/thread_info.h
index 85f0c11b4319..7345350d98c0 100644
--- a/include/asm-sh/thread_info.h
+++ b/include/asm-sh/thread_info.h
@@ -18,7 +18,7 @@
 struct thread_info {
        struct task_struct      *task;          /* main task structure */
        struct exec_domain      *exec_domain;   /* execution domain */
-        __u32                   flags;          /* low level flags */
+        unsigned long           flags;          /* low level flags */
        __u32                   cpu;
        int                     preempt_count; /* 0 => preemptable, <0 => BUG */
        struct restart_block    restart_block;
diff --git a/include/asm-sh/types.h b/include/asm-sh/types.h
index cb7e183a0a6b..488552f43b2a 100644
--- a/include/asm-sh/types.h
+++ b/include/asm-sh/types.h
@@ -58,6 +58,11 @@ typedef u64 sector_t;
 #define HAVE_SECTOR_T
 #endif
+#ifdef CONFIG_LSF
+typedef u64 blkcnt_t;
+#define HAVE_BLKCNT_T
+#endif
 #endif /* __ASSEMBLY__ */
 #endif /* __KERNEL__ */
diff --git a/include/asm-sh64/bitops.h b/include/asm-sh64/bitops.h
index ce9c3ad45fe0..f3bdcdb5d046 100644
--- a/include/asm-sh64/bitops.h
+++ b/include/asm-sh64/bitops.h
@@ -31,16 +31,6 @@ static __inline__ void set_bit(int nr, volatile void * addr)
        local_irq_restore(flags);
 }
-static inline void __set_bit(int nr, void *addr)
-{
-        int     mask;
-        unsigned int *a = addr;
-        a += nr >> 5;
-        mask = 1 << (nr & 0x1f);
-        *a |= mask;
-}
 /*
 * clear_bit() doesn't provide any barrier for the compiler.
 */
@@ -58,15 +48,6 @@ static inline void clear_bit(int nr, volatile unsigned long *a)
        local_irq_restore(flags);
 }
-static inline void __clear_bit(int nr, volatile unsigned long *a)
-{
-        int     mask;
-        a += nr >> 5;
-        mask = 1 << (nr & 0x1f);
-        *a &= ~mask;
-}
 static __inline__ void change_bit(int nr, volatile void * addr)
 {
        int     mask;
@@ -80,16 +61,6 @@ static __inline__ void change_bit(int nr, volatile void * addr)
        local_irq_restore(flags);
 }
-static __inline__ void __change_bit(int nr, volatile void * addr)
-{
-        int     mask;
-        volatile unsigned int *a = addr;
-        a += nr >> 5;
-        mask = 1 << (nr & 0x1f);
-        *a ^= mask;
-}
 static __inline__ int test_and_set_bit(int nr, volatile void * addr)
 {
        int     mask, retval;
@@ -106,19 +77,6 @@ static __inline__ int test_and_set_bit(int nr, volatile void * addr)
        return retval;
 }
-static __inline__ int __test_and_set_bit(int nr, volatile void * addr)
-{
-        int     mask, retval;
-        volatile unsigned int *a = addr;
-        a += nr >> 5;
-        mask = 1 << (nr & 0x1f);
-        retval = (mask & *a) != 0;
-        *a |= mask;
-        return retval;
-}
 static __inline__ int test_and_clear_bit(int nr, volatile void * addr)
 {
        int     mask, retval;
@@ -135,19 +93,6 @@ static __inline__ int test_and_clear_bit(int nr, volatile void * addr)
        return retval;
 }
-static __inline__ int __test_and_clear_bit(int nr, volatile void * addr)
-{
-        int     mask, retval;
-        volatile unsigned int *a = addr;
-        a += nr >> 5;
-        mask = 1 << (nr & 0x1f);
-        retval = (mask & *a) != 0;
-        *a &= ~mask;
-        return retval;
-}
 static __inline__ int test_and_change_bit(int nr, volatile void * addr)
 {
        int     mask, retval;
@@ -164,23 +109,7 @@ static __inline__ int test_and_change_bit(int nr, volatile void * addr)
        return retval;
 }
-static __inline__ int __test_and_change_bit(int nr, volatile void * addr)
+#include <asm-generic/bitops/non-atomic.h>
-{
-        int     mask, retval;
-        volatile unsigned int *a = addr;
-        a += nr >> 5;
-        mask = 1 << (nr & 0x1f);
-        retval = (mask & *a) != 0;
-        *a ^= mask;
-        return retval;
-}
-static __inline__ int test_bit(int nr, const volatile void *addr)
-{
-        return 1UL & (((const volatile unsigned int *) addr)[nr >> 5] >> (nr & 31));
-}
 static __inline__ unsigned long ffz(unsigned long word)
 {
@@ -204,313 +133,16 @@ static __inline__ unsigned long ffz(unsigned long word)
        return result;
 }
-/**
+#include <asm-generic/bitops/__ffs.h>
- * __ffs - find first bit in word
+#include <asm-generic/bitops/find.h>
- * @word: The word to search
+#include <asm-generic/bitops/hweight.h>
- *
+#include <asm-generic/bitops/sched.h>
- * Undefined if no bit exists, so code should check against 0 first.
+#include <asm-generic/bitops/ffs.h>
- */
+#include <asm-generic/bitops/ext2-non-atomic.h>
-static inline unsigned long __ffs(unsigned long word)
+#include <asm-generic/bitops/ext2-atomic.h>
-{
+#include <asm-generic/bitops/minix.h>
-        int r = 0;
+#include <asm-generic/bitops/fls.h>
+#include <asm-generic/bitops/fls64.h>
-        if (!word)
-                return 0;
-        if (!(word & 0xffff)) {
-                word >>= 16;
-                r += 16;
-        }
-        if (!(word & 0xff)) {
-                word >>= 8;
-                r += 8;
-        }
-        if (!(word & 0xf)) {
-                word >>= 4;
-                r += 4;
-        }
-        if (!(word & 3)) {
-                word >>= 2;
-                r += 2;
-        }
-        if (!(word & 1)) {
-                word >>= 1;
-                r += 1;
-        }
-        return r;
-}
-/**
- * find_next_bit - find the next set bit in a memory region
- * @addr: The address to base the search on
- * @offset: The bitnumber to start searching at
- * @size: The maximum size to search
- */
-static inline unsigned long find_next_bit(const unsigned long *addr,
-        unsigned long size, unsigned long offset)
-{
-        unsigned int *p = ((unsigned int *) addr) + (offset >> 5);
-        unsigned int result = offset & ~31UL;
-        unsigned int tmp;
-        if (offset >= size)
-                return size;
-        size -= result;
-        offset &= 31UL;
-        if (offset) {
-                tmp = *p++;
-                tmp &= ~0UL << offset;
-                if (size < 32)
-                        goto found_first;
-                if (tmp)
-                        goto found_middle;
-                size -= 32;
-                result += 32;
-        }
-        while (size >= 32) {
-                if ((tmp = *p++) != 0)
-                        goto found_middle;
-                result += 32;
-                size -= 32;
-        }
-        if (!size)
-                return result;
-        tmp = *p;
-found_first:
-        tmp &= ~0UL >> (32 - size);
-        if (tmp == 0UL)        /* Are any bits set? */
-                return result + size; /* Nope. */
-found_middle:
-        return result + __ffs(tmp);
-}
-/**
- * find_first_bit - find the first set bit in a memory region
- * @addr: The address to start the search at
- * @size: The maximum size to search
- *
- * Returns the bit-number of the first set bit, not the number of the byte
- * containing a bit.
- */
-#define find_first_bit(addr, size) \
-        find_next_bit((addr), (size), 0)
-static inline int find_next_zero_bit(void *addr, int size, int offset)
-{
-        unsigned long *p = ((unsigned long *) addr) + (offset >> 5);
-        unsigned long result = offset & ~31UL;
-        unsigned long tmp;
-        if (offset >= size)
-                return size;
-        size -= result;
-        offset &= 31UL;
-        if (offset) {
-                tmp = *(p++);
-                tmp |= ~0UL >> (32-offset);
-                if (size < 32)
-                        goto found_first;
-                if (~tmp)
-                        goto found_middle;
-                size -= 32;
-                result += 32;
-        }
-        while (size & ~31UL) {
-                if (~(tmp = *(p++)))
-                        goto found_middle;
-                result += 32;
-                size -= 32;
-        }
-        if (!size)
-                return result;
-        tmp = *p;
-found_first:
-        tmp |= ~0UL << size;
-found_middle:
-        return result + ffz(tmp);
-}
-#define find_first_zero_bit(addr, size) \
-        find_next_zero_bit((addr), (size), 0)
-/*
- * hweightN: returns the hamming weight (i.e. the number
- * of bits set) of a N-bit word
- */
-#define hweight32(x)    generic_hweight32(x)
-#define hweight16(x)    generic_hweight16(x)
-#define hweight8(x)     generic_hweight8(x)
-/*
- * Every architecture must define this function. It's the fastest
- * way of searching a 140-bit bitmap where the first 100 bits are
- * unlikely to be set. It's guaranteed that at least one of the 140
- * bits is cleared.
- */
-static inline int sched_find_first_bit(unsigned long *b)
-{
-        if (unlikely(b[0]))
-                return __ffs(b[0]);
-        if (unlikely(b[1]))
-                return __ffs(b[1]) + 32;
-        if (unlikely(b[2]))
-                return __ffs(b[2]) + 64;
-        if (b[3])
-                return __ffs(b[3]) + 96;
-        return __ffs(b[4]) + 128;
-}
-/*
- * ffs: find first bit set. This is defined the same way as
- * the libc and compiler builtin ffs routines, therefore
- * differs in spirit from the above ffz (man ffs).
- */
-#define ffs(x) generic_ffs(x)
-/*
- * hweightN: returns the hamming weight (i.e. the number
- * of bits set) of a N-bit word
- */
-#define hweight32(x) generic_hweight32(x)
-#define hweight16(x) generic_hweight16(x)
-#define hweight8(x) generic_hweight8(x)
-#ifdef __LITTLE_ENDIAN__
-#define ext2_set_bit(nr, addr) test_and_set_bit((nr), (addr))
-#define ext2_clear_bit(nr, addr) test_and_clear_bit((nr), (addr))
-#define ext2_test_bit(nr, addr) test_bit((nr), (addr))
-#define ext2_find_first_zero_bit(addr, size) find_first_zero_bit((addr), (size))
-#define ext2_find_next_zero_bit(addr, size, offset) \
-                find_next_zero_bit((addr), (size), (offset))
-#else
-static __inline__ int ext2_set_bit(int nr, volatile void * addr)
-{
-        int             mask, retval;
-        unsigned long   flags;
-        volatile unsigned char  *ADDR = (unsigned char *) addr;
-        ADDR += nr >> 3;
-        mask = 1 << (nr & 0x07);
-        local_irq_save(flags);
-        retval = (mask & *ADDR) != 0;
-        *ADDR |= mask;
-        local_irq_restore(flags);
-        return retval;
-}
-static __inline__ int ext2_clear_bit(int nr, volatile void * addr)
-{
-        int             mask, retval;
-        unsigned long   flags;
-        volatile unsigned char  *ADDR = (unsigned char *) addr;
-        ADDR += nr >> 3;
-        mask = 1 << (nr & 0x07);
-        local_irq_save(flags);
-        retval = (mask & *ADDR) != 0;
-        *ADDR &= ~mask;
-        local_irq_restore(flags);
-        return retval;
-}
-static __inline__ int ext2_test_bit(int nr, const volatile void * addr)
-{
-        int                     mask;
-        const volatile unsigned char    *ADDR = (const unsigned char *) addr;
-        ADDR += nr >> 3;
-        mask = 1 << (nr & 0x07);
-        return ((mask & *ADDR) != 0);
-}
-#define ext2_find_first_zero_bit(addr, size) \
-        ext2_find_next_zero_bit((addr), (size), 0)
-static __inline__ unsigned long ext2_find_next_zero_bit(void *addr, unsigned long size, unsigned long offset)
-{
-        unsigned long *p = ((unsigned long *) addr) + (offset >> 5);
-        unsigned long result = offset & ~31UL;
-        unsigned long tmp;
-        if (offset >= size)
-                return size;
-        size -= result;
-        offset &= 31UL;
-        if(offset) {
-                /* We hold the little endian value in tmp, but then the
-                 * shift is illegal. So we could keep a big endian value
-                 * in tmp, like this:
-                 *
-                 * tmp = __swab32(*(p++));
-                 * tmp |= ~0UL >> (32-offset);
-                 *
-                 * but this would decrease preformance, so we change the
-                 * shift:
-                 */
-                tmp = *(p++);
-                tmp |= __swab32(~0UL >> (32-offset));
-                if(size < 32)
-                        goto found_first;
-                if(~tmp)
-                        goto found_middle;
-                size -= 32;
-                result += 32;
-        }
-        while(size & ~31UL) {
-                if(~(tmp = *(p++)))
-                        goto found_middle;
-                result += 32;
-                size -= 32;
-        }
-        if(!size)
-                return result;
-        tmp = *p;
-found_first:
-        /* tmp is little endian, so we would have to swab the shift,
-         * see above. But then we have to swab tmp below for ffz, so
-         * we might as well do this here.
-         */
-        return result + ffz(__swab32(tmp) | (~0UL << size));
-found_middle:
-        return result + ffz(__swab32(tmp));
-}
-#endif
-#define ext2_set_bit_atomic(lock, nr, addr)             \
-        ({                                              \
-                int ret;                                \
-                spin_lock(lock);                        \
-                ret = ext2_set_bit((nr), (addr));       \
-                spin_unlock(lock);                      \
-                ret;                                    \
-        })
-#define ext2_clear_bit_atomic(lock, nr, addr)           \
-        ({                                              \
-                int ret;                                \
-                spin_lock(lock);                        \
-                ret = ext2_clear_bit((nr), (addr));     \
-                spin_unlock(lock);                      \
-                ret;                                    \
-        })
-/* Bitmap functions for the minix filesystem.  */
-#define minix_test_and_set_bit(nr,addr) test_and_set_bit(nr,addr)
-#define minix_set_bit(nr,addr) set_bit(nr,addr)
-#define minix_test_and_clear_bit(nr,addr) test_and_clear_bit(nr,addr)
-#define minix_test_bit(nr,addr) test_bit(nr,addr)
-#define minix_find_first_zero_bit(addr,size) find_first_zero_bit(addr,size)
-#define ffs(x)  generic_ffs(x)
-#define fls(x)  generic_fls(x)
-#define fls64(x)   generic_fls64(x)
 #endif /* __KERNEL__ */
diff --git a/include/asm-sh64/page.h b/include/asm-sh64/page.h
index c86df90f7cbd..e4937cdabebd 100644
--- a/include/asm-sh64/page.h
+++ b/include/asm-sh64/page.h
@@ -105,9 +105,7 @@ typedef struct { unsigned long pgprot; } pgprot_t;
 /* PFN start number, because of __MEMORY_START */
 #define PFN_START               (__MEMORY_START >> PAGE_SHIFT)
+#define ARCH_PFN_OFFSET         (PFN_START)
-#define pfn_to_page(pfn)        (mem_map + (pfn) - PFN_START)
-#define page_to_pfn(page)       ((unsigned long)((page) - mem_map) + PFN_START)
 #define virt_to_page(kaddr)     pfn_to_page(__pa(kaddr) >> PAGE_SHIFT)
 #define pfn_valid(pfn)          (((pfn) - PFN_START) < max_mapnr)
 #define virt_addr_valid(kaddr)  pfn_valid(__pa(kaddr) >> PAGE_SHIFT)
@@ -117,6 +115,7 @@ typedef struct { unsigned long pgprot; } pgprot_t;
 #endif /* __KERNEL__ */
+#include <asm-generic/memory_model.h>
 #include <asm-generic/page.h>
 #endif /* __ASM_SH64_PAGE_H */
diff --git a/include/asm-sh64/platform.h b/include/asm-sh64/platform.h
index 7046a9014027..bd0d9c405a80 100644
--- a/include/asm-sh64/platform.h
+++ b/include/asm-sh64/platform.h
@@ -61,9 +61,4 @@ extern int platform_int_priority[NR_INTC_IRQS];
 #define code_resource (platform_parms.kram_res_p[STANDARD_KRAM_RESOURCES - 2])
 #define data_resource (platform_parms.kram_res_p[STANDARD_KRAM_RESOURCES - 1])
-/* Be prepared to 64-bit sign extensions */
-#define PFN_UP(x)       ((((x) + PAGE_SIZE-1) >> PAGE_SHIFT) & 0x000fffff)
-#define PFN_DOWN(x)     (((x) >> PAGE_SHIFT) & 0x000fffff)
-#define PFN_PHYS(x)     ((x) << PAGE_SHIFT)
 #endif  /* __ASM_SH64_PLATFORM_H */
diff --git a/include/asm-sparc/bitops.h b/include/asm-sparc/bitops.h
index 41722b5e45ef..04aa3318f76a 100644
--- a/include/asm-sparc/bitops.h
+++ b/include/asm-sparc/bitops.h
@@ -152,386 +152,22 @@ static inline void change_bit(unsigned long nr, volatile unsigned long *addr)
        : "memory", "cc");
 }
-/*
+#include <asm-generic/bitops/non-atomic.h>
- * non-atomic versions
- */
-static inline void __set_bit(int nr, volatile unsigned long *addr)
-{
-        unsigned long mask = 1UL << (nr & 0x1f);
-        unsigned long *p = ((unsigned long *)addr) + (nr >> 5);
-        *p |= mask;
-}
-static inline void __clear_bit(int nr, volatile unsigned long *addr)
-{
-        unsigned long mask = 1UL << (nr & 0x1f);
-        unsigned long *p = ((unsigned long *)addr) + (nr >> 5);
-        *p &= ~mask;
-}
-static inline void __change_bit(int nr, volatile unsigned long *addr)
-{
-        unsigned long mask = 1UL << (nr & 0x1f);
-        unsigned long *p = ((unsigned long *)addr) + (nr >> 5);
-        *p ^= mask;
-}
-static inline int __test_and_set_bit(int nr, volatile unsigned long *addr)
-{
-        unsigned long mask = 1UL << (nr & 0x1f);
-        unsigned long *p = ((unsigned long *)addr) + (nr >> 5);
-        unsigned long old = *p;
-        *p = old | mask;
-        return (old & mask) != 0;
-}
-static inline int __test_and_clear_bit(int nr, volatile unsigned long *addr)
-{
-        unsigned long mask = 1UL << (nr & 0x1f);
-        unsigned long *p = ((unsigned long *)addr) + (nr >> 5);
-        unsigned long old = *p;
-        *p = old & ~mask;
-        return (old & mask) != 0;
-}
-static inline int __test_and_change_bit(int nr, volatile unsigned long *addr)
-{
-        unsigned long mask = 1UL << (nr & 0x1f);
-        unsigned long *p = ((unsigned long *)addr) + (nr >> 5);
-        unsigned long old = *p;
-        *p = old ^ mask;
-        return (old & mask) != 0;
-}
 #define smp_mb__before_clear_bit()      do { } while(0)
 #define smp_mb__after_clear_bit()       do { } while(0)
-/* The following routine need not be atomic. */
+#include <asm-generic/bitops/ffz.h>
-static inline int test_bit(int nr, __const__ volatile unsigned long *addr)
+#include <asm-generic/bitops/__ffs.h>
-{
+#include <asm-generic/bitops/sched.h>
-        return (1UL & (((unsigned long *)addr)[nr >> 5] >> (nr & 31))) != 0UL;
+#include <asm-generic/bitops/ffs.h>
-}
+#include <asm-generic/bitops/fls.h>
+#include <asm-generic/bitops/fls64.h>
-/* The easy/cheese version for now. */
+#include <asm-generic/bitops/hweight.h>
-static inline unsigned long ffz(unsigned long word)
+#include <asm-generic/bitops/find.h>
-{
+#include <asm-generic/bitops/ext2-non-atomic.h>
-        unsigned long result = 0;
+#include <asm-generic/bitops/ext2-atomic.h>
+#include <asm-generic/bitops/minix.h>
-        while(word & 1) {
-                result++;
-                word >>= 1;
-        }
-        return result;
-}
-/**
- * __ffs - find first bit in word.
- * @word: The word to search
- *
- * Undefined if no bit exists, so code should check against 0 first.
- */
-static inline int __ffs(unsigned long word)
-{
-        int num = 0;
-        if ((word & 0xffff) == 0) {
-                num += 16;
-                word >>= 16;
-        }
-        if ((word & 0xff) == 0) {
-                num += 8;
-                word >>= 8;
-        }
-        if ((word & 0xf) == 0) {
-                num += 4;
-                word >>= 4;
-        }
-        if ((word & 0x3) == 0) {
-                num += 2;
-                word >>= 2;
-        }
-        if ((word & 0x1) == 0)
-                num += 1;
-        return num;
-}
-/*
- * Every architecture must define this function. It's the fastest
- * way of searching a 140-bit bitmap where the first 100 bits are
- * unlikely to be set. It's guaranteed that at least one of the 140
- * bits is cleared.
- */
-static inline int sched_find_first_bit(unsigned long *b)
-{
-        if (unlikely(b[0]))
-                return __ffs(b[0]);
-        if (unlikely(b[1]))
-                return __ffs(b[1]) + 32;
-        if (unlikely(b[2]))
-                return __ffs(b[2]) + 64;
-        if (b[3])
-                return __ffs(b[3]) + 96;
-        return __ffs(b[4]) + 128;
-}
-/*
- * ffs: find first bit set. This is defined the same way as
- * the libc and compiler builtin ffs routines, therefore
- * differs in spirit from the above ffz (man ffs).
- */
-static inline int ffs(int x)
-{
-        if (!x)
-                return 0;
-        return __ffs((unsigned long)x) + 1;
-}
-/*
- * fls: find last (most-significant) bit set.
- * Note fls(0) = 0, fls(1) = 1, fls(0x80000000) = 32.
- */
-#define fls(x) generic_fls(x)
-#define fls64(x)   generic_fls64(x)
-/*
- * hweightN: returns the hamming weight (i.e. the number
- * of bits set) of a N-bit word
- */
-#define hweight32(x) generic_hweight32(x)
-#define hweight16(x) generic_hweight16(x)
-#define hweight8(x) generic_hweight8(x)
-/*
- * find_next_zero_bit() finds the first zero bit in a bit string of length
- * 'size' bits, starting the search at bit 'offset'. This is largely based
- * on Linus's ALPHA routines, which are pretty portable BTW.
- */
-static inline unsigned long find_next_zero_bit(const unsigned long *addr,
-    unsigned long size, unsigned long offset)
-{
-        const unsigned long *p = addr + (offset >> 5);
-        unsigned long result = offset & ~31UL;
-        unsigned long tmp;
-        if (offset >= size)
-                return size;
-        size -= result;
-        offset &= 31UL;
-        if (offset) {
-                tmp = *(p++);
-                tmp |= ~0UL >> (32-offset);
-                if (size < 32)
-                        goto found_first;
-                if (~tmp)
-                        goto found_middle;
-                size -= 32;
-                result += 32;
-        }
-        while (size & ~31UL) {
-                if (~(tmp = *(p++)))
-                        goto found_middle;
-                result += 32;
-                size -= 32;
-        }
-        if (!size)
-                return result;
-        tmp = *p;
-found_first:
-        tmp |= ~0UL << size;
-        if (tmp == ~0UL)        /* Are any bits zero? */
-                return result + size; /* Nope. */
-found_middle:
-        return result + ffz(tmp);
-}
-/*
- * Linus sez that gcc can optimize the following correctly, we'll see if this
- * holds on the Sparc as it does for the ALPHA.
- */
-#define find_first_zero_bit(addr, size) \
-        find_next_zero_bit((addr), (size), 0)
-/**
- * find_next_bit - find the first set bit in a memory region
- * @addr: The address to base the search on
- * @offset: The bitnumber to start searching at
- * @size: The maximum size to search
- *
- * Scheduler induced bitop, do not use.
- */
-static inline int find_next_bit(const unsigned long *addr, int size, int offset)
-{
-        const unsigned long *p = addr + (offset >> 5);
-        int num = offset & ~0x1f;
-        unsigned long word;
-        word = *p++;
-        word &= ~((1 << (offset & 0x1f)) - 1);
-        while (num < size) {
-                if (word != 0) {
-                        return __ffs(word) + num;
-                }
-                word = *p++;
-                num += 0x20;
-        }
-        return num;
-}
-/**
- * find_first_bit - find the first set bit in a memory region
- * @addr: The address to start the search at
- * @size: The maximum size to search
- *
- * Returns the bit-number of the first set bit, not the number of the byte
- * containing a bit.
- */
-#define find_first_bit(addr, size) \
-        find_next_bit((addr), (size), 0)
-/*
- */
-static inline int test_le_bit(int nr, __const__ unsigned long * addr)
-{
-        __const__ unsigned char *ADDR = (__const__ unsigned char *) addr;
-        return (ADDR[nr >> 3] >> (nr & 7)) & 1;
-}
-/*
- * non-atomic versions
- */
-static inline void __set_le_bit(int nr, unsigned long *addr)
-{
-        unsigned char *ADDR = (unsigned char *)addr;
-        ADDR += nr >> 3;
-        *ADDR |= 1 << (nr & 0x07);
-}
-static inline void __clear_le_bit(int nr, unsigned long *addr)
-{
-        unsigned char *ADDR = (unsigned char *)addr;
-        ADDR += nr >> 3;
-        *ADDR &= ~(1 << (nr & 0x07));
-}
-static inline int __test_and_set_le_bit(int nr, unsigned long *addr)
-{
-        int mask, retval;
-        unsigned char *ADDR = (unsigned char *)addr;
-        ADDR += nr >> 3;
-        mask = 1 << (nr & 0x07);
-        retval = (mask & *ADDR) != 0;
-        *ADDR |= mask;
-        return retval;
-}
-static inline int __test_and_clear_le_bit(int nr, unsigned long *addr)
-{
-        int mask, retval;
-        unsigned char *ADDR = (unsigned char *)addr;
-        ADDR += nr >> 3;
-        mask = 1 << (nr & 0x07);
-        retval = (mask & *ADDR) != 0;
-        *ADDR &= ~mask;
-        return retval;
-}
-static inline unsigned long find_next_zero_le_bit(const unsigned long *addr,
-    unsigned long size, unsigned long offset)
-{
-        const unsigned long *p = addr + (offset >> 5);
-        unsigned long result = offset & ~31UL;
-        unsigned long tmp;
-        if (offset >= size)
-                return size;
-        size -= result;
-        offset &= 31UL;
-        if(offset) {
-                tmp = *(p++);
-                tmp |= __swab32(~0UL >> (32-offset));
-                if(size < 32)
-                        goto found_first;
-                if(~tmp)
-                        goto found_middle;
-                size -= 32;
-                result += 32;
-        }
-        while(size & ~31UL) {
-                if(~(tmp = *(p++)))
-                        goto found_middle;
-                result += 32;
-                size -= 32;
-        }
-        if(!size)
-                return result;
-        tmp = *p;
-found_first:
-        tmp = __swab32(tmp) | (~0UL << size);
-        if (tmp == ~0UL)        /* Are any bits zero? */
-                return result + size; /* Nope. */
-        return result + ffz(tmp);
-found_middle:
-        return result + ffz(__swab32(tmp));
-}
-#define find_first_zero_le_bit(addr, size) \
-        find_next_zero_le_bit((addr), (size), 0)
-#define ext2_set_bit(nr,addr)   \
-        __test_and_set_le_bit((nr),(unsigned long *)(addr))
-#define ext2_clear_bit(nr,addr) \
-        __test_and_clear_le_bit((nr),(unsigned long *)(addr))
-#define ext2_set_bit_atomic(lock, nr, addr)             \
-        ({                                              \
-                int ret;                                \
-                spin_lock(lock);                        \
-                ret = ext2_set_bit((nr), (unsigned long *)(addr)); \
-                spin_unlock(lock);                      \
-                ret;                                    \
-        })
-#define ext2_clear_bit_atomic(lock, nr, addr)           \
-        ({                                              \
-                int ret;                                \
-                spin_lock(lock);                        \
-                ret = ext2_clear_bit((nr), (unsigned long *)(addr)); \
-                spin_unlock(lock);                      \
-                ret;                                    \
-        })
-#define ext2_test_bit(nr,addr)  \
-        test_le_bit((nr),(unsigned long *)(addr))
-#define ext2_find_first_zero_bit(addr, size) \
-        find_first_zero_le_bit((unsigned long *)(addr), (size))
-#define ext2_find_next_zero_bit(addr, size, off) \
-        find_next_zero_le_bit((unsigned long *)(addr), (size), (off))
-/* Bitmap functions for the minix filesystem.  */
-#define minix_test_and_set_bit(nr,addr) \
-        test_and_set_bit((nr),(unsigned long *)(addr))
-#define minix_set_bit(nr,addr)          \
-        set_bit((nr),(unsigned long *)(addr))
-#define minix_test_and_clear_bit(nr,addr) \
-        test_and_clear_bit((nr),(unsigned long *)(addr))
-#define minix_test_bit(nr,addr)         \
-        test_bit((nr),(unsigned long *)(addr))
-#define minix_find_first_zero_bit(addr,size) \
-        find_first_zero_bit((unsigned long *)(addr),(size))
 #endif /* __KERNEL__ */
diff --git a/include/asm-sparc/page.h b/include/asm-sparc/page.h
index 9122684f6c1e..ec3274b7ddf4 100644
--- a/include/asm-sparc/page.h
+++ b/include/asm-sparc/page.h
@@ -152,8 +152,7 @@ extern unsigned long pfn_base;
 #define virt_to_phys            __pa
 #define phys_to_virt            __va
-#define pfn_to_page(pfn)        (mem_map + ((pfn)-(pfn_base)))
+#define ARCH_PFN_OFFSET         (pfn_base)
-#define page_to_pfn(page)       ((unsigned long)(((page) - mem_map) + pfn_base))
 #define virt_to_page(kaddr)     (mem_map + ((((unsigned long)(kaddr)-PAGE_OFFSET)>>PAGE_SHIFT)))
 #define pfn_valid(pfn)          (((pfn) >= (pfn_base)) && (((pfn)-(pfn_base)) < max_mapnr))
@@ -164,6 +163,7 @@ extern unsigned long pfn_base;
 #endif /* __KERNEL__ */
+#include <asm-generic/memory_model.h>
 #include <asm-generic/page.h>
 #endif /* _SPARC_PAGE_H */
diff --git a/include/asm-sparc64/bitops.h b/include/asm-sparc64/bitops.h
index 6efc0162fb09..71944b0f09de 100644
--- a/include/asm-sparc64/bitops.h
+++ b/include/asm-sparc64/bitops.h
@@ -18,58 +18,7 @@ extern void set_bit(unsigned long nr, volatile unsigned long *addr);
 extern void clear_bit(unsigned long nr, volatile unsigned long *addr);
 extern void change_bit(unsigned long nr, volatile unsigned long *addr);
-/* "non-atomic" versions... */
+#include <asm-generic/bitops/non-atomic.h>
-static inline void __set_bit(int nr, volatile unsigned long *addr)
-{
-        unsigned long *m = ((unsigned long *)addr) + (nr >> 6);
-        *m |= (1UL << (nr & 63));
-}
-static inline void __clear_bit(int nr, volatile unsigned long *addr)
-{
-        unsigned long *m = ((unsigned long *)addr) + (nr >> 6);
-        *m &= ~(1UL << (nr & 63));
-}
-static inline void __change_bit(int nr, volatile unsigned long *addr)
-{
-        unsigned long *m = ((unsigned long *)addr) + (nr >> 6);
-        *m ^= (1UL << (nr & 63));
-}
-static inline int __test_and_set_bit(int nr, volatile unsigned long *addr)
-{
-        unsigned long *m = ((unsigned long *)addr) + (nr >> 6);
-        unsigned long old = *m;
-        unsigned long mask = (1UL << (nr & 63));
-        *m = (old | mask);
-        return ((old & mask) != 0);
-}
-static inline int __test_and_clear_bit(int nr, volatile unsigned long *addr)
-{
-        unsigned long *m = ((unsigned long *)addr) + (nr >> 6);
-        unsigned long old = *m;
-        unsigned long mask = (1UL << (nr & 63));
-        *m = (old & ~mask);
-        return ((old & mask) != 0);
-}
-static inline int __test_and_change_bit(int nr, volatile unsigned long *addr)
-{
-        unsigned long *m = ((unsigned long *)addr) + (nr >> 6);
-        unsigned long old = *m;
-        unsigned long mask = (1UL << (nr & 63));
-        *m = (old ^ mask);
-        return ((old & mask) != 0);
-}
 #ifdef CONFIG_SMP
 #define smp_mb__before_clear_bit()      membar_storeload_loadload()
@@ -79,78 +28,15 @@ static inline int __test_and_change_bit(int nr, volatile unsigned long *addr)
 #define smp_mb__after_clear_bit()       barrier()
 #endif
-static inline int test_bit(int nr, __const__ volatile unsigned long *addr)
+#include <asm-generic/bitops/ffz.h>
-{
+#include <asm-generic/bitops/__ffs.h>
-        return (1UL & (addr[nr >> 6] >> (nr & 63))) != 0UL;
+#include <asm-generic/bitops/fls.h>
-}
+#include <asm-generic/bitops/fls64.h>
-/* The easy/cheese version for now. */
-static inline unsigned long ffz(unsigned long word)
-{
-        unsigned long result;
-        result = 0;
-        while(word & 1) {
-                result++;
-                word >>= 1;
-        }
-        return result;
-}
-/**
- * __ffs - find first bit in word.
- * @word: The word to search
- *
- * Undefined if no bit exists, so code should check against 0 first.
- */
-static inline unsigned long __ffs(unsigned long word)
-{
-        unsigned long result = 0;
-        while (!(word & 1UL)) {
-                result++;
-                word >>= 1;
-        }
-        return result;
-}
-/*
- * fls: find last bit set.
- */
-#define fls(x) generic_fls(x)
-#define fls64(x)   generic_fls64(x)
 #ifdef __KERNEL__
-/*
+#include <asm-generic/bitops/sched.h>
- * Every architecture must define this function. It's the fastest
+#include <asm-generic/bitops/ffs.h>
- * way of searching a 140-bit bitmap where the first 100 bits are
- * unlikely to be set. It's guaranteed that at least one of the 140
- * bits is cleared.
- */
-static inline int sched_find_first_bit(unsigned long *b)
-{
-        if (unlikely(b[0]))
-                return __ffs(b[0]);
-        if (unlikely(((unsigned int)b[1])))
-                return __ffs(b[1]) + 64;
-        if (b[1] >> 32)
-                return __ffs(b[1] >> 32) + 96;
-        return __ffs(b[2]) + 128;
-}
-/*
- * ffs: find first bit set. This is defined the same way as
- * the libc and compiler builtin ffs routines, therefore
- * differs in spirit from the above ffz (man ffs).
- */
-static inline int ffs(int x)
-{
-        if (!x)
-                return 0;
-        return __ffs((unsigned long)x) + 1;
-}
 /*
 * hweightN: returns the hamming weight (i.e. the number
@@ -193,102 +79,23 @@ static inline unsigned int hweight8(unsigned int w)
 #else
-#define hweight64(x) generic_hweight64(x)
+#include <asm-generic/bitops/hweight.h>
-#define hweight32(x) generic_hweight32(x)
-#define hweight16(x) generic_hweight16(x)
-#define hweight8(x) generic_hweight8(x)
 #endif
 #endif /* __KERNEL__ */
-/**
+#include <asm-generic/bitops/find.h>
- * find_next_bit - find the next set bit in a memory region
- * @addr: The address to base the search on
- * @offset: The bitnumber to start searching at
- * @size: The maximum size to search
- */
-extern unsigned long find_next_bit(const unsigned long *, unsigned long,
-                                        unsigned long);
-/**
- * find_first_bit - find the first set bit in a memory region
- * @addr: The address to start the search at
- * @size: The maximum size to search
- *
- * Returns the bit-number of the first set bit, not the number of the byte
- * containing a bit.
- */
-#define find_first_bit(addr, size) \
-        find_next_bit((addr), (size), 0)
-/* find_next_zero_bit() finds the first zero bit in a bit string of length
- * 'size' bits, starting the search at bit 'offset'. This is largely based
- * on Linus's ALPHA routines, which are pretty portable BTW.
- */
-extern unsigned long find_next_zero_bit(const unsigned long *,
-                                        unsigned long, unsigned long);
-#define find_first_zero_bit(addr, size) \
-        find_next_zero_bit((addr), (size), 0)
-#define test_and_set_le_bit(nr,addr)    \
-        test_and_set_bit((nr) ^ 0x38, (addr))
-#define test_and_clear_le_bit(nr,addr)  \
-        test_and_clear_bit((nr) ^ 0x38, (addr))
-static inline int test_le_bit(int nr, __const__ unsigned long * addr)
-{
-        int                     mask;
-        __const__ unsigned char *ADDR = (__const__ unsigned char *) addr;
-        ADDR += nr >> 3;
-        mask = 1 << (nr & 0x07);
-        return ((mask & *ADDR) != 0);
-}
-#define find_first_zero_le_bit(addr, size) \
-        find_next_zero_le_bit((addr), (size), 0)
-extern unsigned long find_next_zero_le_bit(unsigned long *, unsigned long, unsigned long);
 #ifdef __KERNEL__
-#define __set_le_bit(nr, addr) \
+#include <asm-generic/bitops/ext2-non-atomic.h>
-        __set_bit((nr) ^ 0x38, (addr))
-#define __clear_le_bit(nr, addr) \
-        __clear_bit((nr) ^ 0x38, (addr))
-#define __test_and_clear_le_bit(nr, addr) \
-        __test_and_clear_bit((nr) ^ 0x38, (addr))
-#define __test_and_set_le_bit(nr, addr) \
-        __test_and_set_bit((nr) ^ 0x38, (addr))
-#define ext2_set_bit(nr,addr)   \
-        __test_and_set_le_bit((nr),(unsigned long *)(addr))
 #define ext2_set_bit_atomic(lock,nr,addr) \
-        test_and_set_le_bit((nr),(unsigned long *)(addr))
+        test_and_set_bit((nr) ^ 0x38,(unsigned long *)(addr))
-#define ext2_clear_bit(nr,addr) \
-        __test_and_clear_le_bit((nr),(unsigned long *)(addr))
 #define ext2_clear_bit_atomic(lock,nr,addr) \
-        test_and_clear_le_bit((nr),(unsigned long *)(addr))
+        test_and_clear_bit((nr) ^ 0x38,(unsigned long *)(addr))
-#define ext2_test_bit(nr,addr)  \
-        test_le_bit((nr),(unsigned long *)(addr))
-#define ext2_find_first_zero_bit(addr, size) \
-        find_first_zero_le_bit((unsigned long *)(addr), (size))
-#define ext2_find_next_zero_bit(addr, size, off) \
-        find_next_zero_le_bit((unsigned long *)(addr), (size), (off))
-/* Bitmap functions for the minix filesystem.  */
+#include <asm-generic/bitops/minix.h>
-#define minix_test_and_set_bit(nr,addr) \
-        test_and_set_bit((nr),(unsigned long *)(addr))
-#define minix_set_bit(nr,addr)  \
-        set_bit((nr),(unsigned long *)(addr))
-#define minix_test_and_clear_bit(nr,addr) \
-        test_and_clear_bit((nr),(unsigned long *)(addr))
-#define minix_test_bit(nr,addr) \
-        test_bit((nr),(unsigned long *)(addr))
-#define minix_find_first_zero_bit(addr,size) \
-        find_first_zero_bit((unsigned long *)(addr),(size))
 #endif /* __KERNEL__ */
diff --git a/include/asm-sparc64/futex.h b/include/asm-sparc64/futex.h
index 34c4b43d3f98..cd340a233156 100644
--- a/include/asm-sparc64/futex.h
+++ b/include/asm-sparc64/futex.h
@@ -83,4 +83,10 @@ static inline int futex_atomic_op_inuser(int encoded_op, int __user *uaddr)
        return ret;
 }
+static inline int
+futex_atomic_cmpxchg_inuser(int __user *uaddr, int oldval, int newval)
+{
+        return -ENOSYS;
+}
 #endif /* !(_SPARC64_FUTEX_H) */
diff --git a/include/asm-sparc64/kdebug.h b/include/asm-sparc64/kdebug.h
index 6321f5a0198d..4040d127ac3e 100644
--- a/include/asm-sparc64/kdebug.h
+++ b/include/asm-sparc64/kdebug.h
@@ -15,12 +15,9 @@ struct die_args {
        int signr;
 };
-/* Note - you should never unregister because that can race with NMIs.
+extern int register_die_notifier(struct notifier_block *);
- * If you really want to do it first unregister - then synchronize_sched
+extern int unregister_die_notifier(struct notifier_block *);
- * - then free.
+extern struct atomic_notifier_head sparc64die_chain;
- */
-int register_die_notifier(struct notifier_block *nb);
-extern struct notifier_block *sparc64die_chain;
 extern void bad_trap(struct pt_regs *, long);
@@ -46,7 +43,7 @@ static inline int notify_die(enum die_val val,char *str, struct pt_regs *regs,
                                 .trapnr        = trap,
                                 .signr         = sig };
-        return notifier_call_chain(&sparc64die_chain, val, &args);
+        return atomic_notifier_call_chain(&sparc64die_chain, val, &args);
 }
 #endif
diff --git a/include/asm-sparc64/page.h b/include/asm-sparc64/page.h
index 66fe4ac59fd6..aabb21906724 100644
--- a/include/asm-sparc64/page.h
+++ b/include/asm-sparc64/page.h
@@ -111,6 +111,8 @@ typedef unsigned long pgprot_t;
                                 (_AC(0x0000000070000000,UL)) : \
                                 (_AC(0xfffff80000000000,UL) + (1UL << 32UL)))
+#include <asm-generic/memory_model.h>
 #endif /* !(__ASSEMBLY__) */
 /* to align the pointer to the (next) page boundary */
diff --git a/include/asm-um/page.h b/include/asm-um/page.h
index 0229814af31e..41364330aff1 100644
--- a/include/asm-um/page.h
+++ b/include/asm-um/page.h
@@ -106,9 +106,6 @@ extern unsigned long uml_physmem;
 #define __pa(virt) to_phys((void *) (unsigned long) (virt))
 #define __va(phys) to_virt((unsigned long) (phys))
-#define page_to_pfn(page) ((page) - mem_map)
-#define pfn_to_page(pfn) (mem_map + (pfn))
 #define phys_to_pfn(p) ((p) >> PAGE_SHIFT)
 #define pfn_to_phys(pfn) ((pfn) << PAGE_SHIFT)
@@ -121,6 +118,7 @@ extern struct page *arch_validate(struct page *page, gfp_t mask, int order);
 extern void arch_free_page(struct page *page, int order);
 #define HAVE_ARCH_FREE_PAGE
+#include <asm-generic/memory_model.h>
 #include <asm-generic/page.h>
 #endif
diff --git a/include/asm-um/uaccess.h b/include/asm-um/uaccess.h
index 2ee028b8de9d..4e460d6f5ac8 100644
--- a/include/asm-um/uaccess.h
+++ b/include/asm-um/uaccess.h
@@ -41,16 +41,16 @@
 #define __get_user(x, ptr) \
 ({ \
-        const __typeof__(ptr) __private_ptr = ptr; \
+        const __typeof__(ptr) __private_ptr = ptr;      \
-        __typeof__(*(__private_ptr)) __private_val; \
+        __typeof__(x) __private_val;                    \
-        int __private_ret = -EFAULT; \
+        int __private_ret = -EFAULT;                    \
-        (x) = (__typeof__(*(__private_ptr)))0; \
+        (x) = (__typeof__(*(__private_ptr)))0;                          \
-        if (__copy_from_user(&__private_val, (__private_ptr), \
+        if (__copy_from_user((void *) &__private_val, (__private_ptr),  \
-            sizeof(*(__private_ptr))) == 0) {\
+                             sizeof(*(__private_ptr))) == 0) {          \
-                (x) = (__typeof__(*(__private_ptr))) __private_val; \
+                (x) = (__typeof__(*(__private_ptr))) __private_val;     \
-                __private_ret = 0; \
+                __private_ret = 0;                                      \
-        } \
+        }                                                               \
-        __private_ret; \
+        __private_ret;                                                  \
 }) 
 #define get_user(x, ptr) \
@@ -89,14 +89,3 @@ struct exception_table_entry
 };
 #endif
-/*
- * Overrides for Emacs so that we follow Linus's tabbing style.
- * Emacs will notice this stuff at the end of the file and automatically
- * adjust the settings for this buffer only.  This must remain at the end
- * of the file.
- * ---------------------------------------------------------------------------
- * Local variables:
- * c-file-style: "linux"
- * End:
- */
diff --git a/include/asm-v850/bitops.h b/include/asm-v850/bitops.h
index 609b9e87222a..1f6fd5ab4177 100644
--- a/include/asm-v850/bitops.h
+++ b/include/asm-v850/bitops.h
@@ -22,25 +22,11 @@
 #ifdef __KERNEL__
-/*
+#include <asm-generic/bitops/ffz.h>
- * The __ functions are not atomic
- */
 /*
- * ffz = Find First Zero in word. Undefined if no zero exists,
+ * The __ functions are not atomic
- * so code should check against ~0UL first..
 */
-static inline unsigned long ffz (unsigned long word)
-{
-        unsigned long result = 0;
-        while (word & 1) {
-                result++;
-                word >>= 1;
-        }
-        return result;
-}
 /* In the following constant-bit-op macros, a "g" constraint is used when
   we really need an integer ("i" constraint).  This is to avoid
@@ -153,203 +139,19 @@ static inline int __test_bit (int nr, const void *addr)
 #define smp_mb__before_clear_bit()      barrier ()
 #define smp_mb__after_clear_bit()       barrier ()
+#include <asm-generic/bitops/ffs.h>
+#include <asm-generic/bitops/fls.h>
+#include <asm-generic/bitops/fls64.h>
+#include <asm-generic/bitops/__ffs.h>
+#include <asm-generic/bitops/find.h>
+#include <asm-generic/bitops/sched.h>
+#include <asm-generic/bitops/hweight.h>
-#define find_first_zero_bit(addr, size) \
+#include <asm-generic/bitops/ext2-non-atomic.h>
-  find_next_zero_bit ((addr), (size), 0)
-static inline int find_next_zero_bit(const void *addr, int size, int offset)
-{
-        unsigned long *p = ((unsigned long *) addr) + (offset >> 5);
-        unsigned long result = offset & ~31UL;
-        unsigned long tmp;
-        if (offset >= size)
-                return size;
-        size -= result;
-        offset &= 31UL;
-        if (offset) {
-                tmp = * (p++);
-                tmp |= ~0UL >> (32-offset);
-                if (size < 32)
-                        goto found_first;
-                if (~tmp)
-                        goto found_middle;
-                size -= 32;
-                result += 32;
-        }
-        while (size & ~31UL) {
-                if (~ (tmp = * (p++)))
-                        goto found_middle;
-                result += 32;
-                size -= 32;
-        }
-        if (!size)
-                return result;
-        tmp = *p;
- found_first:
-        tmp |= ~0UL << size;
- found_middle:
-        return result + ffz (tmp);
-}
-/* This is the same as generic_ffs, but we can't use that because it's
-   inline and the #include order mucks things up.  */
-static inline int generic_ffs_for_find_next_bit(int x)
-{
-        int r = 1;
-        if (!x)
-                return 0;
-        if (!(x & 0xffff)) {
-                x >>= 16;
-                r += 16;
-        }
-        if (!(x & 0xff)) {
-                x >>= 8;
-                r += 8;
-        }
-        if (!(x & 0xf)) {
-                x >>= 4;
-                r += 4;
-        }
-        if (!(x & 3)) {
-                x >>= 2;
-                r += 2;
-        }
-        if (!(x & 1)) {
-                x >>= 1;
-                r += 1;
-        }
-        return r;
-}
-/*
- * Find next one bit in a bitmap reasonably efficiently.
- */
-static __inline__ unsigned long find_next_bit(const unsigned long *addr,
-        unsigned long size, unsigned long offset)
-{
-        unsigned int *p = ((unsigned int *) addr) + (offset >> 5);
-        unsigned int result = offset & ~31UL;
-        unsigned int tmp;
-        if (offset >= size)
-                return size;
-        size -= result;
-        offset &= 31UL;
-        if (offset) {
-                tmp = *p++;
-                tmp &= ~0UL << offset;
-                if (size < 32)
-                        goto found_first;
-                if (tmp)
-                        goto found_middle;
-                size -= 32;
-                result += 32;
-        }
-        while (size >= 32) {
-                if ((tmp = *p++) != 0)
-                        goto found_middle;
-                result += 32;
-                size -= 32;
-        }
-        if (!size)
-                return result;
-        tmp = *p;
-found_first:
-        tmp &= ~0UL >> (32 - size);
-        if (tmp == 0UL)        /* Are any bits set? */
-                return result + size; /* Nope. */
-found_middle:
-        return result + generic_ffs_for_find_next_bit(tmp);
-}
-/*
- * find_first_bit - find the first set bit in a memory region
- */
-#define find_first_bit(addr, size) \
-        find_next_bit((addr), (size), 0)
-#define ffs(x) generic_ffs (x)
-#define fls(x) generic_fls (x)
-#define fls64(x) generic_fls64(x)
-#define __ffs(x) ffs(x)
-/*
- * This is just `generic_ffs' from <linux/bitops.h>, except that it assumes
- * that at least one bit is set, and returns the real index of the bit
- * (rather than the bit index + 1, like ffs does).
- */
-static inline int sched_ffs(int x)
-{
-        int r = 0;
-        if (!(x & 0xffff)) {
-                x >>= 16;
-                r += 16;
-        }
-        if (!(x & 0xff)) {
-                x >>= 8;
-                r += 8;
-        }
-        if (!(x & 0xf)) {
-                x >>= 4;
-                r += 4;
-        }
-        if (!(x & 3)) {
-                x >>= 2;
-                r += 2;
-        }
-        if (!(x & 1)) {
-                x >>= 1;
-                r += 1;
-        }
-        return r;
-}
-/*
- * Every architecture must define this function. It's the fastest
- * way of searching a 140-bit bitmap where the first 100 bits are
- * unlikely to be set. It's guaranteed that at least one of the 140
- * bits is set.
- */
-static inline int sched_find_first_bit(unsigned long *b)
-{
-        unsigned offs = 0;
-        while (! *b) {
-                b++;
-                offs += 32;
-        }
-        return sched_ffs (*b) + offs;
-}
-/*
- * hweightN: returns the hamming weight (i.e. the number
- * of bits set) of a N-bit word
- */
-#define hweight32(x)                    generic_hweight32 (x)
-#define hweight16(x)                    generic_hweight16 (x)
-#define hweight8(x)                     generic_hweight8 (x)
-#define ext2_set_bit                    test_and_set_bit
 #define ext2_set_bit_atomic(l,n,a)      test_and_set_bit(n,a)
-#define ext2_clear_bit                  test_and_clear_bit
 #define ext2_clear_bit_atomic(l,n,a)    test_and_clear_bit(n,a)
-#define ext2_test_bit                   test_bit
-#define ext2_find_first_zero_bit        find_first_zero_bit
-#define ext2_find_next_zero_bit         find_next_zero_bit
-/* Bitmap functions for the minix filesystem.  */
+#include <asm-generic/bitops/minix.h>
-#define minix_test_and_set_bit          test_and_set_bit
-#define minix_set_bit                   set_bit
-#define minix_test_and_clear_bit        test_and_clear_bit
-#define minix_test_bit                  test_bit
-#define minix_find_first_zero_bit       find_first_zero_bit
 #endif /* __KERNEL__ */
diff --git a/include/asm-v850/page.h b/include/asm-v850/page.h
index b4bc85e7b91a..ad03c46a1f92 100644
--- a/include/asm-v850/page.h
+++ b/include/asm-v850/page.h
@@ -111,8 +111,7 @@ typedef unsigned long pgprot_t;
 #define page_to_virt(page) \
  ((((page) - mem_map) << PAGE_SHIFT) + PAGE_OFFSET)
-#define pfn_to_page(pfn)        virt_to_page (pfn_to_virt (pfn))
+#define ARCH_PFN_OFFSET         (PAGE_OFFSET >> PAGE_SHIFT)
-#define page_to_pfn(page)       virt_to_pfn (page_to_virt (page))
 #define pfn_valid(pfn)          ((pfn) < max_mapnr)
 #define virt_addr_valid(kaddr)                                          \
@@ -125,6 +124,7 @@ typedef unsigned long pgprot_t;
 #endif /* KERNEL */
+#include <asm-generic/memory_model.h>
 #include <asm-generic/page.h>
 #endif /* __V850_PAGE_H__ */
diff --git a/include/asm-x86_64/bitops.h b/include/asm-x86_64/bitops.h
index eb4df23e1e41..79212128d0f7 100644
--- a/include/asm-x86_64/bitops.h
+++ b/include/asm-x86_64/bitops.h
@@ -356,14 +356,7 @@ static __inline__ unsigned long __fls(unsigned long word)
 #ifdef __KERNEL__
-static inline int sched_find_first_bit(const unsigned long *b)
+#include <asm-generic/bitops/sched.h>
-{
-        if (b[0])
-                return __ffs(b[0]);
-        if (b[1])
-                return __ffs(b[1]) + 64;
-        return __ffs(b[2]) + 128;
-}
 /**
 * ffs - find first bit set
@@ -412,43 +405,20 @@ static __inline__ int fls(int x)
        return r+1;
 }
-/**
+#include <asm-generic/bitops/hweight.h>
- * hweightN - returns the hamming weight of a N-bit word
- * @x: the word to weigh
- *
- * The Hamming Weight of a number is the total number of bits set in it.
- */
-#define hweight64(x) generic_hweight64(x)
-#define hweight32(x) generic_hweight32(x)
-#define hweight16(x) generic_hweight16(x)
-#define hweight8(x) generic_hweight8(x)
 #endif /* __KERNEL__ */
 #ifdef __KERNEL__
-#define ext2_set_bit(nr,addr) \
+#include <asm-generic/bitops/ext2-non-atomic.h>
-        __test_and_set_bit((nr),(unsigned long*)addr)
 #define ext2_set_bit_atomic(lock,nr,addr) \
                test_and_set_bit((nr),(unsigned long*)addr)
-#define ext2_clear_bit(nr, addr) \
-        __test_and_clear_bit((nr),(unsigned long*)addr)
 #define ext2_clear_bit_atomic(lock,nr,addr) \
                test_and_clear_bit((nr),(unsigned long*)addr)
-#define ext2_test_bit(nr, addr)      test_bit((nr),(unsigned long*)addr)
-#define ext2_find_first_zero_bit(addr, size) \
+#include <asm-generic/bitops/minix.h>
-        find_first_zero_bit((unsigned long*)addr, size)
-#define ext2_find_next_zero_bit(addr, size, off) \
-        find_next_zero_bit((unsigned long*)addr, size, off)
-/* Bitmap functions for the minix filesystem.  */
-#define minix_test_and_set_bit(nr,addr) __test_and_set_bit(nr,(void*)addr)
-#define minix_set_bit(nr,addr) __set_bit(nr,(void*)addr)
-#define minix_test_and_clear_bit(nr,addr) __test_and_clear_bit(nr,(void*)addr)
-#define minix_test_bit(nr,addr) test_bit(nr,(void*)addr)
-#define minix_find_first_zero_bit(addr,size) \
-        find_first_zero_bit((void*)addr,size)
 #endif /* __KERNEL__ */
diff --git a/include/asm-x86_64/futex.h b/include/asm-x86_64/futex.h
index 8602c09bf89e..9804bf07b092 100644
--- a/include/asm-x86_64/futex.h
+++ b/include/asm-x86_64/futex.h
@@ -94,5 +94,32 @@ futex_atomic_op_inuser (int encoded_op, int __user *uaddr)
        return ret;
 }
+static inline int
+futex_atomic_cmpxchg_inatomic(int __user *uaddr, int oldval, int newval)
+{
+        if (!access_ok(VERIFY_WRITE, uaddr, sizeof(int)))
+                return -EFAULT;
+        __asm__ __volatile__(
+                "1:     " LOCK_PREFIX "cmpxchgl %3, %1          \n"
+                "2:     .section .fixup, \"ax\"                 \n"
+                "3:     mov     %2, %0                          \n"
+                "       jmp     2b                              \n"
+                "       .previous                               \n"
+                "       .section __ex_table, \"a\"              \n"
+                "       .align  8                               \n"
+                "       .quad   1b,3b                           \n"
+                "       .previous                               \n"
+                : "=a" (oldval), "=m" (*uaddr)
+                : "i" (-EFAULT), "r" (newval), "0" (oldval)
+                : "memory"
+        );
+        return oldval;
+}
 #endif
 #endif
diff --git a/include/asm-x86_64/kdebug.h b/include/asm-x86_64/kdebug.h
index b9ed4c0c8783..cf795631d9b4 100644
--- a/include/asm-x86_64/kdebug.h
+++ b/include/asm-x86_64/kdebug.h
@@ -5,21 +5,20 @@
 struct pt_regs;
-struct die_args { 
+struct die_args {
        struct pt_regs *regs;
        const char *str;
-        long err; 
+        long err;
        int trapnr;
        int signr;
-}; 
+};
+extern int register_die_notifier(struct notifier_block *);
+extern int unregister_die_notifier(struct notifier_block *);
+extern struct atomic_notifier_head die_chain;
-/* Note - you should never unregister because that can race with NMIs.
-   If you really want to do it first unregister - then synchronize_sched - then free.
-  */
-int register_die_notifier(struct notifier_block *nb);
-extern struct notifier_block *die_chain;
 /* Grossly misnamed. */
-enum die_val { 
+enum die_val {
        DIE_OOPS = 1,
        DIE_INT3,
        DIE_DEBUG,
@@ -33,8 +32,8 @@ enum die_val {
        DIE_CALL,
        DIE_NMI_IPI,
        DIE_PAGE_FAULT,
-}; 
+};
-        
 static inline int notify_die(enum die_val val, const char *str,
                        struct pt_regs *regs, long err, int trap, int sig)
 {
@@ -45,7 +44,7 @@ static inline int notify_die(enum die_val val, const char *str,
                .trapnr = trap,
                .signr = sig
        };
-        return notifier_call_chain(&die_chain, val, &args); 
+        return atomic_notifier_call_chain(&die_chain, val, &args);
 } 
 extern int printk_address(unsigned long address);
diff --git a/include/asm-x86_64/mmzone.h b/include/asm-x86_64/mmzone.h
index 937f99b26883..6b18cd8f293d 100644
--- a/include/asm-x86_64/mmzone.h
+++ b/include/asm-x86_64/mmzone.h
@@ -44,12 +44,8 @@ static inline __attribute__((pure)) int phys_to_nid(unsigned long addr)
 #define pfn_to_nid(pfn) phys_to_nid((unsigned long)(pfn) << PAGE_SHIFT)
 #define kvaddr_to_nid(kaddr)    phys_to_nid(__pa(kaddr))
-extern struct page *pfn_to_page(unsigned long pfn);
-extern unsigned long page_to_pfn(struct page *page);
 extern int pfn_valid(unsigned long pfn);
 #endif
-#define local_mapnr(kvaddr) \
-        ( (__pa(kvaddr) >> PAGE_SHIFT) - node_start_pfn(kvaddr_to_nid(kvaddr)) )
 #endif
 #endif
diff --git a/include/asm-x86_64/page.h b/include/asm-x86_64/page.h
index 615e3e494929..408185bac351 100644
--- a/include/asm-x86_64/page.h
+++ b/include/asm-x86_64/page.h
@@ -123,8 +123,6 @@ typedef struct { unsigned long pgprot; } pgprot_t;
 #define __boot_va(x)            __va(x)
 #define __boot_pa(x)            __pa(x)
 #ifdef CONFIG_FLATMEM
-#define pfn_to_page(pfn)        (mem_map + (pfn))
-#define page_to_pfn(page)       ((unsigned long)((page) - mem_map))
 #define pfn_valid(pfn)          ((pfn) < end_pfn)
 #endif
@@ -140,6 +138,7 @@ typedef struct { unsigned long pgprot; } pgprot_t;
 #endif /* __KERNEL__ */
+#include <asm-generic/memory_model.h>
 #include <asm-generic/page.h>
 #endif /* _X86_64_PAGE_H */
diff --git a/include/asm-x86_64/processor.h b/include/asm-x86_64/processor.h
index 8c8d88c036ed..1aa2cee43344 100644
--- a/include/asm-x86_64/processor.h
+++ b/include/asm-x86_64/processor.h
@@ -20,6 +20,7 @@
 #include <asm/mmsegment.h>
 #include <asm/percpu.h>
 #include <linux/personality.h>
+#include <linux/cpumask.h>
 #define TF_MASK         0x00000100
 #define IF_MASK         0x00000200
@@ -65,6 +66,9 @@ struct cpuinfo_x86 {
        __u32   x86_power;      
        __u32   extended_cpuid_level;   /* Max extended CPUID function supported */
        unsigned long loops_per_jiffy;
+#ifdef CONFIG_SMP
+        cpumask_t llc_shared_map;       /* cpus sharing the last level cache */
+#endif
        __u8    apicid;
        __u8    booted_cores;   /* number of cores as seen by OS */
 } ____cacheline_aligned;
diff --git a/include/asm-x86_64/smp.h b/include/asm-x86_64/smp.h
index 9ccbb2cfd5c0..a4fdaeb5c397 100644
--- a/include/asm-x86_64/smp.h
+++ b/include/asm-x86_64/smp.h
@@ -56,6 +56,7 @@ extern cpumask_t cpu_sibling_map[NR_CPUS];
 extern cpumask_t cpu_core_map[NR_CPUS];
 extern u8 phys_proc_id[NR_CPUS];
 extern u8 cpu_core_id[NR_CPUS];
+extern u8 cpu_llc_id[NR_CPUS];
 #define SMP_TRAMPOLINE_BASE 0x6000
diff --git a/include/asm-x86_64/topology.h b/include/asm-x86_64/topology.h
index c642f5d9882d..9db54e9d17bb 100644
--- a/include/asm-x86_64/topology.h
+++ b/include/asm-x86_64/topology.h
@@ -68,4 +68,6 @@ extern int __node_distance(int, int);
 #include <asm-generic/topology.h>
+extern cpumask_t cpu_coregroup_map(int cpu);
 #endif
diff --git a/include/asm-x86_64/unistd.h b/include/asm-x86_64/unistd.h
index da0341c57949..fcc516353087 100644
--- a/include/asm-x86_64/unistd.h
+++ b/include/asm-x86_64/unistd.h
@@ -605,8 +605,12 @@ __SYSCALL(__NR_pselect6, sys_ni_syscall)	/* for now */
 __SYSCALL(__NR_ppoll,   sys_ni_syscall)         /* for now */
 #define __NR_unshare            272
 __SYSCALL(__NR_unshare, sys_unshare)
+#define __NR_set_robust_list    273
+__SYSCALL(__NR_set_robust_list, sys_set_robust_list)
+#define __NR_get_robust_list    274
+__SYSCALL(__NR_get_robust_list, sys_get_robust_list)
-#define __NR_syscall_max __NR_unshare
+#define __NR_syscall_max __NR_get_robust_list
 #ifndef __NO_STUBS
diff --git a/include/asm-xtensa/bitops.h b/include/asm-xtensa/bitops.h
index 0a2065f1a372..d815649617aa 100644
--- a/include/asm-xtensa/bitops.h
+++ b/include/asm-xtensa/bitops.h
@@ -23,156 +23,11 @@
 # error SMP not supported on this architecture
 #endif
-static __inline__ void set_bit(int nr, volatile void * addr)
-{
-        unsigned long mask = 1 << (nr & 0x1f);
-        unsigned long *a = ((unsigned long *)addr) + (nr >> 5);
-        unsigned long flags;
-        local_irq_save(flags);
-        *a |= mask;
-        local_irq_restore(flags);
-}
-static __inline__ void __set_bit(int nr, volatile unsigned long * addr)
-{
-        unsigned long mask = 1 << (nr & 0x1f);
-        unsigned long *a = ((unsigned long *)addr) + (nr >> 5);
-        *a |= mask;
-}
-static __inline__ void clear_bit(int nr, volatile void * addr)
-{
-        unsigned long mask = 1 << (nr & 0x1f);
-        unsigned long *a = ((unsigned long *)addr) + (nr >> 5);
-        unsigned long flags;
-        local_irq_save(flags);
-        *a &= ~mask;
-        local_irq_restore(flags);
-}
-static __inline__ void __clear_bit(int nr, volatile unsigned long *addr)
-{
-        unsigned long mask = 1 << (nr & 0x1f);
-        unsigned long *a = ((unsigned long *)addr) + (nr >> 5);
-        *a &= ~mask;
-}
-/*
- * clear_bit() doesn't provide any barrier for the compiler.
- */
 #define smp_mb__before_clear_bit()      barrier()
 #define smp_mb__after_clear_bit()       barrier()
-static __inline__ void change_bit(int nr, volatile void * addr)
+#include <asm-generic/bitops/atomic.h>
-{
+#include <asm-generic/bitops/non-atomic.h>
-        unsigned long mask = 1 << (nr & 0x1f);
-        unsigned long *a = ((unsigned long *)addr) + (nr >> 5);
-        unsigned long flags;
-        local_irq_save(flags);
-        *a ^= mask;
-        local_irq_restore(flags);
-}
-static __inline__ void __change_bit(int nr, volatile void * addr)
-{
-        unsigned long mask = 1 << (nr & 0x1f);
-        unsigned long *a = ((unsigned long *)addr) + (nr >> 5);
-        *a ^= mask;
-}
-static __inline__ int test_and_set_bit(int nr, volatile void * addr)
-{
-        unsigned long retval;
-        unsigned long mask = 1 << (nr & 0x1f);
-        unsigned long *a = ((unsigned long *)addr) + (nr >> 5);
-        unsigned long flags;
-        local_irq_save(flags);
-        retval = (mask & *a) != 0;
-        *a |= mask;
-        local_irq_restore(flags);
-        return retval;
-}
-static __inline__ int __test_and_set_bit(int nr, volatile void * addr)
-{
-        unsigned long retval;
-        unsigned long mask = 1 << (nr & 0x1f);
-        unsigned long *a = ((unsigned long *)addr) + (nr >> 5);
-        retval = (mask & *a) != 0;
-        *a |= mask;
-        return retval;
-}
-static __inline__ int test_and_clear_bit(int nr, volatile void * addr)
-{
-        unsigned long retval;
-        unsigned long mask = 1 << (nr & 0x1f);
-        unsigned long *a = ((unsigned long *)addr) + (nr >> 5);
-        unsigned long flags;
-        local_irq_save(flags);
-        retval = (mask & *a) != 0;
-        *a &= ~mask;
-        local_irq_restore(flags);
-        return retval;
-}
-static __inline__ int __test_and_clear_bit(int nr, volatile void * addr)
-{
-        unsigned long mask = 1 << (nr & 0x1f);
-        unsigned long *a = ((unsigned long *)addr) + (nr >> 5);
-        unsigned long old = *a;
-        *a = old & ~mask;
-        return (old & mask) != 0;
-}
-static __inline__ int test_and_change_bit(int nr, volatile void * addr)
-{
-        unsigned long retval;
-        unsigned long mask = 1 << (nr & 0x1f);
-        unsigned long *a = ((unsigned long *)addr) + (nr >> 5);
-        unsigned long flags;
-        local_irq_save(flags);
-        retval = (mask & *a) != 0;
-        *a ^= mask;
-        local_irq_restore(flags);
-        return retval;
-}
-/*
- * non-atomic version; can be reordered
- */
-static __inline__ int __test_and_change_bit(int nr, volatile void *addr)
-{
-        unsigned long mask = 1 << (nr & 0x1f);
-        unsigned long *a = ((unsigned long *)addr) + (nr >> 5);
-        unsigned long old = *a;
-        *a = old ^ mask;
-        return (old & mask) != 0;
-}
-static __inline__ int test_bit(int nr, const volatile void *addr)
-{
-        return 1UL & (((const volatile unsigned int *)addr)[nr>>5] >> (nr&31));
-}
 #if XCHAL_HAVE_NSA
@@ -245,202 +100,23 @@ static __inline__ int fls (unsigned int x)
 {
        return __cntlz(x);
 }
-#define fls64(x)   generic_fls64(x)
+#include <asm-generic/bitops/fls64.h>
+#include <asm-generic/bitops/find.h>
-static __inline__ int
+#include <asm-generic/bitops/ext2-non-atomic.h>
-find_next_bit(const unsigned long *addr, int size, int offset)
-{
-        const unsigned long *p = addr + (offset >> 5);
-        unsigned long result = offset & ~31UL;
-        unsigned long tmp;
-        if (offset >= size)
-                return size;
-        size -= result;
-        offset &= 31UL;
-        if (offset) {
-                tmp = *p++;
-                tmp &= ~0UL << offset;
-                if (size < 32)
-                        goto found_first;
-                if (tmp)
-                        goto found_middle;
-                size -= 32;
-                result += 32;
-        }
-        while (size >= 32) {
-                if ((tmp = *p++) != 0)
-                        goto found_middle;
-                result += 32;
-                size -= 32;
-        }
-        if (!size)
-                return result;
-        tmp = *p;
-found_first:
-        tmp &= ~0UL >> (32 - size);
-        if (tmp == 0UL) /* Are any bits set? */
-                return result + size;   /* Nope. */
-found_middle:
-        return result + __ffs(tmp);
-}
-/**
- * find_first_bit - find the first set bit in a memory region
- * @addr: The address to start the search at
- * @size: The maximum size to search
- *
- * Returns the bit-number of the first set bit, not the number of the byte
- * containing a bit.
- */
-#define find_first_bit(addr, size) \
-        find_next_bit((addr), (size), 0)
-static __inline__ int
-find_next_zero_bit(const unsigned long *addr, int size, int offset)
-{
-        const unsigned long *p = addr + (offset >> 5);
-        unsigned long result = offset & ~31UL;
-        unsigned long tmp;
-        if (offset >= size)
-                return size;
-        size -= result;
-        offset &= 31UL;
-        if (offset) {
-                tmp = *p++;
-                tmp |= ~0UL >> (32-offset);
-                if (size < 32)
-                        goto found_first;
-                if (~tmp)
-                        goto found_middle;
-                size -= 32;
-                result += 32;
-        }
-        while (size & ~31UL) {
-                if (~(tmp = *p++))
-                        goto found_middle;
-                result += 32;
-                size -= 32;
-        }
-        if (!size)
-                return result;
-        tmp = *p;
-found_first:
-        tmp |= ~0UL << size;
-found_middle:
-        return result + ffz(tmp);
-}
-#define find_first_zero_bit(addr, size) \
-        find_next_zero_bit((addr), (size), 0)
 #ifdef __XTENSA_EL__
-# define ext2_set_bit(nr,addr) __test_and_set_bit((nr), (addr))
 # define ext2_set_bit_atomic(lock,nr,addr) test_and_set_bit((nr),(addr))
-# define ext2_clear_bit(nr,addr) __test_and_clear_bit((nr), (addr))
 # define ext2_clear_bit_atomic(lock,nr,addr) test_and_clear_bit((nr),(addr))
-# define ext2_test_bit(nr,addr) test_bit((nr), (addr))
-# define ext2_find_first_zero_bit(addr, size) find_first_zero_bit((addr),(size))
-# define ext2_find_next_zero_bit(addr, size, offset) \
-                find_next_zero_bit((addr), (size), (offset))
 #elif defined(__XTENSA_EB__)
-# define ext2_set_bit(nr,addr) __test_and_set_bit((nr) ^ 0x18, (addr))
 # define ext2_set_bit_atomic(lock,nr,addr) test_and_set_bit((nr) ^ 0x18, (addr))
-# define ext2_clear_bit(nr,addr) __test_and_clear_bit((nr) ^ 18, (addr))
 # define ext2_clear_bit_atomic(lock,nr,addr) test_and_clear_bit((nr)^0x18,(addr))
-# define ext2_test_bit(nr,addr) test_bit((nr) ^ 0x18, (addr))
-# define ext2_find_first_zero_bit(addr, size) \
-        ext2_find_next_zero_bit((addr), (size), 0)
-static __inline__ unsigned long ext2_find_next_zero_bit(void *addr, unsigned long size, unsigned long offset)
-{
-        unsigned long *p = ((unsigned long *) addr) + (offset >> 5);
-        unsigned long result = offset & ~31UL;
-        unsigned long tmp;
-        if (offset >= size)
-                return size;
-        size -= result;
-        offset &= 31UL;
-        if(offset) {
-                /* We hold the little endian value in tmp, but then the
-                 * shift is illegal. So we could keep a big endian value
-                 * in tmp, like this:
-                 *
-                 * tmp = __swab32(*(p++));
-                 * tmp |= ~0UL >> (32-offset);
-                 *
-                 * but this would decrease preformance, so we change the
-                 * shift:
-                 */
-                tmp = *(p++);
-                tmp |= __swab32(~0UL >> (32-offset));
-                if(size < 32)
-                        goto found_first;
-                if(~tmp)
-                        goto found_middle;
-                size -= 32;
-                result += 32;
-        }
-        while(size & ~31UL) {
-                if(~(tmp = *(p++)))
-                        goto found_middle;
-                result += 32;
-                size -= 32;
-        }
-        if(!size)
-                return result;
-        tmp = *p;
-found_first:
-        /* tmp is little endian, so we would have to swab the shift,
-         * see above. But then we have to swab tmp below for ffz, so
-         * we might as well do this here.
-         */
-        return result + ffz(__swab32(tmp) | (~0UL << size));
-found_middle:
-        return result + ffz(__swab32(tmp));
-}
 #else
 # error processor byte order undefined!
 #endif
+#include <asm-generic/bitops/hweight.h>
-#define hweight32(x)    generic_hweight32(x)
+#include <asm-generic/bitops/sched.h>
-#define hweight16(x)    generic_hweight16(x)
+#include <asm-generic/bitops/minix.h>
-#define hweight8(x)     generic_hweight8(x)
-/*
- * Find the first bit set in a 140-bit bitmap.
- * The first 100 bits are unlikely to be set.
- */
-static inline int sched_find_first_bit(const unsigned long *b)
-{
-        if (unlikely(b[0]))
-                return __ffs(b[0]);
-        if (unlikely(b[1]))
-                return __ffs(b[1]) + 32;
-        if (unlikely(b[2]))
-                return __ffs(b[2]) + 64;
-        if (b[3])
-                return __ffs(b[3]) + 96;
-        return __ffs(b[4]) + 128;
-}
-/* Bitmap functions for the minix filesystem.  */
-#define minix_test_and_set_bit(nr,addr) test_and_set_bit(nr,addr)
-#define minix_set_bit(nr,addr) set_bit(nr,addr)
-#define minix_test_and_clear_bit(nr,addr) test_and_clear_bit(nr,addr)
-#define minix_test_bit(nr,addr) test_bit(nr,addr)
-#define minix_find_first_zero_bit(addr,size) find_first_zero_bit(addr,size)
 #endif  /* __KERNEL__ */
diff --git a/include/asm-xtensa/page.h b/include/asm-xtensa/page.h
index 8ded36f255a2..992bac5c1258 100644
--- a/include/asm-xtensa/page.h
+++ b/include/asm-xtensa/page.h
@@ -109,10 +109,7 @@ void copy_user_page(void *to,void* from,unsigned long vaddr,struct page* page);
 #define __pa(x)                 ((unsigned long) (x) - PAGE_OFFSET)
 #define __va(x)                 ((void *)((unsigned long) (x) + PAGE_OFFSET))
 #define pfn_valid(pfn)          ((unsigned long)pfn < max_mapnr)
-#ifndef CONFIG_DISCONTIGMEM
+#ifdef CONFIG_DISCONTIGMEM
-# define pfn_to_page(pfn)       (mem_map + (pfn))
-# define page_to_pfn(page)      ((unsigned long)((page) - mem_map))
-#else
 # error CONFIG_DISCONTIGMEM not supported
 #endif
@@ -130,4 +127,5 @@ void copy_user_page(void *to,void* from,unsigned long vaddr,struct page* page);
                                 VM_MAYREAD | VM_MAYWRITE | VM_MAYEXEC)
 #endif /* __KERNEL__ */
+#include <asm-generic/memory_model.h>
 #endif /* _XTENSA_PAGE_H */
diff --git a/include/linux/adb.h b/include/linux/adb.h
index e9fdc63483c7..b7305b178279 100644
--- a/include/linux/adb.h
+++ b/include/linux/adb.h
@@ -85,7 +85,7 @@ enum adb_message {
    ADB_MSG_POST_RESET  /* Called after resetting the bus (re-do init & register) */
 };
 extern struct adb_driver *adb_controller;
-extern struct notifier_block *adb_client_list;
+extern struct blocking_notifier_head adb_client_list;
 int adb_request(struct adb_request *req, void (*done)(struct adb_request *),
                int flags, int nbytes, ...);
diff --git a/include/linux/auto_fs4.h b/include/linux/auto_fs4.h
index 9343c89d843c..0a6bc52ffe88 100644
--- a/include/linux/auto_fs4.h
+++ b/include/linux/auto_fs4.h
@@ -19,18 +19,37 @@
 #undef AUTOFS_MIN_PROTO_VERSION
 #undef AUTOFS_MAX_PROTO_VERSION
-#define AUTOFS_PROTO_VERSION            4
+#define AUTOFS_PROTO_VERSION            5
 #define AUTOFS_MIN_PROTO_VERSION        3
-#define AUTOFS_MAX_PROTO_VERSION        4
+#define AUTOFS_MAX_PROTO_VERSION        5
-#define AUTOFS_PROTO_SUBVERSION         7
+#define AUTOFS_PROTO_SUBVERSION         0
 /* Mask for expire behaviour */
 #define AUTOFS_EXP_IMMEDIATE            1
 #define AUTOFS_EXP_LEAVES               2
-/* New message type */
+/* Daemon notification packet types */
-#define autofs_ptype_expire_multi       2       /* Expire entry (umount request) */
+enum autofs_notify {
+        NFY_NONE,
+        NFY_MOUNT,
+        NFY_EXPIRE
+};
+/* Kernel protocol version 4 packet types */
+/* Expire entry (umount request) */
+#define autofs_ptype_expire_multi       2
+/* Kernel protocol version 5 packet types */
+/* Indirect mount missing and expire requests. */
+#define autofs_ptype_missing_indirect   3
+#define autofs_ptype_expire_indirect    4
+/* Direct mount missing and expire requests */
+#define autofs_ptype_missing_direct     5
+#define autofs_ptype_expire_direct      6
 /* v4 multi expire (via pipe) */
 struct autofs_packet_expire_multi {
@@ -40,14 +59,36 @@ struct autofs_packet_expire_multi {
        char name[NAME_MAX+1];
 };
+/* autofs v5 common packet struct */
+struct autofs_v5_packet {
+        struct autofs_packet_hdr hdr;
+        autofs_wqt_t wait_queue_token;
+        __u32 dev;
+        __u64 ino;
+        __u32 uid;
+        __u32 gid;
+        __u32 pid;
+        __u32 tgid;
+        __u32 len;
+        char name[NAME_MAX+1];
+};
+typedef struct autofs_v5_packet autofs_packet_missing_indirect_t;
+typedef struct autofs_v5_packet autofs_packet_expire_indirect_t;
+typedef struct autofs_v5_packet autofs_packet_missing_direct_t;
+typedef struct autofs_v5_packet autofs_packet_expire_direct_t;
 union autofs_packet_union {
        struct autofs_packet_hdr hdr;
        struct autofs_packet_missing missing;
        struct autofs_packet_expire expire;
        struct autofs_packet_expire_multi expire_multi;
+        struct autofs_v5_packet v5_packet;
 };
 #define AUTOFS_IOC_EXPIRE_MULTI         _IOW(0x93,0x66,int)
+#define AUTOFS_IOC_EXPIRE_INDIRECT      AUTOFS_IOC_EXPIRE_MULTI
+#define AUTOFS_IOC_EXPIRE_DIRECT        AUTOFS_IOC_EXPIRE_MULTI
 #define AUTOFS_IOC_PROTOSUBVER          _IOR(0x93,0x67,int)
 #define AUTOFS_IOC_ASKREGHOST           _IOR(0x93,0x68,int)
 #define AUTOFS_IOC_TOGGLEREGHOST        _IOR(0x93,0x69,int)
diff --git a/include/linux/bitops.h b/include/linux/bitops.h
index f17525a963d1..5d1eabcde5d5 100644
--- a/include/linux/bitops.h
+++ b/include/linux/bitops.h
@@ -3,88 +3,11 @@
 #include <asm/types.h>
 /*
- * ffs: find first bit set. This is defined the same way as
- * the libc and compiler builtin ffs routines, therefore
- * differs in spirit from the above ffz (man ffs).
- */
-static inline int generic_ffs(int x)
-{
-        int r = 1;
-        if (!x)
-                return 0;
-        if (!(x & 0xffff)) {
-                x >>= 16;
-                r += 16;
-        }
-        if (!(x & 0xff)) {
-                x >>= 8;
-                r += 8;
-        }
-        if (!(x & 0xf)) {
-                x >>= 4;
-                r += 4;
-        }
-        if (!(x & 3)) {
-                x >>= 2;
-                r += 2;
-        }
-        if (!(x & 1)) {
-                x >>= 1;
-                r += 1;
-        }
-        return r;
-}
-/*
- * fls: find last bit set.
- */
-static __inline__ int generic_fls(int x)
-{
-        int r = 32;
-        if (!x)
-                return 0;
-        if (!(x & 0xffff0000u)) {
-                x <<= 16;
-                r -= 16;
-        }
-        if (!(x & 0xff000000u)) {
-                x <<= 8;
-                r -= 8;
-        }
-        if (!(x & 0xf0000000u)) {
-                x <<= 4;
-                r -= 4;
-        }
-        if (!(x & 0xc0000000u)) {
-                x <<= 2;
-                r -= 2;
-        }
-        if (!(x & 0x80000000u)) {
-                x <<= 1;
-                r -= 1;
-        }
-        return r;
-}
-/*
 * Include this here because some architectures need generic_ffs/fls in
 * scope
 */
 #include <asm/bitops.h>
-static inline int generic_fls64(__u64 x)
-{
-        __u32 h = x >> 32;
-        if (h)
-                return fls(h) + 32;
-        return fls(x);
-}
 static __inline__ int get_bitmask_order(unsigned int count)
 {
        int order;
@@ -103,54 +26,9 @@ static __inline__ int get_count_order(unsigned int count)
        return order;
 }
-/*
- * hweightN: returns the hamming weight (i.e. the number
- * of bits set) of a N-bit word
- */
-static inline unsigned int generic_hweight32(unsigned int w)
-{
-        unsigned int res = (w & 0x55555555) + ((w >> 1) & 0x55555555);
-        res = (res & 0x33333333) + ((res >> 2) & 0x33333333);
-        res = (res & 0x0F0F0F0F) + ((res >> 4) & 0x0F0F0F0F);
-        res = (res & 0x00FF00FF) + ((res >> 8) & 0x00FF00FF);
-        return (res & 0x0000FFFF) + ((res >> 16) & 0x0000FFFF);
-}
-static inline unsigned int generic_hweight16(unsigned int w)
-{
-        unsigned int res = (w & 0x5555) + ((w >> 1) & 0x5555);
-        res = (res & 0x3333) + ((res >> 2) & 0x3333);
-        res = (res & 0x0F0F) + ((res >> 4) & 0x0F0F);
-        return (res & 0x00FF) + ((res >> 8) & 0x00FF);
-}
-static inline unsigned int generic_hweight8(unsigned int w)
-{
-        unsigned int res = (w & 0x55) + ((w >> 1) & 0x55);
-        res = (res & 0x33) + ((res >> 2) & 0x33);
-        return (res & 0x0F) + ((res >> 4) & 0x0F);
-}
-static inline unsigned long generic_hweight64(__u64 w)
-{
-#if BITS_PER_LONG < 64
-        return generic_hweight32((unsigned int)(w >> 32)) +
-                                generic_hweight32((unsigned int)w);
-#else
-        u64 res;
-        res = (w & 0x5555555555555555ul) + ((w >> 1) & 0x5555555555555555ul);
-        res = (res & 0x3333333333333333ul) + ((res >> 2) & 0x3333333333333333ul);
-        res = (res & 0x0F0F0F0F0F0F0F0Ful) + ((res >> 4) & 0x0F0F0F0F0F0F0F0Ful);
-        res = (res & 0x00FF00FF00FF00FFul) + ((res >> 8) & 0x00FF00FF00FF00FFul);
-        res = (res & 0x0000FFFF0000FFFFul) + ((res >> 16) & 0x0000FFFF0000FFFFul);
-        return (res & 0x00000000FFFFFFFFul) + ((res >> 32) & 0x00000000FFFFFFFFul);
-#endif
-}
 static inline unsigned long hweight_long(unsigned long w)
 {
-        return sizeof(w) == 4 ? generic_hweight32(w) : generic_hweight64(w);
+        return sizeof(w) == 4 ? hweight32(w) : hweight64(w);
 }
 /*
diff --git a/include/linux/bootmem.h b/include/linux/bootmem.h
index 7155452fb4a8..de3eb8d8ae26 100644
--- a/include/linux/bootmem.h
+++ b/include/linux/bootmem.h
@@ -38,6 +38,7 @@ typedef struct bootmem_data {
        unsigned long last_pos;
        unsigned long last_success;     /* Previous allocation point.  To speed
                                         * up searching */
+        struct list_head list;
 } bootmem_data_t;
 extern unsigned long __init bootmem_bootmap_pages (unsigned long);
diff --git a/include/linux/buffer_head.h b/include/linux/buffer_head.h
index 9f159baf153f..fb7e9b7ccbe3 100644
--- a/include/linux/buffer_head.h
+++ b/include/linux/buffer_head.h
@@ -46,25 +46,28 @@ struct address_space;
 typedef void (bh_end_io_t)(struct buffer_head *bh, int uptodate);
 /*
- * Keep related fields in common cachelines.  The most commonly accessed
+ * Historically, a buffer_head was used to map a single block
- * field (b_state) goes at the start so the compiler does not generate
+ * within a page, and of course as the unit of I/O through the
- * indexed addressing for it.
+ * filesystem and block layers.  Nowadays the basic I/O unit
+ * is the bio, and buffer_heads are used for extracting block
+ * mappings (via a get_block_t call), for tracking state within
+ * a page (via a page_mapping) and for wrapping bio submission
+ * for backward compatibility reasons (e.g. submit_bh).
 */
 struct buffer_head {
-        /* First cache line: */
        unsigned long b_state;          /* buffer state bitmap (see above) */
        struct buffer_head *b_this_page;/* circular list of page's buffers */
        struct page *b_page;            /* the page this bh is mapped to */
-        atomic_t b_count;               /* users using this block */
-        u32 b_size;                     /* block size */
-        sector_t b_blocknr;             /* block number */
+        sector_t b_blocknr;             /* start block number */
-        char *b_data;                   /* pointer to data block */
+        size_t b_size;                  /* size of mapping */
+        char *b_data;                   /* pointer to data within the page */
        struct block_device *b_bdev;
        bh_end_io_t *b_end_io;          /* I/O completion */
        void *b_private;                /* reserved for b_end_io */
        struct list_head b_assoc_buffers; /* associated with another mapping */
+        atomic_t b_count;               /* users using this buffer_head */
 };
 /*
@@ -189,8 +192,8 @@ extern int buffer_heads_over_limit;
 * address_spaces.
 */
 int try_to_release_page(struct page * page, gfp_t gfp_mask);
-int block_invalidatepage(struct page *page, unsigned long offset);
+void block_invalidatepage(struct page *page, unsigned long offset);
-int do_invalidatepage(struct page *page, unsigned long offset);
+void do_invalidatepage(struct page *page, unsigned long offset);
 int block_write_full_page(struct page *page, get_block_t *get_block,
                                struct writeback_control *wbc);
 int block_read_full_page(struct page*, get_block_t*);
@@ -200,7 +203,7 @@ int cont_prepare_write(struct page*, unsigned, unsigned, get_block_t*,
 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 *);
+void block_sync_page(struct page *);
 sector_t generic_block_bmap(struct address_space *, sector_t, get_block_t *);
 int generic_commit_write(struct file *, struct page *, unsigned, unsigned);
 int block_truncate_page(struct address_space *, loff_t, get_block_t *);
@@ -277,6 +280,7 @@ map_bh(struct buffer_head *bh, struct super_block *sb, sector_t block)
        set_buffer_mapped(bh);
        bh->b_bdev = sb->s_bdev;
        bh->b_blocknr = block;
+        bh->b_size = sb->s_blocksize;
 }
 /*
diff --git a/include/linux/compat.h b/include/linux/compat.h
index c9ab2a26348c..6d3a654be1ae 100644
--- a/include/linux/compat.h
+++ b/include/linux/compat.h
@@ -45,6 +45,32 @@ struct compat_tms {
        compat_clock_t          tms_cstime;
 };
+struct compat_timex {
+        compat_uint_t modes;
+        compat_long_t offset;
+        compat_long_t freq;
+        compat_long_t maxerror;
+        compat_long_t esterror;
+        compat_int_t status;
+        compat_long_t constant;
+        compat_long_t precision;
+        compat_long_t tolerance;
+        struct compat_timeval time;
+        compat_long_t tick;
+        compat_long_t ppsfreq;
+        compat_long_t jitter;
+        compat_int_t shift;
+        compat_long_t stabil;
+        compat_long_t jitcnt;
+        compat_long_t calcnt;
+        compat_long_t errcnt;
+        compat_long_t stbcnt;
+        compat_int_t :32; compat_int_t :32; compat_int_t :32; compat_int_t :32;
+        compat_int_t :32; compat_int_t :32; compat_int_t :32; compat_int_t :32;
+        compat_int_t :32; compat_int_t :32; compat_int_t :32; compat_int_t :32;
+};
 #define _COMPAT_NSIG_WORDS      (_COMPAT_NSIG / _COMPAT_NSIG_BPW)
 typedef struct {
@@ -121,6 +147,24 @@ typedef struct compat_sigevent {
        } _sigev_un;
 } compat_sigevent_t;
+struct compat_robust_list {
+        compat_uptr_t                   next;
+};
+struct compat_robust_list_head {
+        struct compat_robust_list       list;
+        compat_long_t                   futex_offset;
+        compat_uptr_t                   list_op_pending;
+};
+extern void compat_exit_robust_list(struct task_struct *curr);
+asmlinkage long
+compat_sys_set_robust_list(struct compat_robust_list_head __user *head,
+                           compat_size_t len);
+asmlinkage long
+compat_sys_get_robust_list(int pid, compat_uptr_t *head_ptr,
+                           compat_size_t __user *len_ptr);
 long compat_sys_semctl(int first, int second, int third, void __user *uptr);
 long compat_sys_msgsnd(int first, int second, int third, void __user *uptr);
@@ -181,5 +225,7 @@ static inline int compat_timespec_compare(struct compat_timespec *lhs,
        return lhs->tv_nsec - rhs->tv_nsec;
 }
+asmlinkage long compat_sys_adjtimex(struct compat_timex __user *utp);
 #endif /* CONFIG_COMPAT */
 #endif /* _LINUX_COMPAT_H */
diff --git a/include/linux/compat_ioctl.h b/include/linux/compat_ioctl.h
index efb518f16bb3..89ab677cb993 100644
--- a/include/linux/compat_ioctl.h
+++ b/include/linux/compat_ioctl.h
@@ -140,6 +140,7 @@ COMPATIBLE_IOCTL(DM_TABLE_DEPS_32)
 COMPATIBLE_IOCTL(DM_TABLE_STATUS_32)
 COMPATIBLE_IOCTL(DM_LIST_VERSIONS_32)
 COMPATIBLE_IOCTL(DM_TARGET_MSG_32)
+COMPATIBLE_IOCTL(DM_DEV_SET_GEOMETRY_32)
 COMPATIBLE_IOCTL(DM_VERSION)
 COMPATIBLE_IOCTL(DM_REMOVE_ALL)
 COMPATIBLE_IOCTL(DM_LIST_DEVICES)
@@ -155,6 +156,7 @@ COMPATIBLE_IOCTL(DM_TABLE_DEPS)
 COMPATIBLE_IOCTL(DM_TABLE_STATUS)
 COMPATIBLE_IOCTL(DM_LIST_VERSIONS)
 COMPATIBLE_IOCTL(DM_TARGET_MSG)
+COMPATIBLE_IOCTL(DM_DEV_SET_GEOMETRY)
 /* Big K */
 COMPATIBLE_IOCTL(PIO_FONT)
 COMPATIBLE_IOCTL(GIO_FONT)
diff --git a/include/linux/device-mapper.h b/include/linux/device-mapper.h
index 51e0e95a421a..aee10b2ea4c6 100644
--- a/include/linux/device-mapper.h
+++ b/include/linux/device-mapper.h
@@ -97,6 +97,7 @@ struct io_restrictions {
        unsigned short          hardsect_size;
        unsigned int            max_segment_size;
        unsigned long           seg_boundary_mask;
+        unsigned char           no_cluster; /* inverted so that 0 is default */
 };
 struct dm_target {
diff --git a/include/linux/dm-ioctl.h b/include/linux/dm-ioctl.h
index fa75ba0d635e..c67c6786612a 100644
--- a/include/linux/dm-ioctl.h
+++ b/include/linux/dm-ioctl.h
@@ -80,6 +80,16 @@
 *
 * DM_TARGET_MSG:
 * Pass a message string to the target at a specific offset of a device.
+ *
+ * DM_DEV_SET_GEOMETRY:
+ * Set the geometry of a device by passing in a string in this format:
+ *
+ * "cylinders heads sectors_per_track start_sector"
+ *
+ * Beware that CHS geometry is nearly obsolete and only provided
+ * for compatibility with dm devices that can be booted by a PC
+ * BIOS.  See struct hd_geometry for range limits.  Also note that
+ * the geometry is erased if the device size changes.
 */
 /*
@@ -218,6 +228,7 @@ enum {
        /* Added later */
        DM_LIST_VERSIONS_CMD,
        DM_TARGET_MSG_CMD,
+        DM_DEV_SET_GEOMETRY_CMD
 };
 /*
@@ -247,6 +258,7 @@ typedef char ioctl_struct[308];
 #define DM_TABLE_STATUS_32  _IOWR(DM_IOCTL, DM_TABLE_STATUS_CMD, ioctl_struct)
 #define DM_LIST_VERSIONS_32 _IOWR(DM_IOCTL, DM_LIST_VERSIONS_CMD, ioctl_struct)
 #define DM_TARGET_MSG_32    _IOWR(DM_IOCTL, DM_TARGET_MSG_CMD, ioctl_struct)
+#define DM_DEV_SET_GEOMETRY_32  _IOWR(DM_IOCTL, DM_DEV_SET_GEOMETRY_CMD, ioctl_struct)
 #endif
 #define DM_IOCTL 0xfd
@@ -270,11 +282,12 @@ typedef char ioctl_struct[308];
 #define DM_LIST_VERSIONS _IOWR(DM_IOCTL, DM_LIST_VERSIONS_CMD, struct dm_ioctl)
 #define DM_TARGET_MSG    _IOWR(DM_IOCTL, DM_TARGET_MSG_CMD, struct dm_ioctl)
+#define DM_DEV_SET_GEOMETRY     _IOWR(DM_IOCTL, DM_DEV_SET_GEOMETRY_CMD, struct dm_ioctl)
 #define DM_VERSION_MAJOR        4
-#define DM_VERSION_MINOR        5
+#define DM_VERSION_MINOR        6
 #define DM_VERSION_PATCHLEVEL   0
-#define DM_VERSION_EXTRA        "-ioctl (2005-10-04)"
+#define DM_VERSION_EXTRA        "-ioctl (2006-02-17)"
 /* Status bits */
 #define DM_READONLY_FLAG        (1 << 0) /* In/Out */
diff --git a/include/linux/efi.h b/include/linux/efi.h
index c7c5dd316182..e203613d3aec 100644
--- a/include/linux/efi.h
+++ b/include/linux/efi.h
@@ -240,19 +240,21 @@ struct efi_memory_map {
        unsigned long desc_size;
 };
+#define EFI_INVALID_TABLE_ADDR          (~0UL)
 /*
 * All runtime access to EFI goes through this structure:
 */
 extern struct efi {
        efi_system_table_t *systab;     /* EFI system table */
-        void *mps;                      /* MPS table */
+        unsigned long mps;              /* MPS table */
-        void *acpi;                     /* ACPI table  (IA64 ext 0.71) */
+        unsigned long acpi;             /* ACPI table  (IA64 ext 0.71) */
-        void *acpi20;                   /* ACPI table  (ACPI 2.0) */
+        unsigned long acpi20;           /* ACPI table  (ACPI 2.0) */
-        void *smbios;                   /* SM BIOS table */
+        unsigned long smbios;           /* SM BIOS table */
-        void *sal_systab;               /* SAL system table */
+        unsigned long sal_systab;       /* SAL system table */
-        void *boot_info;                /* boot info table */
+        unsigned long boot_info;        /* boot info table */
-        void *hcdp;                     /* HCDP table */
+        unsigned long hcdp;             /* HCDP table */
-        void *uga;                      /* UGA table */
+        unsigned long uga;              /* UGA table */
        efi_get_time_t *get_time;
        efi_set_time_t *set_time;
        efi_get_wakeup_time_t *get_wakeup_time;
@@ -292,6 +294,8 @@ extern void efi_enter_virtual_mode (void);	/* switch EFI to virtual mode, if pos
 extern u64 efi_get_iobase (void);
 extern u32 efi_mem_type (unsigned long phys_addr);
 extern u64 efi_mem_attributes (unsigned long phys_addr);
+extern int efi_mem_attribute_range (unsigned long phys_addr, unsigned long size,
+                                    u64 attr);
 extern int __init efi_uart_console_only (void);
 extern void efi_initialize_iomem_resources(struct resource *code_resource,
                                        struct resource *data_resource);
diff --git a/include/linux/ext3_fs.h b/include/linux/ext3_fs.h
index e7239f2f97a1..8bb4f842cded 100644
--- a/include/linux/ext3_fs.h
+++ b/include/linux/ext3_fs.h
@@ -36,7 +36,8 @@ struct statfs;
 * Define EXT3_RESERVATION to reserve data blocks for expanding files
 */
 #define EXT3_DEFAULT_RESERVE_BLOCKS     8
-#define EXT3_MAX_RESERVE_BLOCKS         1024
+/*max window size: 1024(direct blocks) + 3([t,d]indirect blocks) */
+#define EXT3_MAX_RESERVE_BLOCKS         1027
 #define EXT3_RESERVE_WINDOW_NOT_ALLOCATED 0
 /*
 * Always enable hashed directories
@@ -732,6 +733,8 @@ struct dir_private_info {
 extern int ext3_bg_has_super(struct super_block *sb, int group);
 extern unsigned long ext3_bg_num_gdb(struct super_block *sb, int group);
 extern int ext3_new_block (handle_t *, struct inode *, unsigned long, int *);
+extern int ext3_new_blocks (handle_t *, struct inode *, unsigned long,
+                        unsigned long *, int *);
 extern void ext3_free_blocks (handle_t *, struct inode *, unsigned long,
                              unsigned long);
 extern void ext3_free_blocks_sb (handle_t *, struct super_block *,
@@ -775,9 +778,9 @@ extern unsigned long ext3_count_free (struct buffer_head *, unsigned);
 int ext3_forget(handle_t *, int, struct inode *, struct buffer_head *, int);
 struct buffer_head * ext3_getblk (handle_t *, struct inode *, long, int, int *);
 struct buffer_head * ext3_bread (handle_t *, struct inode *, int, int, int *);
-int ext3_get_block_handle(handle_t *handle, struct inode *inode,
+int ext3_get_blocks_handle(handle_t *handle, struct inode *inode,
-        sector_t iblock, struct buffer_head *bh_result, int create,
+        sector_t iblock, unsigned long maxblocks, struct buffer_head *bh_result,
-        int extend_disksize);
+        int create, int extend_disksize);
 extern void ext3_read_inode (struct inode *);
 extern int  ext3_write_inode (struct inode *, int);
diff --git a/include/linux/fs.h b/include/linux/fs.h
index 5adf32b90f36..680d913350e7 100644
--- a/include/linux/fs.h
+++ b/include/linux/fs.h
@@ -252,9 +252,6 @@ extern void __init files_init(unsigned long);
 struct buffer_head;
 typedef int (get_block_t)(struct inode *inode, sector_t iblock,
                        struct buffer_head *bh_result, int create);
-typedef int (get_blocks_t)(struct inode *inode, sector_t iblock,
-                        unsigned long max_blocks,
-                        struct buffer_head *bh_result, int create);
 typedef void (dio_iodone_t)(struct kiocb *iocb, loff_t offset,
                        ssize_t bytes, void *private);
@@ -350,7 +347,7 @@ struct writeback_control;
 struct address_space_operations {
        int (*writepage)(struct page *page, struct writeback_control *wbc);
        int (*readpage)(struct file *, struct page *);
-        int (*sync_page)(struct page *);
+        void (*sync_page)(struct page *);
        /* Write back some dirty pages from this mapping. */
        int (*writepages)(struct address_space *, struct writeback_control *);
@@ -369,7 +366,7 @@ struct address_space_operations {
        int (*commit_write)(struct file *, struct page *, unsigned, unsigned);
        /* Unfortunately this kludge is needed for FIBMAP. Don't use it */
        sector_t (*bmap)(struct address_space *, sector_t);
-        int (*invalidatepage) (struct page *, unsigned long);
+        void (*invalidatepage) (struct page *, unsigned long);
        int (*releasepage) (struct page *, gfp_t);
        ssize_t (*direct_IO)(int, struct kiocb *, const struct iovec *iov,
                        loff_t offset, unsigned long nr_segs);
@@ -413,6 +410,9 @@ struct block_device {
        struct list_head        bd_inodes;
        void *                  bd_holder;
        int                     bd_holders;
+#ifdef CONFIG_SYSFS
+        struct list_head        bd_holder_list;
+#endif
        struct block_device *   bd_contains;
        unsigned                bd_block_size;
        struct hd_struct *      bd_part;
@@ -490,7 +490,7 @@ struct inode {
        unsigned int            i_blkbits;
        unsigned long           i_blksize;
        unsigned long           i_version;
-        unsigned long           i_blocks;
+        blkcnt_t                i_blocks;
        unsigned short          i_bytes;
        spinlock_t              i_lock; /* i_blocks, i_bytes, maybe i_size */
        struct mutex            i_mutex;
@@ -763,6 +763,7 @@ extern void locks_copy_lock(struct file_lock *, struct file_lock *);
 extern void locks_remove_posix(struct file *, fl_owner_t);
 extern void locks_remove_flock(struct file *);
 extern int posix_test_lock(struct file *, struct file_lock *, struct file_lock *);
+extern int posix_lock_file_conf(struct file *, struct file_lock *, struct file_lock *);
 extern int posix_lock_file(struct file *, struct file_lock *);
 extern int posix_lock_file_wait(struct file *, struct file_lock *);
 extern int posix_unblock_lock(struct file *, struct file_lock *);
@@ -1401,6 +1402,13 @@ extern int blkdev_get(struct block_device *, mode_t, unsigned);
 extern int blkdev_put(struct block_device *);
 extern int bd_claim(struct block_device *, void *);
 extern void bd_release(struct block_device *);
+#ifdef CONFIG_SYSFS
+extern int bd_claim_by_disk(struct block_device *, void *, struct gendisk *);
+extern void bd_release_from_disk(struct block_device *, struct gendisk *);
+#else
+#define bd_claim_by_disk(bdev, holder, disk)    bd_claim(bdev, holder)
+#define bd_release_from_disk(bdev, disk)        bd_release(bdev)
+#endif
 /* fs/char_dev.c */
 extern int alloc_chrdev_region(dev_t *, unsigned, unsigned, const char *);
@@ -1644,7 +1652,7 @@ static inline void do_generic_file_read(struct file * filp, loff_t *ppos,
 ssize_t __blockdev_direct_IO(int rw, struct kiocb *iocb, struct inode *inode,
        struct block_device *bdev, const struct iovec *iov, loff_t offset,
-        unsigned long nr_segs, get_blocks_t get_blocks, dio_iodone_t end_io,
+        unsigned long nr_segs, get_block_t get_block, dio_iodone_t end_io,
        int lock_type);
 enum {
@@ -1655,29 +1663,29 @@ enum {
 static inline ssize_t blockdev_direct_IO(int rw, struct kiocb *iocb,
        struct inode *inode, struct block_device *bdev, const struct iovec *iov,
-        loff_t offset, unsigned long nr_segs, get_blocks_t get_blocks,
+        loff_t offset, unsigned long nr_segs, get_block_t get_block,
        dio_iodone_t end_io)
 {
        return __blockdev_direct_IO(rw, iocb, inode, bdev, iov, offset,
-                                nr_segs, get_blocks, end_io, DIO_LOCKING);
+                                nr_segs, get_block, end_io, DIO_LOCKING);
 }
 static inline ssize_t blockdev_direct_IO_no_locking(int rw, struct kiocb *iocb,
        struct inode *inode, struct block_device *bdev, const struct iovec *iov,
-        loff_t offset, unsigned long nr_segs, get_blocks_t get_blocks,
+        loff_t offset, unsigned long nr_segs, get_block_t get_block,
        dio_iodone_t end_io)
 {
        return __blockdev_direct_IO(rw, iocb, inode, bdev, iov, offset,
-                                nr_segs, get_blocks, end_io, DIO_NO_LOCKING);
+                                nr_segs, get_block, end_io, DIO_NO_LOCKING);
 }
 static inline ssize_t blockdev_direct_IO_own_locking(int rw, struct kiocb *iocb,
        struct inode *inode, struct block_device *bdev, const struct iovec *iov,
-        loff_t offset, unsigned long nr_segs, get_blocks_t get_blocks,
+        loff_t offset, unsigned long nr_segs, get_block_t get_block,
        dio_iodone_t end_io)
 {
        return __blockdev_direct_IO(rw, iocb, inode, bdev, iov, offset,
-                                nr_segs, get_blocks, end_io, DIO_OWN_LOCKING);
+                                nr_segs, get_block, end_io, DIO_OWN_LOCKING);
 }
 extern struct file_operations generic_ro_fops;
diff --git a/include/linux/futex.h b/include/linux/futex.h
index 10f96c31971e..966a5b3da439 100644
--- a/include/linux/futex.h
+++ b/include/linux/futex.h
@@ -1,6 +1,8 @@
 #ifndef _LINUX_FUTEX_H
 #define _LINUX_FUTEX_H
+#include <linux/sched.h>
 /* Second argument to futex syscall */
@@ -11,10 +13,97 @@
 #define FUTEX_CMP_REQUEUE       4
 #define FUTEX_WAKE_OP           5
+/*
+ * Support for robust futexes: the kernel cleans up held futexes at
+ * thread exit time.
+ */
+/*
+ * Per-lock list entry - embedded in user-space locks, somewhere close
+ * to the futex field. (Note: user-space uses a double-linked list to
+ * achieve O(1) list add and remove, but the kernel only needs to know
+ * about the forward link)
+ *
+ * NOTE: this structure is part of the syscall ABI, and must not be
+ * changed.
+ */
+struct robust_list {
+        struct robust_list __user *next;
+};
+/*
+ * Per-thread list head:
+ *
+ * NOTE: this structure is part of the syscall ABI, and must only be
+ * changed if the change is first communicated with the glibc folks.
+ * (When an incompatible change is done, we'll increase the structure
+ *  size, which glibc will detect)
+ */
+struct robust_list_head {
+        /*
+         * The head of the list. Points back to itself if empty:
+         */
+        struct robust_list list;
+        /*
+         * This relative offset is set by user-space, it gives the kernel
+         * the relative position of the futex field to examine. This way
+         * we keep userspace flexible, to freely shape its data-structure,
+         * without hardcoding any particular offset into the kernel:
+         */
+        long futex_offset;
+        /*
+         * The death of the thread may race with userspace setting
+         * up a lock's links. So to handle this race, userspace first
+         * sets this field to the address of the to-be-taken lock,
+         * then does the lock acquire, and then adds itself to the
+         * list, and then clears this field. Hence the kernel will
+         * always have full knowledge of all locks that the thread
+         * _might_ have taken. We check the owner TID in any case,
+         * so only truly owned locks will be handled.
+         */
+        struct robust_list __user *list_op_pending;
+};
+/*
+ * Are there any waiters for this robust futex:
+ */
+#define FUTEX_WAITERS           0x80000000
+/*
+ * The kernel signals via this bit that a thread holding a futex
+ * has exited without unlocking the futex. The kernel also does
+ * a FUTEX_WAKE on such futexes, after setting the bit, to wake
+ * up any possible waiters:
+ */
+#define FUTEX_OWNER_DIED        0x40000000
+/*
+ * The rest of the robust-futex field is for the TID:
+ */
+#define FUTEX_TID_MASK          0x3fffffff
+/*
+ * This limit protects against a deliberately circular list.
+ * (Not worth introducing an rlimit for it)
+ */
+#define ROBUST_LIST_LIMIT       2048
 long do_futex(unsigned long uaddr, int op, int val,
                unsigned long timeout, unsigned long uaddr2, int val2,
                int val3);
+extern int handle_futex_death(u32 __user *uaddr, struct task_struct *curr);
+#ifdef CONFIG_FUTEX
+extern void exit_robust_list(struct task_struct *curr);
+#else
+static inline void exit_robust_list(struct task_struct *curr)
+{
+}
+#endif
 #define FUTEX_OP_SET            0       /* *(int *)UADDR2 = OPARG; */
 #define FUTEX_OP_ADD            1       /* *(int *)UADDR2 += OPARG; */
 #define FUTEX_OP_OR             2       /* *(int *)UADDR2 |= OPARG; */
diff --git a/include/linux/gameport.h b/include/linux/gameport.h
index 2401dea2b867..9c8e6da2393b 100644
--- a/include/linux/gameport.h
+++ b/include/linux/gameport.h
@@ -119,7 +119,7 @@ static inline void gameport_set_name(struct gameport *gameport, const char *name
 }
 /*
- * Use the following fucntions to manipulate gameport's per-port
+ * Use the following functions to manipulate gameport's per-port
 * driver-specific data.
 */
 static inline void *gameport_get_drvdata(struct gameport *gameport)
@@ -133,7 +133,7 @@ static inline void gameport_set_drvdata(struct gameport *gameport, void *data)
 }
 /*
- * Use the following fucntions to pin gameport's driver in process context
+ * Use the following functions to pin gameport's driver in process context
 */
 static inline int gameport_pin_driver(struct gameport *gameport)
 {
diff --git a/include/linux/genhd.h b/include/linux/genhd.h
index fd647fde5ec1..3c1b0294a742 100644
--- a/include/linux/genhd.h
+++ b/include/linux/genhd.h
@@ -78,6 +78,7 @@ struct hd_struct {
        sector_t start_sect;
        sector_t nr_sects;
        struct kobject kobj;
+        struct kobject *holder_dir;
        unsigned ios[2], sectors[2];    /* READs and WRITEs */
        int policy, partno;
 };
@@ -89,12 +90,12 @@ struct hd_struct {
 #define GENHD_FL_SUPPRESS_PARTITION_INFO        32
 struct disk_stats {
-        unsigned sectors[2];            /* READs and WRITEs */
+        unsigned long sectors[2];       /* READs and WRITEs */
-        unsigned ios[2];
+        unsigned long ios[2];
-        unsigned merges[2];
+        unsigned long merges[2];
-        unsigned ticks[2];
+        unsigned long ticks[2];
-        unsigned io_ticks;
+        unsigned long io_ticks;
-        unsigned time_in_queue;
+        unsigned long time_in_queue;
 };
        
 struct gendisk {
@@ -114,6 +115,8 @@ struct gendisk {
        int number;                     /* more of the same */
        struct device *driverfs_dev;
        struct kobject kobj;
+        struct kobject *holder_dir;
+        struct kobject *slave_dir;
        struct timer_rand_state *random;
        int policy;
diff --git a/include/linux/gigaset_dev.h b/include/linux/gigaset_dev.h
new file mode 100644
index 000000000000..70ad09c8ad1e
--- /dev/null
+++ b/include/linux/gigaset_dev.h
@@ -0,0 +1,32 @@
+/*
+ * interface to user space for the gigaset driver
+ *
+ * Copyright (c) 2004 by Hansjoerg Lipp <hjlipp@web.de>
+ *
+ * =====================================================================
+ *    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.
+ * =====================================================================
+ * Version: $Id: gigaset_dev.h,v 1.4.4.4 2005/11/21 22:28:09 hjlipp Exp $
+ * =====================================================================
+ */
+#ifndef GIGASET_INTERFACE_H
+#define GIGASET_INTERFACE_H
+#include <linux/ioctl.h>
+#define GIGASET_IOCTL 0x47
+#define GIGVER_DRIVER 0
+#define GIGVER_COMPAT 1
+#define GIGVER_FWBASE 2
+#define GIGASET_REDIR    _IOWR (GIGASET_IOCTL, 0, int)
+#define GIGASET_CONFIG   _IOWR (GIGASET_IOCTL, 1, int)
+#define GIGASET_BRKCHARS _IOW  (GIGASET_IOCTL, 2, unsigned char[6]) //FIXME [6] okay?
+#define GIGASET_VERSION  _IOWR (GIGASET_IOCTL, 3, unsigned[4])
+#endif
diff --git a/include/linux/highmem.h b/include/linux/highmem.h
index 6bece9280eb7..892c4ea1b425 100644
--- a/include/linux/highmem.h
+++ b/include/linux/highmem.h
@@ -7,6 +7,18 @@
 #include <asm/cacheflush.h>
+#ifndef ARCH_HAS_FLUSH_ANON_PAGE
+static inline void flush_anon_page(struct page *page, unsigned long vmaddr)
+{
+}
+#endif
+#ifndef ARCH_HAS_FLUSH_KERNEL_DCACHE_PAGE
+static inline void flush_kernel_dcache_page(struct page *page)
+{
+}
+#endif
 #ifdef CONFIG_HIGHMEM
 #include <asm/highmem.h>
diff --git a/include/linux/hpet.h b/include/linux/hpet.h
index 27238194b212..707f7cb9e795 100644
--- a/include/linux/hpet.h
+++ b/include/linux/hpet.h
@@ -3,6 +3,8 @@
 #include <linux/compiler.h>
+#ifdef __KERNEL__
 /*
 * Offsets into HPET Registers
 */
@@ -85,22 +87,6 @@ struct hpet {
 #define Tn_FSB_INT_ADDR_SHIFT           (32UL)
 #define Tn_FSB_INT_VAL_MASK             (0x00000000ffffffffULL)
-struct hpet_info {
-        unsigned long hi_ireqfreq;      /* Hz */
-        unsigned long hi_flags; /* information */
-        unsigned short hi_hpet;
-        unsigned short hi_timer;
-};
-#define HPET_INFO_PERIODIC      0x0001  /* timer is periodic */
-#define HPET_IE_ON      _IO('h', 0x01)  /* interrupt on */
-#define HPET_IE_OFF     _IO('h', 0x02)  /* interrupt off */
-#define HPET_INFO       _IOR('h', 0x03, struct hpet_info)
-#define HPET_EPI        _IO('h', 0x04)  /* enable periodic */
-#define HPET_DPI        _IO('h', 0x05)  /* disable periodic */
-#define HPET_IRQFREQ    _IOW('h', 0x6, unsigned long)   /* IRQFREQ usec */
 /*
 * exported interfaces
 */
@@ -133,4 +119,22 @@ int hpet_register(struct hpet_task *, int);
 int hpet_unregister(struct hpet_task *);
 int hpet_control(struct hpet_task *, unsigned int, unsigned long);
+#endif /* __KERNEL__ */
+struct hpet_info {
+        unsigned long hi_ireqfreq;      /* Hz */
+        unsigned long hi_flags; /* information */
+        unsigned short hi_hpet;
+        unsigned short hi_timer;
+};
+#define HPET_INFO_PERIODIC      0x0001  /* timer is periodic */
+#define HPET_IE_ON      _IO('h', 0x01)  /* interrupt on */
+#define HPET_IE_OFF     _IO('h', 0x02)  /* interrupt off */
+#define HPET_INFO       _IOR('h', 0x03, struct hpet_info)
+#define HPET_EPI        _IO('h', 0x04)  /* enable periodic */
+#define HPET_DPI        _IO('h', 0x05)  /* disable periodic */
+#define HPET_IRQFREQ    _IOW('h', 0x6, unsigned long)   /* IRQFREQ usec */
 #endif                          /* !__HPET__ */
diff --git a/include/linux/hrtimer.h b/include/linux/hrtimer.h
index 6401c31d6add..93830158348e 100644
--- a/include/linux/hrtimer.h
+++ b/include/linux/hrtimer.h
@@ -34,15 +34,7 @@ enum hrtimer_restart {
        HRTIMER_RESTART,
 };
-/*
+#define HRTIMER_INACTIVE        ((void *)1UL)
- * Timer states:
- */
-enum hrtimer_state {
-        HRTIMER_INACTIVE,       /* Timer is inactive */
-        HRTIMER_EXPIRED,                /* Timer is expired */
-        HRTIMER_RUNNING,                /* Timer is running the callback function */
-        HRTIMER_PENDING,                /* Timer is pending */
-};
 struct hrtimer_base;
@@ -53,9 +45,7 @@ struct hrtimer_base;
 * @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()
@@ -63,23 +53,23 @@ struct hrtimer_base;
 struct hrtimer {
        struct rb_node          node;
        ktime_t                 expires;
-        enum hrtimer_state      state;
+        int                     (*function)(struct hrtimer *);
-        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
+ * @index:              clock type index for per_cpu support when moving a timer
- *              to a base on another cpu.
+ *                      to a base on another cpu.
- * @lock:       lock protecting the base and associated timers
+ * @lock:               lock protecting the base and associated timers
- * @active:     red black tree root node for the active timers
+ * @active:             red black tree root node for the active timers
- * @first:      pointer to the timer node which expires first
+ * @first:              pointer to the timer node which expires first
- * @resolution: the resolution of the clock, in nanoseconds
+ * @resolution:         the resolution of the clock, in nanoseconds
- * @get_time:   function to retrieve the current time of the clock
+ * @get_time:           function to retrieve the current time of the clock
- * @curr_timer: the timer which is executing a callback right now
+ * @get_sofirq_time:    function to retrieve the current time from the softirq
+ * @curr_timer:         the timer which is executing a callback right now
+ * @softirq_time:       the time when running the hrtimer queue in the softirq
 */
 struct hrtimer_base {
        clockid_t               index;
@@ -88,7 +78,9 @@ struct hrtimer_base {
        struct rb_node          *first;
        ktime_t                 resolution;
        ktime_t                 (*get_time)(void);
+        ktime_t                 (*get_softirq_time)(void);
        struct hrtimer          *curr_timer;
+        ktime_t                 softirq_time;
 };
 /*
@@ -122,11 +114,12 @@ extern ktime_t hrtimer_get_next_event(void);
 static inline int hrtimer_active(const struct hrtimer *timer)
 {
-        return timer->state == HRTIMER_PENDING;
+        return timer->node.rb_parent != HRTIMER_INACTIVE;
 }
 /* Forward a hrtimer so it expires after now: */
-extern unsigned long hrtimer_forward(struct hrtimer *timer, ktime_t interval);
+extern unsigned long
+hrtimer_forward(struct hrtimer *timer, ktime_t now, ktime_t interval);
 /* Precise sleep: */
 extern long hrtimer_nanosleep(struct timespec *rqtp,
diff --git a/include/linux/i2c-id.h b/include/linux/i2c-id.h
index 679b46a6a565..c8b81f419fd8 100644
--- a/include/linux/i2c-id.h
+++ b/include/linux/i2c-id.h
@@ -108,6 +108,10 @@
 #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_DS1672     81      /* Dallas/Maxim DS1672 RTC      */
+#define I2C_DRIVERID_X1205      82      /* Xicor/Intersil X1205 RTC     */
+#define I2C_DRIVERID_PCF8563    83      /* Philips PCF8563 RTC          */
+#define I2C_DRIVERID_RS5C372    84      /* Ricoh RS5C372 RTC            */
 #define I2C_DRIVERID_I2CDEV     900
 #define I2C_DRIVERID_ARP        902    /* SMBus ARP Client              */
diff --git a/include/linux/i2o.h b/include/linux/i2o.h
index 5a9d8c599171..dd7d627bf66f 100644
--- a/include/linux/i2o.h
+++ b/include/linux/i2o.h
@@ -950,9 +950,7 @@ static inline int i2o_pool_alloc(struct i2o_pool *pool, const char *name,
        if (!pool->slab)
                goto free_name;
-        pool->mempool =
+        pool->mempool = mempool_create_slab_pool(min_nr, pool->slab);
-            mempool_create(min_nr, mempool_alloc_slab, mempool_free_slab,
-                           pool->slab);
        if (!pool->mempool)
                goto free_slab;
diff --git a/include/linux/ipmi.h b/include/linux/ipmi.h
index d6276e60b3bf..0a84b56935c2 100644
--- a/include/linux/ipmi.h
+++ b/include/linux/ipmi.h
@@ -36,6 +36,7 @@
 #include <linux/ipmi_msgdefs.h>
 #include <linux/compiler.h>
+#include <linux/device.h>
 /*
 * This file describes an interface to an IPMI driver.  You have to
@@ -397,7 +398,7 @@ struct ipmi_smi_watcher
           the watcher list.  So you can add and remove users from the
           IPMI interface, send messages, etc., but you cannot add
           or remove SMI watchers or SMI interfaces. */
-        void (*new_smi)(int if_num);
+        void (*new_smi)(int if_num, struct device *dev);
        void (*smi_gone)(int if_num);
 };
diff --git a/include/linux/ipmi_msgdefs.h b/include/linux/ipmi_msgdefs.h
index 03bc64dc2ec1..22f5e2afda4f 100644
--- a/include/linux/ipmi_msgdefs.h
+++ b/include/linux/ipmi_msgdefs.h
@@ -47,6 +47,7 @@
 #define IPMI_NETFN_APP_RESPONSE                 0x07
 #define IPMI_GET_DEVICE_ID_CMD          0x01
 #define IPMI_CLEAR_MSG_FLAGS_CMD        0x30
+#define IPMI_GET_DEVICE_GUID_CMD        0x08
 #define IPMI_GET_MSG_FLAGS_CMD          0x31
 #define IPMI_SEND_MSG_CMD               0x34
 #define IPMI_GET_MSG_CMD                0x33
diff --git a/include/linux/ipmi_smi.h b/include/linux/ipmi_smi.h
index e36ee157ad67..53571288a9fc 100644
--- a/include/linux/ipmi_smi.h
+++ b/include/linux/ipmi_smi.h
@@ -37,6 +37,9 @@
 #include <linux/ipmi_msgdefs.h>
 #include <linux/proc_fs.h>
 #include <linux/module.h>
+#include <linux/device.h>
+#include <linux/platform_device.h>
+#include <linux/ipmi_smi.h>
 /* This files describes the interface for IPMI system management interface
   drivers to bind into the IPMI message handler. */
@@ -113,12 +116,52 @@ struct ipmi_smi_handlers
        void (*dec_usecount)(void *send_info);
 };
+struct ipmi_device_id {
+        unsigned char device_id;
+        unsigned char device_revision;
+        unsigned char firmware_revision_1;
+        unsigned char firmware_revision_2;
+        unsigned char ipmi_version;
+        unsigned char additional_device_support;
+        unsigned int  manufacturer_id;
+        unsigned int  product_id;
+        unsigned char aux_firmware_revision[4];
+        unsigned int  aux_firmware_revision_set : 1;
+};
+#define ipmi_version_major(v) ((v)->ipmi_version & 0xf)
+#define ipmi_version_minor(v) ((v)->ipmi_version >> 4)
+/* Take a pointer to a raw data buffer and a length and extract device
+   id information from it.  The first byte of data must point to the
+   byte from the get device id response after the completion code.
+   The caller is responsible for making sure the length is at least
+   11 and the command completed without error. */
+static inline void ipmi_demangle_device_id(unsigned char *data,
+                                           unsigned int  data_len,
+                                           struct ipmi_device_id *id)
+{
+        id->device_id = data[0];
+        id->device_revision = data[1];
+        id->firmware_revision_1 = data[2];
+        id->firmware_revision_2 = data[3];
+        id->ipmi_version = data[4];
+        id->additional_device_support = data[5];
+        id->manufacturer_id = data[6] | (data[7] << 8) | (data[8] << 16);
+        id->product_id = data[9] | (data[10] << 8);
+        if (data_len >= 15) {
+                memcpy(id->aux_firmware_revision, data+11, 4);
+                id->aux_firmware_revision_set = 1;
+        } else
+                id->aux_firmware_revision_set = 0;
+}
 /* Add a low-level interface to the IPMI driver.  Note that if the
   interface doesn't know its slave address, it should pass in zero. */
 int ipmi_register_smi(struct ipmi_smi_handlers *handlers,
                      void                     *send_info,
-                      unsigned char            version_major,
+                      struct ipmi_device_id    *device_id,
-                      unsigned char            version_minor,
+                      struct device            *dev,
                      unsigned char            slave_addr,
                      ipmi_smi_t               *intf);
diff --git a/include/linux/jbd.h b/include/linux/jbd.h
index 4fc7dffd66ef..6a425e370cb3 100644
--- a/include/linux/jbd.h
+++ b/include/linux/jbd.h
@@ -895,7 +895,7 @@ extern int	 journal_dirty_metadata (handle_t *, struct buffer_head *);
 extern void      journal_release_buffer (handle_t *, struct buffer_head *);
 extern int       journal_forget (handle_t *, struct buffer_head *);
 extern void      journal_sync_buffer (struct buffer_head *);
-extern int       journal_invalidatepage(journal_t *,
+extern void      journal_invalidatepage(journal_t *,
                                struct page *, unsigned long);
 extern int       journal_try_to_free_buffers(journal_t *, struct page *, gfp_t);
 extern int       journal_stop(handle_t *);
diff --git a/include/linux/kernel.h b/include/linux/kernel.h
index 03d6cfaa5b8a..a3720f973ea5 100644
--- a/include/linux/kernel.h
+++ b/include/linux/kernel.h
@@ -87,7 +87,7 @@ extern int cond_resched(void);
                (__x < 0) ? -__x : __x;         \
        })
-extern struct notifier_block *panic_notifier_list;
+extern struct atomic_notifier_head panic_notifier_list;
 extern long (*panic_blink)(long time);
 NORET_TYPE void panic(const char * fmt, ...)
        __attribute__ ((NORET_AND format (printf, 1, 2)));
diff --git a/include/linux/ktime.h b/include/linux/ktime.h
index f3dec45ef874..62bc57580707 100644
--- a/include/linux/ktime.h
+++ b/include/linux/ktime.h
@@ -64,9 +64,6 @@ typedef union {
 #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
 *
@@ -113,9 +110,6 @@ static inline ktime_t timeval_to_ktime(struct timeval tv)
 /* 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)
@@ -136,9 +130,6 @@ static inline ktime_t timeval_to_ktime(struct timeval tv)
 *   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)
 {
@@ -255,17 +246,6 @@ static inline struct timeval ktime_to_timeval(const ktime_t kt)
 }
 /**
- * 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
 *
diff --git a/include/linux/m48t86.h b/include/linux/m48t86.h
new file mode 100644
index 000000000000..9065199319d0
--- /dev/null
+++ b/include/linux/m48t86.h
@@ -0,0 +1,16 @@
+/*
+ * ST M48T86 / Dallas DS12887 RTC driver
+ * Copyright (c) 2006 Tower Technologies
+ *
+ * Author: Alessandro Zummo <a.zummo@towertech.it>
+ *
+ * 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.
+*/
+struct m48t86_ops
+{
+        void (*writeb)(unsigned char value, unsigned long addr);
+        unsigned char (*readb)(unsigned long addr);
+};
diff --git a/include/linux/memory.h b/include/linux/memory.h
index e251dc43d0f5..8f04143ca363 100644
--- a/include/linux/memory.h
+++ b/include/linux/memory.h
@@ -77,7 +77,6 @@ extern int remove_memory_block(unsigned long, struct mem_section *, int);
 #define CONFIG_MEM_BLOCK_SIZE   (PAGES_PER_SECTION<<PAGE_SHIFT)
-struct notifier_block;
 #endif /* CONFIG_MEMORY_HOTPLUG */
diff --git a/include/linux/mempool.h b/include/linux/mempool.h
index f2427d7394b0..9be484d11283 100644
--- a/include/linux/mempool.h
+++ b/include/linux/mempool.h
@@ -6,6 +6,8 @@
 #include <linux/wait.h>
+struct kmem_cache;
 typedef void * (mempool_alloc_t)(gfp_t gfp_mask, void *pool_data);
 typedef void (mempool_free_t)(void *element, void *pool_data);
@@ -37,5 +39,41 @@ extern void mempool_free(void *element, mempool_t *pool);
 */
 void *mempool_alloc_slab(gfp_t gfp_mask, void *pool_data);
 void mempool_free_slab(void *element, void *pool_data);
+static inline mempool_t *
+mempool_create_slab_pool(int min_nr, struct kmem_cache *kc)
+{
+        return mempool_create(min_nr, mempool_alloc_slab, mempool_free_slab,
+                              (void *) kc);
+}
+/*
+ * 2 mempool_alloc_t's and a mempool_free_t to kmalloc/kzalloc and kfree
+ * the amount of memory specified by pool_data
+ */
+void *mempool_kmalloc(gfp_t gfp_mask, void *pool_data);
+void *mempool_kzalloc(gfp_t gfp_mask, void *pool_data);
+void mempool_kfree(void *element, void *pool_data);
+static inline mempool_t *mempool_create_kmalloc_pool(int min_nr, size_t size)
+{
+        return mempool_create(min_nr, mempool_kmalloc, mempool_kfree,
+                              (void *) size);
+}
+static inline mempool_t *mempool_create_kzalloc_pool(int min_nr, size_t size)
+{
+        return mempool_create(min_nr, mempool_kzalloc, mempool_kfree,
+                              (void *) size);
+}
+/*
+ * A mempool_alloc_t and mempool_free_t for a simple page allocator that
+ * allocates pages of the order specified by pool_data
+ */
+void *mempool_alloc_pages(gfp_t gfp_mask, void *pool_data);
+void mempool_free_pages(void *element, void *pool_data);
+static inline mempool_t *mempool_create_page_pool(int min_nr, int order)
+{
+        return mempool_create(min_nr, mempool_alloc_pages, mempool_free_pages,
+                              (void *)(long)order);
+}
 #endif /* _LINUX_MEMPOOL_H */
diff --git a/include/linux/mmzone.h b/include/linux/mmzone.h
index ebfc238cc243..b5c21122c299 100644
--- a/include/linux/mmzone.h
+++ b/include/linux/mmzone.h
@@ -13,6 +13,7 @@
 #include <linux/numa.h>
 #include <linux/init.h>
 #include <linux/seqlock.h>
+#include <linux/nodemask.h>
 #include <asm/atomic.h>
 /* Free memory management - zoned buddy allocator.  */
@@ -225,7 +226,6 @@ struct zone {
         * Discontig memory support fields.
         */
        struct pglist_data      *zone_pgdat;
-        struct page             *zone_mem_map;
        /* zone_start_pfn == zone_start_paddr >> PAGE_SHIFT */
        unsigned long           zone_start_pfn;
@@ -307,7 +307,6 @@ typedef struct pglist_data {
        unsigned long node_spanned_pages; /* total size of physical page
                                             range, including holes */
        int node_id;
-        struct pglist_data *pgdat_next;
        wait_queue_head_t kswapd_wait;
        struct task_struct *kswapd;
        int kswapd_max_order;
@@ -324,8 +323,6 @@ typedef struct pglist_data {
 #include <linux/memory_hotplug.h>
-extern struct pglist_data *pgdat_list;
 void __get_zone_counts(unsigned long *active, unsigned long *inactive,
                        unsigned long *free, struct pglist_data *pgdat);
 void get_zone_counts(unsigned long *active, unsigned long *inactive,
@@ -350,57 +347,6 @@ unsigned long __init node_memmap_size_bytes(int, unsigned long, unsigned long);
 */
 #define zone_idx(zone)          ((zone) - (zone)->zone_pgdat->node_zones)
-/**
- * for_each_pgdat - helper macro to iterate over all nodes
- * @pgdat - pointer to a pg_data_t variable
- *
- * Meant to help with common loops of the form
- * pgdat = pgdat_list;
- * while(pgdat) {
- *      ...
- *      pgdat = pgdat->pgdat_next;
- * }
- */
-#define for_each_pgdat(pgdat) \
-        for (pgdat = pgdat_list; pgdat; pgdat = pgdat->pgdat_next)
-/*
- * next_zone - helper magic for for_each_zone()
- * Thanks to William Lee Irwin III for this piece of ingenuity.
- */
-static inline struct zone *next_zone(struct zone *zone)
-{
-        pg_data_t *pgdat = zone->zone_pgdat;
-        if (zone < pgdat->node_zones + MAX_NR_ZONES - 1)
-                zone++;
-        else if (pgdat->pgdat_next) {
-                pgdat = pgdat->pgdat_next;
-                zone = pgdat->node_zones;
-        } else
-                zone = NULL;
-        return zone;
-}
-/**
- * for_each_zone - helper macro to iterate over all memory zones
- * @zone - pointer to struct zone variable
- *
- * The user only needs to declare the zone variable, for_each_zone
- * fills it in. This basically means for_each_zone() is an
- * easier to read version of this piece of code:
- *
- * for (pgdat = pgdat_list; pgdat; pgdat = pgdat->node_next)
- *      for (i = 0; i < MAX_NR_ZONES; ++i) {
- *              struct zone * z = pgdat->node_zones + i;
- *              ...
- *      }
- * }
- */
-#define for_each_zone(zone) \
-        for (zone = pgdat_list->node_zones; zone; zone = next_zone(zone))
 static inline int populated_zone(struct zone *zone)
 {
        return (!!zone->present_pages);
@@ -472,6 +418,30 @@ extern struct pglist_data contig_page_data;
 #endif /* !CONFIG_NEED_MULTIPLE_NODES */
+extern struct pglist_data *first_online_pgdat(void);
+extern struct pglist_data *next_online_pgdat(struct pglist_data *pgdat);
+extern struct zone *next_zone(struct zone *zone);
+/**
+ * for_each_pgdat - helper macro to iterate over all nodes
+ * @pgdat - pointer to a pg_data_t variable
+ */
+#define for_each_online_pgdat(pgdat)                    \
+        for (pgdat = first_online_pgdat();              \
+             pgdat;                                     \
+             pgdat = next_online_pgdat(pgdat))
+/**
+ * for_each_zone - helper macro to iterate over all memory zones
+ * @zone - pointer to struct zone variable
+ *
+ * The user only needs to declare the zone variable, for_each_zone
+ * fills it in.
+ */
+#define for_each_zone(zone)                             \
+        for (zone = (first_online_pgdat())->node_zones; \
+             zone;                                      \
+             zone = next_zone(zone))
 #ifdef CONFIG_SPARSEMEM
 #include <asm/sparsemem.h>
 #endif
@@ -602,17 +572,6 @@ static inline struct mem_section *__pfn_to_section(unsigned long pfn)
        return __nr_to_section(pfn_to_section_nr(pfn));
 }
-#define pfn_to_page(pfn)                                                \
-({                                                                      \
-        unsigned long __pfn = (pfn);                                    \
-        __section_mem_map_addr(__pfn_to_section(__pfn)) + __pfn;        \
-})
-#define page_to_pfn(page)                                               \
-({                                                                      \
-        page - __section_mem_map_addr(__nr_to_section(                  \
-                page_to_section(page)));                                \
-})
 static inline int pfn_valid(unsigned long pfn)
 {
        if (pfn_to_section_nr(pfn) >= NR_MEM_SECTIONS)
diff --git a/include/linux/netfilter_ipv4/ip_conntrack.h b/include/linux/netfilter_ipv4/ip_conntrack.h
index f32d75c4f4cf..d54d7b278e96 100644
--- a/include/linux/netfilter_ipv4/ip_conntrack.h
+++ b/include/linux/netfilter_ipv4/ip_conntrack.h
@@ -308,29 +308,30 @@ DECLARE_PER_CPU(struct ip_conntrack_ecache, ip_conntrack_ecache);
 #define CONNTRACK_ECACHE(x)     (__get_cpu_var(ip_conntrack_ecache).x)
 
-extern struct notifier_block *ip_conntrack_chain;
+extern struct atomic_notifier_head ip_conntrack_chain;
-extern struct notifier_block *ip_conntrack_expect_chain;
+extern struct atomic_notifier_head ip_conntrack_expect_chain;
 static inline int ip_conntrack_register_notifier(struct notifier_block *nb)
 {
-        return notifier_chain_register(&ip_conntrack_chain, nb);
+        return atomic_notifier_chain_register(&ip_conntrack_chain, nb);
 }
 static inline int ip_conntrack_unregister_notifier(struct notifier_block *nb)
 {
-        return notifier_chain_unregister(&ip_conntrack_chain, nb);
+        return atomic_notifier_chain_unregister(&ip_conntrack_chain, nb);
 }
 static inline int 
 ip_conntrack_expect_register_notifier(struct notifier_block *nb)
 {
-        return notifier_chain_register(&ip_conntrack_expect_chain, nb);
+        return atomic_notifier_chain_register(&ip_conntrack_expect_chain, nb);
 }
 static inline int
 ip_conntrack_expect_unregister_notifier(struct notifier_block *nb)
 {
-        return notifier_chain_unregister(&ip_conntrack_expect_chain, nb);
+        return atomic_notifier_chain_unregister(&ip_conntrack_expect_chain,
+                        nb);
 }
 extern void ip_ct_deliver_cached_events(const struct ip_conntrack *ct);
@@ -355,14 +356,14 @@ static inline void ip_conntrack_event(enum ip_conntrack_events event,
                                      struct ip_conntrack *ct)
 {
        if (is_confirmed(ct) && !is_dying(ct))
-                notifier_call_chain(&ip_conntrack_chain, event, ct);
+                atomic_notifier_call_chain(&ip_conntrack_chain, event, ct);
 }
 static inline void 
 ip_conntrack_expect_event(enum ip_conntrack_expect_events event,
                          struct ip_conntrack_expect *exp)
 {
-        notifier_call_chain(&ip_conntrack_expect_chain, event, exp);
+        atomic_notifier_call_chain(&ip_conntrack_expect_chain, event, exp);
 }
 #else /* CONFIG_IP_NF_CONNTRACK_EVENTS */
 static inline void ip_conntrack_event_cache(enum ip_conntrack_events event, 
diff --git a/include/linux/nfsd/export.h b/include/linux/nfsd/export.h
index 6bad4766d3d9..d2a8abb5011a 100644
--- a/include/linux/nfsd/export.h
+++ b/include/linux/nfsd/export.h
@@ -67,7 +67,8 @@ struct svc_expkey {
        int                     ek_fsidtype;
        u32                     ek_fsid[3];
-        struct svc_export *     ek_export;
+        struct vfsmount *       ek_mnt;
+        struct dentry *         ek_dentry;
 };
 #define EX_SECURE(exp)          (!((exp)->ex_flags & NFSEXP_INSECURE_PORT))
@@ -85,9 +86,6 @@ void			nfsd_export_shutdown(void);
 void                    nfsd_export_flush(void);
 void                    exp_readlock(void);
 void                    exp_readunlock(void);
-struct svc_expkey *     exp_find_key(struct auth_domain *clp, 
-                                     int fsid_type, u32 *fsidv,
-                                     struct cache_req *reqp);
 struct svc_export *     exp_get_by_name(struct auth_domain *clp,
                                        struct vfsmount *mnt,
                                        struct dentry *dentry,
@@ -101,35 +99,20 @@ int			exp_rootfh(struct auth_domain *,
 int                     exp_pseudoroot(struct auth_domain *, struct svc_fh *fhp, struct cache_req *creq);
 int                     nfserrno(int errno);
-extern void expkey_put(struct cache_head *item, struct cache_detail *cd);
+extern struct cache_detail svc_export_cache;
-extern void svc_export_put(struct cache_head *item, struct cache_detail *cd);
-extern struct cache_detail svc_export_cache, svc_expkey_cache;
 static inline void exp_put(struct svc_export *exp)
 {
-        svc_export_put(&exp->h, &svc_export_cache);
+        cache_put(&exp->h, &svc_export_cache);
 }
 static inline void exp_get(struct svc_export *exp)
 {
        cache_get(&exp->h);
 }
-static inline struct svc_export *
+extern struct svc_export *
 exp_find(struct auth_domain *clp, int fsid_type, u32 *fsidv,
-         struct cache_req *reqp)
+         struct cache_req *reqp);
-{
-        struct svc_expkey *ek = exp_find_key(clp, fsid_type, fsidv, reqp);
-        if (ek && !IS_ERR(ek)) {
-                struct svc_export *exp = ek->ek_export;
-                int err;
-                exp_get(exp);
-                expkey_put(&ek->h, &svc_expkey_cache);
-                if ((err = cache_check(&svc_export_cache, &exp->h, reqp)))
-                        exp = ERR_PTR(err);
-                return exp;
-        } else
-                return ERR_PTR(PTR_ERR(ek));
-}
 #endif /* __KERNEL__ */
diff --git a/include/linux/nodemask.h b/include/linux/nodemask.h
index b959a4525cbd..1a9ef3e627d1 100644
--- a/include/linux/nodemask.h
+++ b/include/linux/nodemask.h
@@ -350,11 +350,15 @@ extern nodemask_t node_possible_map;
 #define num_possible_nodes()    nodes_weight(node_possible_map)
 #define node_online(node)       node_isset((node), node_online_map)
 #define node_possible(node)     node_isset((node), node_possible_map)
+#define first_online_node       first_node(node_online_map)
+#define next_online_node(nid)   next_node((nid), node_online_map)
 #else
 #define num_online_nodes()      1
 #define num_possible_nodes()    1
 #define node_online(node)       ((node) == 0)
 #define node_possible(node)     ((node) == 0)
+#define first_online_node       0
+#define next_online_node(nid)   (MAX_NUMNODES)
 #endif
 #define any_online_node(mask)                   \
diff --git a/include/linux/notifier.h b/include/linux/notifier.h
index 5937dd6053c3..51dbab9710c7 100644
--- a/include/linux/notifier.h
+++ b/include/linux/notifier.h
@@ -10,25 +10,107 @@
 #ifndef _LINUX_NOTIFIER_H
 #define _LINUX_NOTIFIER_H
 #include <linux/errno.h>
+#include <linux/mutex.h>
+#include <linux/rwsem.h>
-struct notifier_block
+/*
-{
+ * Notifier chains are of three types:
-        int (*notifier_call)(struct notifier_block *self, unsigned long, void *);
+ *
+ *      Atomic notifier chains: Chain callbacks run in interrupt/atomic
+ *              context. Callouts are not allowed to block.
+ *      Blocking notifier chains: Chain callbacks run in process context.
+ *              Callouts are allowed to block.
+ *      Raw notifier chains: There are no restrictions on callbacks,
+ *              registration, or unregistration.  All locking and protection
+ *              must be provided by the caller.
+ *
+ * atomic_notifier_chain_register() may be called from an atomic context,
+ * but blocking_notifier_chain_register() must be called from a process
+ * context.  Ditto for the corresponding _unregister() routines.
+ *
+ * atomic_notifier_chain_unregister() and blocking_notifier_chain_unregister()
+ * _must not_ be called from within the call chain.
+ */
+struct notifier_block {
+        int (*notifier_call)(struct notifier_block *, unsigned long, void *);
        struct notifier_block *next;
        int priority;
 };
+struct atomic_notifier_head {
+        spinlock_t lock;
+        struct notifier_block *head;
+};
+struct blocking_notifier_head {
+        struct rw_semaphore rwsem;
+        struct notifier_block *head;
+};
+struct raw_notifier_head {
+        struct notifier_block *head;
+};
+#define ATOMIC_INIT_NOTIFIER_HEAD(name) do {    \
+                spin_lock_init(&(name)->lock);  \
+                (name)->head = NULL;            \
+        } while (0)
+#define BLOCKING_INIT_NOTIFIER_HEAD(name) do {  \
+                init_rwsem(&(name)->rwsem);     \
+                (name)->head = NULL;            \
+        } while (0)
+#define RAW_INIT_NOTIFIER_HEAD(name) do {       \
+                (name)->head = NULL;            \
+        } while (0)
+#define ATOMIC_NOTIFIER_INIT(name) {                            \
+                .lock = SPIN_LOCK_UNLOCKED,                     \
+                .head = NULL }
+#define BLOCKING_NOTIFIER_INIT(name) {                          \
+                .rwsem = __RWSEM_INITIALIZER((name).rwsem),     \
+                .head = NULL }
+#define RAW_NOTIFIER_INIT(name) {                               \
+                .head = NULL }
+#define ATOMIC_NOTIFIER_HEAD(name)                              \
+        struct atomic_notifier_head name =                      \
+                ATOMIC_NOTIFIER_INIT(name)
+#define BLOCKING_NOTIFIER_HEAD(name)                            \
+        struct blocking_notifier_head name =                    \
+                BLOCKING_NOTIFIER_INIT(name)
+#define RAW_NOTIFIER_HEAD(name)                                 \
+        struct raw_notifier_head name =                         \
+                RAW_NOTIFIER_INIT(name)
 #ifdef __KERNEL__
-extern int notifier_chain_register(struct notifier_block **list, struct notifier_block *n);
+extern int atomic_notifier_chain_register(struct atomic_notifier_head *,
-extern int notifier_chain_unregister(struct notifier_block **nl, struct notifier_block *n);
+                struct notifier_block *);
-extern int notifier_call_chain(struct notifier_block **n, unsigned long val, void *v);
+extern int blocking_notifier_chain_register(struct blocking_notifier_head *,
+                struct notifier_block *);
+extern int raw_notifier_chain_register(struct raw_notifier_head *,
+                struct notifier_block *);
+extern int atomic_notifier_chain_unregister(struct atomic_notifier_head *,
+                struct notifier_block *);
+extern int blocking_notifier_chain_unregister(struct blocking_notifier_head *,
+                struct notifier_block *);
+extern int raw_notifier_chain_unregister(struct raw_notifier_head *,
+                struct notifier_block *);
+extern int atomic_notifier_call_chain(struct atomic_notifier_head *,
+                unsigned long val, void *v);
+extern int blocking_notifier_call_chain(struct blocking_notifier_head *,
+                unsigned long val, void *v);
+extern int raw_notifier_call_chain(struct raw_notifier_head *,
+                unsigned long val, void *v);
 #define NOTIFY_DONE             0x0000          /* Don't care */
 #define NOTIFY_OK               0x0001          /* Suits me */
 #define NOTIFY_STOP_MASK        0x8000          /* Don't call further */
-#define NOTIFY_BAD              (NOTIFY_STOP_MASK|0x0002)       /* Bad/Veto action      */
+#define NOTIFY_BAD              (NOTIFY_STOP_MASK|0x0002)
+                                                /* Bad/Veto action */
 /*
 * Clean way to return from the notifier and stop further calls.
 */
diff --git a/include/linux/pci_ids.h b/include/linux/pci_ids.h
index 6f080ae59286..02f6cf20b141 100644
--- a/include/linux/pci_ids.h
+++ b/include/linux/pci_ids.h
@@ -1052,6 +1052,7 @@
 #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 PCIE_DEVICE_ID_NVIDIA_QUADRO_NVS280     0x00fd
 #define PCI_DEVICE_ID_NVIDIA_GEFORCE_SDR        0x0100
 #define PCI_DEVICE_ID_NVIDIA_GEFORCE_DDR        0x0101
 #define PCI_DEVICE_ID_NVIDIA_QUADRO             0x0103
diff --git a/include/linux/pfn.h b/include/linux/pfn.h
new file mode 100644
index 000000000000..bb01f8b92b56
--- /dev/null
+++ b/include/linux/pfn.h
@@ -0,0 +1,9 @@
+#ifndef _LINUX_PFN_H_
+#define _LINUX_PFN_H_
+#define PFN_ALIGN(x)    (((unsigned long)(x) + (PAGE_SIZE - 1)) & PAGE_MASK)
+#define PFN_UP(x)       (((x) + PAGE_SIZE-1) >> PAGE_SHIFT)
+#define PFN_DOWN(x)     ((x) >> PAGE_SHIFT)
+#define PFN_PHYS(x)     ((x) << PAGE_SHIFT)
+#endif
diff --git a/include/linux/proc_fs.h b/include/linux/proc_fs.h
index aa6322d45198..cb224cf653b1 100644
--- a/include/linux/proc_fs.h
+++ b/include/linux/proc_fs.h
@@ -4,6 +4,7 @@
 #include <linux/config.h>
 #include <linux/slab.h>
 #include <linux/fs.h>
+#include <linux/spinlock.h>
 #include <asm/atomic.h>
 /*
@@ -55,7 +56,7 @@ struct proc_dir_entry {
        nlink_t nlink;
        uid_t uid;
        gid_t gid;
-        unsigned long size;
+        loff_t size;
        struct inode_operations * proc_iops;
        struct file_operations * proc_fops;
        get_info_t *get_info;
@@ -92,6 +93,8 @@ extern struct proc_dir_entry *proc_bus;
 extern struct proc_dir_entry *proc_root_driver;
 extern struct proc_dir_entry *proc_root_kcore;
+extern spinlock_t proc_subdir_lock;
 extern void proc_root_init(void);
 extern void proc_misc_init(void);
diff --git a/include/linux/raid/md.h b/include/linux/raid/md.h
index b6e0bcad84e1..66b44e5e0d6e 100644
--- a/include/linux/raid/md.h
+++ b/include/linux/raid/md.h
@@ -92,7 +92,10 @@ extern void md_super_write(mddev_t *mddev, mdk_rdev_t *rdev,
 extern void md_super_wait(mddev_t *mddev);
 extern int sync_page_io(struct block_device *bdev, sector_t sector, int size,
                        struct page *page, int rw);
+extern void md_do_sync(mddev_t *mddev);
+extern void md_new_event(mddev_t *mddev);
+extern void md_update_sb(mddev_t * mddev);
 #define MD_BUG(x...) { printk("md: bug in file %s, line %d\n", __FILE__, __LINE__); md_print_devices(); }
diff --git a/include/linux/raid/md_k.h b/include/linux/raid/md_k.h
index 617b9506c760..e2df61f5b09a 100644
--- a/include/linux/raid/md_k.h
+++ b/include/linux/raid/md_k.h
@@ -132,6 +132,14 @@ struct mddev_s
        char                            uuid[16];
+        /* If the array is being reshaped, we need to record the
+         * new shape and an indication of where we are up to.
+         * This is written to the superblock.
+         * If reshape_position is MaxSector, then no reshape is happening (yet).
+         */
+        sector_t                        reshape_position;
+        int                             delta_disks, new_level, new_layout, new_chunk;
        struct mdk_thread_s             *thread;        /* management thread */
        struct mdk_thread_s             *sync_thread;   /* doing resync or reconstruct */
        sector_t                        curr_resync;    /* blocks scheduled */
@@ -143,6 +151,10 @@ struct mddev_s
        sector_t                        resync_mismatches; /* count of sectors where
                                                            * parity/replica mismatch found
                                                            */
+        /* allow user-space to request suspension of IO to regions of the array */
+        sector_t                        suspend_lo;
+        sector_t                        suspend_hi;
        /* if zero, use the system-wide default */
        int                             sync_speed_min;
        int                             sync_speed_max;
@@ -157,6 +169,9 @@ struct mddev_s
         * DONE:     thread is done and is waiting to be reaped
         * REQUEST:  user-space has requested a sync (used with SYNC)
         * CHECK:    user-space request for for check-only, no repair
+         * RESHAPE:  A reshape is happening
+         *
+         * If neither SYNC or RESHAPE are set, then it is a recovery.
         */
 #define MD_RECOVERY_RUNNING     0
 #define MD_RECOVERY_SYNC        1
@@ -166,10 +181,11 @@ struct mddev_s
 #define MD_RECOVERY_NEEDED      5
 #define MD_RECOVERY_REQUESTED   6
 #define MD_RECOVERY_CHECK       7
+#define MD_RECOVERY_RESHAPE     8
        unsigned long                   recovery;
        int                             in_sync;        /* know to not need resync */
-        struct semaphore                reconfig_sem;
+        struct mutex                    reconfig_mutex;
        atomic_t                        active;
        int                             changed;        /* true if we might need to reread partition info */
@@ -249,7 +265,8 @@ struct mdk_personality
        int (*spare_active) (mddev_t *mddev);
        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 (*check_reshape) (mddev_t *mddev);
+        int (*start_reshape) (mddev_t *mddev);
        int (*reconfig) (mddev_t *mddev, int layout, int chunk_size);
        /* quiesce moves between quiescence states
         * 0 - fully active
diff --git a/include/linux/raid/md_p.h b/include/linux/raid/md_p.h
index c100fa5d4bfa..774e1acfb8c4 100644
--- a/include/linux/raid/md_p.h
+++ b/include/linux/raid/md_p.h
@@ -102,6 +102,18 @@ typedef struct mdp_device_descriptor_s {
 #define MD_SB_ERRORS            1
 #define MD_SB_BITMAP_PRESENT    8 /* bitmap may be present nearby */
+/*
+ * Notes:
+ * - if an array is being reshaped (restriped) in order to change the
+ *   the number of active devices in the array, 'raid_disks' will be
+ *   the larger of the old and new numbers.  'delta_disks' will
+ *   be the "new - old".  So if +ve, raid_disks is the new value, and
+ *   "raid_disks-delta_disks" is the old.  If -ve, raid_disks is the
+ *   old value and "raid_disks+delta_disks" is the new (smaller) value.
+ */
 typedef struct mdp_superblock_s {
        /*
         * Constant generic information
@@ -146,7 +158,13 @@ typedef struct mdp_superblock_s {
        __u32 cp_events_hi;     /* 10 high-order of checkpoint update count   */
 #endif
        __u32 recovery_cp;      /* 11 recovery checkpoint sector count        */
-        __u32 gstate_sreserved[MD_SB_GENERIC_STATE_WORDS - 12];
+        /* There are only valid for minor_version > 90 */
+        __u64 reshape_position; /* 12,13 next address in array-space for reshape */
+        __u32 new_level;        /* 14 new level we are reshaping to           */
+        __u32 delta_disks;      /* 15 change in number of raid_disks          */
+        __u32 new_layout;       /* 16 new layout                              */
+        __u32 new_chunk;        /* 17 new chunk size (bytes)                  */
+        __u32 gstate_sreserved[MD_SB_GENERIC_STATE_WORDS - 18];
        /*
         * Personality information
@@ -207,7 +225,14 @@ struct mdp_superblock_1 {
                                 * 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 */
+        /* These are only valid with feature bit '4' */
+        __u64   reshape_position;       /* next address in array-space for reshape */
+        __u32   new_level;      /* new level we are reshaping to                */
+        __u32   delta_disks;    /* change in number of raid_disks               */
+        __u32   new_layout;     /* new layout                                   */
+        __u32   new_chunk;      /* new chunk size (bytes)                       */
+        __u8    pad1[128-124];  /* set to 0 when written */
        /* constant this-device information - 64 bytes */
        __u64   data_offset;    /* sector start of data, often 0 */
@@ -240,8 +265,9 @@ struct mdp_superblock_1 {
 /* feature_map bits */
 #define MD_FEATURE_BITMAP_OFFSET        1
+#define MD_FEATURE_RESHAPE_ACTIVE       4
-#define MD_FEATURE_ALL                  1
+#define MD_FEATURE_ALL                  5
 #endif 
diff --git a/include/linux/raid/raid5.h b/include/linux/raid/raid5.h
index 394da8207b34..914af667044f 100644
--- a/include/linux/raid/raid5.h
+++ b/include/linux/raid/raid5.h
@@ -135,6 +135,7 @@ struct stripe_head {
        atomic_t                count;                  /* nr of active thread/requests */
        spinlock_t              lock;
        int                     bm_seq; /* sequence number for bitmap flushes */
+        int                     disks;                  /* disks in stripe */
        struct r5dev {
                struct bio      req;
                struct bio_vec  vec;
@@ -156,6 +157,7 @@ struct stripe_head {
 #define R5_ReadError    8       /* seen a read error here recently */
 #define R5_ReWrite      9       /* have tried to over-write the readerror */
+#define R5_Expanded     10      /* This block now has post-expand data */
 /*
 * Write method
 */
@@ -174,7 +176,9 @@ struct stripe_head {
 #define STRIPE_DELAYED          6
 #define STRIPE_DEGRADED         7
 #define STRIPE_BIT_DELAY        8
+#define STRIPE_EXPANDING        9
+#define STRIPE_EXPAND_SOURCE    10
+#define STRIPE_EXPAND_READY     11
 /*
 * Plugging:
 *
@@ -211,12 +215,24 @@ struct raid5_private_data {
        int                     raid_disks, working_disks, failed_disks;
        int                     max_nr_stripes;
+        /* used during an expand */
+        sector_t                expand_progress;        /* MaxSector when no expand happening */
+        sector_t                expand_lo; /* from here up to expand_progress it out-of-bounds
+                                            * as we haven't flushed the metadata yet
+                                            */
+        int                     previous_raid_disks;
        struct list_head        handle_list; /* stripes needing handling */
        struct list_head        delayed_list; /* stripes that have plugged requests */
        struct list_head        bitmap_list; /* stripes delaying awaiting bitmap update */
        atomic_t                preread_active_stripes; /* stripes with scheduled io */
-        char                    cache_name[20];
+        atomic_t                reshape_stripes; /* stripes with pending writes for reshape */
+        /* unfortunately we need two cache names as we temporarily have
+         * two caches.
+         */
+        int                     active_name;
+        char                    cache_name[2][20];
        kmem_cache_t            *slab_cache; /* for allocating stripes */
        int                     seq_flush, seq_write;
@@ -238,9 +254,10 @@ struct raid5_private_data {
        wait_queue_head_t       wait_for_overlap;
        int                     inactive_blocked;       /* release of inactive stripes blocked,
                                                         * waiting for 25% to be free
-                                                         */        
+                                                         */
+        int                     pool_size; /* number of disks in stripeheads in pool */
        spinlock_t              device_lock;
-        struct disk_info        disks[0];
+        struct disk_info        *disks;
 };
 typedef struct raid5_private_data raid5_conf_t;
diff --git a/include/linux/rtc.h b/include/linux/rtc.h
index b739ac1f7ca0..ab61cd1199f2 100644
--- a/include/linux/rtc.h
+++ b/include/linux/rtc.h
@@ -91,10 +91,102 @@ struct rtc_pll_info {
 #define RTC_PLL_GET     _IOR('p', 0x11, struct rtc_pll_info)  /* Get PLL correction */
 #define RTC_PLL_SET     _IOW('p', 0x12, struct rtc_pll_info)  /* Set PLL correction */
+/* interrupt flags */
+#define RTC_IRQF 0x80 /* any of the following is active */
+#define RTC_PF 0x40
+#define RTC_AF 0x20
+#define RTC_UF 0x10
 #ifdef __KERNEL__
 #include <linux/interrupt.h>
+extern int rtc_month_days(unsigned int month, unsigned int year);
+extern int rtc_valid_tm(struct rtc_time *tm);
+extern int rtc_tm_to_time(struct rtc_time *tm, unsigned long *time);
+extern void rtc_time_to_tm(unsigned long time, struct rtc_time *tm);
+#include <linux/device.h>
+#include <linux/seq_file.h>
+#include <linux/cdev.h>
+#include <linux/poll.h>
+#include <linux/mutex.h>
+extern struct class *rtc_class;
+struct rtc_class_ops {
+        int (*open)(struct device *);
+        void (*release)(struct device *);
+        int (*ioctl)(struct device *, unsigned int, unsigned long);
+        int (*read_time)(struct device *, struct rtc_time *);
+        int (*set_time)(struct device *, struct rtc_time *);
+        int (*read_alarm)(struct device *, struct rtc_wkalrm *);
+        int (*set_alarm)(struct device *, struct rtc_wkalrm *);
+        int (*proc)(struct device *, struct seq_file *);
+        int (*set_mmss)(struct device *, unsigned long secs);
+        int (*irq_set_state)(struct device *, int enabled);
+        int (*irq_set_freq)(struct device *, int freq);
+        int (*read_callback)(struct device *, int data);
+};
+#define RTC_DEVICE_NAME_SIZE 20
+struct rtc_task;
+struct rtc_device
+{
+        struct class_device class_dev;
+        struct module *owner;
+        int id;
+        char name[RTC_DEVICE_NAME_SIZE];
+        struct rtc_class_ops *ops;
+        struct mutex ops_lock;
+        struct class_device *rtc_dev;
+        struct cdev char_dev;
+        struct mutex char_lock;
+        unsigned long irq_data;
+        spinlock_t irq_lock;
+        wait_queue_head_t irq_queue;
+        struct fasync_struct *async_queue;
+        struct rtc_task *irq_task;
+        spinlock_t irq_task_lock;
+        int irq_freq;
+};
+#define to_rtc_device(d) container_of(d, struct rtc_device, class_dev)
+extern struct rtc_device *rtc_device_register(const char *name,
+                                        struct device *dev,
+                                        struct rtc_class_ops *ops,
+                                        struct module *owner);
+extern void rtc_device_unregister(struct rtc_device *rdev);
+extern int rtc_interface_register(struct class_interface *intf);
+extern int rtc_read_time(struct class_device *class_dev, struct rtc_time *tm);
+extern int rtc_set_time(struct class_device *class_dev, struct rtc_time *tm);
+extern int rtc_set_mmss(struct class_device *class_dev, unsigned long secs);
+extern int rtc_read_alarm(struct class_device *class_dev,
+                        struct rtc_wkalrm *alrm);
+extern int rtc_set_alarm(struct class_device *class_dev,
+                                struct rtc_wkalrm *alrm);
+extern void rtc_update_irq(struct class_device *class_dev,
+                        unsigned long num, unsigned long events);
+extern struct class_device *rtc_class_open(char *name);
+extern void rtc_class_close(struct class_device *class_dev);
+extern int rtc_irq_register(struct class_device *class_dev,
+                                struct rtc_task *task);
+extern void rtc_irq_unregister(struct class_device *class_dev,
+                                struct rtc_task *task);
+extern int rtc_irq_set_state(struct class_device *class_dev,
+                                struct rtc_task *task, int enabled);
+extern int rtc_irq_set_freq(struct class_device *class_dev,
+                                struct rtc_task *task, int freq);
 typedef struct rtc_task {
        void (*func)(void *private_data);
        void *private_data;
diff --git a/include/linux/sched.h b/include/linux/sched.h
index e0054c1b9a09..20b4f0372e44 100644
--- a/include/linux/sched.h
+++ b/include/linux/sched.h
@@ -35,6 +35,7 @@
 #include <linux/topology.h>
 #include <linux/seccomp.h>
 #include <linux/rcupdate.h>
+#include <linux/futex.h>
 #include <linux/auxvec.h>       /* For AT_VECTOR_SIZE */
@@ -402,6 +403,7 @@ struct signal_struct {
        /* ITIMER_REAL timer for the process */
        struct hrtimer real_timer;
+        struct task_struct *tsk;
        ktime_t it_real_incr;
        /* ITIMER_PROF and ITIMER_VIRTUAL timers for the process */
@@ -871,6 +873,11 @@ struct task_struct {
        int cpuset_mems_generation;
        int cpuset_mem_spread_rotor;
 #endif
+        struct robust_list_head __user *robust_list;
+#ifdef CONFIG_COMPAT
+        struct compat_robust_list_head __user *compat_robust_list;
+#endif
        atomic_t fs_excl;       /* holding fs exclusive resources */
        struct rcu_head rcu;
 };
diff --git a/include/linux/serio.h b/include/linux/serio.h
index aa4d6493a034..690aabca8ed0 100644
--- a/include/linux/serio.h
+++ b/include/linux/serio.h
@@ -119,7 +119,7 @@ static inline void serio_cleanup(struct serio *serio)
 }
 /*
- * Use the following fucntions to manipulate serio's per-port
+ * Use the following functions to manipulate serio's per-port
 * driver-specific data.
 */
 static inline void *serio_get_drvdata(struct serio *serio)
@@ -133,7 +133,7 @@ static inline void serio_set_drvdata(struct serio *serio, void *data)
 }
 /*
- * Use the following fucntions to protect critical sections in
+ * Use the following functions to protect critical sections in
 * driver code from port's interrupt handler
 */
 static inline void serio_pause_rx(struct serio *serio)
@@ -147,7 +147,7 @@ static inline void serio_continue_rx(struct serio *serio)
 }
 /*
- * Use the following fucntions to pin serio's driver in process context
+ * Use the following functions to pin serio's driver in process context
 */
 static inline int serio_pin_driver(struct serio *serio)
 {
diff --git a/include/linux/smp.h b/include/linux/smp.h
index d699a16b0cb2..e2fa3ab4afc5 100644
--- a/include/linux/smp.h
+++ b/include/linux/smp.h
@@ -82,7 +82,11 @@ void smp_prepare_boot_cpu(void);
 */
 #define raw_smp_processor_id()                  0
 #define hard_smp_processor_id()                 0
-#define smp_call_function(func,info,retry,wait) ({ 0; })
+static inline int up_smp_call_function(void)
+{
+        return 0;
+}
+#define smp_call_function(func,info,retry,wait) (up_smp_call_function())
 #define on_each_cpu(func,info,retry,wait)       \
        ({                                      \
                local_irq_disable();            \
diff --git a/include/linux/stat.h b/include/linux/stat.h
index 8ff2a122dfef..8669291352db 100644
--- a/include/linux/stat.h
+++ b/include/linux/stat.h
@@ -69,7 +69,7 @@ struct kstat {
        struct timespec mtime;
        struct timespec ctime;
        unsigned long   blksize;
-        unsigned long   blocks;
+        unsigned long long      blocks;
 };
 #endif
diff --git a/include/linux/statfs.h b/include/linux/statfs.h
index ad83a2bdb821..b34cc829f98d 100644
--- a/include/linux/statfs.h
+++ b/include/linux/statfs.h
@@ -8,11 +8,11 @@
 struct kstatfs {
        long f_type;
        long f_bsize;
-        sector_t f_blocks;
+        u64 f_blocks;
-        sector_t f_bfree;
+        u64 f_bfree;
-        sector_t f_bavail;
+        u64 f_bavail;
-        sector_t f_files;
+        u64 f_files;
-        sector_t f_ffree;
+        u64 f_ffree;
        __kernel_fsid_t f_fsid;
        long f_namelen;
        long f_frsize;
diff --git a/include/linux/sunrpc/cache.h b/include/linux/sunrpc/cache.h
index c4e3ea7cf154..b5612c958cce 100644
--- a/include/linux/sunrpc/cache.h
+++ b/include/linux/sunrpc/cache.h
@@ -50,7 +50,7 @@ struct cache_head {
        time_t          last_refresh;   /* If CACHE_PENDING, this is when upcall 
                                         * was sent, else this is when update was received
                                         */
-        atomic_t        refcnt;
+        struct kref     ref;
        unsigned long   flags;
 };
 #define CACHE_VALID     0       /* Entry contains valid data */
@@ -68,8 +68,7 @@ struct cache_detail {
        atomic_t                inuse; /* active user-space update or lookup */
        char                    *name;
-        void                    (*cache_put)(struct cache_head *,
+        void                    (*cache_put)(struct kref *);
-                                             struct cache_detail*);
        void                    (*cache_request)(struct cache_detail *cd,
                                                 struct cache_head *h,
@@ -81,6 +80,11 @@ struct cache_detail {
                                              struct cache_detail *cd,
                                              struct cache_head *h);
+        struct cache_head *     (*alloc)(void);
+        int                     (*match)(struct cache_head *orig, struct cache_head *new);
+        void                    (*init)(struct cache_head *orig, struct cache_head *new);
+        void                    (*update)(struct cache_head *orig, struct cache_head *new);
        /* fields below this comment are for internal use
         * and should not be touched by cache owners
         */
@@ -123,126 +127,14 @@ struct cache_deferred_req {
                                           int too_many);
 };
-/*
- * just like a template in C++, this macro does cache lookup
- * for us.
- * The function is passed some sort of HANDLE from which a cache_detail
- * structure can be determined (via SETUP, DETAIL), a template
- * cache entry (type RTN*), and a "set" flag.  Using the HASHFN and the 
- * TEST, the function will try to find a matching cache entry in the cache.
- * If "set" == 0 :
- *    If an entry is found, it is returned
- *    If no entry is found, a new non-VALID entry is created.
- * If "set" == 1 and INPLACE == 0 :
- *    If no entry is found a new one is inserted with data from "template"
- *    If a non-CACHE_VALID entry is found, it is updated from template using UPDATE
- *    If a CACHE_VALID entry is found, a new entry is swapped in with data
- *       from "template"
- * If set == 1, and INPLACE == 1 :
- *    As above, except that if a CACHE_VALID entry is found, we UPDATE in place
- *       instead of swapping in a new entry.
- *
- * If the passed handle has the CACHE_NEGATIVE flag set, then UPDATE is not
- * run but insteead CACHE_NEGATIVE is set in any new item.
- *  In any case, the new entry is returned with a reference count.
+extern struct cache_head *
- *
+sunrpc_cache_lookup(struct cache_detail *detail,
- *    
+                    struct cache_head *key, int hash);
- * RTN is a struct type for a cache entry
+extern struct cache_head *
- * MEMBER is the member of the cache which is cache_head, which must be first
+sunrpc_cache_update(struct cache_detail *detail,
- * FNAME is the name for the function   
+                    struct cache_head *new, struct cache_head *old, int hash);
- * ARGS are arguments to function and must contain RTN *item, int set.  May
- *   also contain something to be usedby SETUP or DETAIL to find cache_detail.
- * SETUP  locates the cache detail and makes it available as...
- * DETAIL identifies the cache detail, possibly set up by SETUP
- * HASHFN returns a hash value of the cache entry "item"
- * TEST  tests if "tmp" matches "item"
- * INIT copies key information from "item" to "new"
- * UPDATE copies content information from "item" to "tmp"
- * INPLACE is true if updates can happen inplace rather than allocating a new structure
- *
- * WARNING: any substantial changes to this must be reflected in
- *   net/sunrpc/svcauth.c(auth_domain_lookup)
- *  which is a similar routine that is open-coded.
- */
-#define DefineCacheLookup(RTN,MEMBER,FNAME,ARGS,SETUP,DETAIL,HASHFN,TEST,INIT,UPDATE,INPLACE)   \
-RTN *FNAME ARGS                                                                         \
-{                                                                                       \
-        RTN *tmp, *new=NULL;                                                            \
-        struct cache_head **hp, **head;                                                 \
-        SETUP;                                                                          \
-        head = &(DETAIL)->hash_table[HASHFN];                                           \
- retry:                                                                                 \
-        if (set||new) write_lock(&(DETAIL)->hash_lock);                                 \
-        else read_lock(&(DETAIL)->hash_lock);                                           \
-        for(hp=head; *hp != NULL; hp = &tmp->MEMBER.next) {                             \
-                tmp = container_of(*hp, RTN, MEMBER);                                   \
-                if (TEST) { /* found a match */                                         \
-                                                                                        \
-                        if (set && !INPLACE && test_bit(CACHE_VALID, &tmp->MEMBER.flags) && !new) \
-                                break;                                                  \
-                                                                                        \
-                        if (new)                                                        \
-                                {INIT;}                                                 \
-                        if (set) {                                                      \
-                                if (!INPLACE && test_bit(CACHE_VALID, &tmp->MEMBER.flags))\
-                                { /* need to swap in new */                             \
-                                        RTN *t2;                                        \
-                                                                                        \
-                                        new->MEMBER.next = tmp->MEMBER.next;            \
-                                        *hp = &new->MEMBER;                             \
-                                        tmp->MEMBER.next = NULL;                        \
-                                        t2 = tmp; tmp = new; new = t2;                  \
-                                }                                                       \
-                                if (test_bit(CACHE_NEGATIVE,  &item->MEMBER.flags))     \
-                                        set_bit(CACHE_NEGATIVE, &tmp->MEMBER.flags);    \
-                                else {                                                  \
-                                        UPDATE;                                         \
-                                        clear_bit(CACHE_NEGATIVE, &tmp->MEMBER.flags);  \
-                                }                                                       \
-                        }                                                               \
-                        cache_get(&tmp->MEMBER);                                        \
-                        if (set||new) write_unlock(&(DETAIL)->hash_lock);               \
-                        else read_unlock(&(DETAIL)->hash_lock);                         \
-                        if (set)                                                        \
-                                cache_fresh(DETAIL, &tmp->MEMBER, item->MEMBER.expiry_time); \
-                        if (set && !INPLACE && new) cache_fresh(DETAIL, &new->MEMBER, 0);       \
-                        if (new) (DETAIL)->cache_put(&new->MEMBER, DETAIL);             \
-                        return tmp;                                                     \
-                }                                                                       \
-        }                                                                               \
-        /* Didn't find anything */                                                      \
-        if (new) {                                                                      \
-                INIT;                                                                   \
-                new->MEMBER.next = *head;                                               \
-                *head = &new->MEMBER;                                                   \
-                (DETAIL)->entries ++;                                                   \
-                cache_get(&new->MEMBER);                                                \
-                if (set) {                                                              \
-                        tmp = new;                                                      \
-                        if (test_bit(CACHE_NEGATIVE, &item->MEMBER.flags))              \
-                                set_bit(CACHE_NEGATIVE, &tmp->MEMBER.flags);            \
-                        else {UPDATE;}                                                  \
-                }                                                                       \
-        }                                                                               \
-        if (set||new) write_unlock(&(DETAIL)->hash_lock);                               \
-        else read_unlock(&(DETAIL)->hash_lock);                                         \
-        if (new && set)                                                                 \
-                cache_fresh(DETAIL, &new->MEMBER, item->MEMBER.expiry_time);            \
-        if (new)                                                                        \
-                return new;                                                             \
-        new = kmalloc(sizeof(*new), GFP_KERNEL);                                        \
-        if (new) {                                                                      \
-                cache_init(&new->MEMBER);                                               \
-                goto retry;                                                             \
-        }                                                                               \
-        return NULL;                                                                    \
-}
-#define DefineSimpleCacheLookup(STRUCT,INPLACE) \
-        DefineCacheLookup(struct STRUCT, h, STRUCT##_lookup, (struct STRUCT *item, int set), /*no setup */,     \
-                          & STRUCT##_cache, STRUCT##_hash(item), STRUCT##_match(item, tmp),\
-                          STRUCT##_init(new, item), STRUCT##_update(tmp, item),INPLACE)
 #define cache_for_each(pos, detail, index, member)                                              \
        for (({read_lock(&(detail)->hash_lock); index = (detail)->hash_size;}) ;                \
@@ -258,22 +150,19 @@ extern void cache_clean_deferred(void *owner);
 static inline struct cache_head  *cache_get(struct cache_head *h)
 {
-        atomic_inc(&h->refcnt);
+        kref_get(&h->ref);
        return h;
 }
-static inline int cache_put(struct cache_head *h, struct cache_detail *cd)
+static inline void cache_put(struct cache_head *h, struct cache_detail *cd)
 {
-        if (atomic_read(&h->refcnt) <= 2 &&
+        if (atomic_read(&h->ref.refcount) <= 2 &&
            h->expiry_time < cd->nextcheck)
                cd->nextcheck = h->expiry_time;
-        return atomic_dec_and_test(&h->refcnt);
+        kref_put(&h->ref, cd->cache_put);
 }
-extern void cache_init(struct cache_head *h);
-extern void cache_fresh(struct cache_detail *detail,
-                        struct cache_head *head, time_t expiry);
 extern int cache_check(struct cache_detail *detail,
                       struct cache_head *h, struct cache_req *rqstp);
 extern void cache_flush(void);
diff --git a/include/linux/sunrpc/svcauth.h b/include/linux/sunrpc/svcauth.h
index c119ce7cbd22..2fe2087edd66 100644
--- a/include/linux/sunrpc/svcauth.h
+++ b/include/linux/sunrpc/svcauth.h
@@ -45,9 +45,10 @@ struct svc_rqst;		/* forward decl */
 * of ip addresses to the given client.
 */
 struct auth_domain {
-        struct  cache_head      h;
+        struct kref             ref;
+        struct hlist_node       hash;
        char                    *name;
-        int                     flavour;
+        struct auth_ops         *flavour;
 };
 /*
@@ -86,6 +87,9 @@ struct auth_domain {
 *
 * domain_release()
 *   This call releases a domain.
+ * set_client()
+ *   Givens a pending request (struct svc_rqst), finds and assigns
+ *   an appropriate 'auth_domain' as the client.
 */
 struct auth_ops {
        char *  name;
@@ -117,7 +121,7 @@ extern void	svc_auth_unregister(rpc_authflavor_t flavor);
 extern struct auth_domain *unix_domain_find(char *name);
 extern void auth_domain_put(struct auth_domain *item);
 extern int auth_unix_add_addr(struct in_addr addr, struct auth_domain *dom);
-extern struct auth_domain *auth_domain_lookup(struct auth_domain *item, int set);
+extern struct auth_domain *auth_domain_lookup(char *name, struct auth_domain *new);
 extern struct auth_domain *auth_domain_find(char *name);
 extern struct auth_domain *auth_unix_lookup(struct in_addr addr);
 extern int auth_unix_forget_old(struct auth_domain *dom);
@@ -160,8 +164,6 @@ static inline unsigned long hash_mem(char *buf, int length, int bits)
        return hash >> (BITS_PER_LONG - bits);
 }
-extern struct cache_detail auth_domain_cache, ip_map_cache;
 #endif /* __KERNEL__ */
 #endif /* _LINUX_SUNRPC_SVCAUTH_H_ */
diff --git a/include/linux/threads.h b/include/linux/threads.h
index b59738ac6197..e646bcdf2614 100644
--- a/include/linux/threads.h
+++ b/include/linux/threads.h
@@ -28,7 +28,8 @@
 #define PID_MAX_DEFAULT (CONFIG_BASE_SMALL ? 0x1000 : 0x8000)
 /*
- * A maximum of 4 million PIDs should be enough for a while:
+ * A maximum of 4 million PIDs should be enough for a while.
+ * [NOTE: PID/TIDs are limited to 2^29 ~= 500+ million, see futex.h.]
 */
 #define PID_MAX_LIMIT (CONFIG_BASE_SMALL ? PAGE_SIZE * 8 : \
        (sizeof(long) > 4 ? 4 * 1024 * 1024 : PID_MAX_DEFAULT))
diff --git a/include/linux/time.h b/include/linux/time.h
index bf0e785e2e03..0cd696cee998 100644
--- a/include/linux/time.h
+++ b/include/linux/time.h
@@ -73,12 +73,6 @@ extern void set_normalized_timespec(struct timespec *ts, time_t sec, long nsec);
 #define timespec_valid(ts) \
        (((ts)->tv_sec >= 0) && (((unsigned long) (ts)->tv_nsec) < NSEC_PER_SEC))
-/*
- * 64-bit nanosec type. Large enough to span 292+ years in nanosecond
- * resolution. Ought to be enough for a while.
- */
-typedef s64 nsec_t;
 extern struct timespec xtime;
 extern struct timespec wall_to_monotonic;
 extern seqlock_t xtime_lock;
@@ -114,9 +108,9 @@ extern struct timespec timespec_trunc(struct timespec t, unsigned gran);
 * Returns the scalar nanosecond representation of the timespec
 * parameter.
 */
-static inline nsec_t timespec_to_ns(const struct timespec *ts)
+static inline s64 timespec_to_ns(const struct timespec *ts)
 {
-        return ((nsec_t) ts->tv_sec * NSEC_PER_SEC) + ts->tv_nsec;
+        return ((s64) ts->tv_sec * NSEC_PER_SEC) + ts->tv_nsec;
 }
 /**
@@ -126,9 +120,9 @@ static inline nsec_t timespec_to_ns(const struct timespec *ts)
 * Returns the scalar nanosecond representation of the timeval
 * parameter.
 */
-static inline nsec_t timeval_to_ns(const struct timeval *tv)
+static inline s64 timeval_to_ns(const struct timeval *tv)
 {
-        return ((nsec_t) tv->tv_sec * NSEC_PER_SEC) +
+        return ((s64) tv->tv_sec * NSEC_PER_SEC) +
                tv->tv_usec * NSEC_PER_USEC;
 }
@@ -138,7 +132,7 @@ static inline nsec_t timeval_to_ns(const struct timeval *tv)
 *
 * Returns the timespec representation of the nsec parameter.
 */
-extern struct timespec ns_to_timespec(const nsec_t nsec);
+extern struct timespec ns_to_timespec(const s64 nsec);
 /**
 * ns_to_timeval - Convert nanoseconds to timeval
@@ -146,7 +140,7 @@ extern struct timespec ns_to_timespec(const nsec_t nsec);
 *
 * Returns the timeval representation of the nsec parameter.
 */
-extern struct timeval ns_to_timeval(const nsec_t nsec);
+extern struct timeval ns_to_timeval(const s64 nsec);
 #endif /* __KERNEL__ */
diff --git a/include/linux/timer.h b/include/linux/timer.h
index ee5a09e806e8..b5caabca553c 100644
--- a/include/linux/timer.h
+++ b/include/linux/timer.h
@@ -96,6 +96,7 @@ static inline void add_timer(struct timer_list *timer)
 extern void init_timers(void);
 extern void run_local_timers(void);
-extern int it_real_fn(void *);
+struct hrtimer;
+extern int it_real_fn(struct hrtimer *);
 #endif
diff --git a/include/linux/timex.h b/include/linux/timex.h
index 82dc9ae79d37..03914b7e41b1 100644
--- a/include/linux/timex.h
+++ b/include/linux/timex.h
@@ -307,6 +307,8 @@ time_interpolator_reset(void)
 /* Returns how long ticks are at present, in ns / 2^(SHIFT_SCALE-10). */
 extern u64 current_tick_length(void);
+extern int do_adjtimex(struct timex *);
 #endif /* KERNEL */
 #endif /* LINUX_TIMEX_H */
diff --git a/include/linux/topology.h b/include/linux/topology.h
index e8eb0040ce3a..a305ae2e44b6 100644
--- a/include/linux/topology.h
+++ b/include/linux/topology.h
@@ -164,6 +164,15 @@
        .nr_balance_failed      = 0,                    \
 }
+#ifdef CONFIG_SCHED_MC
+#ifndef SD_MC_INIT
+/* for now its same as SD_CPU_INIT.
+ * TBD: Tune Domain parameters!
+ */
+#define SD_MC_INIT   SD_CPU_INIT
+#endif
+#endif
 #ifdef CONFIG_NUMA
 #ifndef SD_NODE_INIT
 #error Please define an appropriate SD_NODE_INIT in include/asm/topology.h!!!
diff --git a/include/linux/types.h b/include/linux/types.h
index 54ae2d59e71b..1046c7ad86d9 100644
--- a/include/linux/types.h
+++ b/include/linux/types.h
@@ -137,6 +137,10 @@ typedef		__s64		int64_t;
 typedef unsigned long sector_t;
 #endif
+#ifndef HAVE_BLKCNT_T
+typedef unsigned long blkcnt_t;
+#endif
 /*
 * The type of an index into the pagecache.  Use a #define so asm/types.h
 * can override it.
diff --git a/include/linux/x1205.h b/include/linux/x1205.h
deleted file mode 100644
index 64fd3af894a5..000000000000
--- a/include/linux/x1205.h
+++ /dev/null
@@ -1,31 +0,0 @@
-/*
- *  x1205.h - defines for drivers/i2c/chips/x1205.c
- *  Copyright 2004 Karen Spearel
- *  Copyright 2005 Alessandro Zummo
- *
- *  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.
- */
-#ifndef __LINUX_X1205_H__
-#define __LINUX_X1205_H__
-/* commands */
-#define X1205_CMD_GETDATETIME   0
-#define X1205_CMD_SETTIME       1
-#define X1205_CMD_SETDATETIME   2
-#define X1205_CMD_GETALARM      3
-#define X1205_CMD_SETALARM      4
-#define X1205_CMD_GETDTRIM      5
-#define X1205_CMD_SETDTRIM      6
-#define X1205_CMD_GETATRIM      7
-#define X1205_CMD_SETATRIM      8
-extern int x1205_do_command(unsigned int cmd, void *arg);
-extern int x1205_direct_attach(int adapter_id,
-        struct i2c_client_address_data *address_data);
-#endif /* __LINUX_X1205_H__ */
diff --git a/include/net/netfilter/nf_conntrack.h b/include/net/netfilter/nf_conntrack.h
index b6f0905a4ee2..916013ca4a5c 100644
--- a/include/net/netfilter/nf_conntrack.h
+++ b/include/net/netfilter/nf_conntrack.h
@@ -300,29 +300,30 @@ DECLARE_PER_CPU(struct nf_conntrack_ecache, nf_conntrack_ecache);
 #define CONNTRACK_ECACHE(x)     (__get_cpu_var(nf_conntrack_ecache).x)
-extern struct notifier_block *nf_conntrack_chain;
+extern struct atomic_notifier_head nf_conntrack_chain;
-extern struct notifier_block *nf_conntrack_expect_chain;
+extern struct atomic_notifier_head nf_conntrack_expect_chain;
 static inline int nf_conntrack_register_notifier(struct notifier_block *nb)
 {
-        return notifier_chain_register(&nf_conntrack_chain, nb);
+        return atomic_notifier_chain_register(&nf_conntrack_chain, nb);
 }
 static inline int nf_conntrack_unregister_notifier(struct notifier_block *nb)
 {
-        return notifier_chain_unregister(&nf_conntrack_chain, nb);
+        return atomic_notifier_chain_unregister(&nf_conntrack_chain, nb);
 }
 static inline int
 nf_conntrack_expect_register_notifier(struct notifier_block *nb)
 {
-        return notifier_chain_register(&nf_conntrack_expect_chain, nb);
+        return atomic_notifier_chain_register(&nf_conntrack_expect_chain, nb);
 }
 static inline int
 nf_conntrack_expect_unregister_notifier(struct notifier_block *nb)
 {
-        return notifier_chain_unregister(&nf_conntrack_expect_chain, nb);
+        return atomic_notifier_chain_unregister(&nf_conntrack_expect_chain,
+                        nb);
 }
 extern void nf_ct_deliver_cached_events(const struct nf_conn *ct);
@@ -347,14 +348,14 @@ static inline void nf_conntrack_event(enum ip_conntrack_events event,
                                      struct nf_conn *ct)
 {
        if (nf_ct_is_confirmed(ct) && !nf_ct_is_dying(ct))
-                notifier_call_chain(&nf_conntrack_chain, event, ct);
+                atomic_notifier_call_chain(&nf_conntrack_chain, event, ct);
 }
 static inline void
 nf_conntrack_expect_event(enum ip_conntrack_expect_events event,
                          struct nf_conntrack_expect *exp)
 {
-        notifier_call_chain(&nf_conntrack_expect_chain, event, exp);
+        atomic_notifier_call_chain(&nf_conntrack_expect_chain, event, exp);
 }
 #else /* CONFIG_NF_CONNTRACK_EVENTS */
 static inline void nf_conntrack_event_cache(enum ip_conntrack_events event,
diff --git a/include/net/request_sock.h b/include/net/request_sock.h
index 11641c9384f7..c5d7f920c352 100644
--- a/include/net/request_sock.h
+++ b/include/net/request_sock.h
@@ -145,7 +145,7 @@ static inline struct request_sock *
 {
        struct request_sock *req = queue->rskq_accept_head;
-        queue->rskq_accept_head = queue->rskq_accept_head = NULL;
+        queue->rskq_accept_head = NULL;
        return req;
 }