Merge branch 'upstream'

176 files changed, 2284 insertions, 1493 deletions

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/amba/serial.h b/include/linux/amba/serial.h
index dc726ffccebd..48ee32a18ac5 100644
--- a/include/linux/amba/serial.h
+++ b/include/linux/amba/serial.h
@@ -158,4 +158,10 @@
 #define UART01x_RSR_ANY         (UART01x_RSR_OE|UART01x_RSR_BE|UART01x_RSR_PE|UART01x_RSR_FE)
 #define UART01x_FR_MODEM_ANY    (UART01x_FR_DCD|UART01x_FR_DSR|UART01x_FR_CTS)
 
+#ifndef __ASSEMBLY__
+struct amba_pl010_data {
+        void (*set_mctrl)(struct amba_device *dev, void __iomem *base, unsigned int mctrl);
+};
+#endif
+
 #endif
diff --git a/include/linux/audit.h b/include/linux/audit.h
index da3c01955f3d..1c47c59058c1 100644
--- a/include/linux/audit.h
+++ b/include/linux/audit.h
@@ -33,27 +33,42 @@
  * 1200 - 1299 messages internal to the audit daemon
  * 1300 - 1399 audit event messages
  * 1400 - 1499 SE Linux use
- * 1500 - 1999 future use
- * 2000 is for otherwise unclassified kernel audit messages
+ * 1500 - 1599 kernel LSPP events
+ * 1600 - 1699 kernel crypto events
+ * 1700 - 1799 kernel anomaly records
+ * 1800 - 1999 future kernel use (maybe integrity labels and related events)
+ * 2000 is for otherwise unclassified kernel audit messages (legacy)
+ * 2001 - 2099 unused (kernel)
+ * 2100 - 2199 user space anomaly records
+ * 2200 - 2299 user space actions taken in response to anomalies
+ * 2300 - 2399 user space generated LSPP events
+ * 2400 - 2499 user space crypto events
+ * 2500 - 2999 future user space (maybe integrity labels and related events)
  *
- * Messages from 1000-1199 are bi-directional. 1200-1299 are exclusively user
- * space. Anything over that is kernel --> user space communication.
+ * Messages from 1000-1199 are bi-directional. 1200-1299 & 2100 - 2999 are
+ * exclusively user space. 1300-2099 is kernel --> user space 
+ * communication.
  */
 #define AUDIT_GET               1000    /* Get status */
 #define AUDIT_SET               1001    /* Set status (enable/disable/auditd) */
-#define AUDIT_LIST              1002    /* List syscall filtering rules */
-#define AUDIT_ADD               1003    /* Add syscall filtering rule */
-#define AUDIT_DEL               1004    /* Delete syscall filtering rule */
+#define AUDIT_LIST              1002    /* List syscall rules -- deprecated */
+#define AUDIT_ADD               1003    /* Add syscall rule -- deprecated */
+#define AUDIT_DEL               1004    /* Delete syscall rule -- deprecated */
 #define AUDIT_USER              1005    /* Message from userspace -- deprecated */
 #define AUDIT_LOGIN             1006    /* Define the login id and information */
 #define AUDIT_WATCH_INS         1007    /* Insert file/dir watch entry */
 #define AUDIT_WATCH_REM         1008    /* Remove file/dir watch entry */
 #define AUDIT_WATCH_LIST        1009    /* List all file/dir watches */
 #define AUDIT_SIGNAL_INFO       1010    /* Get info about sender of signal to auditd */
+#define AUDIT_ADD_RULE          1011    /* Add syscall filtering rule */
+#define AUDIT_DEL_RULE          1012    /* Delete syscall filtering rule */
+#define AUDIT_LIST_RULES        1013    /* List syscall filtering rules */
 
 #define AUDIT_FIRST_USER_MSG    1100    /* Userspace messages mostly uninteresting to kernel */
 #define AUDIT_USER_AVC          1107    /* We filter this differently */
 #define AUDIT_LAST_USER_MSG     1199
+#define AUDIT_FIRST_USER_MSG2   2100    /* More user space messages */
+#define AUDIT_LAST_USER_MSG2    2999
  
 #define AUDIT_DAEMON_START      1200    /* Daemon startup record */
 #define AUDIT_DAEMON_END        1201    /* Daemon normal stop record */
@@ -72,6 +87,13 @@
 #define AUDIT_AVC               1400    /* SE Linux avc denial or grant */
 #define AUDIT_SELINUX_ERR       1401    /* Internal SE Linux Errors */
 #define AUDIT_AVC_PATH          1402    /* dentry, vfsmount pair from avc */
+#define AUDIT_MAC_POLICY_LOAD   1403    /* Policy file load */
+#define AUDIT_MAC_STATUS        1404    /* Changed enforcing,permissive,off */
+#define AUDIT_MAC_CONFIG_CHANGE 1405    /* Changes to booleans */
+
+#define AUDIT_FIRST_KERN_ANOM_MSG   1700
+#define AUDIT_LAST_KERN_ANOM_MSG    1799
+#define AUDIT_ANOM_PROMISCUOUS      1700 /* Device changed promiscuous mode */
 
 #define AUDIT_KERNEL            2000    /* Asynchronous audit record. NOT A REQUEST. */
 
@@ -81,8 +103,9 @@
 #define AUDIT_FILTER_ENTRY      0x02    /* Apply rule at syscall entry */
 #define AUDIT_FILTER_WATCH      0x03    /* Apply rule to file system watches */
 #define AUDIT_FILTER_EXIT       0x04    /* Apply rule at syscall exit */
+#define AUDIT_FILTER_TYPE       0x05    /* Apply rule at audit_log_start */
 
-#define AUDIT_NR_FILTERS        5
+#define AUDIT_NR_FILTERS        6
 
 #define AUDIT_FILTER_PREPEND    0x10    /* Prepend to front of list */
 
@@ -98,6 +121,13 @@
 #define AUDIT_WORD(nr) ((__u32)((nr)/32))
 #define AUDIT_BIT(nr)  (1 << ((nr) - AUDIT_WORD(nr)*32))
 
+/* This bitmask is used to validate user input.  It represents all bits that
+ * are currently used in an audit field constant understood by the kernel.
+ * If you are adding a new #define AUDIT_<whatever>, please ensure that
+ * AUDIT_UNUSED_BITS is updated if need be. */
+#define AUDIT_UNUSED_BITS       0x0FFFFC00
+
+
 /* Rule fields */
                                 /* These are useful when checking the
                                  * task structure at task creation time
@@ -114,6 +144,7 @@
 #define AUDIT_LOGINUID  9
 #define AUDIT_PERS      10
 #define AUDIT_ARCH      11
+#define AUDIT_MSGTYPE   12
 
                                 /* These are ONLY useful when checking
                                  * at syscall exit time (AUDIT_AT_EXIT). */
@@ -128,8 +159,28 @@
 #define AUDIT_ARG2      (AUDIT_ARG0+2)
 #define AUDIT_ARG3      (AUDIT_ARG0+3)
 
-#define AUDIT_NEGATE    0x80000000
+#define AUDIT_NEGATE                    0x80000000
 
+/* These are the supported operators.
+ *      4  2  1
+ *      =  >  <
+ *      -------
+ *      0  0  0         0       nonsense
+ *      0  0  1         1       <
+ *      0  1  0         2       >
+ *      0  1  1         3       !=
+ *      1  0  0         4       =
+ *      1  0  1         5       <=
+ *      1  1  0         6       >=
+ *      1  1  1         7       all operators
+ */
+#define AUDIT_LESS_THAN                 0x10000000
+#define AUDIT_GREATER_THAN              0x20000000
+#define AUDIT_NOT_EQUAL                 0x30000000
+#define AUDIT_EQUAL                     0x40000000
+#define AUDIT_LESS_THAN_OR_EQUAL        (AUDIT_LESS_THAN|AUDIT_EQUAL)
+#define AUDIT_GREATER_THAN_OR_EQUAL     (AUDIT_GREATER_THAN|AUDIT_EQUAL)
+#define AUDIT_OPERATORS                 (AUDIT_EQUAL|AUDIT_NOT_EQUAL)
 
 /* Status symbols */
                                 /* Mask values */
@@ -186,6 +237,26 @@ struct audit_status {
         __u32           backlog;        /* messages waiting in queue */
 };
 
+/* audit_rule_data supports filter rules with both integer and string
+ * fields.  It corresponds with AUDIT_ADD_RULE, AUDIT_DEL_RULE and
+ * AUDIT_LIST_RULES requests.
+ */
+struct audit_rule_data {
+        __u32           flags;  /* AUDIT_PER_{TASK,CALL}, AUDIT_PREPEND */
+        __u32           action; /* AUDIT_NEVER, AUDIT_POSSIBLE, AUDIT_ALWAYS */
+        __u32           field_count;
+        __u32           mask[AUDIT_BITMASK_SIZE]; /* syscall(s) affected */
+        __u32           fields[AUDIT_MAX_FIELDS];
+        __u32           values[AUDIT_MAX_FIELDS];
+        __u32           fieldflags[AUDIT_MAX_FIELDS];
+        __u32           buflen; /* total length of string fields */
+        char            buf[0]; /* string fields buffer */
+};
+
+/* audit_rule is supported to maintain backward compatibility with
+ * userspace.  It supports integer fields only and corresponds to
+ * AUDIT_ADD, AUDIT_DEL and AUDIT_LIST requests.
+ */
 struct audit_rule {             /* for AUDIT_LIST, AUDIT_ADD, and AUDIT_DEL */
         __u32           flags;  /* AUDIT_PER_{TASK,CALL}, AUDIT_PREPEND */
         __u32           action; /* AUDIT_NEVER, AUDIT_POSSIBLE, AUDIT_ALWAYS */
@@ -222,22 +293,33 @@ extern void audit_syscall_entry(struct task_struct *task, int arch,
 extern void audit_syscall_exit(struct task_struct *task, int failed, long return_code);
 extern void audit_getname(const char *name);
 extern void audit_putname(const char *name);
-extern void audit_inode(const char *name, const struct inode *inode, unsigned flags);
+extern void __audit_inode(const char *name, const struct inode *inode, unsigned flags);
+extern void __audit_inode_child(const char *dname, const struct inode *inode,
+                                unsigned long pino);
+static inline void audit_inode(const char *name, const struct inode *inode,
+                               unsigned flags) {
+        if (unlikely(current->audit_context))
+                __audit_inode(name, inode, flags);
+}
+static inline void audit_inode_child(const char *dname, 
+                                     const struct inode *inode, 
+                                     unsigned long pino) {
+        if (unlikely(current->audit_context))
+                __audit_inode_child(dname, inode, pino);
+}
 
                                 /* Private API (for audit.c only) */
-extern int  audit_receive_filter(int type, int pid, int uid, int seq,
-                                 void *data, uid_t loginuid);
 extern unsigned int audit_serial(void);
 extern void auditsc_get_stamp(struct audit_context *ctx,
                               struct timespec *t, unsigned int *serial);
 extern int  audit_set_loginuid(struct task_struct *task, uid_t loginuid);
 extern uid_t audit_get_loginuid(struct audit_context *ctx);
-extern int audit_ipc_perms(unsigned long qbytes, uid_t uid, gid_t gid, mode_t mode);
+extern int audit_ipc_perms(unsigned long qbytes, uid_t uid, gid_t gid, mode_t mode, struct kern_ipc_perm *ipcp);
 extern int audit_socketcall(int nargs, unsigned long *args);
 extern int audit_sockaddr(int len, void *addr);
 extern int audit_avc_path(struct dentry *dentry, struct vfsmount *mnt);
 extern void audit_signal_info(int sig, struct task_struct *t);
-extern int audit_filter_user(struct netlink_skb_parms *cb, int type);
+extern int audit_set_macxattr(const char *name);
 #else
 #define audit_alloc(t) ({ 0; })
 #define audit_free(t) do { ; } while (0)
@@ -245,16 +327,18 @@ extern int audit_filter_user(struct netlink_skb_parms *cb, int type);
 #define audit_syscall_exit(t,f,r) do { ; } while (0)
 #define audit_getname(n) do { ; } while (0)
 #define audit_putname(n) do { ; } while (0)
+#define __audit_inode(n,i,f) do { ; } while (0)
+#define __audit_inode_child(d,i,p) do { ; } while (0)
 #define audit_inode(n,i,f) do { ; } while (0)
-#define audit_receive_filter(t,p,u,s,d,l) ({ -EOPNOTSUPP; })
+#define audit_inode_child(d,i,p) do { ; } while (0)
 #define auditsc_get_stamp(c,t,s) do { BUG(); } while (0)
 #define audit_get_loginuid(c) ({ -1; })
-#define audit_ipc_perms(q,u,g,m) ({ 0; })
+#define audit_ipc_perms(q,u,g,m,i) ({ 0; })
 #define audit_socketcall(n,a) ({ 0; })
 #define audit_sockaddr(len, addr) ({ 0; })
 #define audit_avc_path(dentry, mnt) ({ 0; })
 #define audit_signal_info(s,t) do { ; } while (0)
-#define audit_filter_user(cb,t) ({ 1; })
+#define audit_set_macxattr(n) do { ; } while (0)
 #endif
 
 #ifdef CONFIG_AUDIT
@@ -278,12 +362,11 @@ extern void		    audit_log_d_path(struct audit_buffer *ab,
                                              const char *prefix,
                                              struct dentry *dentry,
                                              struct vfsmount *vfsmnt);
-                                /* Private API (for auditsc.c only) */
-extern void                 audit_send_reply(int pid, int seq, int type,
-                                             int done, int multi,
-                                             void *payload, int size);
-extern void                 audit_log_lost(const char *message);
-extern struct semaphore audit_netlink_sem;
+                                /* Private API (for audit.c only) */
+extern int audit_filter_user(struct netlink_skb_parms *cb, int type);
+extern int audit_filter_type(int type);
+extern int  audit_receive_filter(int type, int pid, int uid, int seq,
+                                 void *data, size_t datasz, uid_t loginuid);
 #else
 #define audit_log(c,g,t,f,...) do { ; } while (0)
 #define audit_log_start(c,g,t) ({ NULL; })
@@ -293,6 +376,7 @@ extern struct semaphore audit_netlink_sem;
 #define audit_log_hex(a,b,l) do { ; } while (0)
 #define audit_log_untrustedstring(a,s) do { ; } while (0)
 #define audit_log_d_path(b,p,d,v) do { ; } while (0)
+#define audit_panic(m) do { ; } while (0)
 #endif
 #endif
 #endif
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 */
-#define autofs_ptype_expire_multi       2       /* Expire entry (umount request) */
+/* Daemon notification packet types */
+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/bitmap.h b/include/linux/bitmap.h
index 7d8ff97b3e92..d9ed27969855 100644
--- a/include/linux/bitmap.h
+++ b/include/linux/bitmap.h
@@ -46,6 +46,9 @@
  * bitmap_parse(ubuf, ulen, dst, nbits)         Parse bitmap dst from user buf
  * bitmap_scnlistprintf(buf, len, src, nbits)   Print bitmap src as list to buf
  * bitmap_parselist(buf, dst, nbits)            Parse bitmap dst from list
+ * bitmap_find_free_region(bitmap, bits, order) Find and allocate bit region
+ * bitmap_release_region(bitmap, pos, order)    Free specified bit region
+ * bitmap_allocate_region(bitmap, pos, order)   Allocate specified bit region
  */
 
 /*
diff --git a/include/linux/bitops.h b/include/linux/bitops.h
index 208650b1ad3a..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);
 }
 
 /*
@@ -175,4 +53,11 @@ static inline __u32 ror32(__u32 word, unsigned int shift)
         return (word >> shift) | (word << (32 - shift));
 }
 
+static inline unsigned fls_long(unsigned long l)
+{
+        if (sizeof(l) == 4)
+                return fls(l);
+        return fls64(l);
+}
+
 #endif
diff --git a/include/linux/blkdev.h b/include/linux/blkdev.h
index 56bb6a4e15f3..d0cac8b58de7 100644
--- a/include/linux/blkdev.h
+++ b/include/linux/blkdev.h
@@ -22,6 +22,7 @@ typedef struct request_queue request_queue_t;
 struct elevator_queue;
 typedef struct elevator_queue elevator_t;
 struct request_pm_state;
+struct blk_trace;
 
 #define BLKDEV_MIN_RQ   4
 #define BLKDEV_MAX_RQ   128     /* Default maximum */
@@ -54,25 +55,29 @@ struct as_io_context {
 
 struct cfq_queue;
 struct cfq_io_context {
-        /*
-         * circular list of cfq_io_contexts belonging to a process io context
-         */
-        struct list_head list;
-        struct cfq_queue *cfqq[2];
+        struct rb_node rb_node;
         void *key;
 
+        struct cfq_queue *cfqq[2];
+
         struct io_context *ioc;
 
         unsigned long last_end_request;
-        unsigned long last_queue;
+        sector_t last_request_pos;
+        unsigned long last_queue;
+
         unsigned long ttime_total;
         unsigned long ttime_samples;
         unsigned long ttime_mean;
 
+        unsigned int seek_samples;
+        u64 seek_total;
+        sector_t seek_mean;
+
         struct list_head queue_list;
 
-        void (*dtor)(struct cfq_io_context *);
-        void (*exit)(struct cfq_io_context *);
+        void (*dtor)(struct io_context *); /* destructor */
+        void (*exit)(struct io_context *); /* called on task exit */
 };
 
 /*
@@ -93,7 +98,7 @@ struct io_context {
         int nr_batch_requests;     /* Number of requests left in the batch */
 
         struct as_io_context *aic;
-        struct cfq_io_context *cic;
+        struct rb_root cic_root;
 };
 
 void put_io_context(struct io_context *ioc);
@@ -416,6 +421,8 @@ struct request_queue
         unsigned int            sg_reserved_size;
         int                     node;
 
+        struct blk_trace        *blk_trace;
+
         /*
          * reserved for flush operations
          */
diff --git a/include/linux/blktrace_api.h b/include/linux/blktrace_api.h
new file mode 100644
index 000000000000..b34d3e73d5ea
--- /dev/null
+++ b/include/linux/blktrace_api.h
@@ -0,0 +1,277 @@
+#ifndef BLKTRACE_H
+#define BLKTRACE_H
+
+#include <linux/config.h>
+#include <linux/blkdev.h>
+#include <linux/relay.h>
+
+/*
+ * Trace categories
+ */
+enum blktrace_cat {
+        BLK_TC_READ     = 1 << 0,       /* reads */
+        BLK_TC_WRITE    = 1 << 1,       /* writes */
+        BLK_TC_BARRIER  = 1 << 2,       /* barrier */
+        BLK_TC_SYNC     = 1 << 3,       /* barrier */
+        BLK_TC_QUEUE    = 1 << 4,       /* queueing/merging */
+        BLK_TC_REQUEUE  = 1 << 5,       /* requeueing */
+        BLK_TC_ISSUE    = 1 << 6,       /* issue */
+        BLK_TC_COMPLETE = 1 << 7,       /* completions */
+        BLK_TC_FS       = 1 << 8,       /* fs requests */
+        BLK_TC_PC       = 1 << 9,       /* pc requests */
+        BLK_TC_NOTIFY   = 1 << 10,      /* special message */
+
+        BLK_TC_END      = 1 << 15,      /* only 16-bits, reminder */
+};
+
+#define BLK_TC_SHIFT            (16)
+#define BLK_TC_ACT(act)         ((act) << BLK_TC_SHIFT)
+
+/*
+ * Basic trace actions
+ */
+enum blktrace_act {
+        __BLK_TA_QUEUE = 1,             /* queued */
+        __BLK_TA_BACKMERGE,             /* back merged to existing rq */
+        __BLK_TA_FRONTMERGE,            /* front merge to existing rq */
+        __BLK_TA_GETRQ,                 /* allocated new request */
+        __BLK_TA_SLEEPRQ,               /* sleeping on rq allocation */
+        __BLK_TA_REQUEUE,               /* request requeued */
+        __BLK_TA_ISSUE,                 /* sent to driver */
+        __BLK_TA_COMPLETE,              /* completed by driver */
+        __BLK_TA_PLUG,                  /* queue was plugged */
+        __BLK_TA_UNPLUG_IO,             /* queue was unplugged by io */
+        __BLK_TA_UNPLUG_TIMER,          /* queue was unplugged by timer */
+        __BLK_TA_INSERT,                /* insert request */
+        __BLK_TA_SPLIT,                 /* bio was split */
+        __BLK_TA_BOUNCE,                /* bio was bounced */
+        __BLK_TA_REMAP,                 /* bio was remapped */
+};
+
+/*
+ * Trace actions in full. Additionally, read or write is masked
+ */
+#define BLK_TA_QUEUE            (__BLK_TA_QUEUE | BLK_TC_ACT(BLK_TC_QUEUE))
+#define BLK_TA_BACKMERGE        (__BLK_TA_BACKMERGE | BLK_TC_ACT(BLK_TC_QUEUE))
+#define BLK_TA_FRONTMERGE       (__BLK_TA_FRONTMERGE | BLK_TC_ACT(BLK_TC_QUEUE))
+#define BLK_TA_GETRQ            (__BLK_TA_GETRQ | BLK_TC_ACT(BLK_TC_QUEUE))
+#define BLK_TA_SLEEPRQ          (__BLK_TA_SLEEPRQ | BLK_TC_ACT(BLK_TC_QUEUE))
+#define BLK_TA_REQUEUE          (__BLK_TA_REQUEUE | BLK_TC_ACT(BLK_TC_REQUEUE))
+#define BLK_TA_ISSUE            (__BLK_TA_ISSUE | BLK_TC_ACT(BLK_TC_ISSUE))
+#define BLK_TA_COMPLETE         (__BLK_TA_COMPLETE| BLK_TC_ACT(BLK_TC_COMPLETE))
+#define BLK_TA_PLUG             (__BLK_TA_PLUG | BLK_TC_ACT(BLK_TC_QUEUE))
+#define BLK_TA_UNPLUG_IO        (__BLK_TA_UNPLUG_IO | BLK_TC_ACT(BLK_TC_QUEUE))
+#define BLK_TA_UNPLUG_TIMER     (__BLK_TA_UNPLUG_TIMER | BLK_TC_ACT(BLK_TC_QUEUE))
+#define BLK_TA_INSERT           (__BLK_TA_INSERT | BLK_TC_ACT(BLK_TC_QUEUE))
+#define BLK_TA_SPLIT            (__BLK_TA_SPLIT)
+#define BLK_TA_BOUNCE           (__BLK_TA_BOUNCE)
+#define BLK_TA_REMAP            (__BLK_TA_REMAP | BLK_TC_ACT(BLK_TC_QUEUE))
+
+#define BLK_IO_TRACE_MAGIC      0x65617400
+#define BLK_IO_TRACE_VERSION    0x07
+
+/*
+ * The trace itself
+ */
+struct blk_io_trace {
+        u32 magic;              /* MAGIC << 8 | version */
+        u32 sequence;           /* event number */
+        u64 time;               /* in microseconds */
+        u64 sector;             /* disk offset */
+        u32 bytes;              /* transfer length */
+        u32 action;             /* what happened */
+        u32 pid;                /* who did it */
+        u32 device;             /* device number */
+        u32 cpu;                /* on what cpu did it happen */
+        u16 error;              /* completion error */
+        u16 pdu_len;            /* length of data after this trace */
+};
+
+/*
+ * The remap event
+ */
+struct blk_io_trace_remap {
+        u32 device;
+        u32 __pad;
+        u64 sector;
+};
+
+enum {
+        Blktrace_setup = 1,
+        Blktrace_running,
+        Blktrace_stopped,
+};
+
+struct blk_trace {
+        int trace_state;
+        struct rchan *rchan;
+        unsigned long *sequence;
+        u16 act_mask;
+        u64 start_lba;
+        u64 end_lba;
+        u32 pid;
+        u32 dev;
+        struct dentry *dir;
+        struct dentry *dropped_file;
+        atomic_t dropped;
+};
+
+/*
+ * User setup structure passed with BLKTRACESTART
+ */
+struct blk_user_trace_setup {
+        char name[BDEVNAME_SIZE];       /* output */
+        u16 act_mask;                   /* input */
+        u32 buf_size;                   /* input */
+        u32 buf_nr;                     /* input */
+        u64 start_lba;
+        u64 end_lba;
+        u32 pid;
+};
+
+#if defined(CONFIG_BLK_DEV_IO_TRACE)
+extern int blk_trace_ioctl(struct block_device *, unsigned, char __user *);
+extern void blk_trace_shutdown(request_queue_t *);
+extern void __blk_add_trace(struct blk_trace *, sector_t, int, int, u32, int, int, void *);
+
+/**
+ * blk_add_trace_rq - Add a trace for a request oriented action
+ * @q:          queue the io is for
+ * @rq:         the source request
+ * @what:       the action
+ *
+ * Description:
+ *     Records an action against a request. Will log the bio offset + size.
+ *
+ **/
+static inline void blk_add_trace_rq(struct request_queue *q, struct request *rq,
+                                    u32 what)
+{
+        struct blk_trace *bt = q->blk_trace;
+        int rw = rq->flags & 0x07;
+
+        if (likely(!bt))
+                return;
+
+        if (blk_pc_request(rq)) {
+                what |= BLK_TC_ACT(BLK_TC_PC);
+                __blk_add_trace(bt, 0, rq->data_len, rw, what, rq->errors, sizeof(rq->cmd), rq->cmd);
+        } else  {
+                what |= BLK_TC_ACT(BLK_TC_FS);
+                __blk_add_trace(bt, rq->hard_sector, rq->hard_nr_sectors << 9, rw, what, rq->errors, 0, NULL);
+        }
+}
+
+/**
+ * blk_add_trace_bio - Add a trace for a bio oriented action
+ * @q:          queue the io is for
+ * @bio:        the source bio
+ * @what:       the action
+ *
+ * Description:
+ *     Records an action against a bio. Will log the bio offset + size.
+ *
+ **/
+static inline void blk_add_trace_bio(struct request_queue *q, struct bio *bio,
+                                     u32 what)
+{
+        struct blk_trace *bt = q->blk_trace;
+
+        if (likely(!bt))
+                return;
+
+        __blk_add_trace(bt, bio->bi_sector, bio->bi_size, bio->bi_rw, what, !bio_flagged(bio, BIO_UPTODATE), 0, NULL);
+}
+
+/**
+ * blk_add_trace_generic - Add a trace for a generic action
+ * @q:          queue the io is for
+ * @bio:        the source bio
+ * @rw:         the data direction
+ * @what:       the action
+ *
+ * Description:
+ *     Records a simple trace
+ *
+ **/
+static inline void blk_add_trace_generic(struct request_queue *q,
+                                         struct bio *bio, int rw, u32 what)
+{
+        struct blk_trace *bt = q->blk_trace;
+
+        if (likely(!bt))
+                return;
+
+        if (bio)
+                blk_add_trace_bio(q, bio, what);
+        else
+                __blk_add_trace(bt, 0, 0, rw, what, 0, 0, NULL);
+}
+
+/**
+ * blk_add_trace_pdu_int - Add a trace for a bio with an integer payload
+ * @q:          queue the io is for
+ * @what:       the action
+ * @bio:        the source bio
+ * @pdu:        the integer payload
+ *
+ * Description:
+ *     Adds a trace with some integer payload. This might be an unplug
+ *     option given as the action, with the depth at unplug time given
+ *     as the payload
+ *
+ **/
+static inline void blk_add_trace_pdu_int(struct request_queue *q, u32 what,
+                                         struct bio *bio, unsigned int pdu)
+{
+        struct blk_trace *bt = q->blk_trace;
+        u64 rpdu = cpu_to_be64(pdu);
+
+        if (likely(!bt))
+                return;
+
+        if (bio)
+                __blk_add_trace(bt, bio->bi_sector, bio->bi_size, bio->bi_rw, what, !bio_flagged(bio, BIO_UPTODATE), sizeof(rpdu), &rpdu);
+        else
+                __blk_add_trace(bt, 0, 0, 0, what, 0, sizeof(rpdu), &rpdu);
+}
+
+/**
+ * blk_add_trace_remap - Add a trace for a remap operation
+ * @q:          queue the io is for
+ * @bio:        the source bio
+ * @dev:        target device
+ * @from:       source sector
+ * @to:         target sector
+ *
+ * Description:
+ *     Device mapper or raid target sometimes need to split a bio because
+ *     it spans a stripe (or similar). Add a trace for that action.
+ *
+ **/
+static inline void blk_add_trace_remap(struct request_queue *q, struct bio *bio,
+                                       dev_t dev, sector_t from, sector_t to)
+{
+        struct blk_trace *bt = q->blk_trace;
+        struct blk_io_trace_remap r;
+
+        if (likely(!bt))
+                return;
+
+        r.device = cpu_to_be32(dev);
+        r.sector = cpu_to_be64(to);
+
+        __blk_add_trace(bt, from, bio->bi_size, bio->bi_rw, BLK_TA_REMAP, !bio_flagged(bio, BIO_UPTODATE), sizeof(r), &r);
+}
+
+#else /* !CONFIG_BLK_DEV_IO_TRACE */
+#define blk_trace_ioctl(bdev, cmd, arg)         (-ENOTTY)
+#define blk_trace_shutdown(q)                   do { } while (0)
+#define blk_add_trace_rq(q, rq, what)           do { } while (0)
+#define blk_add_trace_bio(q, rq, what)          do { } while (0)
+#define blk_add_trace_generic(q, rq, rw, what)  do { } while (0)
+#define blk_add_trace_pdu_int(q, what, bio, pdu)        do { } while (0)
+#define blk_add_trace_remap(q, bio, dev, f, t)  do {} while (0)
+#endif /* CONFIG_BLK_DEV_IO_TRACE */
+
+#endif
diff --git a/include/linux/bootmem.h b/include/linux/bootmem.h
index 993da8cc9706..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);
@@ -51,6 +52,9 @@ extern void * __init __alloc_bootmem_low_node(pg_data_t *pgdat,
                                               unsigned long size,
                                               unsigned long align,
                                               unsigned long goal);
+extern void * __init __alloc_bootmem_core(struct bootmem_data *bdata,
+                unsigned long size, unsigned long align, unsigned long goal,
+                unsigned long limit);
 #ifndef CONFIG_HAVE_ARCH_BOOTMEM_NODE
 extern void __init reserve_bootmem (unsigned long addr, unsigned long size);
 #define alloc_bootmem(x) \
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
- * field (b_state) goes at the start so the compiler does not generate
- * indexed addressing for it.
+ * Historically, a buffer_head was used to map a single block
+ * within a page, and of course as the unit of I/O through the
+ * 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 */
-        char *b_data;                   /* pointer to data block */
+        sector_t b_blocknr;             /* start block number */
+        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);
-int do_invalidatepage(struct page *page, unsigned long offset);
+void block_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/cache.h b/include/linux/cache.h
index d22e632f41fb..cc4b3aafad9a 100644
--- a/include/linux/cache.h
+++ b/include/linux/cache.h
@@ -13,9 +13,7 @@
 #define SMP_CACHE_BYTES L1_CACHE_BYTES
 #endif
 
-#if defined(CONFIG_X86) || defined(CONFIG_SPARC64) || defined(CONFIG_IA64) || defined(CONFIG_PARISC)
-#define __read_mostly __attribute__((__section__(".data.read_mostly")))
-#else
+#ifndef __read_mostly
 #define __read_mostly
 #endif
 
diff --git a/include/linux/capability.h b/include/linux/capability.h
index 5a23ce752629..6548b35ab9f6 100644
--- a/include/linux/capability.h
+++ b/include/linux/capability.h
@@ -357,7 +357,8 @@ static inline kernel_cap_t cap_invert(kernel_cap_t c)
 
 #define cap_is_fs_cap(c)     (CAP_TO_MASK(c) & CAP_FS_MASK)
 
-extern int capable(int cap);
+int capable(int cap);
+int __capable(struct task_struct *t, int cap);
 
 #endif /* __KERNEL__ */
 
diff --git a/include/linux/cdev.h b/include/linux/cdev.h
index 8da37e29cb87..2216638962d2 100644
--- a/include/linux/cdev.h
+++ b/include/linux/cdev.h
@@ -5,13 +5,13 @@
 struct cdev {
         struct kobject kobj;
         struct module *owner;
-        struct file_operations *ops;
+        const struct file_operations *ops;
         struct list_head list;
         dev_t dev;
         unsigned int count;
 };
 
-void cdev_init(struct cdev *, struct file_operations *);
+void cdev_init(struct cdev *, const struct file_operations *);
 
 struct cdev *cdev_alloc(void);
 
diff --git a/include/linux/cdrom.h b/include/linux/cdrom.h
index b68fdf1f3156..3c9b0bc05123 100644
--- a/include/linux/cdrom.h
+++ b/include/linux/cdrom.h
@@ -378,7 +378,6 @@ struct cdrom_generic_command
 #define CDC_MEDIA_CHANGED       0x80    /* media changed */
 #define CDC_PLAY_AUDIO          0x100   /* audio functions */
 #define CDC_RESET               0x200   /* hard reset device */
-#define CDC_IOCTLS              0x400   /* driver has non-standard ioctls */
 #define CDC_DRIVE_STATUS        0x800   /* driver implements drive status */
 #define CDC_GENERIC_PACKET      0x1000  /* driver implements generic packets */
 #define CDC_CD_R                0x2000  /* drive is a CD-R */
@@ -974,9 +973,7 @@ struct cdrom_device_ops {
         int (*reset) (struct cdrom_device_info *);
         /* play stuff */
         int (*audio_ioctl) (struct cdrom_device_info *,unsigned int, void *);
-        /* dev-specific */
-        int (*dev_ioctl) (struct cdrom_device_info *,
-                          unsigned int, unsigned long);
+
 /* driver specifications */
         const int capability;   /* capability flags */
         int n_minors;           /* number of active minor devices */
diff --git a/include/linux/clk.h b/include/linux/clk.h
index 12848f81bb37..5ca8c6fddb56 100644
--- a/include/linux/clk.h
+++ b/include/linux/clk.h
@@ -8,8 +8,8 @@
  * it under the terms of the GNU General Public License version 2 as
  * published by the Free Software Foundation.
  */
-#ifndef ASMARM_CLOCK_H
-#define ASMARM_CLOCK_H
+#ifndef __LINUX_CLK_H
+#define __LINUX_CLK_H
 
 struct device;
 
diff --git a/include/linux/coda_linux.h b/include/linux/coda_linux.h
index cc621ec409d8..b3ecf8f71d97 100644
--- a/include/linux/coda_linux.h
+++ b/include/linux/coda_linux.h
@@ -30,9 +30,9 @@ extern struct inode_operations coda_ioctl_inode_operations;
 extern struct address_space_operations coda_file_aops;
 extern struct address_space_operations coda_symlink_aops;
 
-extern struct file_operations coda_dir_operations;
-extern struct file_operations coda_file_operations;
-extern struct file_operations coda_ioctl_operations;
+extern const struct file_operations coda_dir_operations;
+extern const struct file_operations coda_file_operations;
+extern const struct file_operations coda_ioctl_operations;
 
 /* operations shared over more than one file */
 int coda_open(struct inode *i, struct file *f);
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 ae7dfb790df3..89ab677cb993 100644
--- a/include/linux/compat_ioctl.h
+++ b/include/linux/compat_ioctl.h
@@ -97,6 +97,10 @@ COMPATIBLE_IOCTL(BLKRRPART)
 COMPATIBLE_IOCTL(BLKFLSBUF)
 COMPATIBLE_IOCTL(BLKSECTSET)
 COMPATIBLE_IOCTL(BLKSSZGET)
+COMPATIBLE_IOCTL(BLKTRACESTART)
+COMPATIBLE_IOCTL(BLKTRACESTOP)
+COMPATIBLE_IOCTL(BLKTRACESETUP)
+COMPATIBLE_IOCTL(BLKTRACETEARDOWN)
 ULONG_IOCTL(BLKRASET)
 ULONG_IOCTL(BLKFRASET)
 /* RAID */
@@ -136,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)
@@ -151,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/cpu.h b/include/linux/cpu.h
index d612b89dce33..08d50c53aab4 100644
--- a/include/linux/cpu.h
+++ b/include/linux/cpu.h
@@ -74,7 +74,6 @@ extern int lock_cpu_hotplug_interruptible(void);
         register_cpu_notifier(&fn##_nb);                        \
 }
 int cpu_down(unsigned int cpu);
-extern int __attribute__((weak)) smp_prepare_cpu(int cpu);
 #define cpu_is_offline(cpu) unlikely(!cpu_online(cpu))
 #else
 #define lock_cpu_hotplug()      do { } while (0)
diff --git a/include/linux/cpumask.h b/include/linux/cpumask.h
index 60e56c6e03dd..9cbb781d6f80 100644
--- a/include/linux/cpumask.h
+++ b/include/linux/cpumask.h
@@ -67,7 +67,7 @@
  *
  * int any_online_cpu(mask)             First online cpu in mask
  *
- * for_each_cpu(cpu)                    for-loop cpu over cpu_possible_map
+ * for_each_possible_cpu(cpu)           for-loop cpu over cpu_possible_map
  * for_each_online_cpu(cpu)             for-loop cpu over cpu_online_map
  * for_each_present_cpu(cpu)            for-loop cpu over cpu_present_map
  *
@@ -212,17 +212,15 @@ static inline void __cpus_shift_left(cpumask_t *dstp,
         bitmap_shift_left(dstp->bits, srcp->bits, n, nbits);
 }
 
-#define first_cpu(src) __first_cpu(&(src), NR_CPUS)
-static inline int __first_cpu(const cpumask_t *srcp, int nbits)
-{
-        return min_t(int, nbits, find_first_bit(srcp->bits, nbits));
-}
-
-#define next_cpu(n, src) __next_cpu((n), &(src), NR_CPUS)
-static inline int __next_cpu(int n, const cpumask_t *srcp, int nbits)
-{
-        return min_t(int, nbits, find_next_bit(srcp->bits, nbits, n+1));
-}
+#ifdef CONFIG_SMP
+int __first_cpu(const cpumask_t *srcp);
+#define first_cpu(src) __first_cpu(&(src))
+int __next_cpu(int n, const cpumask_t *srcp);
+#define next_cpu(n, src) __next_cpu((n), &(src))
+#else
+#define first_cpu(src)          0
+#define next_cpu(n, src)        1
+#endif
 
 #define cpumask_of_cpu(cpu)                                             \
 ({                                                                      \
@@ -398,27 +396,18 @@ extern cpumask_t cpu_present_map;
 #define cpu_present(cpu)        ((cpu) == 0)
 #endif
 
-#define any_online_cpu(mask)                    \
-({                                              \
-        int cpu;                                \
-        for_each_cpu_mask(cpu, (mask))          \
-                if (cpu_online(cpu))            \
-                        break;                  \
-        cpu;                                    \
-})
+#ifdef CONFIG_SMP
+int highest_possible_processor_id(void);
+#define any_online_cpu(mask) __any_online_cpu(&(mask))
+int __any_online_cpu(const cpumask_t *mask);
+#else
+#define highest_possible_processor_id() 0
+#define any_online_cpu(mask)            0
+#endif
 
-#define for_each_cpu(cpu)         for_each_cpu_mask((cpu), cpu_possible_map)
+#define for_each_cpu(cpu)  for_each_cpu_mask((cpu), cpu_possible_map)
+#define for_each_possible_cpu(cpu)  for_each_cpu_mask((cpu), cpu_possible_map)
 #define for_each_online_cpu(cpu)  for_each_cpu_mask((cpu), cpu_online_map)
 #define for_each_present_cpu(cpu) for_each_cpu_mask((cpu), cpu_present_map)
 
-/* Find the highest possible smp_processor_id() */
-#define highest_possible_processor_id() \
-({ \
-        unsigned int cpu, highest = 0; \
-        for_each_cpu_mask(cpu, cpu_possible_map) \
-                highest = cpu; \
-        highest; \
-})
-
-
 #endif /* __LINUX_CPUMASK_H */
diff --git a/include/linux/cpuset.h b/include/linux/cpuset.h
index 3bc606927116..9354722a9217 100644
--- a/include/linux/cpuset.h
+++ b/include/linux/cpuset.h
@@ -4,7 +4,7 @@
  *  cpuset interface
  *
  *  Copyright (C) 2003 BULL SA
- *  Copyright (C) 2004 Silicon Graphics, Inc.
+ *  Copyright (C) 2004-2006 Silicon Graphics, Inc.
  *
  */
 
@@ -51,6 +51,18 @@ extern char *cpuset_task_status_allowed(struct task_struct *task, char *buffer);
 extern void cpuset_lock(void);
 extern void cpuset_unlock(void);
 
+extern int cpuset_mem_spread_node(void);
+
+static inline int cpuset_do_page_mem_spread(void)
+{
+        return current->flags & PF_SPREAD_PAGE;
+}
+
+static inline int cpuset_do_slab_mem_spread(void)
+{
+        return current->flags & PF_SPREAD_SLAB;
+}
+
 #else /* !CONFIG_CPUSETS */
 
 static inline int cpuset_init_early(void) { return 0; }
@@ -99,6 +111,21 @@ static inline char *cpuset_task_status_allowed(struct task_struct *task,
 static inline void cpuset_lock(void) {}
 static inline void cpuset_unlock(void) {}
 
+static inline int cpuset_mem_spread_node(void)
+{
+        return 0;
+}
+
+static inline int cpuset_do_page_mem_spread(void)
+{
+        return 0;
+}
+
+static inline int cpuset_do_slab_mem_spread(void)
+{
+        return 0;
+}
+
 #endif /* !CONFIG_CPUSETS */
 
 #endif /* _LINUX_CPUSET_H */
diff --git a/include/linux/crash_dump.h b/include/linux/crash_dump.h
index 534d750d922d..32503657f14f 100644
--- a/include/linux/crash_dump.h
+++ b/include/linux/crash_dump.h
@@ -11,7 +11,7 @@
 extern unsigned long long elfcorehdr_addr;
 extern ssize_t copy_oldmem_page(unsigned long, char *, size_t,
                                                 unsigned long, int);
-extern struct file_operations proc_vmcore_operations;
+extern const struct file_operations proc_vmcore_operations;
 extern struct proc_dir_entry *proc_vmcore;
 
 #endif /* CONFIG_CRASH_DUMP */
diff --git a/include/linux/dcache.h b/include/linux/dcache.h
index 4361f3789975..d10bd30c337e 100644
--- a/include/linux/dcache.h
+++ b/include/linux/dcache.h
@@ -162,6 +162,8 @@ d_iput:		no		no		no       yes
 #define DCACHE_REFERENCED       0x0008  /* Recently used, don't discard. */
 #define DCACHE_UNHASHED         0x0010  
 
+#define DCACHE_INOTIFY_PARENT_WATCHED   0x0020 /* Parent inode is watched */
+
 extern spinlock_t dcache_lock;
 
 /**
diff --git a/include/linux/debugfs.h b/include/linux/debugfs.h
index 4b0428e335be..176e2d371577 100644
--- a/include/linux/debugfs.h
+++ b/include/linux/debugfs.h
@@ -29,7 +29,7 @@ struct debugfs_blob_wrapper {
 #if defined(CONFIG_DEBUG_FS)
 struct dentry *debugfs_create_file(const char *name, mode_t mode,
                                    struct dentry *parent, void *data,
-                                   struct file_operations *fops);
+                                   const struct file_operations *fops);
 
 struct dentry *debugfs_create_dir(const char *name, struct dentry *parent);
 
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/device.h b/include/linux/device.h
index 5b595fdfb672..f6e72a65a3f2 100644
--- a/include/linux/device.h
+++ b/include/linux/device.h
@@ -378,6 +378,7 @@ extern void device_bind_driver(struct device * dev);
 extern void device_release_driver(struct device * dev);
 extern int  device_attach(struct device * dev);
 extern void driver_attach(struct device_driver * drv);
+extern void device_reprobe(struct device *dev);
 
 
 /*
@@ -399,7 +400,7 @@ extern struct device * get_device(struct device * dev);
 extern void put_device(struct device * dev);
 
 
-/* drivers/base/power.c */
+/* drivers/base/power/shutdown.c */
 extern void device_shutdown(void);
 
 
diff --git a/include/linux/dio.h b/include/linux/dio.h
index fae9395fcf4f..1e65ebc2a3db 100644
--- a/include/linux/dio.h
+++ b/include/linux/dio.h
@@ -276,37 +276,5 @@ static inline void dio_set_drvdata (struct dio_dev *d, void *data)
         dev_set_drvdata(&d->dev, data);
 }
 
-/*
- * A helper function which helps ensure correct dio_driver
- * setup and cleanup for commonly-encountered hotplug/modular cases
- *
- * This MUST stay in a header, as it checks for -DMODULE
- */
-static inline int dio_module_init(struct dio_driver *drv)
-{
-        int rc = dio_register_driver(drv);
-
-        if (rc > 0)
-                return 0;
-
-        /* iff CONFIG_HOTPLUG and built into kernel, we should
-         * leave the driver around for future hotplug events.
-         * For the module case, a hotplug daemon of some sort
-         * should load a module in response to an insert event. */
-#if defined(CONFIG_HOTPLUG) && !defined(MODULE)
-        if (rc == 0)
-                return 0;
-#else
-        if (rc == 0)
-                rc = -ENODEV;
-#endif
-
-        /* if we get here, we need to clean up DIO driver instance
-         * and return some sort of error */
-        dio_unregister_driver(drv);
-
-        return rc;
-}
-
 #endif /* __KERNEL__ */
 #endif /* ndef _LINUX_DIO_H */
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/dma-mapping.h b/include/linux/dma-mapping.h
index 2d80cc761a15..9b4751aecc23 100644
--- a/include/linux/dma-mapping.h
+++ b/include/linux/dma-mapping.h
@@ -20,6 +20,8 @@ enum dma_data_direction {
 #define DMA_31BIT_MASK  0x000000007fffffffULL
 #define DMA_30BIT_MASK  0x000000003fffffffULL
 #define DMA_29BIT_MASK  0x000000001fffffffULL
+#define DMA_28BIT_MASK  0x000000000fffffffULL
+#define DMA_24BIT_MASK 0x0000000000ffffffULL
 
 #include <asm/dma-mapping.h>
 
diff --git a/include/linux/dmi.h b/include/linux/dmi.h
index 2e6bbe014157..64fd6c366604 100644
--- a/include/linux/dmi.h
+++ b/include/linux/dmi.h
@@ -68,6 +68,7 @@ extern char * dmi_get_system_info(int field);
 extern struct dmi_device * dmi_find_device(int type, const char *name,
         struct dmi_device *from);
 extern void dmi_scan_machine(void);
+extern int dmi_get_year(int field);
 
 #else
 
@@ -75,6 +76,7 @@ static inline int dmi_check_system(struct dmi_system_id *list) { return 0; }
 static inline char * dmi_get_system_info(int field) { return NULL; }
 static inline struct dmi_device * dmi_find_device(int type, const char *name,
         struct dmi_device *from) { return NULL; }
+static inline int dmi_get_year(int year) { return 0; }
 
 #endif
 
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 */
-        void *acpi;                     /* ACPI table  (IA64 ext 0.71) */
-        void *acpi20;                   /* ACPI table  (ACPI 2.0) */
-        void *smbios;                   /* SM BIOS table */
-        void *sal_systab;               /* SAL system table */
-        void *boot_info;                /* boot info table */
-        void *hcdp;                     /* HCDP table */
-        void *uga;                      /* UGA table */
+        unsigned long mps;              /* MPS table */
+        unsigned long acpi;             /* ACPI table  (IA64 ext 0.71) */
+        unsigned long acpi20;           /* ACPI table  (ACPI 2.0) */
+        unsigned long smbios;           /* SM BIOS table */
+        unsigned long sal_systab;       /* SAL system table */
+        unsigned long boot_info;        /* boot info table */
+        unsigned long hcdp;             /* HCDP 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/efs_fs.h b/include/linux/efs_fs.h
index 28f368c526fb..fbfa6b52e2fb 100644
--- a/include/linux/efs_fs.h
+++ b/include/linux/efs_fs.h
@@ -37,7 +37,7 @@ static inline struct efs_sb_info *SUPER_INFO(struct super_block *sb)
 struct statfs;
 
 extern struct inode_operations efs_dir_inode_operations;
-extern struct file_operations efs_dir_operations;
+extern const struct file_operations efs_dir_operations;
 extern struct address_space_operations efs_symlink_aops;
 
 extern void efs_read_inode(struct inode *);
diff --git a/include/linux/eventpoll.h b/include/linux/eventpoll.h
index 1289f0ec4c00..1e4bdfcf83a2 100644
--- a/include/linux/eventpoll.h
+++ b/include/linux/eventpoll.h
@@ -52,7 +52,12 @@ struct file;
 #ifdef CONFIG_EPOLL
 
 /* Used to initialize the epoll bits inside the "struct file" */
-void eventpoll_init_file(struct file *file);
+static inline void eventpoll_init_file(struct file *file)
+{
+        INIT_LIST_HEAD(&file->f_ep_links);
+        spin_lock_init(&file->f_ep_lock);
+}
+
 
 /* Used to release the epoll bits inside the "struct file" */
 void eventpoll_release_file(struct file *file);
@@ -85,7 +90,6 @@ static inline void eventpoll_release(struct file *file)
         eventpoll_release_file(file);
 }
 
-
 #else
 
 static inline void eventpoll_init_file(struct file *file) {}
diff --git a/include/linux/ext3_fs.h b/include/linux/ext3_fs.h
index c0272d73ab20..3ade6a4e3bdd 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 *,
@@ -772,9 +775,12 @@ extern unsigned long ext3_count_free (struct buffer_head *, unsigned);
 
 
 /* inode.c */
-extern int ext3_forget(handle_t *, int, struct inode *, struct buffer_head *, int);
-extern struct buffer_head * ext3_getblk (handle_t *, struct inode *, long, int, int *);
-extern struct buffer_head * ext3_bread (handle_t *, struct inode *, int, int, int *);
+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_blocks_handle(handle_t *handle, struct inode *inode,
+        sector_t iblock, unsigned long maxblocks, struct buffer_head *bh_result,
+        int create, int extend_disksize);
 
 extern void ext3_read_inode (struct inode *);
 extern int  ext3_write_inode (struct inode *, int);
@@ -827,11 +833,11 @@ do {								\
  */
 
 /* dir.c */
-extern struct file_operations ext3_dir_operations;
+extern const struct file_operations ext3_dir_operations;
 
 /* file.c */
 extern struct inode_operations ext3_file_inode_operations;
-extern struct file_operations ext3_file_operations;
+extern const struct file_operations ext3_file_operations;
 
 /* namei.c */
 extern struct inode_operations ext3_dir_inode_operations;
diff --git a/include/linux/ext3_fs_i.h b/include/linux/ext3_fs_i.h
index e71dd98dbcae..7abf90147180 100644
--- a/include/linux/ext3_fs_i.h
+++ b/include/linux/ext3_fs_i.h
@@ -19,6 +19,7 @@
 #include <linux/rwsem.h>
 #include <linux/rbtree.h>
 #include <linux/seqlock.h>
+#include <linux/mutex.h>
 
 struct ext3_reserve_window {
         __u32                   _rsv_start;     /* First byte reserved */
@@ -122,16 +123,16 @@ struct ext3_inode_info {
         __u16 i_extra_isize;
 
         /*
-         * truncate_sem is for serialising ext3_truncate() against
+         * truncate_mutex is for serialising ext3_truncate() against
          * ext3_getblock().  In the 2.4 ext2 design, great chunks of inode's
          * data tree are chopped off during truncate. We can't do that in
          * ext3 because whenever we perform intermediate commits during
          * truncate, the inode and all the metadata blocks *must* be in a
          * consistent state which allows truncation of the orphans to restart
          * during recovery.  Hence we must fix the get_block-vs-truncate race
-         * by other means, so we have truncate_sem.
+         * by other means, so we have truncate_mutex.
          */
-        struct semaphore truncate_sem;
+        struct mutex truncate_mutex;
         struct inode vfs_inode;
 };
 
diff --git a/include/linux/fadvise.h b/include/linux/fadvise.h
index e8e747139b9a..b2913bba35d8 100644
--- a/include/linux/fadvise.h
+++ b/include/linux/fadvise.h
@@ -18,4 +18,10 @@
 #define POSIX_FADV_NOREUSE      5 /* Data will be accessed once.  */
 #endif
 
+/*
+ * Linux-specific fadvise() extensions:
+ */
+#define LINUX_FADV_ASYNC_WRITE  32      /* Start writeout on range */
+#define LINUX_FADV_WRITE_WAIT   33      /* Wait upon writeout to range */
+
 #endif  /* FADVISE_H_INCLUDED */
diff --git a/include/linux/fb.h b/include/linux/fb.h
index 2cb19e6503aa..d03fadfcafe3 100644
--- a/include/linux/fb.h
+++ b/include/linux/fb.h
@@ -734,7 +734,7 @@ struct fb_tile_ops {
 
 /* A driver may set this flag to indicate that it does want a set_par to be
  * called every time when fbcon_switch is executed. The advantage is that with
- * this flag set you can really be shure that set_par is always called before
+ * this flag set you can really be sure that set_par is always called before
  * any of the functions dependant on the correct hardware state or altering
  * that state, even if you are using some broken X releases. The disadvantage
  * is that it introduces unwanted delays to every console switch if set_par
diff --git a/include/linux/file.h b/include/linux/file.h
index 9901b850f2e4..9f7c2513866f 100644
--- a/include/linux/file.h
+++ b/include/linux/file.h
@@ -10,6 +10,7 @@
 #include <linux/compiler.h>
 #include <linux/spinlock.h>
 #include <linux/rcupdate.h>
+#include <linux/types.h>
 
 /*
  * The default fd array needs to be at least BITS_PER_LONG,
@@ -17,10 +18,22 @@
  */
 #define NR_OPEN_DEFAULT BITS_PER_LONG
 
+/*
+ * The embedded_fd_set is a small fd_set,
+ * suitable for most tasks (which open <= BITS_PER_LONG files)
+ */
+struct embedded_fd_set {
+        unsigned long fds_bits[1];
+};
+
+/*
+ * More than this number of fds: we use a separately allocated fd_set
+ */
+#define EMBEDDED_FD_SET_SIZE (BITS_PER_BYTE * sizeof(struct embedded_fd_set))
+
 struct fdtable {
         unsigned int max_fds;
         int max_fdset;
-        int next_fd;
         struct file ** fd;      /* current fd array */
         fd_set *close_on_exec;
         fd_set *open_fds;
@@ -33,13 +46,20 @@ struct fdtable {
  * Open file table structure
  */
 struct files_struct {
+  /*
+   * read mostly part
+   */
         atomic_t count;
         struct fdtable *fdt;
         struct fdtable fdtab;
-        fd_set close_on_exec_init;
-        fd_set open_fds_init;
+  /*
+   * written part on a separate cache line in SMP
+   */
+        spinlock_t file_lock ____cacheline_aligned_in_smp;
+        int next_fd;
+        struct embedded_fd_set close_on_exec_init;
+        struct embedded_fd_set open_fds_init;
         struct file * fd_array[NR_OPEN_DEFAULT];
-        spinlock_t file_lock;     /* Protects concurrent writers.  Nests inside tsk->alloc_lock */
 };
 
 #define files_fdtable(files) (rcu_dereference((files)->fdt))
diff --git a/include/linux/fs.h b/include/linux/fs.h
index 128d0082522c..408fe89498f4 100644
--- a/include/linux/fs.h
+++ b/include/linux/fs.h
@@ -65,6 +65,11 @@ extern int dir_notify_enable;
 #define FMODE_PREAD     8
 #define FMODE_PWRITE    FMODE_PREAD     /* These go hand in hand */
 
+/* File is being opened for execution. Primary users of this flag are
+   distributed filesystems that can use it to achieve correct ETXTBUSY
+   behavior for cross-node execution/opening_for_writing of files */
+#define FMODE_EXEC      16
+
 #define RW_MASK         1
 #define RWA_MASK        2
 #define READ 0
@@ -103,7 +108,9 @@ extern int dir_notify_enable;
 #define MS_BIND         4096
 #define MS_MOVE         8192
 #define MS_REC          16384
-#define MS_VERBOSE      32768
+#define MS_VERBOSE      32768   /* War is peace. Verbosity is silence.
+                                   MS_VERBOSE is deprecated. */
+#define MS_SILENT       32768
 #define MS_POSIXACL     (1<<16) /* VFS does not apply the umask */
 #define MS_UNBINDABLE   (1<<17) /* change to unbindable */
 #define MS_PRIVATE      (1<<18) /* change to private */
@@ -197,6 +204,10 @@ extern int dir_notify_enable;
 #define BLKBSZGET  _IOR(0x12,112,size_t)
 #define BLKBSZSET  _IOW(0x12,113,size_t)
 #define BLKGETSIZE64 _IOR(0x12,114,size_t)      /* return device size in bytes (u64 *arg) */
+#define BLKTRACESETUP _IOWR(0x12,115,struct blk_user_trace_setup)
+#define BLKTRACESTART _IO(0x12,116)
+#define BLKTRACESTOP _IO(0x12,117)
+#define BLKTRACETEARDOWN _IO(0x12,118)
 
 #define BMAP_IOCTL 1            /* obsolete - kept for compatibility */
 #define FIBMAP     _IO(0x00,1)  /* bmap access */
@@ -241,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);
 
@@ -339,12 +347,12 @@ 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 *);
 
-        /* Set a page dirty */
+        /* Set a page dirty.  Return true if this dirtied it */
         int (*set_page_dirty)(struct page *page);
 
         int (*readpages)(struct file *filp, struct address_space *mapping,
@@ -358,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);
@@ -397,11 +405,14 @@ struct block_device {
         dev_t                   bd_dev;  /* not a kdev_t - it's a search key */
         struct inode *          bd_inode;       /* will die */
         int                     bd_openers;
-        struct semaphore        bd_sem; /* open/close mutex */
-        struct semaphore        bd_mount_sem;   /* mount mutex */
+        struct mutex            bd_mutex;       /* open/close mutex */
+        struct mutex            bd_mount_mutex; /* mount mutex */
         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;
@@ -479,13 +490,13 @@ 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;
         struct rw_semaphore     i_alloc_sem;
         struct inode_operations *i_op;
-        struct file_operations  *i_fop; /* former ->i_op->default_file_ops */
+        const struct file_operations    *i_fop; /* former ->i_op->default_file_ops */
         struct super_block      *i_sb;
         struct file_lock        *i_flock;
         struct address_space    *i_mapping;
@@ -509,7 +520,7 @@ struct inode {
 
 #ifdef CONFIG_INOTIFY
         struct list_head        inotify_watches; /* watches on this inode */
-        struct semaphore        inotify_sem;    /* protects the watches list */
+        struct mutex            inotify_mutex;  /* protects the watches list */
 #endif
 
         unsigned long           i_state;
@@ -625,7 +636,7 @@ struct file {
         } f_u;
         struct dentry           *f_dentry;
         struct vfsmount         *f_vfsmnt;
-        struct file_operations  *f_op;
+        const struct file_operations    *f_op;
         atomic_t                f_count;
         unsigned int            f_flags;
         mode_t                  f_mode;
@@ -667,7 +678,6 @@ extern spinlock_t files_lock;
 #define FL_POSIX        1
 #define FL_FLOCK        2
 #define FL_ACCESS       8       /* not trying to lock, just looking */
-#define FL_LOCKD        16      /* lock held by rpc.lockd */
 #define FL_LEASE        32      /* lease held on this file */
 #define FL_SLEEP        128     /* A blocking lock */
 
@@ -731,8 +741,6 @@ struct file_lock {
 #define OFFT_OFFSET_MAX INT_LIMIT(off_t)
 #endif
 
-extern struct list_head file_lock_list;
-
 #include <linux/fcntl.h>
 
 extern int fcntl_getlk(struct file *, struct flock __user *);
@@ -754,10 +762,10 @@ extern void locks_init_lock(struct file_lock *);
 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 struct file_lock *posix_test_lock(struct file *, struct file_lock *);
+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 void posix_block_lock(struct file_lock *, struct file_lock *);
 extern int posix_unblock_lock(struct file *, struct file_lock *);
 extern int posix_locks_deadlock(struct file_lock *, struct file_lock *);
 extern int flock_lock_file_wait(struct file *filp, struct file_lock *fl);
@@ -847,7 +855,7 @@ struct super_block {
          * The next field is for VFS *only*. No filesystems have any business
          * even looking at it. You had been warned.
          */
-        struct semaphore s_vfs_rename_sem;      /* Kludge */
+        struct mutex s_vfs_rename_mutex;        /* Kludge */
 
         /* Granuality of c/m/atime in ns.
            Cannot be worse than a second */
@@ -1086,6 +1094,7 @@ struct super_operations {
         void (*umount_begin) (struct super_block *);
 
         int (*show_options)(struct seq_file *, struct vfsmount *);
+        int (*show_stats)(struct seq_file *, struct vfsmount *);
 
         ssize_t (*quota_read)(struct super_block *, int, char *, size_t, loff_t);
         ssize_t (*quota_write)(struct super_block *, int, const char *, size_t, loff_t);
@@ -1115,6 +1124,18 @@ static inline void mark_inode_dirty_sync(struct inode *inode)
         __mark_inode_dirty(inode, I_DIRTY_SYNC);
 }
 
+static inline void inode_inc_link_count(struct inode *inode)
+{
+        inode->i_nlink++;
+        mark_inode_dirty(inode);
+}
+
+static inline void inode_dec_link_count(struct inode *inode)
+{
+        inode->i_nlink--;
+        mark_inode_dirty(inode);
+}
+
 extern void touch_atime(struct vfsmount *mnt, struct dentry *dentry);
 static inline void file_accessed(struct file *file)
 {
@@ -1369,11 +1390,11 @@ extern void bd_set_size(struct block_device *, loff_t size);
 extern void bd_forget(struct inode *inode);
 extern void bdput(struct block_device *);
 extern struct block_device *open_by_devnum(dev_t, unsigned);
-extern struct file_operations def_blk_fops;
+extern const struct file_operations def_blk_fops;
 extern struct address_space_operations def_blk_aops;
-extern struct file_operations def_chr_fops;
-extern struct file_operations bad_sock_fops;
-extern struct file_operations def_fifo_fops;
+extern const struct file_operations def_chr_fops;
+extern const struct file_operations bad_sock_fops;
+extern const struct file_operations def_fifo_fops;
 extern int ioctl_by_bdev(struct block_device *, unsigned, unsigned long);
 extern int blkdev_ioctl(struct inode *, struct file *, unsigned, unsigned long);
 extern long compat_blkdev_ioctl(struct file *, unsigned, unsigned long);
@@ -1381,12 +1402,19 @@ 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 *);
 extern int register_chrdev_region(dev_t, unsigned, const char *);
 extern int register_chrdev(unsigned int, const char *,
-                           struct file_operations *);
+                           const struct file_operations *);
 extern int unregister_chrdev(unsigned int, const char *);
 extern void unregister_chrdev_region(dev_t, unsigned);
 extern int chrdev_open(struct inode *, struct file *);
@@ -1416,9 +1444,9 @@ extern void init_special_inode(struct inode *, umode_t, dev_t);
 extern void make_bad_inode(struct inode *);
 extern int is_bad_inode(struct inode *);
 
-extern struct file_operations read_fifo_fops;
-extern struct file_operations write_fifo_fops;
-extern struct file_operations rdwr_fifo_fops;
+extern const struct file_operations read_fifo_fops;
+extern const struct file_operations write_fifo_fops;
+extern const struct file_operations rdwr_fifo_fops;
 
 extern int fs_may_remount_ro(struct super_block *);
 
@@ -1455,6 +1483,12 @@ extern int filemap_fdatawait(struct address_space *);
 extern int filemap_write_and_wait(struct address_space *mapping);
 extern int filemap_write_and_wait_range(struct address_space *mapping,
                                         loff_t lstart, loff_t lend);
+extern int wait_on_page_writeback_range(struct address_space *mapping,
+                                pgoff_t start, pgoff_t end);
+extern int __filemap_fdatawrite_range(struct address_space *mapping,
+                                loff_t start, loff_t end, int sync_mode);
+
+extern long do_fsync(struct file *file, int datasync);
 extern void sync_supers(void);
 extern void sync_filesystems(int wait);
 extern void emergency_sync(void);
@@ -1534,7 +1568,6 @@ extern void destroy_inode(struct inode *);
 extern struct inode *new_inode(struct super_block *);
 extern int remove_suid(struct dentry *);
 extern void remove_dquot_ref(struct super_block *, int, struct list_head *);
-extern struct semaphore iprune_sem;
 
 extern void __insert_inode_hash(struct inode *, unsigned long hashval);
 extern void remove_inode_hash(struct inode *);
@@ -1619,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 {
@@ -1630,32 +1663,32 @@ 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;
+extern const struct file_operations generic_ro_fops;
 
 #define special_file(m) (S_ISCHR(m)||S_ISBLK(m)||S_ISFIFO(m)||S_ISSOCK(m))
 
@@ -1711,9 +1744,9 @@ extern int simple_commit_write(struct file *file, struct page *page,
 
 extern struct dentry *simple_lookup(struct inode *, struct dentry *, struct nameidata *);
 extern ssize_t generic_read_dir(struct file *, char __user *, size_t, loff_t *);
-extern struct file_operations simple_dir_operations;
+extern const struct file_operations simple_dir_operations;
 extern struct inode_operations simple_dir_inode_operations;
-struct tree_descr { char *name; struct file_operations *ops; int mode; };
+struct tree_descr { char *name; const struct file_operations *ops; int mode; };
 struct dentry *d_alloc_name(struct dentry *, const char *);
 extern int simple_fill_super(struct super_block *, int, struct tree_descr *);
 extern int simple_pin_fs(char *name, struct vfsmount **mount, int *count);
diff --git a/include/linux/fsnotify.h b/include/linux/fsnotify.h
index 03b8e7932b83..11438eff4d44 100644
--- a/include/linux/fsnotify.h
+++ b/include/linux/fsnotify.h
@@ -15,6 +15,26 @@
 
 #include <linux/dnotify.h>
 #include <linux/inotify.h>
+#include <linux/audit.h>
+
+/*
+ * fsnotify_d_instantiate - instantiate a dentry for inode
+ * Called with dcache_lock held.
+ */
+static inline void fsnotify_d_instantiate(struct dentry *entry,
+                                                struct inode *inode)
+{
+        inotify_d_instantiate(entry, inode);
+}
+
+/*
+ * fsnotify_d_move - entry has been moved
+ * Called with dcache_lock and entry->d_lock held.
+ */
+static inline void fsnotify_d_move(struct dentry *entry)
+{
+        inotify_d_move(entry);
+}
 
 /*
  * fsnotify_move - file old_name at old_dir was moved to new_name at new_dir
@@ -45,6 +65,8 @@ static inline void fsnotify_move(struct inode *old_dir, struct inode *new_dir,
         if (source) {
                 inotify_inode_queue_event(source, IN_MOVE_SELF, 0, NULL);
         }
+        audit_inode_child(old_name, source, old_dir->i_ino);
+        audit_inode_child(new_name, target, new_dir->i_ino);
 }
 
 /*
@@ -70,19 +92,22 @@ static inline void fsnotify_inoderemove(struct inode *inode)
 /*
  * fsnotify_create - 'name' was linked in
  */
-static inline void fsnotify_create(struct inode *inode, const char *name)
+static inline void fsnotify_create(struct inode *inode, struct dentry *dentry)
 {
         inode_dir_notify(inode, DN_CREATE);
-        inotify_inode_queue_event(inode, IN_CREATE, 0, name);
+        inotify_inode_queue_event(inode, IN_CREATE, 0, dentry->d_name.name);
+        audit_inode_child(dentry->d_name.name, dentry->d_inode, inode->i_ino);
 }
 
 /*
  * fsnotify_mkdir - directory 'name' was created
  */
-static inline void fsnotify_mkdir(struct inode *inode, const char *name)
+static inline void fsnotify_mkdir(struct inode *inode, struct dentry *dentry)
 {
         inode_dir_notify(inode, DN_CREATE);
-        inotify_inode_queue_event(inode, IN_CREATE | IN_ISDIR, 0, name);
+        inotify_inode_queue_event(inode, IN_CREATE | IN_ISDIR, 0, 
+                                  dentry->d_name.name);
+        audit_inode_child(dentry->d_name.name, dentry->d_inode, inode->i_ino);
 }
 
 /*
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/generic_serial.h b/include/linux/generic_serial.h
index 0abe9d9a0069..652611a4bdcd 100644
--- a/include/linux/generic_serial.h
+++ b/include/linux/generic_serial.h
@@ -12,6 +12,8 @@
 #ifndef GENERIC_SERIAL_H
 #define GENERIC_SERIAL_H
 
+#include <linux/mutex.h>
+
 struct real_driver {
   void                    (*disable_tx_interrupts) (void *);
   void                    (*enable_tx_interrupts) (void *);
@@ -34,7 +36,7 @@ struct gs_port {
   int                     xmit_head;
   int                     xmit_tail;
   int                     xmit_cnt;
-  struct semaphore        port_write_sem;
+  struct mutex            port_write_mutex;
   int                     flags;
   wait_queue_head_t       open_wait;
   wait_queue_head_t       close_wait;
diff --git a/include/linux/genhd.h b/include/linux/genhd.h
index eef5ccdcd731..10a27f29d692 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 ios[2];
-        unsigned merges[2];
-        unsigned ticks[2];
-        unsigned io_ticks;
-        unsigned time_in_queue;
+        unsigned long sectors[2];       /* READs and WRITEs */
+        unsigned long ios[2];
+        unsigned long merges[2];
+        unsigned long ticks[2];
+        unsigned long io_ticks;
+        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;
@@ -149,22 +152,16 @@ struct disk_attribute {
 ({                                                                      \
         typeof(gendiskp->dkstats->field) res = 0;                       \
         int i;                                                          \
-        for (i=0; i < NR_CPUS; i++) {                                   \
-                if (!cpu_possible(i))                                   \
-                        continue;                                       \
+        for_each_possible_cpu(i)                                        \
                 res += per_cpu_ptr(gendiskp->dkstats, i)->field;        \
-        }                                                               \
         res;                                                            \
 })
 
 static inline void disk_stat_set_all(struct gendisk *gendiskp, int value)       {
         int i;
-        for (i=0; i < NR_CPUS; i++) {
-                if (cpu_possible(i)) {
-                        memset(per_cpu_ptr(gendiskp->dkstats, i), value,        
-                                        sizeof (struct disk_stats));
-                }
-        }
+        for_each_possible_cpu(i)
+                memset(per_cpu_ptr(gendiskp->dkstats, i), value,
+                                sizeof (struct disk_stats));
 }               
                                 
 #else
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,
 };
 
-/*
- * 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 */
-};
+#define HRTIMER_INACTIVE        ((void *)1UL)
 
 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)(void *);
-        void                    *data;
+        int                     (*function)(struct hrtimer *);
         struct hrtimer_base     *base;
 };
 
 /**
  * struct hrtimer_base - the timer base for a specific clock
  *
- * @index:      clock type index for per_cpu support when moving a timer
- *              to a base on another cpu.
- * @lock:       lock protecting the base and associated timers
- * @active:     red black tree root node for the active timers
- * @first:      pointer to the timer node which expires first
- * @resolution: the resolution of the clock, in nanoseconds
- * @get_time:   function to retrieve the current time of the clock
- * @curr_timer: the timer which is executing a callback right now
+ * @index:              clock type index for per_cpu support when moving a timer
+ *                      to a base on another cpu.
+ * @lock:               lock protecting the base and associated timers
+ * @active:             red black tree root node for the active timers
+ * @first:              pointer to the timer node which expires first
+ * @resolution:         the resolution of the clock, in nanoseconds
+ * @get_time:           function to retrieve the current time of the clock
+ * @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/hugetlb.h b/include/linux/hugetlb.h
index 68d82ad6b17c..4c5e610fe442 100644
--- a/include/linux/hugetlb.h
+++ b/include/linux/hugetlb.h
@@ -20,10 +20,7 @@ void unmap_hugepage_range(struct vm_area_struct *, unsigned long, unsigned long)
 int hugetlb_prefault(struct address_space *, struct vm_area_struct *);
 int hugetlb_report_meminfo(char *);
 int hugetlb_report_node_meminfo(int, char *);
-int is_hugepage_mem_enough(size_t);
 unsigned long hugetlb_total_pages(void);
-struct page *alloc_huge_page(struct vm_area_struct *, unsigned long);
-void free_huge_page(struct page *);
 int hugetlb_fault(struct mm_struct *mm, struct vm_area_struct *vma,
                         unsigned long address, int write_access);
 
@@ -39,18 +36,35 @@ struct page *follow_huge_addr(struct mm_struct *mm, unsigned long address,
                               int write);
 struct page *follow_huge_pmd(struct mm_struct *mm, unsigned long address,
                                 pmd_t *pmd, int write);
-int is_aligned_hugepage_range(unsigned long addr, unsigned long len);
 int pmd_huge(pmd_t pmd);
+void hugetlb_change_protection(struct vm_area_struct *vma,
+                unsigned long address, unsigned long end, pgprot_t newprot);
 
 #ifndef ARCH_HAS_HUGEPAGE_ONLY_RANGE
 #define is_hugepage_only_range(mm, addr, len)   0
-#define hugetlb_free_pgd_range(tlb, addr, end, floor, ceiling) \
-                                                do { } while (0)
+#endif
+
+#ifndef ARCH_HAS_HUGETLB_FREE_PGD_RANGE
+#define hugetlb_free_pgd_range  free_pgd_range
+#else
+void hugetlb_free_pgd_range(struct mmu_gather **tlb, unsigned long addr,
+                            unsigned long end, unsigned long floor,
+                            unsigned long ceiling);
 #endif
 
 #ifndef ARCH_HAS_PREPARE_HUGEPAGE_RANGE
-#define prepare_hugepage_range(addr, len)       \
-        is_aligned_hugepage_range(addr, len)
+/*
+ * If the arch doesn't supply something else, assume that hugepage
+ * size aligned regions are ok without further preparation.
+ */
+static inline int prepare_hugepage_range(unsigned long addr, unsigned long len)
+{
+        if (len & ~HPAGE_MASK)
+                return -EINVAL;
+        if (addr & ~HPAGE_MASK)
+                return -EINVAL;
+        return 0;
+}
 #else
 int prepare_hugepage_range(unsigned long addr, unsigned long len);
 #endif
@@ -87,20 +101,17 @@ static inline unsigned long hugetlb_total_pages(void)
 #define copy_hugetlb_page_range(src, dst, vma)  ({ BUG(); 0; })
 #define hugetlb_prefault(mapping, vma)          ({ BUG(); 0; })
 #define unmap_hugepage_range(vma, start, end)   BUG()
-#define is_hugepage_mem_enough(size)            0
 #define hugetlb_report_meminfo(buf)             0
 #define hugetlb_report_node_meminfo(n, buf)     0
 #define follow_huge_pmd(mm, addr, pmd, write)   NULL
-#define is_aligned_hugepage_range(addr, len)    0
 #define prepare_hugepage_range(addr, len)       (-EINVAL)
 #define pmd_huge(x)     0
 #define is_hugepage_only_range(mm, addr, len)   0
-#define hugetlb_free_pgd_range(tlb, addr, end, floor, ceiling) \
-                                                do { } while (0)
-#define alloc_huge_page(vma, addr)              ({ NULL; })
-#define free_huge_page(p)                       ({ (void)(p); BUG(); })
+#define hugetlb_free_pgd_range(tlb, addr, end, floor, ceiling) ({BUG(); 0; })
 #define hugetlb_fault(mm, vma, addr, write)     ({ BUG(); 0; })
 
+#define hugetlb_change_protection(vma, address, end, newprot)
+
 #ifndef HPAGE_MASK
 #define HPAGE_MASK      PAGE_MASK               /* Keep the compiler happy */
 #define HPAGE_SIZE      PAGE_SIZE
@@ -128,6 +139,8 @@ struct hugetlbfs_sb_info {
 
 struct hugetlbfs_inode_info {
         struct shared_policy policy;
+        /* Protected by the (global) hugetlb_lock */
+        unsigned long prereserved_hpages;
         struct inode vfs_inode;
 };
 
@@ -141,9 +154,13 @@ static inline struct hugetlbfs_sb_info *HUGETLBFS_SB(struct super_block *sb)
         return sb->s_fs_info;
 }
 
-extern struct file_operations hugetlbfs_file_operations;
+extern const struct file_operations hugetlbfs_file_operations;
 extern struct vm_operations_struct hugetlb_vm_ops;
 struct file *hugetlb_zero_setup(size_t);
+int hugetlb_extend_reservation(struct hugetlbfs_inode_info *info,
+                               unsigned long atleast_hpages);
+void hugetlb_truncate_reservation(struct hugetlbfs_inode_info *info,
+                                  unsigned long atmost_hpages);
 int hugetlb_get_quota(struct address_space *mapping);
 void hugetlb_put_quota(struct address_space *mapping);
 
diff --git a/include/linux/hwmon-sysfs.h b/include/linux/hwmon-sysfs.h
index 7eb4004b3601..a90c09d331c1 100644
--- a/include/linux/hwmon-sysfs.h
+++ b/include/linux/hwmon-sysfs.h
@@ -27,11 +27,13 @@ struct sensor_device_attribute{
 #define to_sensor_dev_attr(_dev_attr) \
         container_of(_dev_attr, struct sensor_device_attribute, dev_attr)
 
-#define SENSOR_DEVICE_ATTR(_name,_mode,_show,_store,_index)     \
-struct sensor_device_attribute sensor_dev_attr_##_name = {      \
-        .dev_attr =     __ATTR(_name,_mode,_show,_store),       \
-        .index =        _index,                                 \
-}
+#define SENSOR_ATTR(_name, _mode, _show, _store, _index)        \
+        { .dev_attr = __ATTR(_name, _mode, _show, _store),      \
+          .index = _index }
+
+#define SENSOR_DEVICE_ATTR(_name, _mode, _show, _store, _index) \
+struct sensor_device_attribute sensor_dev_attr_##_name          \
+        = SENSOR_ATTR(_name, _mode, _show, _store, _index)
 
 struct sensor_device_attribute_2 {
         struct device_attribute dev_attr;
@@ -41,11 +43,13 @@ struct sensor_device_attribute_2 {
 #define to_sensor_dev_attr_2(_dev_attr) \
         container_of(_dev_attr, struct sensor_device_attribute_2, dev_attr)
 
+#define SENSOR_ATTR_2(_name, _mode, _show, _store, _nr, _index) \
+        { .dev_attr = __ATTR(_name, _mode, _show, _store),      \
+          .index = _index,                                      \
+          .nr = _nr }
+
 #define SENSOR_DEVICE_ATTR_2(_name,_mode,_show,_store,_nr,_index)       \
-struct sensor_device_attribute_2 sensor_dev_attr_##_name = {    \
-        .dev_attr =     __ATTR(_name,_mode,_show,_store),       \
-        .index =        _index,                                 \
-        .nr =           _nr,                                    \
-}
+struct sensor_device_attribute_2 sensor_dev_attr_##_name                \
+        = SENSOR_ATTR_2(_name, _mode, _show, _store, _nr, _index)
 
 #endif /* _LINUX_HWMON_SYSFS_H */
diff --git a/include/linux/i2c-id.h b/include/linux/i2c-id.h
index 474c8f4f5d4f..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              */
@@ -172,7 +176,6 @@
 #define I2C_HW_B_RIVA           0x010010 /* Riva based graphics cards */
 #define I2C_HW_B_IOC            0x010011 /* IOC bit-wiggling */
 #define I2C_HW_B_TSUNA          0x010012 /* DEC Tsunami chipset */
-#define I2C_HW_B_FRODO          0x010013 /* 2d3D SA-1110 Development Board */
 #define I2C_HW_B_OMAHA          0x010014 /* Omaha I2C interface (ARM) */
 #define I2C_HW_B_GUIDE          0x010015 /* Guide bit-basher */
 #define I2C_HW_B_IXP2000        0x010016 /* GPIO on IXP2000 systems */
@@ -185,6 +188,7 @@
 #define I2C_HW_B_SAVAGE         0x01001d /* savage framebuffer driver */
 #define I2C_HW_B_RADEON         0x01001e /* radeon framebuffer driver */
 #define I2C_HW_B_EM28XX         0x01001f /* em28xx video capture cards */
+#define I2C_HW_B_CX2341X        0x010020 /* Conexant CX2341X MPEG encoder cards */
 
 /* --- PCF 8584 based algorithms                                        */
 #define I2C_HW_P_LP             0x020000 /* Parallel port interface */
diff --git a/include/linux/i2c.h b/include/linux/i2c.h
index 63f1d63cc1d8..1635ee25918f 100644
--- a/include/linux/i2c.h
+++ b/include/linux/i2c.h
@@ -32,7 +32,7 @@
 #include <linux/mod_devicetable.h>
 #include <linux/device.h>       /* for struct device */
 #include <linux/sched.h>        /* for completion */
-#include <asm/semaphore.h>
+#include <linux/mutex.h>
 
 /* --- For i2c-isa ---------------------------------------------------- */
 
@@ -225,8 +225,8 @@ struct i2c_adapter {
         int (*client_unregister)(struct i2c_client *);
 
         /* data fields that are valid for all devices   */
-        struct semaphore bus_lock;
-        struct semaphore clist_lock;
+        struct mutex bus_lock;
+        struct mutex clist_lock;
 
         int timeout;
         int retries;
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 =
-            mempool_create(min_nr, mempool_alloc_slab, mempool_free_slab,
-                           pool->slab);
+        pool->mempool = mempool_create_slab_pool(min_nr, pool->slab);
         if (!pool->mempool)
                 goto free_slab;
 
diff --git a/include/linux/ide.h b/include/linux/ide.h
index a7fc4cc79b23..8d2db412ba9c 100644
--- a/include/linux/ide.h
+++ b/include/linux/ide.h
@@ -792,6 +792,7 @@ typedef struct hwif_s {
         unsigned        no_dsc     : 1; /* 0 default, 1 dsc_overlap disabled */
         unsigned        auto_poll  : 1; /* supports nop auto-poll */
         unsigned        sg_mapped  : 1; /* sg_table and sg_nents are ready */
+        unsigned        no_io_32bit : 1; /* 1 = can not do 32-bit IO ops */
 
         struct device   gendev;
         struct completion gendev_rel_comp; /* To deal with device release() */
diff --git a/include/linux/init.h b/include/linux/init.h
index ff8d8b8632f4..ed0ac7c39fdc 100644
--- a/include/linux/init.h
+++ b/include/linux/init.h
@@ -69,6 +69,10 @@ extern initcall_t __security_initcall_start[], __security_initcall_end[];
 
 /* Defined in init/main.c */
 extern char saved_command_line[];
+
+/* used by init/main.c */
+extern void setup_arch(char **);
+
 #endif
   
 #ifndef MODULE
diff --git a/include/linux/init_task.h b/include/linux/init_task.h
index dcfd2ecccb5d..41ecbb847f32 100644
--- a/include/linux/init_task.h
+++ b/include/linux/init_task.h
@@ -7,11 +7,10 @@
 #define INIT_FDTABLE \
 {                                                       \
         .max_fds        = NR_OPEN_DEFAULT,              \
-        .max_fdset      = __FD_SETSIZE,                 \
-        .next_fd        = 0,                            \
+        .max_fdset      = EMBEDDED_FD_SET_SIZE,         \
         .fd             = &init_files.fd_array[0],      \
-        .close_on_exec  = &init_files.close_on_exec_init, \
-        .open_fds       = &init_files.open_fds_init,    \
+        .close_on_exec  = (fd_set *)&init_files.close_on_exec_init, \
+        .open_fds       = (fd_set *)&init_files.open_fds_init,  \
         .rcu            = RCU_HEAD_INIT,                \
         .free_files     = NULL,                         \
         .next           = NULL,                         \
@@ -20,9 +19,10 @@
 #define INIT_FILES \
 {                                                       \
         .count          = ATOMIC_INIT(1),               \
-        .file_lock      = SPIN_LOCK_UNLOCKED,           \
         .fdt            = &init_files.fdtab,            \
         .fdtab          = INIT_FDTABLE,                 \
+        .file_lock      = SPIN_LOCK_UNLOCKED,           \
+        .next_fd        = 0,                            \
         .close_on_exec_init = { { 0, } },               \
         .open_fds_init  = { { 0, } },                   \
         .fd_array       = { NULL, }                     \
@@ -62,6 +62,8 @@
         .posix_timers    = LIST_HEAD_INIT(sig.posix_timers),            \
         .cpu_timers     = INIT_CPU_TIMERS(sig.cpu_timers),              \
         .rlim           = INIT_RLIMITS,                                 \
+        .pgrp           = 1,                                            \
+        .session        = 1,                                            \
 }
 
 #define INIT_SIGHAND(sighand) {                                         \
diff --git a/include/linux/inotify.h b/include/linux/inotify.h
index 267c88b5f742..09e00433c78e 100644
--- a/include/linux/inotify.h
+++ b/include/linux/inotify.h
@@ -71,6 +71,8 @@ struct inotify_event {
 
 #ifdef CONFIG_INOTIFY
 
+extern void inotify_d_instantiate(struct dentry *, struct inode *);
+extern void inotify_d_move(struct dentry *);
 extern void inotify_inode_queue_event(struct inode *, __u32, __u32,
                                       const char *);
 extern void inotify_dentry_parent_queue_event(struct dentry *, __u32, __u32,
@@ -81,6 +83,15 @@ extern u32 inotify_get_cookie(void);
 
 #else
 
+static inline void inotify_d_instantiate(struct dentry *dentry,
+                                        struct inode *inode)
+{
+}
+
+static inline void inotify_d_move(struct dentry *dentry)
+{
+}
+
 static inline void inotify_inode_queue_event(struct inode *inode,
                                              __u32 mask, __u32 cookie,
                                              const char *filename)
diff --git a/include/linux/input.h b/include/linux/input.h
index 6d4cc3c110d6..1d4e341b72e6 100644
--- a/include/linux/input.h
+++ b/include/linux/input.h
@@ -957,7 +957,7 @@ struct input_handler {
         struct input_handle* (*connect)(struct input_handler *handler, struct input_dev *dev, struct input_device_id *id);
         void (*disconnect)(struct input_handle *handle);
 
-        struct file_operations *fops;
+        const struct file_operations *fops;
         int minor;
         char *name;
 
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,
-                      unsigned char            version_minor,
+                      struct ipmi_device_id    *device_id,
+                      struct device            *dev,
                       unsigned char            slave_addr,
                       ipmi_smi_t               *intf);
 
diff --git a/include/linux/irq.h b/include/linux/irq.h
index 6c5d4c898ccb..ee2a82a572f7 100644
--- a/include/linux/irq.h
+++ b/include/linux/irq.h
@@ -114,53 +114,8 @@ static inline void set_native_irq_info(int irq, cpumask_t mask)
 #if defined (CONFIG_GENERIC_PENDING_IRQ) || defined (CONFIG_IRQBALANCE)
 extern cpumask_t pending_irq_cpumask[NR_IRQS];
 
-static inline void set_pending_irq(unsigned int irq, cpumask_t mask)
-{
-        irq_desc_t *desc = irq_desc + irq;
-        unsigned long flags;
-
-        spin_lock_irqsave(&desc->lock, flags);
-        desc->move_irq = 1;
-        pending_irq_cpumask[irq] = mask;
-        spin_unlock_irqrestore(&desc->lock, flags);
-}
-
-static inline void
-move_native_irq(int irq)
-{
-        cpumask_t tmp;
-        irq_desc_t *desc = irq_descp(irq);
-
-        if (likely (!desc->move_irq))
-                return;
-
-        desc->move_irq = 0;
-
-        if (likely(cpus_empty(pending_irq_cpumask[irq])))
-                return;
-
-        if (!desc->handler->set_affinity)
-                return;
-
-        /* note - we hold the desc->lock */
-        cpus_and(tmp, pending_irq_cpumask[irq], cpu_online_map);
-
-        /*
-         * If there was a valid mask to work with, please
-         * do the disable, re-program, enable sequence.
-         * This is *not* particularly important for level triggered
-         * but in a edge trigger case, we might be setting rte
-         * when an active trigger is comming in. This could
-         * cause some ioapics to mal-function.
-         * Being paranoid i guess!
-         */
-        if (unlikely(!cpus_empty(tmp))) {
-                desc->handler->disable(irq);
-                desc->handler->set_affinity(irq,tmp);
-                desc->handler->enable(irq);
-        }
-        cpus_clear(pending_irq_cpumask[irq]);
-}
+void set_pending_irq(unsigned int irq, cpumask_t mask);
+void move_native_irq(int irq);
 
 #ifdef CONFIG_PCI_MSI
 /*
diff --git a/include/linux/jbd.h b/include/linux/jbd.h
index 41ee79962bb2..6a425e370cb3 100644
--- a/include/linux/jbd.h
+++ b/include/linux/jbd.h
@@ -28,6 +28,9 @@
 #include <linux/journal-head.h>
 #include <linux/stddef.h>
 #include <linux/bit_spinlock.h>
+#include <linux/mutex.h>
+#include <linux/timer.h>
+
 #include <asm/semaphore.h>
 #endif
 
@@ -575,7 +578,7 @@ struct transaction_s
  * @j_wait_checkpoint:  Wait queue to trigger checkpointing
  * @j_wait_commit: Wait queue to trigger commit
  * @j_wait_updates: Wait queue to wait for updates to complete
- * @j_checkpoint_sem: Semaphore for locking against concurrent checkpoints
+ * @j_checkpoint_mutex: Mutex for locking against concurrent checkpoints
  * @j_head: Journal head - identifies the first unused block in the journal
  * @j_tail: Journal tail - identifies the oldest still-used block in the
  *  journal.
@@ -645,7 +648,7 @@ struct journal_s
         int                     j_barrier_count;
 
         /* The barrier lock itself */
-        struct semaphore        j_barrier;
+        struct mutex            j_barrier;
 
         /*
          * Transactions: The current running transaction...
@@ -687,7 +690,7 @@ struct journal_s
         wait_queue_head_t       j_wait_updates;
 
         /* Semaphore for locking against concurrent checkpoints */
-        struct semaphore        j_checkpoint_sem;
+        struct mutex            j_checkpoint_mutex;
 
         /*
          * Journal head: identifies the first unused block in the journal.
@@ -786,7 +789,7 @@ struct journal_s
         unsigned long           j_commit_interval;
 
         /* The timer used to wakeup the commit thread: */
-        struct timer_list       *j_commit_timer;
+        struct timer_list       j_commit_timer;
 
         /*
          * The revoke table: maintains the list of revoked blocks in the
@@ -892,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 3b507bf05d09..a3720f973ea5 100644
--- a/include/linux/kernel.h
+++ b/include/linux/kernel.h
@@ -87,10 +87,13 @@ 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)));
+extern void oops_enter(void);
+extern void oops_exit(void);
+extern int oops_may_print(void);
 fastcall NORET_TYPE void do_exit(long error_code)
         ATTRIB_NORET;
 NORET_TYPE void complete_and_exit(struct completion *, long)
@@ -151,9 +154,10 @@ static inline int __attribute_pure__ long_log2(unsigned long x)
         return r;
 }
 
-static inline unsigned long __attribute_const__ roundup_pow_of_two(unsigned long x)
+static inline unsigned long
+__attribute_const__ roundup_pow_of_two(unsigned long x)
 {
-        return (1UL << fls(x - 1));
+        return 1UL << fls_long(x - 1);
 }
 
 extern int printk_ratelimit(void);
diff --git a/include/linux/kernel_stat.h b/include/linux/kernel_stat.h
index a484572c302e..b46249082cca 100644
--- a/include/linux/kernel_stat.h
+++ b/include/linux/kernel_stat.h
@@ -46,7 +46,7 @@ static inline int kstat_irqs(int irq)
 {
         int cpu, sum = 0;
 
-        for_each_cpu(cpu)
+        for_each_possible_cpu(cpu)
                 sum += kstat_cpu(cpu).irqs[irq];
 
         return sum;
diff --git a/include/linux/kprobes.h b/include/linux/kprobes.h
index 669756bc20a2..778adc0fa640 100644
--- a/include/linux/kprobes.h
+++ b/include/linux/kprobes.h
@@ -36,6 +36,7 @@
 #include <linux/percpu.h>
 #include <linux/spinlock.h>
 #include <linux/rcupdate.h>
+#include <linux/mutex.h>
 
 #ifdef CONFIG_KPROBES
 #include <asm/kprobes.h>
@@ -152,7 +153,7 @@ struct kretprobe_instance {
 };
 
 extern spinlock_t kretprobe_lock;
-extern struct semaphore kprobe_mutex;
+extern struct mutex kprobe_mutex;
 extern int arch_prepare_kprobe(struct kprobe *p);
 extern void arch_arm_kprobe(struct kprobe *p);
 extern void arch_disarm_kprobe(struct kprobe *p);
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/libata.h b/include/linux/libata.h
index 4dff3cf9d389..c2215469a101 100644
--- a/include/linux/libata.h
+++ b/include/linux/libata.h
@@ -161,8 +161,10 @@ enum {
         ATA_QCFLAG_DMAMAP       = ATA_QCFLAG_SG | ATA_QCFLAG_SINGLE,
         ATA_QCFLAG_EH_SCHEDULED = (1 << 5), /* EH scheduled */
 
+        /* host set flags */
+        ATA_HOST_SIMPLEX        = (1 << 0),     /* Host is simplex, one DMA channel per host_set only */
+        
         /* various lengths of time */
-        ATA_TMOUT_EDD           = 5 * HZ,       /* heuristic */
         ATA_TMOUT_PIO           = 30 * HZ,
         ATA_TMOUT_BOOT          = 30 * HZ,      /* heuristic */
         ATA_TMOUT_BOOT_QUICK    = 7 * HZ,       /* heuristic */
@@ -280,6 +282,7 @@ struct ata_probe_ent {
         unsigned long           irq;
         unsigned int            irq_flags;
         unsigned long           host_flags;
+        unsigned long           host_set_flags;
         void __iomem            *mmio_base;
         void                    *private_data;
 };
@@ -292,6 +295,9 @@ struct ata_host_set {
         unsigned int            n_ports;
         void                    *private_data;
         const struct ata_port_operations *ops;
+        unsigned long           flags;
+        int                     simplex_claimed;        /* Keep seperate in case we
+                                                           ever need to do this locked */
         struct ata_port *       ports[0];
 };
 
@@ -359,6 +365,11 @@ struct ata_device {
         unsigned int            max_sectors;    /* per-device max sectors */
         unsigned int            cdb_len;
 
+        /* per-dev xfer mask */
+        unsigned int            pio_mask;
+        unsigned int            mwdma_mask;
+        unsigned int            udma_mask;
+
         /* for CHS addressing */
         u16                     cylinders;      /* Number of cylinders */
         u16                     heads;          /* Number of heads */
@@ -396,6 +407,7 @@ struct ata_port {
 
         struct ata_host_stats   stats;
         struct ata_host_set     *host_set;
+        struct device           *dev;
 
         struct work_struct      port_task;
 
@@ -415,6 +427,7 @@ struct ata_port_operations {
 
         void (*set_piomode) (struct ata_port *, struct ata_device *);
         void (*set_dmamode) (struct ata_port *, struct ata_device *);
+        unsigned long (*mode_filter) (const struct ata_port *, struct ata_device *, unsigned long);
 
         void (*tf_load) (struct ata_port *ap, const struct ata_taskfile *tf);
         void (*tf_read) (struct ata_port *ap, struct ata_taskfile *tf);
@@ -425,6 +438,7 @@ struct ata_port_operations {
         void (*dev_select)(struct ata_port *ap, unsigned int device);
 
         void (*phy_reset) (struct ata_port *ap); /* obsolete */
+        void (*set_mode) (struct ata_port *ap);
         int (*probe_reset) (struct ata_port *ap, unsigned int *classes);
 
         void (*post_set_mode) (struct ata_port *ap);
@@ -510,16 +524,15 @@ extern void ata_host_set_remove(struct ata_host_set *host_set);
 extern int ata_scsi_detect(struct scsi_host_template *sht);
 extern int ata_scsi_ioctl(struct scsi_device *dev, int cmd, void __user *arg);
 extern int ata_scsi_queuecmd(struct scsi_cmnd *cmd, void (*done)(struct scsi_cmnd *));
-extern enum scsi_eh_timer_return ata_scsi_timed_out(struct scsi_cmnd *cmd);
 extern int ata_scsi_error(struct Scsi_Host *host);
 extern void ata_eh_qc_complete(struct ata_queued_cmd *qc);
 extern void ata_eh_qc_retry(struct ata_queued_cmd *qc);
 extern int ata_scsi_release(struct Scsi_Host *host);
 extern unsigned int ata_host_intr(struct ata_port *ap, struct ata_queued_cmd *qc);
 extern int ata_scsi_device_resume(struct scsi_device *);
-extern int ata_scsi_device_suspend(struct scsi_device *);
+extern int ata_scsi_device_suspend(struct scsi_device *, pm_message_t state);
 extern int ata_device_resume(struct ata_port *, struct ata_device *);
-extern int ata_device_suspend(struct ata_port *, struct ata_device *);
+extern int ata_device_suspend(struct ata_port *, struct ata_device *, pm_message_t state);
 extern int ata_ratelimit(void);
 extern unsigned int ata_busy_sleep(struct ata_port *ap,
                                    unsigned long timeout_pat,
@@ -570,6 +583,8 @@ extern int ata_std_bios_param(struct scsi_device *sdev,
                               struct block_device *bdev,
                               sector_t capacity, int geom[]);
 extern int ata_scsi_slave_config(struct scsi_device *sdev);
+extern struct ata_device *ata_dev_pair(struct ata_port *ap, 
+                                       struct ata_device *adev);
 
 /*
  * Timing helpers
diff --git a/include/linux/linkage.h b/include/linux/linkage.h
index 147eb01e0d4b..c08c9983e840 100644
--- a/include/linux/linkage.h
+++ b/include/linux/linkage.h
@@ -28,17 +28,27 @@
 #define ALIGN __ALIGN
 #define ALIGN_STR __ALIGN_STR
 
+#ifndef ENTRY
 #define ENTRY(name) \
   .globl name; \
   ALIGN; \
   name:
+#endif
 
 #define KPROBE_ENTRY(name) \
   .section .kprobes.text, "ax"; \
-  .globl name; \
-  ALIGN; \
-  name:
+  ENTRY(name)
 
+#ifndef END
+#define END(name) \
+  .size name, .-name
+#endif
+
+#ifndef ENDPROC
+#define ENDPROC(name) \
+  .type name, @function; \
+  END(name)
+#endif
 
 #endif
 
diff --git a/include/linux/lockd/lockd.h b/include/linux/lockd/lockd.h
index ef21ed296039..995f89dc8c04 100644
--- a/include/linux/lockd/lockd.h
+++ b/include/linux/lockd/lockd.h
@@ -14,6 +14,7 @@
 #include <linux/config.h>
 #include <linux/in.h>
 #include <linux/fs.h>
+#include <linux/kref.h>
 #include <linux/utsname.h>
 #include <linux/nfsd/nfsfh.h>
 #include <linux/lockd/bind.h>
@@ -58,6 +59,8 @@ struct nlm_host {
         unsigned long           h_expires;      /* eligible for GC */
         struct list_head        h_lockowners;   /* Lockowners for the client */
         spinlock_t              h_lock;
+        struct list_head        h_granted;      /* Locks in GRANTED state */
+        struct list_head        h_reclaim;      /* Locks in RECLAIM state */
 };
 
 /*
@@ -83,9 +86,9 @@ struct nlm_rqst {
         struct nlm_host *       a_host;         /* host handle */
         struct nlm_args         a_args;         /* arguments */
         struct nlm_res          a_res;          /* result */
-        struct nlm_wait *       a_block;
+        struct nlm_block *      a_block;
         unsigned int            a_retries;      /* Retry count */
-        char                    a_owner[NLMCLNT_OHSIZE];
+        u8                      a_owner[NLMCLNT_OHSIZE];
 };
 
 /*
@@ -110,16 +113,16 @@ struct nlm_file {
  */
 #define NLM_NEVER               (~(unsigned long) 0)
 struct nlm_block {
+        struct kref             b_count;        /* Reference count */
         struct nlm_block *      b_next;         /* linked list (all blocks) */
         struct nlm_block *      b_fnext;        /* linked list (per file) */
-        struct nlm_rqst         b_call;         /* RPC args & callback info */
+        struct nlm_rqst *       b_call;         /* RPC args & callback info */
         struct svc_serv *       b_daemon;       /* NLM service */
         struct nlm_host *       b_host;         /* host handle for RPC clnt */
         unsigned long           b_when;         /* next re-xmit */
         unsigned int            b_id;           /* block id */
         unsigned char           b_queued;       /* re-queued */
         unsigned char           b_granted;      /* VFS granted lock */
-        unsigned char           b_incall;       /* doing callback */
         unsigned char           b_done;         /* callback complete */
         struct nlm_file *       b_file;         /* file in question */
 };
@@ -145,15 +148,16 @@ extern unsigned long		nlmsvc_timeout;
 /*
  * Lockd client functions
  */
-struct nlm_rqst * nlmclnt_alloc_call(void);
-int               nlmclnt_prepare_block(struct nlm_rqst *req, struct nlm_host *host, struct file_lock *fl);
-void              nlmclnt_finish_block(struct nlm_rqst *req);
-long              nlmclnt_block(struct nlm_rqst *req, long timeout);
+struct nlm_rqst * nlm_alloc_call(struct nlm_host *host);
+void              nlm_release_call(struct nlm_rqst *);
+int               nlm_async_call(struct nlm_rqst *, u32, const struct rpc_call_ops *);
+int               nlm_async_reply(struct nlm_rqst *, u32, const struct rpc_call_ops *);
+struct nlm_wait * nlmclnt_prepare_block(struct nlm_host *host, struct file_lock *fl);
+void              nlmclnt_finish_block(struct nlm_wait *block);
+int               nlmclnt_block(struct nlm_wait *block, struct nlm_rqst *req, long timeout);
 u32               nlmclnt_grant(const struct sockaddr_in *addr, const struct nlm_lock *);
 void              nlmclnt_recovery(struct nlm_host *, u32);
 int               nlmclnt_reclaim(struct nlm_host *, struct file_lock *);
-int               nlmclnt_setgrantargs(struct nlm_rqst *, struct nlm_lock *);
-void              nlmclnt_freegrantargs(struct nlm_rqst *);
 
 /*
  * Host cache
@@ -172,7 +176,6 @@ extern struct nlm_host *nlm_find_client(void);
 /*
  * Server-side lock handling
  */
-int               nlmsvc_async_call(struct nlm_rqst *, u32, const struct rpc_call_ops *);
 u32               nlmsvc_lock(struct svc_rqst *, struct nlm_file *,
                                         struct nlm_lock *, int, struct nlm_cookie *);
 u32               nlmsvc_unlock(struct nlm_file *, struct nlm_lock *);
@@ -180,7 +183,7 @@ u32		  nlmsvc_testlock(struct nlm_file *, struct nlm_lock *,
                                         struct nlm_lock *);
 u32               nlmsvc_cancel_blocked(struct nlm_file *, struct nlm_lock *);
 unsigned long     nlmsvc_retry_blocked(void);
-int               nlmsvc_traverse_blocks(struct nlm_host *, struct nlm_file *,
+void              nlmsvc_traverse_blocks(struct nlm_host *, struct nlm_file *,
                                         int action);
 void      nlmsvc_grant_reply(struct svc_rqst *, struct nlm_cookie *, u32);
 
diff --git a/include/linux/lockd/share.h b/include/linux/lockd/share.h
index 5d8aa325f140..c75a424ebe4c 100644
--- a/include/linux/lockd/share.h
+++ b/include/linux/lockd/share.h
@@ -25,6 +25,6 @@ u32	nlmsvc_share_file(struct nlm_host *, struct nlm_file *,
                                                struct nlm_args *);
 u32     nlmsvc_unshare_file(struct nlm_host *, struct nlm_file *,
                                                struct nlm_args *);
-int     nlmsvc_traverse_shares(struct nlm_host *, struct nlm_file *, int);
+void    nlmsvc_traverse_shares(struct nlm_host *, struct nlm_file *, int);
 
 #endif /* LINUX_LOCKD_SHARE_H */
diff --git a/include/linux/lockd/xdr.h b/include/linux/lockd/xdr.h
index d7a5cc4cfa97..bb0a0f1caa91 100644
--- a/include/linux/lockd/xdr.h
+++ b/include/linux/lockd/xdr.h
@@ -28,6 +28,7 @@ struct nlm_lock {
         int                     len;    /* length of "caller" */
         struct nfs_fh           fh;
         struct xdr_netobj       oh;
+        u32                     svid;
         struct file_lock        fl;
 };
 
diff --git a/include/linux/loop.h b/include/linux/loop.h
index f96506782ebe..e76c7611d6cc 100644
--- a/include/linux/loop.h
+++ b/include/linux/loop.h
@@ -17,6 +17,7 @@
 #include <linux/bio.h>
 #include <linux/blkdev.h>
 #include <linux/spinlock.h>
+#include <linux/mutex.h>
 
 /* Possible states of device */
 enum {
@@ -60,7 +61,7 @@ struct loop_device {
         int                     lo_state;
         struct completion       lo_done;
         struct completion       lo_bh_done;
-        struct semaphore        lo_ctl_mutex;
+        struct mutex            lo_ctl_mutex;
         int                     lo_pending;
 
         request_queue_t         *lo_queue;
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/major.h b/include/linux/major.h
index e36a46702d94..0a74c52924c9 100644
--- a/include/linux/major.h
+++ b/include/linux/major.h
@@ -113,6 +113,7 @@
 
 #define UBD_MAJOR               98
 
+#define PP_MAJOR                99
 #define JSFD_MAJOR              99
 
 #define PHONE_MAJOR             100
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/mempolicy.h b/include/linux/mempolicy.h
index bbd2221923c3..6a7621b2b12b 100644
--- a/include/linux/mempolicy.h
+++ b/include/linux/mempolicy.h
@@ -147,6 +147,7 @@ extern void mpol_rebind_policy(struct mempolicy *pol, const nodemask_t *new);
 extern void mpol_rebind_task(struct task_struct *tsk,
                                         const nodemask_t *new);
 extern void mpol_rebind_mm(struct mm_struct *mm, nodemask_t *new);
+extern void mpol_fix_fork_child_flag(struct task_struct *p);
 #define set_cpuset_being_rebound(x) (cpuset_being_rebound = (x))
 
 #ifdef CONFIG_CPUSET
@@ -248,6 +249,10 @@ static inline void mpol_rebind_mm(struct mm_struct *mm, nodemask_t *new)
 {
 }
 
+static inline void mpol_fix_fork_child_flag(struct task_struct *p)
+{
+}
+
 #define set_cpuset_being_rebound(x) do {} while (0)
 
 static inline struct zonelist *huge_zonelist(struct vm_area_struct *vma,
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/migrate.h b/include/linux/migrate.h
new file mode 100644
index 000000000000..7d09962c3c0b
--- /dev/null
+++ b/include/linux/migrate.h
@@ -0,0 +1,36 @@
+#ifndef _LINUX_MIGRATE_H
+#define _LINUX_MIGRATE_H
+
+#include <linux/config.h>
+#include <linux/mm.h>
+
+#ifdef CONFIG_MIGRATION
+extern int isolate_lru_page(struct page *p, struct list_head *pagelist);
+extern int putback_lru_pages(struct list_head *l);
+extern int migrate_page(struct page *, struct page *);
+extern void migrate_page_copy(struct page *, struct page *);
+extern int migrate_page_remove_references(struct page *, struct page *, int);
+extern int migrate_pages(struct list_head *l, struct list_head *t,
+                struct list_head *moved, struct list_head *failed);
+int migrate_pages_to(struct list_head *pagelist,
+                        struct vm_area_struct *vma, int dest);
+extern int fail_migrate_page(struct page *, struct page *);
+
+extern int migrate_prep(void);
+
+#else
+
+static inline int isolate_lru_page(struct page *p, struct list_head *list)
+                                        { return -ENOSYS; }
+static inline int putback_lru_pages(struct list_head *l) { return 0; }
+static inline int migrate_pages(struct list_head *l, struct list_head *t,
+        struct list_head *moved, struct list_head *failed) { return -ENOSYS; }
+
+static inline int migrate_prep(void) { return -ENOSYS; }
+
+/* Possible settings for the migrate_page() method in address_operations */
+#define migrate_page NULL
+#define fail_migrate_page NULL
+
+#endif /* CONFIG_MIGRATION */
+#endif /* _LINUX_MIGRATE_H */
diff --git a/include/linux/miscdevice.h b/include/linux/miscdevice.h
index 14ceebfc1efa..5b584dafb5a6 100644
--- a/include/linux/miscdevice.h
+++ b/include/linux/miscdevice.h
@@ -36,7 +36,7 @@ struct class_device;
 struct miscdevice  {
         int minor;
         const char *name;
-        struct file_operations *fops;
+        const struct file_operations *fops;
         struct list_head list;
         struct device *dev;
         struct class_device *class;
diff --git a/include/linux/mm.h b/include/linux/mm.h
index 498ff8778fb6..6aa016f1d3ae 100644
--- a/include/linux/mm.h
+++ b/include/linux/mm.h
@@ -286,43 +286,34 @@ struct page {
  *
  * Also, many kernel routines increase the page count before a critical
  * routine so they can be sure the page doesn't go away from under them.
- *
- * Since 2.6.6 (approx), a free page has ->_count = -1.  This is so that we
- * can use atomic_add_negative(-1, page->_count) to detect when the page
- * becomes free and so that we can also use atomic_inc_and_test to atomically
- * detect when we just tried to grab a ref on a page which some other CPU has
- * already deemed to be freeable.
- *
- * NO code should make assumptions about this internal detail!  Use the provided
- * macros which retain the old rules: page_count(page) == 0 is a free page.
  */
 
 /*
  * Drop a ref, return true if the logical refcount fell to zero (the page has
  * no users)
  */
-#define put_page_testzero(p)                            \
-        ({                                              \
-                BUG_ON(atomic_read(&(p)->_count) == -1);\
-                atomic_add_negative(-1, &(p)->_count);  \
-        })
+static inline int put_page_testzero(struct page *page)
+{
+        BUG_ON(atomic_read(&page->_count) == 0);
+        return atomic_dec_and_test(&page->_count);
+}
 
 /*
- * Grab a ref, return true if the page previously had a logical refcount of
- * zero.  ie: returns true if we just grabbed an already-deemed-to-be-free page
+ * Try to grab a ref unless the page has a refcount of zero, return false if
+ * that is the case.
  */
-#define get_page_testone(p)     atomic_inc_and_test(&(p)->_count)
-
-#define set_page_count(p,v)     atomic_set(&(p)->_count, (v) - 1)
-#define __put_page(p)           atomic_dec(&(p)->_count)
+static inline int get_page_unless_zero(struct page *page)
+{
+        return atomic_inc_not_zero(&page->_count);
+}
 
 extern void FASTCALL(__page_cache_release(struct page *));
 
 static inline int page_count(struct page *page)
 {
-        if (PageCompound(page))
+        if (unlikely(PageCompound(page)))
                 page = (struct page *)page_private(page);
-        return atomic_read(&page->_count) + 1;
+        return atomic_read(&page->_count);
 }
 
 static inline void get_page(struct page *page)
@@ -332,8 +323,19 @@ static inline void get_page(struct page *page)
         atomic_inc(&page->_count);
 }
 
+/*
+ * Setup the page count before being freed into the page allocator for
+ * the first time (boot or memory hotplug)
+ */
+static inline void init_page_count(struct page *page)
+{
+        atomic_set(&page->_count, 1);
+}
+
 void put_page(struct page *page);
 
+void split_page(struct page *page, unsigned int order);
+
 /*
  * Multiple processes may "see" the same page. E.g. for untouched
  * mappings of /dev/null, all processes see the same page full of
@@ -1046,7 +1048,7 @@ int in_gate_area_no_task(unsigned long addr);
 
 int drop_caches_sysctl_handler(struct ctl_table *, int, struct file *,
                                         void __user *, size_t *, loff_t *);
-int shrink_slab(unsigned long scanned, gfp_t gfp_mask,
+unsigned long shrink_slab(unsigned long scanned, gfp_t gfp_mask,
                         unsigned long lru_pages);
 void drop_pagecache(void);
 void drop_slab(void);
diff --git a/include/linux/mm_inline.h b/include/linux/mm_inline.h
index 8ac854f7f190..3b6723dfaff3 100644
--- a/include/linux/mm_inline.h
+++ b/include/linux/mm_inline.h
@@ -32,7 +32,7 @@ del_page_from_lru(struct zone *zone, struct page *page)
 {
         list_del(&page->lru);
         if (PageActive(page)) {
-                ClearPageActive(page);
+                __ClearPageActive(page);
                 zone->nr_active--;
         } else {
                 zone->nr_inactive--;
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/module.h b/include/linux/module.h
index 70bd843c71cb..eaec13ddd667 100644
--- a/include/linux/module.h
+++ b/include/linux/module.h
@@ -183,6 +183,7 @@ void *__symbol_get_gpl(const char *symbol);
 
 /* For every exported symbol, place a struct in the __ksymtab section */
 #define __EXPORT_SYMBOL(sym, sec)                               \
+        extern typeof(sym) sym;                                 \
         __CRC_SYMBOL(sym, sec)                                  \
         static const char __kstrtab_##sym[]                     \
         __attribute__((section("__ksymtab_strings")))           \
@@ -554,25 +555,6 @@ static inline void module_remove_driver(struct device_driver *driver)
 
 /* BELOW HERE ALL THESE ARE OBSOLETE AND WILL VANISH */
 
-struct obsolete_modparm {
-        char name[64];
-        char type[64-sizeof(void *)];
-        void *addr;
-};
-
-static inline void MODULE_PARM_(void) { }
-#ifdef MODULE
-/* DEPRECATED: Do not use. */
-#define MODULE_PARM(var,type)                                               \
-extern struct obsolete_modparm __parm_##var \
-__attribute__((section("__obsparm"))); \
-struct obsolete_modparm __parm_##var = \
-{ __stringify(var), type, &MODULE_PARM_ }; \
-__MODULE_PARM_TYPE(var, type);
-#else
-#define MODULE_PARM(var,type) static void __attribute__((__unused__)) *__parm_##var = &MODULE_PARM_;
-#endif
-
 #define __MODULE_STRING(x) __stringify(x)
 
 /* Use symbol_get and symbol_put instead.  You'll thank me. */
diff --git a/include/linux/moduleparam.h b/include/linux/moduleparam.h
index b5c98c43779e..7c0c2c198f1f 100644
--- a/include/linux/moduleparam.h
+++ b/include/linux/moduleparam.h
@@ -162,13 +162,6 @@ extern int param_array_get(char *buffer, struct kernel_param *kp);
 extern int param_set_copystring(const char *val, struct kernel_param *kp);
 extern int param_get_string(char *buffer, struct kernel_param *kp);
 
-int param_array(const char *name,
-                const char *val,
-                unsigned int min, unsigned int max,
-                void *elem, int elemsize,
-                int (*set)(const char *, struct kernel_param *kp),
-                int *num);
-
 /* for exporting parameters in /sys/parameters */
 
 struct module;
diff --git a/include/linux/msdos_fs.h b/include/linux/msdos_fs.h
index e933e2a355ad..d9035c73e5d1 100644
--- a/include/linux/msdos_fs.h
+++ b/include/linux/msdos_fs.h
@@ -184,6 +184,7 @@ struct fat_slot_info {
 #include <linux/string.h>
 #include <linux/nls.h>
 #include <linux/fs.h>
+#include <linux/mutex.h>
 
 struct fat_mount_options {
         uid_t fs_uid;
@@ -199,7 +200,7 @@ struct fat_mount_options {
                  sys_immutable:1, /* set = system files are immutable */
                  dotsOK:1,        /* set = hidden and system files are named '.filename' */
                  isvfat:1,        /* 0=no vfat long filename support, 1=vfat support */
-                 utf8:1,          /* Use of UTF8 character set (Default) */
+                 utf8:1,          /* Use of UTF-8 character set (Default) */
                  unicode_xlate:1, /* create escape sequences for unhandled Unicode */
                  numtail:1,       /* Does first alias have a numeric '~1' type tail? */
                  atari:1,         /* Use Atari GEMDOS variation of MS-DOS fs */
@@ -226,7 +227,7 @@ struct msdos_sb_info {
         unsigned long max_cluster;   /* maximum cluster number */
         unsigned long root_cluster;  /* first cluster of the root directory */
         unsigned long fsinfo_sector; /* sector number of FAT32 fsinfo */
-        struct semaphore fat_lock;
+        struct mutex fat_lock;
         unsigned int prev_free;      /* previously allocated cluster number */
         unsigned int free_clusters;  /* -1 if undefined */
         struct fat_mount_options options;
@@ -333,7 +334,7 @@ extern int fat_bmap(struct inode *inode, sector_t sector, sector_t *phys,
                     unsigned long *mapped_blocks);
 
 /* fat/dir.c */
-extern struct file_operations fat_dir_operations;
+extern const struct file_operations fat_dir_operations;
 extern int fat_search_long(struct inode *inode, const unsigned char *name,
                            int name_len, struct fat_slot_info *sinfo);
 extern int fat_dir_empty(struct inode *dir);
@@ -396,7 +397,7 @@ extern int fat_count_free_clusters(struct super_block *sb);
 /* fat/file.c */
 extern int fat_generic_ioctl(struct inode *inode, struct file *filp,
                              unsigned int cmd, unsigned long arg);
-extern struct file_operations fat_file_operations;
+extern const struct file_operations fat_file_operations;
 extern struct inode_operations fat_file_inode_operations;
 extern int fat_notify_change(struct dentry * dentry, struct iattr * attr);
 extern void fat_truncate(struct inode *inode);
@@ -419,6 +420,9 @@ extern int date_dos2unix(unsigned short time, unsigned short date);
 extern void fat_date_unix2dos(int unix_date, __le16 *time, __le16 *date);
 extern int fat_sync_bhs(struct buffer_head **bhs, int nr_bhs);
 
+int fat_cache_init(void);
+void fat_cache_destroy(void);
+
 #endif /* __KERNEL__ */
 
 #endif
diff --git a/include/linux/nbd.h b/include/linux/nbd.h
index f95d51fae733..a6ce409ec6fc 100644
--- a/include/linux/nbd.h
+++ b/include/linux/nbd.h
@@ -38,6 +38,7 @@ enum {
 #ifdef __KERNEL__
 
 #include <linux/wait.h>
+#include <linux/mutex.h>
 
 /* values for flags field */
 #define NBD_READ_ONLY 0x0001
@@ -57,7 +58,7 @@ struct nbd_device {
         struct request *active_req;
         wait_queue_head_t active_wq;
 
-        struct semaphore tx_lock;
+        struct mutex tx_lock;
         struct gendisk *disk;
         int blksize;
         u64 bytesize;
diff --git a/include/linux/ncp_fs.h b/include/linux/ncp_fs.h
index e01342568530..96dc237b8f03 100644
--- a/include/linux/ncp_fs.h
+++ b/include/linux/ncp_fs.h
@@ -209,7 +209,7 @@ void ncp_update_inode2(struct inode *, struct ncp_entry_info *);
 
 /* linux/fs/ncpfs/dir.c */
 extern struct inode_operations ncp_dir_inode_operations;
-extern struct file_operations ncp_dir_operations;
+extern const struct file_operations ncp_dir_operations;
 int ncp_conn_logged_in(struct super_block *);
 int ncp_date_dos2unix(__le16 time, __le16 date);
 void ncp_date_unix2dos(int unix_date, __le16 * time, __le16 * date);
@@ -230,7 +230,7 @@ void ncp_unlock_server(struct ncp_server *server);
 
 /* linux/fs/ncpfs/file.c */
 extern struct inode_operations ncp_file_inode_operations;
-extern struct file_operations ncp_file_operations;
+extern const struct file_operations ncp_file_operations;
 int ncp_make_open(struct inode *, int);
 
 /* linux/fs/ncpfs/mmap.c */
diff --git a/include/linux/ncp_fs_i.h b/include/linux/ncp_fs_i.h
index 415be1ec6f98..bdb4c8ae6924 100644
--- a/include/linux/ncp_fs_i.h
+++ b/include/linux/ncp_fs_i.h
@@ -19,7 +19,7 @@ struct ncp_inode_info {
         __le32  DosDirNum;
         __u8    volNumber;
         __le32  nwattr;
-        struct semaphore open_sem;
+        struct mutex open_mutex;
         atomic_t        opened;
         int     access;
         int     flags;
diff --git a/include/linux/ncp_fs_sb.h b/include/linux/ncp_fs_sb.h
index cf858eb80f0b..b089d9506283 100644
--- a/include/linux/ncp_fs_sb.h
+++ b/include/linux/ncp_fs_sb.h
@@ -11,6 +11,7 @@
 #include <linux/types.h>
 #include <linux/ncp_mount.h>
 #include <linux/net.h>
+#include <linux/mutex.h>
 
 #ifdef __KERNEL__
 
@@ -51,7 +52,7 @@ struct ncp_server {
                                    receive replies */
 
         int lock;               /* To prevent mismatch in protocols. */
-        struct semaphore sem;
+        struct mutex mutex;
 
         int current_size;       /* for packet preparation */
         int has_subfunction;
@@ -96,7 +97,7 @@ struct ncp_server {
         struct {
                 struct work_struct tq;          /* STREAM/DGRAM: data/error ready */
                 struct ncp_request_reply* creq; /* STREAM/DGRAM: awaiting reply from this request */
-                struct semaphore creq_sem;      /* DGRAM only: lock accesses to rcv.creq */
+                struct mutex creq_mutex;        /* DGRAM only: lock accesses to rcv.creq */
 
                 unsigned int state;             /* STREAM only: receiver state */
                 struct {
diff --git a/include/linux/net.h b/include/linux/net.h
index 152fa6551fd8..84a490e5f0a1 100644
--- a/include/linux/net.h
+++ b/include/linux/net.h
@@ -143,6 +143,8 @@ struct proto_ops {
                                       struct poll_table_struct *wait);
         int             (*ioctl)     (struct socket *sock, unsigned int cmd,
                                       unsigned long arg);
+        int             (*compat_ioctl) (struct socket *sock, unsigned int cmd,
+                                      unsigned long arg);
         int             (*listen)    (struct socket *sock, int len);
         int             (*shutdown)  (struct socket *sock, int flags);
         int             (*setsockopt)(struct socket *sock, int level,
@@ -251,6 +253,8 @@ SOCKCALL_UWRAP(name, poll, (struct file *file, struct socket *sock, struct poll_
               (file, sock, wait)) \
 SOCKCALL_WRAP(name, ioctl, (struct socket *sock, unsigned int cmd, \
                          unsigned long arg), (sock, cmd, arg)) \
+SOCKCALL_WRAP(name, compat_ioctl, (struct socket *sock, unsigned int cmd, \
+                         unsigned long arg), (sock, cmd, arg)) \
 SOCKCALL_WRAP(name, listen, (struct socket *sock, int len), (sock, len)) \
 SOCKCALL_WRAP(name, shutdown, (struct socket *sock, int flags), (sock, flags)) \
 SOCKCALL_WRAP(name, setsockopt, (struct socket *sock, int level, int optname, \
@@ -275,6 +279,7 @@ static const struct proto_ops name##_ops = {			\
         .getname        = __lock_##name##_getname,      \
         .poll           = __lock_##name##_poll,         \
         .ioctl          = __lock_##name##_ioctl,        \
+        .compat_ioctl   = __lock_##name##_compat_ioctl, \
         .listen         = __lock_##name##_listen,       \
         .shutdown       = __lock_##name##_shutdown,     \
         .setsockopt     = __lock_##name##_setsockopt,   \
@@ -283,6 +288,7 @@ static const struct proto_ops name##_ops = {			\
         .recvmsg        = __lock_##name##_recvmsg,      \
         .mmap           = __lock_##name##_mmap,         \
 };
+
 #endif
 
 #define MODULE_ALIAS_NETPROTO(proto) \
diff --git a/include/linux/netfilter/x_tables.h b/include/linux/netfilter/x_tables.h
index 46a0f974f87c..1350e47b0234 100644
--- a/include/linux/netfilter/x_tables.h
+++ b/include/linux/netfilter/x_tables.h
@@ -4,6 +4,62 @@
 #define XT_FUNCTION_MAXNAMELEN 30
 #define XT_TABLE_MAXNAMELEN 32
 
+struct xt_entry_match
+{
+        union {
+                struct {
+                        u_int16_t match_size;
+
+                        /* Used by userspace */
+                        char name[XT_FUNCTION_MAXNAMELEN-1];
+
+                        u_int8_t revision;
+                } user;
+                struct {
+                        u_int16_t match_size;
+
+                        /* Used inside the kernel */
+                        struct xt_match *match;
+                } kernel;
+
+                /* Total length */
+                u_int16_t match_size;
+        } u;
+
+        unsigned char data[0];
+};
+
+struct xt_entry_target
+{
+        union {
+                struct {
+                        u_int16_t target_size;
+
+                        /* Used by userspace */
+                        char name[XT_FUNCTION_MAXNAMELEN-1];
+
+                        u_int8_t revision;
+                } user;
+                struct {
+                        u_int16_t target_size;
+
+                        /* Used inside the kernel */
+                        struct xt_target *target;
+                } kernel;
+
+                /* Total length */
+                u_int16_t target_size;
+        } u;
+
+        unsigned char data[0];
+};
+
+struct xt_standard_target
+{
+        struct xt_entry_target target;
+        int verdict;
+};
+
 /* The argument to IPT_SO_GET_REVISION_*.  Returns highest revision
  * kernel supports, if >= revision. */
 struct xt_get_revision
@@ -220,10 +276,10 @@ struct xt_table_info
         char *entries[NR_CPUS];
 };
 
-extern int xt_register_target(int af, struct xt_target *target);
-extern void xt_unregister_target(int af, struct xt_target *target);
-extern int xt_register_match(int af, struct xt_match *target);
-extern void xt_unregister_match(int af, struct xt_match *target);
+extern int xt_register_target(struct xt_target *target);
+extern void xt_unregister_target(struct xt_target *target);
+extern int xt_register_match(struct xt_match *target);
+extern void xt_unregister_match(struct xt_match *target);
 
 extern int xt_check_match(const struct xt_match *match, unsigned short family,
                           unsigned int size, const char *table, unsigned int hook,
diff --git a/include/linux/netfilter_arp/arp_tables.h b/include/linux/netfilter_arp/arp_tables.h
index fd21796e5131..62cc27daca4e 100644
--- a/include/linux/netfilter_arp/arp_tables.h
+++ b/include/linux/netfilter_arp/arp_tables.h
@@ -65,35 +65,8 @@ struct arpt_arp {
         u_int16_t invflags;
 };
 
-struct arpt_entry_target
-{
-        union {
-                struct {
-                        u_int16_t target_size;
-
-                        /* Used by userspace */
-                        char name[ARPT_FUNCTION_MAXNAMELEN-1];
-                        u_int8_t revision;
-                } user;
-                struct {
-                        u_int16_t target_size;
-
-                        /* Used inside the kernel */
-                        struct arpt_target *target;
-                } kernel;
-
-                /* Total length */
-                u_int16_t target_size;
-        } u;
-
-        unsigned char data[0];
-};
-
-struct arpt_standard_target
-{
-        struct arpt_entry_target target;
-        int verdict;
-};
+#define arpt_entry_target xt_entry_target
+#define arpt_standard_target xt_standard_target
 
 /* Values for "flag" field in struct arpt_ip (general arp structure).
  * No flags defined yet.
@@ -263,8 +236,10 @@ static __inline__ struct arpt_entry_target *arpt_get_target(struct arpt_entry *e
  */
 #ifdef __KERNEL__
 
-#define arpt_register_target(tgt) xt_register_target(NF_ARP, tgt)
-#define arpt_unregister_target(tgt) xt_unregister_target(NF_ARP, tgt)
+#define arpt_register_target(tgt)       \
+({      (tgt)->family = NF_ARP;         \
+        xt_register_target(tgt); })
+#define arpt_unregister_target(tgt) xt_unregister_target(tgt)
 
 extern int arpt_register_table(struct arpt_table *table,
                                const struct arpt_replace *repl);
diff --git a/include/linux/netfilter_ipv4/ip_conntrack.h b/include/linux/netfilter_ipv4/ip_conntrack.h
index 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 notifier_block *ip_conntrack_expect_chain;
+extern struct atomic_notifier_head ip_conntrack_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/netfilter_ipv4/ip_tables.h b/include/linux/netfilter_ipv4/ip_tables.h
index 76ba24b68515..d5b8c0d6a12b 100644
--- a/include/linux/netfilter_ipv4/ip_tables.h
+++ b/include/linux/netfilter_ipv4/ip_tables.h
@@ -52,61 +52,9 @@ struct ipt_ip {
         u_int8_t invflags;
 };
 
-struct ipt_entry_match
-{
-        union {
-                struct {
-                        u_int16_t match_size;
-
-                        /* Used by userspace */
-                        char name[IPT_FUNCTION_MAXNAMELEN-1];
-
-                        u_int8_t revision;
-                } user;
-                struct {
-                        u_int16_t match_size;
-
-                        /* Used inside the kernel */
-                        struct ipt_match *match;
-                } kernel;
-
-                /* Total length */
-                u_int16_t match_size;
-        } u;
-
-        unsigned char data[0];
-};
-
-struct ipt_entry_target
-{
-        union {
-                struct {
-                        u_int16_t target_size;
-
-                        /* Used by userspace */
-                        char name[IPT_FUNCTION_MAXNAMELEN-1];
-
-                        u_int8_t revision;
-                } user;
-                struct {
-                        u_int16_t target_size;
-
-                        /* Used inside the kernel */
-                        struct ipt_target *target;
-                } kernel;
-
-                /* Total length */
-                u_int16_t target_size;
-        } u;
-
-        unsigned char data[0];
-};
-
-struct ipt_standard_target
-{
-        struct ipt_entry_target target;
-        int verdict;
-};
+#define ipt_entry_match xt_entry_match
+#define ipt_entry_target xt_entry_target
+#define ipt_standard_target xt_standard_target
 
 #define ipt_counters xt_counters
 
@@ -321,11 +269,15 @@ ipt_get_target(struct ipt_entry *e)
 #include <linux/init.h>
 extern void ipt_init(void) __init;
 
-#define ipt_register_target(tgt) xt_register_target(AF_INET, tgt)
-#define ipt_unregister_target(tgt) xt_unregister_target(AF_INET, tgt)
+#define ipt_register_target(tgt)        \
+({      (tgt)->family = AF_INET;        \
+        xt_register_target(tgt); })
+#define ipt_unregister_target(tgt) xt_unregister_target(tgt)
 
-#define ipt_register_match(mtch) xt_register_match(AF_INET, mtch)
-#define ipt_unregister_match(mtch) xt_unregister_match(AF_INET, mtch)
+#define ipt_register_match(mtch)        \
+({      (mtch)->family = AF_INET;       \
+        xt_register_match(mtch); })
+#define ipt_unregister_match(mtch) xt_unregister_match(mtch)
 
 //#define ipt_register_table(tbl, repl) xt_register_table(AF_INET, tbl, repl)
 //#define ipt_unregister_table(tbl) xt_unregister_table(AF_INET, tbl)
diff --git a/include/linux/netfilter_ipv6/ip6_tables.h b/include/linux/netfilter_ipv6/ip6_tables.h
index f249b574f0fa..d0d5d1ee4be3 100644
--- a/include/linux/netfilter_ipv6/ip6_tables.h
+++ b/include/linux/netfilter_ipv6/ip6_tables.h
@@ -56,60 +56,9 @@ struct ip6t_ip6 {
         u_int8_t invflags;
 };
 
-/* FIXME: If alignment in kernel different from userspace? --RR */
-struct ip6t_entry_match
-{
-        union {
-                struct {
-                        u_int16_t match_size;
-
-                        /* Used by userspace */
-                        char name[IP6T_FUNCTION_MAXNAMELEN-1];
-                        u_int8_t revision;
-                } user;
-                struct {
-                        u_int16_t match_size;
-
-                        /* Used inside the kernel */
-                        struct ip6t_match *match;
-                } kernel;
-
-                /* Total length */
-                u_int16_t match_size;
-        } u;
-
-        unsigned char data[0];
-};
-
-struct ip6t_entry_target
-{
-        union {
-                struct {
-                        u_int16_t target_size;
-
-                        /* Used by userspace */
-                        char name[IP6T_FUNCTION_MAXNAMELEN-1];
-                        u_int8_t revision;
-                } user;
-                struct {
-                        u_int16_t target_size;
-
-                        /* Used inside the kernel */
-                        struct ip6t_target *target;
-                } kernel;
-
-                /* Total length */
-                u_int16_t target_size;
-        } u;
-
-        unsigned char data[0];
-};
-
-struct ip6t_standard_target
-{
-        struct ip6t_entry_target target;
-        int verdict;
-};
+#define ip6t_entry_match xt_entry_match
+#define ip6t_entry_target xt_entry_target
+#define ip6t_standard_target xt_standard_target
 
 #define ip6t_counters   xt_counters
 
@@ -334,11 +283,15 @@ ip6t_get_target(struct ip6t_entry *e)
 #include <linux/init.h>
 extern void ip6t_init(void) __init;
 
-#define ip6t_register_target(tgt) xt_register_target(AF_INET6, tgt)
-#define ip6t_unregister_target(tgt) xt_unregister_target(AF_INET6, tgt)
+#define ip6t_register_target(tgt)               \
+({      (tgt)->family = AF_INET6;               \
+        xt_register_target(tgt); })
+#define ip6t_unregister_target(tgt) xt_unregister_target(tgt)
 
-#define ip6t_register_match(match) xt_register_match(AF_INET6, match)
-#define ip6t_unregister_match(match) xt_unregister_match(AF_INET6, match)
+#define ip6t_register_match(match)              \
+({      (match)->family = AF_INET6;             \
+        xt_register_match(match); })
+#define ip6t_unregister_match(match) xt_unregister_match(match)
 
 extern int ip6t_register_table(struct ip6t_table *table,
                                const struct ip6t_replace *repl);
diff --git a/include/linux/nfs_fs.h b/include/linux/nfs_fs.h
index b4dc6e2e10c9..c71227dd4389 100644
--- a/include/linux/nfs_fs.h
+++ b/include/linux/nfs_fs.h
@@ -56,9 +56,7 @@
  * When flushing a cluster of dirty pages, there can be different
  * strategies:
  */
-#define FLUSH_AGING             0       /* only flush old buffers */
 #define FLUSH_SYNC              1       /* file being synced, or contention */
-#define FLUSH_WAIT              2       /* wait for completion */
 #define FLUSH_STABLE            4       /* commit to stable storage */
 #define FLUSH_LOWPRI            8       /* low priority background flush */
 #define FLUSH_HIGHPRI           16      /* high priority memory reclaim flush */
@@ -78,6 +76,7 @@ struct nfs_access_entry {
 struct nfs4_state;
 struct nfs_open_context {
         atomic_t count;
+        struct vfsmount *vfsmnt;
         struct dentry *dentry;
         struct rpc_cred *cred;
         struct nfs4_state *state;
@@ -118,8 +117,7 @@ struct nfs_inode {
         unsigned long           cache_validity;         /* bit mask */
 
         /*
-         * read_cache_jiffies is when we started read-caching this inode,
-         * and read_cache_mtime is the mtime of the inode at that time.
+         * read_cache_jiffies is when we started read-caching this inode.
          * attrtimeo is for how long the cached information is assumed
          * to be valid. A successful attribute revalidation doubles
          * attrtimeo (up to acregmax/acdirmax), a failure resets it to
@@ -128,11 +126,6 @@ struct nfs_inode {
          * We need to revalidate the cached attrs for this inode if
          *
          *      jiffies - read_cache_jiffies > attrtimeo
-         *
-         * and invalidate any cached data/flush out any dirty pages if
-         * we find that
-         *
-         *      mtime != read_cache_mtime
          */
         unsigned long           read_cache_jiffies;
         unsigned long           attrtimeo;
@@ -311,12 +304,9 @@ extern void nfs_begin_attr_update(struct inode *);
 extern void nfs_end_attr_update(struct inode *);
 extern void nfs_begin_data_update(struct inode *);
 extern void nfs_end_data_update(struct inode *);
-extern struct nfs_open_context *alloc_nfs_open_context(struct dentry *dentry, struct rpc_cred *cred);
 extern struct nfs_open_context *get_nfs_open_context(struct nfs_open_context *ctx);
 extern void put_nfs_open_context(struct nfs_open_context *ctx);
-extern void nfs_file_set_open_context(struct file *filp, struct nfs_open_context *ctx);
 extern struct nfs_open_context *nfs_find_open_context(struct inode *inode, struct rpc_cred *cred, int mode);
-extern void nfs_file_clear_open_context(struct file *filp);
 
 /* linux/net/ipv4/ipconfig.c: trims ip addr off front of name, too. */
 extern u32 root_nfs_parse_addr(char *name); /*__init*/
@@ -334,7 +324,7 @@ extern struct inode_operations nfs_file_inode_operations;
 #ifdef CONFIG_NFS_V3
 extern struct inode_operations nfs3_file_inode_operations;
 #endif /* CONFIG_NFS_V3 */
-extern struct file_operations nfs_file_operations;
+extern const struct file_operations nfs_file_operations;
 extern struct address_space_operations nfs_file_aops;
 
 static inline struct rpc_cred *nfs_file_cred(struct file *file)
@@ -381,7 +371,7 @@ extern struct inode_operations nfs_dir_inode_operations;
 #ifdef CONFIG_NFS_V3
 extern struct inode_operations nfs3_dir_inode_operations;
 #endif /* CONFIG_NFS_V3 */
-extern struct file_operations nfs_dir_operations;
+extern const struct file_operations nfs_dir_operations;
 extern struct dentry_operations nfs_dentry_operations;
 
 extern int nfs_instantiate(struct dentry *dentry, struct nfs_fh *fh, struct nfs_fattr *fattr);
@@ -415,21 +405,22 @@ extern int  nfs_writepage(struct page *page, struct writeback_control *wbc);
 extern int  nfs_writepages(struct address_space *, struct writeback_control *);
 extern int  nfs_flush_incompatible(struct file *file, struct page *page);
 extern int  nfs_updatepage(struct file *, struct page *, unsigned int, unsigned int);
-extern void nfs_writeback_done(struct rpc_task *task, void *data);
-extern void nfs_writedata_release(void *data);
+extern int nfs_writeback_done(struct rpc_task *, struct nfs_write_data *);
+extern void nfs_writedata_release(void *);
 
 #if defined(CONFIG_NFS_V3) || defined(CONFIG_NFS_V4)
-extern void nfs_commit_done(struct rpc_task *, void *data);
-extern void nfs_commit_release(void *data);
+struct nfs_write_data *nfs_commit_alloc(unsigned int pagecount);
+void nfs_commit_free(struct nfs_write_data *p);
 #endif
 
 /*
  * Try to write back everything synchronously (but check the
  * return value!)
  */
-extern int  nfs_sync_inode(struct inode *, unsigned long, unsigned int, int);
+extern int  nfs_sync_inode_wait(struct inode *, unsigned long, unsigned int, int);
 #if defined(CONFIG_NFS_V3) || defined(CONFIG_NFS_V4)
 extern int  nfs_commit_inode(struct inode *, int);
+extern void nfs_commit_release(void *wdata);
 #else
 static inline int
 nfs_commit_inode(struct inode *inode, int how)
@@ -447,7 +438,7 @@ nfs_have_writebacks(struct inode *inode)
 static inline int
 nfs_wb_all(struct inode *inode)
 {
-        int error = nfs_sync_inode(inode, 0, 0, FLUSH_WAIT);
+        int error = nfs_sync_inode_wait(inode, 0, 0, 0);
         return (error < 0) ? error : 0;
 }
 
@@ -456,8 +447,8 @@ nfs_wb_all(struct inode *inode)
  */
 static inline int nfs_wb_page_priority(struct inode *inode, struct page* page, int how)
 {
-        int error = nfs_sync_inode(inode, page->index, 1,
-                        how | FLUSH_WAIT | FLUSH_STABLE);
+        int error = nfs_sync_inode_wait(inode, page->index, 1,
+                        how | FLUSH_STABLE);
         return (error < 0) ? error : 0;
 }
 
@@ -469,37 +460,8 @@ static inline int nfs_wb_page(struct inode *inode, struct page* page)
 /*
  * Allocate and free nfs_write_data structures
  */
-extern mempool_t *nfs_wdata_mempool;
-
-static inline struct nfs_write_data *nfs_writedata_alloc(unsigned int pagecount)
-{
-        struct nfs_write_data *p = mempool_alloc(nfs_wdata_mempool, SLAB_NOFS);
-
-        if (p) {
-                memset(p, 0, sizeof(*p));
-                INIT_LIST_HEAD(&p->pages);
-                if (pagecount < NFS_PAGEVEC_SIZE)
-                        p->pagevec = &p->page_array[0];
-                else {
-                        size_t size = ++pagecount * sizeof(struct page *);
-                        p->pagevec = kmalloc(size, GFP_NOFS);
-                        if (p->pagevec) {
-                                memset(p->pagevec, 0, size);
-                        } else {
-                                mempool_free(p, nfs_wdata_mempool);
-                                p = NULL;
-                        }
-                }
-        }
-        return p;
-}
-
-static inline void nfs_writedata_free(struct nfs_write_data *p)
-{
-        if (p && (p->pagevec != &p->page_array[0]))
-                kfree(p->pagevec);
-        mempool_free(p, nfs_wdata_mempool);
-}
+extern struct nfs_write_data *nfs_writedata_alloc(unsigned int pagecount);
+extern void nfs_writedata_free(struct nfs_write_data *p);
 
 /*
  * linux/fs/nfs/read.c
@@ -507,44 +469,14 @@ static inline void nfs_writedata_free(struct nfs_write_data *p)
 extern int  nfs_readpage(struct file *, struct page *);
 extern int  nfs_readpages(struct file *, struct address_space *,
                 struct list_head *, unsigned);
-extern void nfs_readpage_result(struct rpc_task *, void *);
-extern void  nfs_readdata_release(void *data);
-
+extern int  nfs_readpage_result(struct rpc_task *, struct nfs_read_data *);
+extern void nfs_readdata_release(void *data);
 
 /*
  * Allocate and free nfs_read_data structures
  */
-extern mempool_t *nfs_rdata_mempool;
-
-static inline struct nfs_read_data *nfs_readdata_alloc(unsigned int pagecount)
-{
-        struct nfs_read_data *p = mempool_alloc(nfs_rdata_mempool, SLAB_NOFS);
-
-        if (p) {
-                memset(p, 0, sizeof(*p));
-                INIT_LIST_HEAD(&p->pages);
-                if (pagecount < NFS_PAGEVEC_SIZE)
-                        p->pagevec = &p->page_array[0];
-                else {
-                        size_t size = ++pagecount * sizeof(struct page *);
-                        p->pagevec = kmalloc(size, GFP_NOFS);
-                        if (p->pagevec) {
-                                memset(p->pagevec, 0, size);
-                        } else {
-                                mempool_free(p, nfs_rdata_mempool);
-                                p = NULL;
-                        }
-                }
-        }
-        return p;
-}
-
-static inline void nfs_readdata_free(struct nfs_read_data *p)
-{
-        if (p && (p->pagevec != &p->page_array[0]))
-                kfree(p->pagevec);
-        mempool_free(p, nfs_rdata_mempool);
-}
+extern struct nfs_read_data *nfs_readdata_alloc(unsigned int pagecount);
+extern void nfs_readdata_free(struct nfs_read_data *p);
 
 /*
  * linux/fs/nfs3proc.c
diff --git a/include/linux/nfs_fs_i.h b/include/linux/nfs_fs_i.h
index e2c18dabff86..861730275ba0 100644
--- a/include/linux/nfs_fs_i.h
+++ b/include/linux/nfs_fs_i.h
@@ -12,8 +12,8 @@ struct nlm_lockowner;
  */
 struct nfs_lock_info {
         u32             state;
-        u32             flags;
         struct nlm_lockowner *owner;
+        struct list_head list;
 };
 
 struct nfs4_lock_state;
@@ -21,10 +21,4 @@ struct nfs4_lock_info {
         struct nfs4_lock_state *owner;
 };
 
-/*
- * Lock flag values
- */
-#define NFS_LCK_GRANTED         0x0001          /* lock has been granted */
-#define NFS_LCK_RECLAIM         0x0002          /* lock marked for reclaiming */
-
 #endif
diff --git a/include/linux/nfs_fs_sb.h b/include/linux/nfs_fs_sb.h
index 3d3a305488cf..65dec21af774 100644
--- a/include/linux/nfs_fs_sb.h
+++ b/include/linux/nfs_fs_sb.h
@@ -4,6 +4,8 @@
 #include <linux/list.h>
 #include <linux/backing-dev.h>
 
+struct nfs_iostats;
+
 /*
  * NFS client parameters stored in the superblock.
  */
@@ -12,6 +14,7 @@ struct nfs_server {
         struct rpc_clnt *       client_sys;     /* 2nd handle for FSINFO */
         struct rpc_clnt *       client_acl;     /* ACL RPC client handle */
         struct nfs_rpc_ops *    rpc_ops;        /* NFS protocol vector */
+        struct nfs_iostats *    io_stats;       /* I/O statistics */
         struct backing_dev_info backing_dev_info;
         int                     flags;          /* various flags */
         unsigned int            caps;           /* server capabilities */
@@ -26,10 +29,13 @@ struct nfs_server {
         unsigned int            acregmax;
         unsigned int            acdirmin;
         unsigned int            acdirmax;
+        unsigned long           retrans_timeo;  /* retransmit timeout */
+        unsigned int            retrans_count;  /* number of retransmit tries */
         unsigned int            namelen;
         char *                  hostname;       /* remote hostname */
         struct nfs_fh           fh;
         struct sockaddr_in      addr;
+        unsigned long           mount_time;     /* when this fs was mounted */
 #ifdef CONFIG_NFS_V4
         /* Our own IP address, as a null-terminated string.
          * This is used to generate the clientid, and the callback address.
diff --git a/include/linux/nfs_xdr.h b/include/linux/nfs_xdr.h
index 6d6f69ec5675..7fafc4c546b7 100644
--- a/include/linux/nfs_xdr.h
+++ b/include/linux/nfs_xdr.h
@@ -695,7 +695,6 @@ struct nfs_read_data {
 #ifdef CONFIG_NFS_V4
         unsigned long           timestamp;      /* For lease renewal */
 #endif
-        void (*complete) (struct nfs_read_data *, int);
         struct page             *page_array[NFS_PAGEVEC_SIZE + 1];
 };
 
@@ -714,7 +713,6 @@ struct nfs_write_data {
 #ifdef CONFIG_NFS_V4
         unsigned long           timestamp;      /* For lease renewal */
 #endif
-        void (*complete) (struct nfs_write_data *, int);
         struct page             *page_array[NFS_PAGEVEC_SIZE + 1];
 };
 
@@ -769,8 +767,11 @@ struct nfs_rpc_ops {
                              struct nfs_pathconf *);
         u32 *   (*decode_dirent)(u32 *, struct nfs_entry *, int plus);
         void    (*read_setup)   (struct nfs_read_data *);
+        int     (*read_done)  (struct rpc_task *, struct nfs_read_data *);
         void    (*write_setup)  (struct nfs_write_data *, int how);
+        int     (*write_done)  (struct rpc_task *, struct nfs_write_data *);
         void    (*commit_setup) (struct nfs_write_data *, int how);
+        int     (*commit_done) (struct rpc_task *, struct nfs_write_data *);
         int     (*file_open)   (struct inode *, struct file *);
         int     (*file_release) (struct inode *, struct file *);
         int     (*lock)(struct file *, int, struct file_lock *);
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 void svc_export_put(struct cache_head *item, struct cache_detail *cd);
-extern struct cache_detail svc_export_cache, svc_expkey_cache;
+extern struct cache_detail svc_export_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 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));
-}
+         struct cache_req *reqp);
 
 #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
-{
-        int (*notifier_call)(struct notifier_block *self, unsigned long, void *);
+/*
+ * Notifier chains are of three types:
+ *
+ *      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 notifier_chain_unregister(struct notifier_block **nl, struct notifier_block *n);
-extern int notifier_call_chain(struct notifier_block **n, unsigned long val, void *v);
+extern int atomic_notifier_chain_register(struct atomic_notifier_head *,
+                struct notifier_block *);
+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/oprofile.h b/include/linux/oprofile.h
index 559c4c38a9c7..0d514b252454 100644
--- a/include/linux/oprofile.h
+++ b/include/linux/oprofile.h
@@ -61,6 +61,16 @@ void oprofile_arch_exit(void);
  */
 void oprofile_add_sample(struct pt_regs * const regs, unsigned long event);
 
+/**
+ * Add an extended sample.  Use this when the PC is not from the regs, and
+ * we cannot determine if we're in kernel mode from the regs.
+ *
+ * This function does perform a backtrace.
+ *
+ */
+void oprofile_add_ext_sample(unsigned long pc, struct pt_regs * const regs,
+                                unsigned long event, int is_kernel);
+
 /* Use this instead when the PC value is not from the regs. Doesn't
  * backtrace. */
 void oprofile_add_pc(unsigned long pc, int is_kernel, unsigned long event);
@@ -74,10 +84,10 @@ void oprofile_add_trace(unsigned long eip);
  * the specified file operations.
  */
 int oprofilefs_create_file(struct super_block * sb, struct dentry * root,
-        char const * name, struct file_operations * fops);
+        char const * name, const struct file_operations * fops);
 
 int oprofilefs_create_file_perm(struct super_block * sb, struct dentry * root,
-        char const * name, struct file_operations * fops, int perm);
+        char const * name, const struct file_operations * fops, int perm);
  
 /** Create a file for read/write access to an unsigned long. */
 int oprofilefs_create_ulong(struct super_block * sb, struct dentry * root,
diff --git a/include/linux/page-flags.h b/include/linux/page-flags.h
index d52999c43336..9ea629c02a4b 100644
--- a/include/linux/page-flags.h
+++ b/include/linux/page-flags.h
@@ -86,8 +86,9 @@
  * - The __xxx_page_state variants can be used safely when interrupts are
  * disabled.
  * - The __xxx_page_state variants can be used if the field is only
- * modified from process context, or only modified from interrupt context.
- * In this case, the field should be commented here.
+ * modified from process context and protected from preemption, or only
+ * modified from interrupt context.  In this case, the field should be
+ * commented here.
  */
 struct page_state {
         unsigned long nr_dirty;         /* Dirty writeable pages */
@@ -239,22 +240,19 @@ extern void __mod_page_state_offset(unsigned long offset, unsigned long delta);
 #define __ClearPageDirty(page)  __clear_bit(PG_dirty, &(page)->flags)
 #define TestClearPageDirty(page) test_and_clear_bit(PG_dirty, &(page)->flags)
 
-#define SetPageLRU(page)        set_bit(PG_lru, &(page)->flags)
 #define PageLRU(page)           test_bit(PG_lru, &(page)->flags)
-#define TestSetPageLRU(page)    test_and_set_bit(PG_lru, &(page)->flags)
-#define TestClearPageLRU(page)  test_and_clear_bit(PG_lru, &(page)->flags)
+#define SetPageLRU(page)        set_bit(PG_lru, &(page)->flags)
+#define ClearPageLRU(page)      clear_bit(PG_lru, &(page)->flags)
+#define __ClearPageLRU(page)    __clear_bit(PG_lru, &(page)->flags)
 
 #define PageActive(page)        test_bit(PG_active, &(page)->flags)
 #define SetPageActive(page)     set_bit(PG_active, &(page)->flags)
 #define ClearPageActive(page)   clear_bit(PG_active, &(page)->flags)
-#define TestClearPageActive(page) test_and_clear_bit(PG_active, &(page)->flags)
-#define TestSetPageActive(page) test_and_set_bit(PG_active, &(page)->flags)
+#define __ClearPageActive(page) __clear_bit(PG_active, &(page)->flags)
 
 #define PageSlab(page)          test_bit(PG_slab, &(page)->flags)
-#define SetPageSlab(page)       set_bit(PG_slab, &(page)->flags)
-#define ClearPageSlab(page)     clear_bit(PG_slab, &(page)->flags)
-#define TestClearPageSlab(page) test_and_clear_bit(PG_slab, &(page)->flags)
-#define TestSetPageSlab(page)   test_and_set_bit(PG_slab, &(page)->flags)
+#define __SetPageSlab(page)     __set_bit(PG_slab, &(page)->flags)
+#define __ClearPageSlab(page)   __clear_bit(PG_slab, &(page)->flags)
 
 #ifdef CONFIG_HIGHMEM
 #define PageHighMem(page)       is_highmem(page_zone(page))
@@ -329,8 +327,8 @@ extern void __mod_page_state_offset(unsigned long offset, unsigned long delta);
 #define TestClearPageReclaim(page) test_and_clear_bit(PG_reclaim, &(page)->flags)
 
 #define PageCompound(page)      test_bit(PG_compound, &(page)->flags)
-#define SetPageCompound(page)   set_bit(PG_compound, &(page)->flags)
-#define ClearPageCompound(page) clear_bit(PG_compound, &(page)->flags)
+#define __SetPageCompound(page) __set_bit(PG_compound, &(page)->flags)
+#define __ClearPageCompound(page) __clear_bit(PG_compound, &(page)->flags)
 
 #ifdef CONFIG_SWAP
 #define PageSwapCache(page)     test_bit(PG_swapcache, &(page)->flags)
diff --git a/include/linux/pagemap.h b/include/linux/pagemap.h
index ee700c6eb442..839f0b3c23aa 100644
--- a/include/linux/pagemap.h
+++ b/include/linux/pagemap.h
@@ -51,6 +51,10 @@ static inline void mapping_set_gfp_mask(struct address_space *m, gfp_t mask)
 #define page_cache_release(page)        put_page(page)
 void release_pages(struct page **pages, int nr, int cold);
 
+#ifdef CONFIG_NUMA
+extern struct page *page_cache_alloc(struct address_space *x);
+extern struct page *page_cache_alloc_cold(struct address_space *x);
+#else
 static inline struct page *page_cache_alloc(struct address_space *x)
 {
         return alloc_pages(mapping_gfp_mask(x), 0);
@@ -60,6 +64,7 @@ static inline struct page *page_cache_alloc_cold(struct address_space *x)
 {
         return alloc_pages(mapping_gfp_mask(x)|__GFP_COLD, 0);
 }
+#endif
 
 typedef int filler_t(void *, struct page *);
 
diff --git a/include/linux/pci.h b/include/linux/pci.h
index fe1a2b02fc55..0aad5a378e95 100644
--- a/include/linux/pci.h
+++ b/include/linux/pci.h
@@ -95,6 +95,11 @@ enum pci_channel_state {
         pci_channel_io_perm_failure = (__force pci_channel_state_t) 3,
 };
 
+typedef unsigned short __bitwise pci_bus_flags_t;
+enum pci_bus_flags {
+        PCI_BUS_FLAGS_NO_MSI = (pci_bus_flags_t) 1,
+};
+
 /*
  * The pci_dev structure is used to describe PCI devices.
  */
@@ -203,7 +208,7 @@ struct pci_bus {
         char            name[48];
 
         unsigned short  bridge_ctl;     /* manage NO_ISA/FBB/et al behaviors */
-        unsigned short  pad2;
+        pci_bus_flags_t bus_flags;      /* Inherited by child busses */
         struct device           *bridge;
         struct class_device     class_dev;
         struct bin_attribute    *legacy_io; /* legacy I/O for this bus */
@@ -485,9 +490,9 @@ void pdev_sort_resources(struct pci_dev *, struct resource_list *);
 void pci_fixup_irqs(u8 (*)(struct pci_dev *, u8 *),
                     int (*)(struct pci_dev *, u8, u8));
 #define HAVE_PCI_REQ_REGIONS    2
-int pci_request_regions(struct pci_dev *, char *);
+int pci_request_regions(struct pci_dev *, const char *);
 void pci_release_regions(struct pci_dev *);
-int pci_request_region(struct pci_dev *, int, char *);
+int pci_request_region(struct pci_dev *, int, const char *);
 void pci_release_region(struct pci_dev *, int);
 
 /* drivers/pci/bus.c */
@@ -516,6 +521,7 @@ int pci_scan_bridge(struct pci_bus *bus, struct pci_dev * dev, int max, int pass
 void pci_walk_bus(struct pci_bus *top, void (*cb)(struct pci_dev *, void *),
                   void *userdata);
 int pci_cfg_space_size(struct pci_dev *dev);
+unsigned char pci_bus_max_busnr(struct pci_bus* bus);
 
 /* kmem_cache style wrapper around pci_alloc_consistent() */
 
diff --git a/include/linux/pci_ids.h b/include/linux/pci_ids.h
index b9810ddf435a..870fe38378b1 100644
--- a/include/linux/pci_ids.h
+++ b/include/linux/pci_ids.h
@@ -69,6 +69,7 @@
 #define PCI_CLASS_SYSTEM_TIMER          0x0802
 #define PCI_CLASS_SYSTEM_RTC            0x0803
 #define PCI_CLASS_SYSTEM_PCI_HOTPLUG    0x0804
+#define PCI_CLASS_SYSTEM_SDHCI          0x0805
 #define PCI_CLASS_SYSTEM_OTHER          0x0880
 
 #define PCI_BASE_CLASS_INPUT            0x09
@@ -641,6 +642,7 @@
 #define PCI_DEVICE_ID_SI_965            0x0965
 #define PCI_DEVICE_ID_SI_5511           0x5511
 #define PCI_DEVICE_ID_SI_5513           0x5513
+#define PCI_DEVICE_ID_SI_5517           0x5517
 #define PCI_DEVICE_ID_SI_5518           0x5518
 #define PCI_DEVICE_ID_SI_5571           0x5571
 #define PCI_DEVICE_ID_SI_5581           0x5581
@@ -771,6 +773,7 @@
 #define PCI_DEVICE_ID_MOTOROLA_HAWK     0x4803
 #define PCI_DEVICE_ID_MOTOROLA_HARRIER  0x480b
 #define PCI_DEVICE_ID_MOTOROLA_MPC5200  0x5803
+#define PCI_DEVICE_ID_MOTOROLA_MPC5200B 0x5809
 
 #define PCI_VENDOR_ID_PROMISE           0x105a
 #define PCI_DEVICE_ID_PROMISE_20265     0x0d30
@@ -852,6 +855,8 @@
 #define PCI_DEVICE_ID_QLOGIC_ISP2432    0x2432
 #define PCI_DEVICE_ID_QLOGIC_ISP2512    0x2512
 #define PCI_DEVICE_ID_QLOGIC_ISP2522    0x2522
+#define PCI_DEVICE_ID_QLOGIC_ISP5422    0x5422
+#define PCI_DEVICE_ID_QLOGIC_ISP5432    0x5432
 
 #define PCI_VENDOR_ID_CYRIX             0x1078
 #define PCI_DEVICE_ID_CYRIX_5510        0x0000
@@ -1049,6 +1054,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
@@ -1369,6 +1375,7 @@
 #define PCI_DEVICE_ID_SERVERWORKS_OSB4    0x0200
 #define PCI_DEVICE_ID_SERVERWORKS_CSB5    0x0201
 #define PCI_DEVICE_ID_SERVERWORKS_CSB6    0x0203
+#define PCI_DEVICE_ID_SERVERWORKS_HT1000SB 0x0205
 #define PCI_DEVICE_ID_SERVERWORKS_OSB4IDE 0x0211
 #define PCI_DEVICE_ID_SERVERWORKS_CSB5IDE 0x0212
 #define PCI_DEVICE_ID_SERVERWORKS_CSB6IDE 0x0213
@@ -1862,11 +1869,13 @@
 #define PCI_DEVICE_ID_TIGON3_5780S      0x166b
 #define PCI_DEVICE_ID_TIGON3_5705F      0x166e
 #define PCI_DEVICE_ID_TIGON3_5754M      0x1672
+#define PCI_DEVICE_ID_TIGON3_5755M      0x1673
 #define PCI_DEVICE_ID_TIGON3_5750       0x1676
 #define PCI_DEVICE_ID_TIGON3_5751       0x1677
 #define PCI_DEVICE_ID_TIGON3_5715       0x1678
 #define PCI_DEVICE_ID_TIGON3_5715S      0x1679
 #define PCI_DEVICE_ID_TIGON3_5754       0x167a
+#define PCI_DEVICE_ID_TIGON3_5755       0x167b
 #define PCI_DEVICE_ID_TIGON3_5750M      0x167c
 #define PCI_DEVICE_ID_TIGON3_5751M      0x167d
 #define PCI_DEVICE_ID_TIGON3_5751F      0x167e
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/pid.h b/include/linux/pid.h
index 5b2fcb19d2da..5b9082cc600f 100644
--- a/include/linux/pid.h
+++ b/include/linux/pid.h
@@ -4,7 +4,6 @@
 enum pid_type
 {
         PIDTYPE_PID,
-        PIDTYPE_TGID,
         PIDTYPE_PGID,
         PIDTYPE_SID,
         PIDTYPE_MAX
@@ -38,7 +37,6 @@ extern struct pid *FASTCALL(find_pid(enum pid_type, int));
 
 extern int alloc_pidmap(void);
 extern void FASTCALL(free_pidmap(int));
-extern void switch_exec_pids(struct task_struct *leader, struct task_struct *thread);
 
 #define do_each_task_pid(who, type, task)                               \
         if ((task = find_task_by_pid_type(type, who))) {                \
diff --git a/include/linux/platform.h b/include/linux/platform.h
deleted file mode 100644
index 3c33084a6ec2..000000000000
--- a/include/linux/platform.h
+++ /dev/null
@@ -1,43 +0,0 @@
-/*
- * include/linux/platform.h - platform driver definitions
- *
- * Because of the prolific consumerism of the average American,
- * and the dominant marketing budgets of PC OEMs, we have been
- * blessed with frequent updates of the PC architecture. 
- *
- * While most of these calls are singular per architecture, they 
- * require an extra layer of abstraction on the x86 so the right
- * subsystem gets the right call. 
- *
- * Basically, this consolidates the power off and reboot callbacks 
- * into one structure, as well as adding power management hooks.
- *
- * When adding a platform driver, please make sure all callbacks are 
- * filled. There are defaults defined below that do nothing; use those
- * if you do not support that callback.
- */ 
-
-#ifndef _PLATFORM_H_
-#define _PLATFORM_H_
-#ifdef __KERNEL__
-
-#include <linux/types.h>
-
-struct platform_t {
-        char    * name;
-        u32     suspend_states;
-        void    (*reboot)(char * cmd);
-        void    (*halt)(void);
-        void    (*power_off)(void);
-        int     (*suspend)(int state, int flags);
-        void    (*idle)(void);
-};
-
-extern struct platform_t * platform;
-extern void default_reboot(char * cmd);
-extern void default_halt(void);
-extern int default_suspend(int state, int flags);
-extern void default_idle(void);
-
-#endif /* __KERNEL__ */
-#endif /* _PLATFORM_H */
diff --git a/include/linux/pm.h b/include/linux/pm.h
index 5be87ba3b7ac..6df2585c0169 100644
--- a/include/linux/pm.h
+++ b/include/linux/pm.h
@@ -188,6 +188,8 @@ extern void device_power_up(void);
 extern void device_resume(void);
 
 #ifdef CONFIG_PM
+extern suspend_disk_method_t pm_disk_mode;
+
 extern int device_suspend(pm_message_t state);
 
 #define device_set_wakeup_enable(dev,val) \
@@ -215,7 +217,6 @@ static inline int dpm_runtime_suspend(struct device * dev, pm_message_t state)
 
 static inline void dpm_runtime_resume(struct device * dev)
 {
-
 }
 
 #endif
diff --git a/include/linux/poll.h b/include/linux/poll.h
index 8e8f6098508a..51e1b56741fb 100644
--- a/include/linux/poll.h
+++ b/include/linux/poll.h
@@ -11,6 +11,15 @@
 #include <linux/mm.h>
 #include <asm/uaccess.h>
 
+/* ~832 bytes of stack space used max in sys_select/sys_poll before allocating
+   additional memory. */
+#define MAX_STACK_ALLOC 832
+#define FRONTEND_STACK_ALLOC    256
+#define SELECT_STACK_ALLOC      FRONTEND_STACK_ALLOC
+#define POLL_STACK_ALLOC        FRONTEND_STACK_ALLOC
+#define WQUEUES_STACK_ALLOC     (MAX_STACK_ALLOC - FRONTEND_STACK_ALLOC)
+#define N_INLINE_POLL_ENTRIES   (WQUEUES_STACK_ALLOC / sizeof(struct poll_table_entry))
+
 struct poll_table_struct;
 
 /* 
@@ -33,6 +42,12 @@ static inline void init_poll_funcptr(poll_table *pt, poll_queue_proc qproc)
         pt->qproc = qproc;
 }
 
+struct poll_table_entry {
+        struct file * filp;
+        wait_queue_t wait;
+        wait_queue_head_t * wait_address;
+};
+
 /*
  * Structures and helpers for sys_poll/sys_poll
  */
@@ -40,6 +55,8 @@ struct poll_wqueues {
         poll_table pt;
         struct poll_table_page * table;
         int error;
+        int inline_index;
+        struct poll_table_entry inline_entries[N_INLINE_POLL_ENTRIES];
 };
 
 extern void poll_initwait(struct poll_wqueues *pwq);
diff --git a/include/linux/ppdev.h b/include/linux/ppdev.h
index 141c96586824..f376a7598a78 100644
--- a/include/linux/ppdev.h
+++ b/include/linux/ppdev.h
@@ -14,8 +14,6 @@
  * Added PPGETMODES/PPGETMODE/PPGETPHASE, Fred Barnes <frmb2@ukc.ac.uk>, 03/01/2001
  */
 
-#define PP_MAJOR        99
-
 #define PP_IOCTL        'p'
 
 /* Set mode for read/write (e.g. IEEE1284_MODE_EPP) */
diff --git a/include/linux/proc_fs.h b/include/linux/proc_fs.h
index aa6322d45198..135871df9911 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,9 +56,9 @@ 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;
+        const struct file_operations * proc_fops;
         get_info_t *get_info;
         struct module *owner;
         struct proc_dir_entry *next, *parent, *subdir;
@@ -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);
 
@@ -125,9 +128,9 @@ extern int proc_match(int, const char *,struct proc_dir_entry *);
 extern int proc_readdir(struct file *, void *, filldir_t);
 extern struct dentry *proc_lookup(struct inode *, struct dentry *, struct nameidata *);
 
-extern struct file_operations proc_kcore_operations;
-extern struct file_operations proc_kmsg_operations;
-extern struct file_operations ppc_htab_operations;
+extern const struct file_operations proc_kcore_operations;
+extern const struct file_operations proc_kmsg_operations;
+extern const struct file_operations ppc_htab_operations;
 
 /*
  * proc_tty.c
@@ -186,7 +189,7 @@ static inline struct proc_dir_entry *proc_net_create(const char *name,
 }
 
 static inline struct proc_dir_entry *proc_net_fops_create(const char *name,
-        mode_t mode, struct file_operations *fops)
+        mode_t mode, const struct file_operations *fops)
 {
         struct proc_dir_entry *res = create_proc_entry(name, mode, proc_net);
         if (res)
diff --git a/include/linux/profile.h b/include/linux/profile.h
index 026969a5595c..1f2fea6640a4 100644
--- a/include/linux/profile.h
+++ b/include/linux/profile.h
@@ -14,6 +14,7 @@
 
 struct proc_dir_entry;
 struct pt_regs;
+struct notifier_block;
 
 /* init basic kernel profiler */
 void __init profile_init(void);
@@ -32,7 +33,6 @@ enum profile_type {
 
 #ifdef CONFIG_PROFILING
 
-struct notifier_block;
 struct task_struct;
 struct mm_struct;
 
diff --git a/include/linux/qnx4_fs.h b/include/linux/qnx4_fs.h
index fc610bb0f733..27f49c85d5d6 100644
--- a/include/linux/qnx4_fs.h
+++ b/include/linux/qnx4_fs.h
@@ -118,8 +118,8 @@ extern struct buffer_head *qnx4_bread(struct inode *, int, int);
 
 extern struct inode_operations qnx4_file_inode_operations;
 extern struct inode_operations qnx4_dir_inode_operations;
-extern struct file_operations qnx4_file_operations;
-extern struct file_operations qnx4_dir_operations;
+extern const struct file_operations qnx4_file_operations;
+extern const struct file_operations qnx4_dir_operations;
 extern int qnx4_is_free(struct super_block *sb, long block);
 extern int qnx4_set_bitmap(struct super_block *sb, long block, int busy);
 extern int qnx4_create(struct inode *inode, struct dentry *dentry, int mode, struct nameidata *nd);
diff --git a/include/linux/quota.h b/include/linux/quota.h
index f33aeb22c26a..2dab71e1c3d1 100644
--- a/include/linux/quota.h
+++ b/include/linux/quota.h
@@ -38,6 +38,7 @@
 #include <linux/errno.h>
 #include <linux/types.h>
 #include <linux/spinlock.h>
+#include <linux/mutex.h>
 
 #define __DQUOT_VERSION__       "dquot_6.5.1"
 #define __DQUOT_NUM_VERSION__   6*10000+5*100+1
@@ -208,14 +209,13 @@ extern struct dqstats dqstats;
 #define DQ_FAKE_B       3       /* no limits only usage */
 #define DQ_READ_B       4       /* dquot was read into memory */
 #define DQ_ACTIVE_B     5       /* dquot is active (dquot_release not called) */
-#define DQ_WAITFREE_B   6       /* dquot being waited (by invalidate_dquots) */
 
 struct dquot {
         struct hlist_node dq_hash;      /* Hash list in memory */
         struct list_head dq_inuse;      /* List of all quotas */
         struct list_head dq_free;       /* Free list element */
         struct list_head dq_dirty;      /* List of dirty dquots */
-        struct semaphore dq_lock;       /* dquot IO lock */
+        struct mutex dq_lock;           /* dquot IO lock */
         atomic_t dq_count;              /* Use count */
         wait_queue_head_t dq_wait_unused;       /* Wait queue for dquot to become unused */
         struct super_block *dq_sb;      /* superblock this applies to */
@@ -285,8 +285,8 @@ struct quota_format_type {
 
 struct quota_info {
         unsigned int flags;                     /* Flags for diskquotas on this device */
-        struct semaphore dqio_sem;              /* lock device while I/O in progress */
-        struct semaphore dqonoff_sem;           /* Serialize quotaon & quotaoff */
+        struct mutex dqio_mutex;                /* lock device while I/O in progress */
+        struct mutex dqonoff_mutex;             /* Serialize quotaon & quotaoff */
         struct rw_semaphore dqptr_sem;          /* serialize ops using quota_info struct, pointers from inode to dquots */
         struct inode *files[MAXQUOTAS];         /* inodes of quotafiles */
         struct mem_dqinfo info[MAXQUOTAS];      /* Information for each quota type */
diff --git a/include/linux/radix-tree.h b/include/linux/radix-tree.h
index c57ff2fcb30a..dd83cca28001 100644
--- a/include/linux/radix-tree.h
+++ b/include/linux/radix-tree.h
@@ -45,6 +45,8 @@ do {									\
         (root)->rnode = NULL;                                           \
 } while (0)
 
+#define RADIX_TREE_MAX_TAGS 2
+
 int radix_tree_insert(struct radix_tree_root *, unsigned long, void *);
 void *radix_tree_lookup(struct radix_tree_root *, unsigned long);
 void **radix_tree_lookup_slot(struct radix_tree_root *, unsigned long);
@@ -55,15 +57,16 @@ radix_tree_gang_lookup(struct radix_tree_root *root, void **results,
 int radix_tree_preload(gfp_t gfp_mask);
 void radix_tree_init(void);
 void *radix_tree_tag_set(struct radix_tree_root *root,
-                        unsigned long index, int tag);
+                        unsigned long index, unsigned int tag);
 void *radix_tree_tag_clear(struct radix_tree_root *root,
-                        unsigned long index, int tag);
+                        unsigned long index, unsigned int tag);
 int radix_tree_tag_get(struct radix_tree_root *root,
-                        unsigned long index, int tag);
+                        unsigned long index, unsigned int tag);
 unsigned int
 radix_tree_gang_lookup_tag(struct radix_tree_root *root, void **results,
-                unsigned long first_index, unsigned int max_items, int tag);
-int radix_tree_tagged(struct radix_tree_root *root, int tag);
+                unsigned long first_index, unsigned int max_items,
+                unsigned int tag);
+int radix_tree_tagged(struct radix_tree_root *root, unsigned int tag);
 
 static inline void radix_tree_preload_end(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/raid1.h b/include/linux/raid/raid1.h
index 9d5494aaac0f..3009c813d83d 100644
--- a/include/linux/raid/raid1.h
+++ b/include/linux/raid/raid1.h
@@ -130,6 +130,6 @@ struct r1bio_s {
  * with failure when last write completes (and all failed).
  * Record that bi_end_io was called with this flag...
  */
-#define R1BIO_Returned 4
+#define R1BIO_Returned 6
 
 #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/ramfs.h b/include/linux/ramfs.h
index 953b6df5d037..78ecfa28b1c2 100644
--- a/include/linux/ramfs.h
+++ b/include/linux/ramfs.h
@@ -15,7 +15,7 @@ extern unsigned long ramfs_nommu_get_unmapped_area(struct file *file,
 extern int ramfs_nommu_mmap(struct file *file, struct vm_area_struct *vma);
 #endif
 
-extern struct file_operations ramfs_file_operations;
+extern const struct file_operations ramfs_file_operations;
 extern struct vm_operations_struct generic_file_vm_ops;
 
 #endif
diff --git a/include/linux/rcupdate.h b/include/linux/rcupdate.h
index c2ec6c77874e..5673008b61e1 100644
--- a/include/linux/rcupdate.h
+++ b/include/linux/rcupdate.h
@@ -113,8 +113,6 @@ struct rcu_data {
 
 DECLARE_PER_CPU(struct rcu_data, rcu_data);
 DECLARE_PER_CPU(struct rcu_data, rcu_bh_data);
-extern struct rcu_ctrlblk rcu_ctrlblk;
-extern struct rcu_ctrlblk rcu_bh_ctrlblk;
 
 /*
  * Increment the quiescent state counter.
diff --git a/include/linux/reiserfs_fs.h b/include/linux/reiserfs_fs.h
index dad78cecfd20..5676c4210e2c 100644
--- a/include/linux/reiserfs_fs.h
+++ b/include/linux/reiserfs_fs.h
@@ -1704,6 +1704,11 @@ static inline int reiserfs_transaction_running(struct super_block *s)
         return 0;
 }
 
+static inline int reiserfs_transaction_free_space(struct reiserfs_transaction_handle *th)
+{
+        return th->t_blocks_allocated - th->t_blocks_logged;
+}
+
 int reiserfs_async_progress_wait(struct super_block *s);
 
 struct reiserfs_transaction_handle *reiserfs_persistent_transaction(struct
@@ -1955,7 +1960,7 @@ int reiserfs_global_version_in_proc(char *buffer, char **start, off_t offset,
 extern struct inode_operations reiserfs_dir_inode_operations;
 extern struct inode_operations reiserfs_symlink_inode_operations;
 extern struct inode_operations reiserfs_special_inode_operations;
-extern struct file_operations reiserfs_dir_operations;
+extern const struct file_operations reiserfs_dir_operations;
 
 /* tail_conversion.c */
 int direct2indirect(struct reiserfs_transaction_handle *, struct inode *,
@@ -1967,7 +1972,7 @@ void reiserfs_unmap_buffer(struct buffer_head *);
 
 /* file.c */
 extern struct inode_operations reiserfs_file_inode_operations;
-extern struct file_operations reiserfs_file_operations;
+extern const struct file_operations reiserfs_file_operations;
 extern struct address_space_operations reiserfs_address_space_operations;
 
 /* fix_nodes.c */
diff --git a/include/linux/reiserfs_xattr.h b/include/linux/reiserfs_xattr.h
index 87280eb6083d..5353afb11db3 100644
--- a/include/linux/reiserfs_xattr.h
+++ b/include/linux/reiserfs_xattr.h
@@ -101,13 +101,13 @@ static inline void reiserfs_mark_inode_private(struct inode *inode)
 #else
 
 #define is_reiserfs_priv_object(inode) 0
-#define reiserfs_mark_inode_private(inode)
+#define reiserfs_mark_inode_private(inode) do {;} while(0)
 #define reiserfs_getxattr NULL
 #define reiserfs_setxattr NULL
 #define reiserfs_listxattr NULL
 #define reiserfs_removexattr NULL
-#define reiserfs_write_lock_xattrs(sb)
-#define reiserfs_write_unlock_xattrs(sb)
+#define reiserfs_write_lock_xattrs(sb) do {;} while(0)
+#define reiserfs_write_unlock_xattrs(sb) do {;} while(0)
 #define reiserfs_read_lock_xattrs(sb)
 #define reiserfs_read_unlock_xattrs(sb)
 
diff --git a/include/linux/relayfs_fs.h b/include/linux/relay.h
index 7342e66247fb..4bcc1531d6a9 100644
--- a/include/linux/relayfs_fs.h
+++ b/include/linux/relay.h
@@ -1,14 +1,14 @@
 /*
- * linux/include/linux/relayfs_fs.h
+ * linux/include/linux/relay.h
  *
  * Copyright (C) 2002, 2003 - Tom Zanussi (zanussi@us.ibm.com), IBM Corp
  * Copyright (C) 1999, 2000, 2001, 2002 - Karim Yaghmour (karim@opersys.com)
  *
- * RelayFS definitions and declarations
+ * CONFIG_RELAY definitions and declarations
  */
 
-#ifndef _LINUX_RELAYFS_FS_H
-#define _LINUX_RELAYFS_FS_H
+#ifndef _LINUX_RELAY_H
+#define _LINUX_RELAY_H
 
 #include <linux/config.h>
 #include <linux/types.h>
@@ -19,6 +19,9 @@
 #include <linux/poll.h>
 #include <linux/kref.h>
 
+/* Needs a _much_ better name... */
+#define FIX_SIZE(x) ((((x) - 1) & PAGE_MASK) + PAGE_SIZE)
+
 /*
  * Tracks changes to rchan/rchan_buf structs
  */
@@ -92,26 +95,26 @@ struct rchan_callbacks
                              size_t prev_padding);
 
         /*
-         * buf_mapped - relayfs buffer mmap notification
+         * buf_mapped - relay buffer mmap notification
          * @buf: the channel buffer
-         * @filp: relayfs file pointer
+         * @filp: relay file pointer
          *
-         * Called when a relayfs file is successfully mmapped
+         * Called when a relay file is successfully mmapped
          */
         void (*buf_mapped)(struct rchan_buf *buf,
                            struct file *filp);
 
         /*
-         * buf_unmapped - relayfs buffer unmap notification
+         * buf_unmapped - relay buffer unmap notification
          * @buf: the channel buffer
-         * @filp: relayfs file pointer
+         * @filp: relay file pointer
          *
-         * Called when a relayfs file is successfully unmapped
+         * Called when a relay file is successfully unmapped
          */
         void (*buf_unmapped)(struct rchan_buf *buf,
                              struct file *filp);
         /*
-         * create_buf_file - create file to represent a relayfs channel buffer
+         * create_buf_file - create file to represent a relay channel buffer
          * @filename: the name of the file to create
          * @parent: the parent of the file to create
          * @mode: the mode of the file to create
@@ -121,7 +124,7 @@ struct rchan_callbacks
          * Called during relay_open(), once for each per-cpu buffer,
          * to allow the client to create a file to be used to
          * represent the corresponding channel buffer.  If the file is
-         * created outside of relayfs, the parent must also exist in
+         * created outside of relay, the parent must also exist in
          * that filesystem.
          *
          * The callback should return the dentry of the file created
@@ -140,7 +143,7 @@ struct rchan_callbacks
                                           int *is_global);
 
         /*
-         * remove_buf_file - remove file representing a relayfs channel buffer
+         * remove_buf_file - remove file representing a relay channel buffer
          * @dentry: the dentry of the file to remove
          *
          * Called during relay_close(), once for each per-cpu buffer,
@@ -153,7 +156,7 @@ struct rchan_callbacks
 };
 
 /*
- * relayfs kernel API, fs/relayfs/relay.c
+ * CONFIG_RELAY kernel API, kernel/relay.c
  */
 
 struct rchan *relay_open(const char *base_filename,
@@ -171,15 +174,6 @@ extern int relay_buf_full(struct rchan_buf *buf);
 
 extern size_t relay_switch_subbuf(struct rchan_buf *buf,
                                   size_t length);
-extern struct dentry *relayfs_create_dir(const char *name,
-                                         struct dentry *parent);
-extern int relayfs_remove_dir(struct dentry *dentry);
-extern struct dentry *relayfs_create_file(const char *name,
-                                          struct dentry *parent,
-                                          int mode,
-                                          struct file_operations *fops,
-                                          void *data);
-extern int relayfs_remove_file(struct dentry *dentry);
 
 /**
  *      relay_write - write data into the channel
@@ -279,9 +273,9 @@ static inline void subbuf_start_reserve(struct rchan_buf *buf,
 }
 
 /*
- * exported relay file operations, fs/relayfs/inode.c
+ * exported relay file operations, kernel/relay.c
  */
 extern struct file_operations relay_file_operations;
 
-#endif /* _LINUX_RELAYFS_FS_H */
+#endif /* _LINUX_RELAY_H */
 
diff --git a/include/linux/rtc.h b/include/linux/rtc.h
index 0b2ba67ff13c..ab61cd1199f2 100644
--- a/include/linux/rtc.h
+++ b/include/linux/rtc.h
@@ -11,8 +11,6 @@
 #ifndef _LINUX_RTC_H_
 #define _LINUX_RTC_H_
 
-#include <linux/interrupt.h>
-
 /*
  * The struct used to pass data via the following ioctl. Similar to the
  * struct tm in <time.h>, but it needs to be here so that the kernel 
@@ -93,8 +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/rtnetlink.h b/include/linux/rtnetlink.h
index d572d5376319..df0cdd41085c 100644
--- a/include/linux/rtnetlink.h
+++ b/include/linux/rtnetlink.h
@@ -839,6 +839,7 @@ enum
 #define RTMGRP_IPV4_IFADDR      0x10
 #define RTMGRP_IPV4_MROUTE      0x20
 #define RTMGRP_IPV4_ROUTE       0x40
+#define RTMGRP_IPV4_RULE        0x80
 
 #define RTMGRP_IPV6_IFADDR      0x100
 #define RTMGRP_IPV6_MROUTE      0x200
@@ -869,7 +870,8 @@ enum rtnetlink_groups {
 #define RTNLGRP_IPV4_MROUTE     RTNLGRP_IPV4_MROUTE
         RTNLGRP_IPV4_ROUTE,
 #define RTNLGRP_IPV4_ROUTE      RTNLGRP_IPV4_ROUTE
-        RTNLGRP_NOP1,
+        RTNLGRP_IPV4_RULE,
+#define RTNLGRP_IPV4_RULE       RTNLGRP_IPV4_RULE
         RTNLGRP_IPV6_IFADDR,
 #define RTNLGRP_IPV6_IFADDR     RTNLGRP_IPV6_IFADDR
         RTNLGRP_IPV6_MROUTE,
diff --git a/include/linux/sched.h b/include/linux/sched.h
index 62e6314382f0..d04186d8cc68 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 */
 
@@ -206,11 +207,11 @@ extern void update_process_times(int user);
 extern void scheduler_tick(void);
 
 #ifdef CONFIG_DETECT_SOFTLOCKUP
-extern void softlockup_tick(struct pt_regs *regs);
+extern void softlockup_tick(void);
 extern void spawn_softlockup_task(void);
 extern void touch_softlockup_watchdog(void);
 #else
-static inline void softlockup_tick(struct pt_regs *regs)
+static inline void softlockup_tick(void)
 {
 }
 static inline void spawn_softlockup_task(void)
@@ -354,16 +355,8 @@ struct sighand_struct {
         atomic_t                count;
         struct k_sigaction      action[_NSIG];
         spinlock_t              siglock;
-        struct rcu_head         rcu;
 };
 
-extern void sighand_free_cb(struct rcu_head *rhp);
-
-static inline void sighand_free(struct sighand_struct *sp)
-{
-        call_rcu(&sp->rcu, sighand_free_cb);
-}
-
 /*
  * NOTE! "signal_struct" does not have it's own
  * locking, because a shared signal_struct always
@@ -402,6 +395,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 */
@@ -706,6 +700,7 @@ struct task_struct {
         prio_array_t *array;
 
         unsigned short ioprio;
+        unsigned int btrace_seq;
 
         unsigned long sleep_avg;
         unsigned long long timestamp, last_ran;
@@ -757,6 +752,7 @@ struct task_struct {
 
         /* PID/PID hash table linkage. */
         struct pid pids[PIDTYPE_MAX];
+        struct list_head thread_group;
 
         struct completion *vfork_done;          /* for vfork() */
         int __user *set_child_tid;              /* CLONE_CHILD_SETTID */
@@ -868,7 +864,13 @@ struct task_struct {
         struct cpuset *cpuset;
         nodemask_t mems_allowed;
         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;
 };
@@ -928,6 +930,9 @@ static inline void put_task_struct(struct task_struct *t)
 #define PF_BORROWED_MM  0x00400000      /* I am a kthread doing use_mm */
 #define PF_RANDOMIZE    0x00800000      /* randomize virtual address space */
 #define PF_SWAPWRITE    0x01000000      /* Allowed to write to swap */
+#define PF_SPREAD_PAGE  0x04000000      /* Spread page cache over cpuset */
+#define PF_SPREAD_SLAB  0x08000000      /* Spread some slab caches over cpuset */
+#define PF_MEMPOLICY    0x10000000      /* Non-default NUMA mempolicy */
 
 /*
  * Only the _current_ task can read/write to tsk->flags, but other
@@ -1089,7 +1094,6 @@ extern void force_sig_specific(int, struct task_struct *);
 extern int send_sig(int, struct task_struct *, int);
 extern void zap_other_threads(struct task_struct *p);
 extern int kill_pg(pid_t, int, int);
-extern int kill_sl(pid_t, int, int);
 extern int kill_proc(pid_t, int, int);
 extern struct sigqueue *sigqueue_alloc(void);
 extern void sigqueue_free(struct sigqueue *);
@@ -1146,10 +1150,8 @@ extern void flush_thread(void);
 extern void exit_thread(void);
 
 extern void exit_files(struct task_struct *);
-extern void exit_signal(struct task_struct *);
-extern void __exit_signal(struct task_struct *);
-extern void exit_sighand(struct task_struct *);
-extern void __exit_sighand(struct task_struct *);
+extern void __cleanup_signal(struct signal_struct *);
+extern void __cleanup_sighand(struct sighand_struct *);
 extern void exit_itimers(struct signal_struct *);
 
 extern NORET_TYPE void do_group_exit(int);
@@ -1173,19 +1175,7 @@ extern void wait_task_inactive(task_t * p);
 #endif
 
 #define remove_parent(p)        list_del_init(&(p)->sibling)
-#define add_parent(p, parent)   list_add_tail(&(p)->sibling,&(parent)->children)
-
-#define REMOVE_LINKS(p) do {                                    \
-        if (thread_group_leader(p))                             \
-                list_del_init(&(p)->tasks);                     \
-        remove_parent(p);                                       \
-        } while (0)
-
-#define SET_LINKS(p) do {                                       \
-        if (thread_group_leader(p))                             \
-                list_add_tail(&(p)->tasks,&init_task.tasks);    \
-        add_parent(p, (p)->parent);                             \
-        } while (0)
+#define add_parent(p)           list_add_tail(&(p)->sibling,&(p)->parent->children)
 
 #define next_task(p)    list_entry((p)->tasks.next, struct task_struct, tasks)
 #define prev_task(p)    list_entry((p)->tasks.prev, struct task_struct, tasks)
@@ -1203,20 +1193,22 @@ extern void wait_task_inactive(task_t * p);
 #define while_each_thread(g, t) \
         while ((t = next_thread(t)) != g)
 
-extern task_t * FASTCALL(next_thread(const task_t *p));
-
 #define thread_group_leader(p)  (p->pid == p->tgid)
 
+static inline task_t *next_thread(task_t *p)
+{
+        return list_entry(rcu_dereference(p->thread_group.next),
+                                task_t, thread_group);
+}
+
 static inline int thread_group_empty(task_t *p)
 {
-        return list_empty(&p->pids[PIDTYPE_TGID].pid_list);
+        return list_empty(&p->thread_group);
 }
 
 #define delay_group_leader(p) \
                 (thread_group_leader(p) && !thread_group_empty(p))
 
-extern void unhash_process(struct task_struct *p);
-
 /*
  * Protects ->fs, ->files, ->mm, ->ptrace, ->group_info, ->comm, keyring
  * subscriptions and synchronises with wait4().  Also used in procfs.  Also
@@ -1236,6 +1228,15 @@ static inline void task_unlock(struct task_struct *p)
         spin_unlock(&p->alloc_lock);
 }
 
+extern struct sighand_struct *lock_task_sighand(struct task_struct *tsk,
+                                                        unsigned long *flags);
+
+static inline void unlock_task_sighand(struct task_struct *tsk,
+                                                unsigned long *flags)
+{
+        spin_unlock_irqrestore(&tsk->sighand->siglock, *flags);
+}
+
 #ifndef __HAVE_THREAD_FUNCTIONS
 
 #define task_thread_info(task) (task)->thread_info
diff --git a/include/linux/security.h b/include/linux/security.h
index b18eb8cfa639..aaa0a5cdbf75 100644
--- a/include/linux/security.h
+++ b/include/linux/security.h
@@ -869,6 +869,11 @@ struct swap_info_struct;
  *      @ipcp contains the kernel IPC permission structure
  *      @flag contains the desired (requested) permission set
  *      Return 0 if permission is granted.
+ * @ipc_getsecurity:
+ *      Copy the security label associated with the ipc object into
+ *      @buffer.  @buffer may be NULL to request the size of the buffer 
+ *      required.  @size indicates the size of @buffer in bytes. Return 
+ *      number of bytes used/required on success.
  *
  * Security hooks for individual messages held in System V IPC message queues
  * @msg_msg_alloc_security:
@@ -1040,6 +1045,11 @@ struct swap_info_struct;
  *      @effective contains the effective capability set.
  *      @inheritable contains the inheritable capability set.
  *      @permitted contains the permitted capability set.
+ * @capable:
+ *      Check whether the @tsk process has the @cap capability.
+ *      @tsk contains the task_struct for the process.
+ *      @cap contains the capability <include/linux/capability.h>.
+ *      Return 0 if the capability is granted for @tsk.
  * @acct:
  *      Check permission before enabling or disabling process accounting.  If
  *      accounting is being enabled, then @file refers to the open file used to
@@ -1053,11 +1063,6 @@ struct swap_info_struct;
  *      @table contains the ctl_table structure for the sysctl variable.
  *      @op contains the operation (001 = search, 002 = write, 004 = read).
  *      Return 0 if permission is granted.
- * @capable:
- *      Check whether the @tsk process has the @cap capability.
- *      @tsk contains the task_struct for the process.
- *      @cap contains the capability <include/linux/capability.h>.
- *      Return 0 if the capability is granted for @tsk.
  * @syslog:
  *      Check permission before accessing the kernel message ring or changing
  *      logging to the console.
@@ -1099,9 +1104,9 @@ struct security_operations {
                             kernel_cap_t * effective,
                             kernel_cap_t * inheritable,
                             kernel_cap_t * permitted);
+        int (*capable) (struct task_struct * tsk, int cap);
         int (*acct) (struct file * file);
         int (*sysctl) (struct ctl_table * table, int op);
-        int (*capable) (struct task_struct * tsk, int cap);
         int (*quotactl) (int cmds, int type, int id, struct super_block * sb);
         int (*quota_on) (struct dentry * dentry);
         int (*syslog) (int type);
@@ -1168,7 +1173,8 @@ struct security_operations {
         int (*inode_getxattr) (struct dentry *dentry, char *name);
         int (*inode_listxattr) (struct dentry *dentry);
         int (*inode_removexattr) (struct dentry *dentry, char *name);
-        int (*inode_getsecurity)(struct inode *inode, const char *name, void *buffer, size_t size, int err);
+        const char *(*inode_xattr_getsuffix) (void);
+        int (*inode_getsecurity)(const struct inode *inode, const char *name, void *buffer, size_t size, int err);
         int (*inode_setsecurity)(struct inode *inode, const char *name, const void *value, size_t size, int flags);
         int (*inode_listsecurity)(struct inode *inode, char *buffer, size_t buffer_size);
 
@@ -1217,6 +1223,7 @@ struct security_operations {
         void (*task_to_inode)(struct task_struct *p, struct inode *inode);
 
         int (*ipc_permission) (struct kern_ipc_perm * ipcp, short flag);
+        int (*ipc_getsecurity)(struct kern_ipc_perm *ipcp, void *buffer, size_t size);
 
         int (*msg_msg_alloc_security) (struct msg_msg * msg);
         void (*msg_msg_free_security) (struct msg_msg * msg);
@@ -1347,6 +1354,11 @@ static inline void security_capset_set (struct task_struct *target,
         security_ops->capset_set (target, effective, inheritable, permitted);
 }
 
+static inline int security_capable(struct task_struct *tsk, int cap)
+{
+        return security_ops->capable(tsk, cap);
+}
+
 static inline int security_acct (struct file *file)
 {
         return security_ops->acct (file);
@@ -1675,7 +1687,12 @@ static inline int security_inode_removexattr (struct dentry *dentry, char *name)
         return security_ops->inode_removexattr (dentry, name);
 }
 
-static inline int security_inode_getsecurity(struct inode *inode, const char *name, void *buffer, size_t size, int err)
+static inline const char *security_inode_xattr_getsuffix(void)
+{
+        return security_ops->inode_xattr_getsuffix();
+}
+
+static inline int security_inode_getsecurity(const struct inode *inode, const char *name, void *buffer, size_t size, int err)
 {
         if (unlikely (IS_PRIVATE (inode)))
                 return 0;
@@ -1870,6 +1887,11 @@ static inline int security_ipc_permission (struct kern_ipc_perm *ipcp,
         return security_ops->ipc_permission (ipcp, flag);
 }
 
+static inline int security_ipc_getsecurity(struct kern_ipc_perm *ipcp, void *buffer, size_t size)
+{
+        return security_ops->ipc_getsecurity(ipcp, buffer, size);
+}
+
 static inline int security_msg_msg_alloc (struct msg_msg * msg)
 {
         return security_ops->msg_msg_alloc_security (msg);
@@ -2050,6 +2072,11 @@ static inline void security_capset_set (struct task_struct *target,
         cap_capset_set (target, effective, inheritable, permitted);
 }
 
+static inline int security_capable(struct task_struct *tsk, int cap)
+{
+        return cap_capable(tsk, cap);
+}
+
 static inline int security_acct (struct file *file)
 {
         return 0;
@@ -2317,7 +2344,12 @@ static inline int security_inode_removexattr (struct dentry *dentry, char *name)
         return cap_inode_removexattr(dentry, name);
 }
 
-static inline int security_inode_getsecurity(struct inode *inode, const char *name, void *buffer, size_t size, int err)
+static inline const char *security_inode_xattr_getsuffix (void)
+{
+        return NULL ;
+}
+
+static inline int security_inode_getsecurity(const struct inode *inode, const char *name, void *buffer, size_t size, int err)
 {
         return -EOPNOTSUPP;
 }
@@ -2500,6 +2532,11 @@ static inline int security_ipc_permission (struct kern_ipc_perm *ipcp,
         return 0;
 }
 
+static inline int security_ipc_getsecurity(struct kern_ipc_perm *ipcp, void *buffer, size_t size)
+{
+        return -EOPNOTSUPP;
+}
+
 static inline int security_msg_msg_alloc (struct msg_msg * msg)
 {
         return 0;
diff --git a/include/linux/seq_file.h b/include/linux/seq_file.h
index 850a974ee505..b95f6eb7254c 100644
--- a/include/linux/seq_file.h
+++ b/include/linux/seq_file.h
@@ -4,7 +4,7 @@
 
 #include <linux/types.h>
 #include <linux/string.h>
-#include <asm/semaphore.h>
+#include <linux/mutex.h>
 
 struct seq_operations;
 struct file;
@@ -19,7 +19,7 @@ struct seq_file {
         size_t count;
         loff_t index;
         loff_t version;
-        struct semaphore sem;
+        struct mutex lock;
         struct seq_operations *op;
         void *private;
 };
diff --git a/include/linux/serial_8250.h b/include/linux/serial_8250.h
index 73b464f0926a..8e9681413726 100644
--- a/include/linux/serial_8250.h
+++ b/include/linux/serial_8250.h
@@ -37,6 +37,7 @@ enum {
         PLAT8250_DEV_LEGACY = -1,
         PLAT8250_DEV_PLATFORM,
         PLAT8250_DEV_PLATFORM1,
+        PLAT8250_DEV_PLATFORM2,
         PLAT8250_DEV_FOURPORT,
         PLAT8250_DEV_ACCENT,
         PLAT8250_DEV_BOCA,
diff --git a/include/linux/serial_core.h b/include/linux/serial_core.h
index 57abcea1cb5d..c32e60e79dea 100644
--- a/include/linux/serial_core.h
+++ b/include/linux/serial_core.h
@@ -369,6 +369,9 @@ void uart_parse_options(char *options, int *baud, int *parity, int *bits,
 int uart_set_options(struct uart_port *port, struct console *co, int baud,
                      int parity, int bits, int flow);
 struct tty_driver *uart_console_device(struct console *co, int *index);
+void uart_console_write(struct uart_port *port, const char *s,
+                        unsigned int count,
+                        void (*putchar)(struct uart_port *, int));
 
 /*
  * Port/driver registration/removal
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/signal.h b/include/linux/signal.h
index b7d093520bb6..162a8fd10b29 100644
--- a/include/linux/signal.h
+++ b/include/linux/signal.h
@@ -249,6 +249,8 @@ static inline void init_sigpending(struct sigpending *sig)
         INIT_LIST_HEAD(&sig->list);
 }
 
+extern void flush_sigqueue(struct sigpending *queue);
+
 /* Test if 'sig' is valid signal. Use this instead of testing _NSIG directly */
 static inline int valid_signal(unsigned long sig)
 {
diff --git a/include/linux/slab.h b/include/linux/slab.h
index 8cf52939d0ab..3af03b19c983 100644
--- a/include/linux/slab.h
+++ b/include/linux/slab.h
@@ -38,7 +38,6 @@ typedef struct kmem_cache kmem_cache_t;
 #define SLAB_DEBUG_INITIAL      0x00000200UL    /* Call constructor (as verifier) */
 #define SLAB_RED_ZONE           0x00000400UL    /* Red zone objs in a cache */
 #define SLAB_POISON             0x00000800UL    /* Poison objects */
-#define SLAB_NO_REAP            0x00001000UL    /* never reap from the cache */
 #define SLAB_HWCACHE_ALIGN      0x00002000UL    /* align objs on a h/w cache lines */
 #define SLAB_CACHE_DMA          0x00004000UL    /* use GFP_DMA memory */
 #define SLAB_MUST_HWCACHE_ALIGN 0x00008000UL    /* force alignment */
@@ -47,6 +46,7 @@ typedef struct kmem_cache kmem_cache_t;
                                                    what is reclaimable later*/
 #define SLAB_PANIC              0x00040000UL    /* panic if kmem_cache_create() fails */
 #define SLAB_DESTROY_BY_RCU     0x00080000UL    /* defer freeing pages to RCU */
+#define SLAB_MEM_SPREAD         0x00100000UL    /* Spread some memory over cpuset */
 
 /* flags passed to a constructor func */
 #define SLAB_CTOR_CONSTRUCTOR   0x001UL         /* if not set, then deconstructor */
@@ -64,6 +64,7 @@ extern kmem_cache_t *kmem_cache_create(const char *, size_t, size_t, unsigned lo
 extern int kmem_cache_destroy(kmem_cache_t *);
 extern int kmem_cache_shrink(kmem_cache_t *);
 extern void *kmem_cache_alloc(kmem_cache_t *, gfp_t);
+extern void *kmem_cache_zalloc(struct kmem_cache *, gfp_t);
 extern void kmem_cache_free(kmem_cache_t *, void *);
 extern unsigned int kmem_cache_size(kmem_cache_t *);
 extern const char *kmem_cache_name(kmem_cache_t *);
@@ -77,11 +78,12 @@ struct cache_sizes {
 };
 extern struct cache_sizes malloc_sizes[];
 
-#ifndef CONFIG_DEBUG_SLAB
 extern void *__kmalloc(size_t, gfp_t);
+#ifndef CONFIG_DEBUG_SLAB
+#define ____kmalloc(size, flags) __kmalloc(size, flags)
 #else
 extern void *__kmalloc_track_caller(size_t, gfp_t, void*);
-#define __kmalloc(size, flags) \
+#define ____kmalloc(size, flags) \
     __kmalloc_track_caller(size, flags, __builtin_return_address(0))
 #endif
 
@@ -108,7 +110,30 @@ found:
         return __kmalloc(size, flags);
 }
 
-extern void *kzalloc(size_t, gfp_t);
+extern void *__kzalloc(size_t, gfp_t);
+
+static inline void *kzalloc(size_t size, gfp_t flags)
+{
+        if (__builtin_constant_p(size)) {
+                int i = 0;
+#define CACHE(x) \
+                if (size <= x) \
+                        goto found; \
+                else \
+                        i++;
+#include "kmalloc_sizes.h"
+#undef CACHE
+                {
+                        extern void __you_cannot_kzalloc_that_much(void);
+                        __you_cannot_kzalloc_that_much();
+                }
+found:
+                return kmem_cache_zalloc((flags & GFP_DMA) ?
+                        malloc_sizes[i].cs_dmacachep :
+                        malloc_sizes[i].cs_cachep, flags);
+        }
+        return __kzalloc(size, flags);
+}
 
 /**
  * kcalloc - allocate memory for an array. The memory is set to zero.
@@ -118,7 +143,7 @@ extern void *kzalloc(size_t, gfp_t);
  */
 static inline void *kcalloc(size_t n, size_t size, gfp_t flags)
 {
-        if (n != 0 && size > INT_MAX / n)
+        if (n != 0 && size > ULONG_MAX / n)
                 return NULL;
         return kzalloc(n * size, flags);
 }
@@ -155,17 +180,18 @@ struct kmem_cache *kmem_cache_create(const char *c, size_t, size_t,
         void (*)(void *, struct kmem_cache *, unsigned long));
 int kmem_cache_destroy(struct kmem_cache *c);
 void *kmem_cache_alloc(struct kmem_cache *c, gfp_t flags);
+void *kmem_cache_zalloc(struct kmem_cache *, gfp_t);
 void kmem_cache_free(struct kmem_cache *c, void *b);
 const char *kmem_cache_name(struct kmem_cache *);
 void *kmalloc(size_t size, gfp_t flags);
-void *kzalloc(size_t size, gfp_t flags);
+void *__kzalloc(size_t size, gfp_t flags);
 void kfree(const void *m);
 unsigned int ksize(const void *m);
 unsigned int kmem_cache_size(struct kmem_cache *c);
 
 static inline void *kcalloc(size_t n, size_t size, gfp_t flags)
 {
-        return kzalloc(n * size, flags);
+        return __kzalloc(n * size, flags);
 }
 
 #define kmem_cache_shrink(d) (0)
@@ -173,6 +199,8 @@ static inline void *kcalloc(size_t n, size_t size, gfp_t flags)
 #define kmem_ptr_validate(a, b) (0)
 #define kmem_cache_alloc_node(c, f, n) kmem_cache_alloc(c, f)
 #define kmalloc_node(s, f, n) kmalloc(s, f)
+#define kzalloc(s, f) __kzalloc(s, f)
+#define ____kmalloc kmalloc
 
 #endif /* CONFIG_SLOB */
 
@@ -182,7 +210,6 @@ extern kmem_cache_t	*names_cachep;
 extern kmem_cache_t     *files_cachep;
 extern kmem_cache_t     *filp_cachep;
 extern kmem_cache_t     *fs_cachep;
-extern kmem_cache_t     *signal_cachep;
 extern kmem_cache_t     *sighand_cachep;
 extern kmem_cache_t     *bio_cachep;
 
diff --git a/include/linux/smp.h b/include/linux/smp.h
index 44153fdf73fc..e2fa3ab4afc5 100644
--- a/include/linux/smp.h
+++ b/include/linux/smp.h
@@ -52,23 +52,12 @@ extern void smp_cpus_done(unsigned int max_cpus);
 /*
  * Call a function on all other processors
  */
-extern int smp_call_function (void (*func) (void *info), void *info,
-                              int retry, int wait);
+int smp_call_function(void(*func)(void *info), void *info, int retry, int wait);
 
 /*
  * Call a function on all processors
  */
-static inline int on_each_cpu(void (*func) (void *info), void *info,
-                              int retry, int wait)
-{
-        int ret = 0;
-
-        preempt_disable();
-        ret = smp_call_function(func, info, retry, wait);
-        func(info);
-        preempt_enable();
-        return ret;
-}
+int on_each_cpu(void (*func) (void *info), void *info, int retry, int wait);
 
 #define MSG_ALL_BUT_SELF        0x8000  /* Assume <32768 CPU's */
 #define MSG_ALL                 0x8001
@@ -93,8 +82,18 @@ 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; })
-#define on_each_cpu(func,info,retry,wait)       ({ func(info); 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();            \
+                func(info);                     \
+                local_irq_enable();             \
+                0;                              \
+        })
 static inline void smp_send_reschedule(int cpu) { }
 #define num_booting_cpus()                      1
 #define smp_prepare_boot_cpu()                  do {} while (0)
diff --git a/include/linux/sound.h b/include/linux/sound.h
index 72b9af4c3fd4..f63d8342ffa3 100644
--- a/include/linux/sound.h
+++ b/include/linux/sound.h
@@ -30,12 +30,12 @@
  */
  
 struct device;
-extern int register_sound_special(struct file_operations *fops, int unit);
-extern int register_sound_special_device(struct file_operations *fops, int unit, struct device *dev);
-extern int register_sound_mixer(struct file_operations *fops, int dev);
-extern int register_sound_midi(struct file_operations *fops, int dev);
-extern int register_sound_dsp(struct file_operations *fops, int dev);
-extern int register_sound_synth(struct file_operations *fops, int dev);
+extern int register_sound_special(const struct file_operations *fops, int unit);
+extern int register_sound_special_device(const struct file_operations *fops, int unit, struct device *dev);
+extern int register_sound_mixer(const struct file_operations *fops, int dev);
+extern int register_sound_midi(const struct file_operations *fops, int dev);
+extern int register_sound_dsp(const struct file_operations *fops, int dev);
+extern int register_sound_synth(const struct file_operations *fops, int dev);
 
 extern void unregister_sound_special(int unit);
 extern void unregister_sound_mixer(int unit);
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;
-        sector_t f_bfree;
-        sector_t f_bavail;
-        sector_t f_files;
-        sector_t f_ffree;
+        u64 f_blocks;
+        u64 f_bfree;
+        u64 f_bavail;
+        u64 f_files;
+        u64 f_ffree;
         __kernel_fsid_t f_fsid;
         long f_namelen;
         long f_frsize;
diff --git a/include/linux/string.h b/include/linux/string.h
index 369be3264a55..dee221429ad0 100644
--- a/include/linux/string.h
+++ b/include/linux/string.h
@@ -18,6 +18,8 @@ extern char * strsep(char **,const char *);
 extern __kernel_size_t strspn(const char *,const char *);
 extern __kernel_size_t strcspn(const char *,const char *);
 
+extern char *strndup_user(const char __user *, long);
+
 /*
  * Include machine specific inline routines
  */
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 *,
-                                             struct cache_detail*);
+        void                    (*cache_put)(struct kref *);
 
         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.
- *
- *    
- * RTN is a struct type for a cache entry
- * MEMBER is the member of the cache which is cache_head, which must be first
- * FNAME is the name for the function   
- * 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;                                                                    \
-}
+extern struct cache_head *
+sunrpc_cache_lookup(struct cache_detail *detail,
+                    struct cache_head *key, int hash);
+extern struct cache_head *
+sunrpc_cache_update(struct cache_detail *detail,
+                    struct cache_head *new, struct cache_head *old, int hash);
 
-#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/clnt.h b/include/linux/sunrpc/clnt.h
index f147e6b84332..8fe9f35eba31 100644
--- a/include/linux/sunrpc/clnt.h
+++ b/include/linux/sunrpc/clnt.h
@@ -45,7 +45,8 @@ struct rpc_clnt {
         char *                  cl_server;      /* server machine name */
         char *                  cl_protname;    /* protocol name */
         struct rpc_auth *       cl_auth;        /* authenticator */
-        struct rpc_stat *       cl_stats;       /* statistics */
+        struct rpc_stat *       cl_stats;       /* per-program statistics */
+        struct rpc_iostats *    cl_metrics;     /* per-client statistics */
 
         unsigned int            cl_softrtry : 1,/* soft timeouts */
                                 cl_intr     : 1,/* interruptible */
@@ -59,6 +60,7 @@ struct rpc_clnt {
         int                     cl_nodelen;     /* nodename length */
         char                    cl_nodename[UNX_MAXNODENAME];
         char                    cl_pathname[30];/* Path in rpc_pipe_fs */
+        struct vfsmount *       cl_vfsmnt;
         struct dentry *         cl_dentry;      /* inode */
         struct rpc_clnt *       cl_parent;      /* Points to parent of clones */
         struct rpc_rtt          cl_rtt_default;
@@ -100,6 +102,8 @@ struct rpc_procinfo {
         unsigned int            p_bufsiz;       /* req. buffer size */
         unsigned int            p_count;        /* call count */
         unsigned int            p_timer;        /* Which RTT timer to use */
+        u32                     p_statidx;      /* Which procedure to account */
+        char *                  p_name;         /* name of procedure */
 };
 
 #define RPC_CONGESTED(clnt)     (RPCXPRT_CONGESTED((clnt)->cl_xprt))
@@ -137,20 +141,6 @@ size_t		rpc_max_payload(struct rpc_clnt *);
 void            rpc_force_rebind(struct rpc_clnt *);
 int             rpc_ping(struct rpc_clnt *clnt, int flags);
 
-static __inline__
-int rpc_call(struct rpc_clnt *clnt, u32 proc, void *argp, void *resp, int flags)
-{
-        struct rpc_message msg = {
-                .rpc_proc       = &clnt->cl_procinfo[proc],
-                .rpc_argp       = argp,
-                .rpc_resp       = resp,
-                .rpc_cred       = NULL
-        };
-        return rpc_call_sync(clnt, &msg, flags);
-}
-                
-extern void rpciod_wake_up(void);
-
 /*
  * Helper function for NFSroot support
  */
diff --git a/include/linux/sunrpc/gss_krb5.h b/include/linux/sunrpc/gss_krb5.h
index 2c3601d31045..1279280d7196 100644
--- a/include/linux/sunrpc/gss_krb5.h
+++ b/include/linux/sunrpc/gss_krb5.h
@@ -53,6 +53,8 @@ struct krb5_ctx {
         struct xdr_netobj       mech_used;
 };
 
+extern spinlock_t krb5_seq_lock;
+
 #define KG_TOK_MIC_MSG    0x0101
 #define KG_TOK_WRAP_MSG   0x0201
 
diff --git a/include/linux/sunrpc/metrics.h b/include/linux/sunrpc/metrics.h
new file mode 100644
index 000000000000..8f96e9dc369a
--- /dev/null
+++ b/include/linux/sunrpc/metrics.h
@@ -0,0 +1,77 @@
+/*
+ *  linux/include/linux/sunrpc/metrics.h
+ *
+ *  Declarations for RPC client per-operation metrics
+ *
+ *  Copyright (C) 2005  Chuck Lever <cel@netapp.com>
+ *
+ *  RPC client per-operation statistics provide latency and retry
+ *  information about each type of RPC procedure in a given RPC program.
+ *  These statistics are not for detailed problem diagnosis, but simply
+ *  to indicate whether the problem is local or remote.
+ *
+ *  These counters are not meant to be human-readable, but are meant to be
+ *  integrated into system monitoring tools such as "sar" and "iostat".  As
+ *  such, the counters are sampled by the tools over time, and are never
+ *  zeroed after a file system is mounted.  Moving averages can be computed
+ *  by the tools by taking the difference between two instantaneous samples
+ *  and dividing that by the time between the samples.
+ *
+ *  The counters are maintained in a single array per RPC client, indexed
+ *  by procedure number.  There is no need to maintain separate counter
+ *  arrays per-CPU because these counters are always modified behind locks.
+ */
+
+#ifndef _LINUX_SUNRPC_METRICS_H
+#define _LINUX_SUNRPC_METRICS_H
+
+#include <linux/seq_file.h>
+
+#define RPC_IOSTATS_VERS        "1.0"
+
+struct rpc_iostats {
+        /*
+         * These counters give an idea about how many request
+         * transmissions are required, on average, to complete that
+         * particular procedure.  Some procedures may require more
+         * than one transmission because the server is unresponsive,
+         * the client is retransmitting too aggressively, or the
+         * requests are large and the network is congested.
+         */
+        unsigned long           om_ops,         /* count of operations */
+                                om_ntrans,      /* count of RPC transmissions */
+                                om_timeouts;    /* count of major timeouts */
+
+        /*
+         * These count how many bytes are sent and received for a
+         * given RPC procedure type.  This indicates how much load a
+         * particular procedure is putting on the network.  These
+         * counts include the RPC and ULP headers, and the request
+         * payload.
+         */
+        unsigned long long      om_bytes_sent,  /* count of bytes out */
+                                om_bytes_recv;  /* count of bytes in */
+
+        /*
+         * The length of time an RPC request waits in queue before
+         * transmission, the network + server latency of the request,
+         * and the total time the request spent from init to release
+         * are measured.
+         */
+        unsigned long long      om_queue,       /* jiffies queued for xmit */
+                                om_rtt,         /* jiffies for RPC RTT */
+                                om_execute;     /* jiffies for RPC execution */
+} ____cacheline_aligned;
+
+struct rpc_task;
+struct rpc_clnt;
+
+/*
+ * EXPORTed functions for managing rpc_iostats structures
+ */
+struct rpc_iostats *    rpc_alloc_iostats(struct rpc_clnt *);
+void                    rpc_count_iostats(struct rpc_task *);
+void                    rpc_print_iostats(struct seq_file *, struct rpc_clnt *);
+void                    rpc_free_iostats(struct rpc_iostats *);
+
+#endif /* _LINUX_SUNRPC_METRICS_H */
diff --git a/include/linux/sunrpc/rpc_pipe_fs.h b/include/linux/sunrpc/rpc_pipe_fs.h
index 63929349571f..2c2189cb30aa 100644
--- a/include/linux/sunrpc/rpc_pipe_fs.h
+++ b/include/linux/sunrpc/rpc_pipe_fs.h
@@ -45,6 +45,8 @@ extern struct dentry *rpc_mkdir(char *, struct rpc_clnt *);
 extern int rpc_rmdir(char *);
 extern struct dentry *rpc_mkpipe(char *, void *, struct rpc_pipe_ops *, int flags);
 extern int rpc_unlink(char *);
+extern struct vfsmount *rpc_get_mount(void);
+extern void rpc_put_mount(void);
 
 #endif
 #endif
diff --git a/include/linux/sunrpc/sched.h b/include/linux/sunrpc/sched.h
index 8b25629accd8..82a91bb22362 100644
--- a/include/linux/sunrpc/sched.h
+++ b/include/linux/sunrpc/sched.h
@@ -86,6 +86,12 @@ struct rpc_task {
                 struct work_struct      tk_work;        /* Async task work queue */
                 struct rpc_wait         tk_wait;        /* RPC wait */
         } u;
+
+        unsigned short          tk_timeouts;    /* maj timeouts */
+        size_t                  tk_bytes_sent;  /* total bytes sent */
+        unsigned long           tk_start;       /* RPC task init timestamp */
+        long                    tk_rtt;         /* round-trip time (jiffies) */
+
 #ifdef RPC_DEBUG
         unsigned short          tk_pid;         /* debugging aid */
 #endif
@@ -203,6 +209,7 @@ struct rpc_wait_queue {
         unsigned char           priority;               /* current priority */
         unsigned char           count;                  /* # task groups remaining serviced so far */
         unsigned char           nr;                     /* # tasks remaining for cookie */
+        unsigned short          qlen;                   /* total # tasks waiting in queue */
 #ifdef RPC_DEBUG
         const char *            name;
 #endif
@@ -269,13 +276,13 @@ void *		rpc_malloc(struct rpc_task *, size_t);
 void            rpc_free(struct rpc_task *);
 int             rpciod_up(void);
 void            rpciod_down(void);
-void            rpciod_wake_up(void);
 int             __rpc_wait_for_completion_task(struct rpc_task *task, int (*)(void *));
 #ifdef RPC_DEBUG
 void            rpc_show_tasks(void);
 #endif
 int             rpc_init_mempool(void);
 void            rpc_destroy_mempool(void);
+extern struct workqueue_struct *rpciod_workqueue;
 
 static inline void rpc_exit(struct rpc_task *task, int status)
 {
diff --git a/include/linux/sunrpc/stats.h b/include/linux/sunrpc/stats.h
index 0d6ed3c8bdc4..d93c24b47f3f 100644
--- a/include/linux/sunrpc/stats.h
+++ b/include/linux/sunrpc/stats.h
@@ -50,7 +50,7 @@ struct proc_dir_entry *	rpc_proc_register(struct rpc_stat *);
 void                    rpc_proc_unregister(const char *);
 void                    rpc_proc_zero(struct rpc_program *);
 struct proc_dir_entry * svc_proc_register(struct svc_stat *,
-                                          struct file_operations *);
+                                          const struct file_operations *);
 void                    svc_proc_unregister(const char *);
 
 void                    svc_seq_show(struct seq_file *,
@@ -65,7 +65,7 @@ static inline void rpc_proc_unregister(const char *p) {}
 static inline void rpc_proc_zero(struct rpc_program *p) {}
 
 static inline struct proc_dir_entry *svc_proc_register(struct svc_stat *s,
-                                                       struct file_operations *f) { return NULL; }
+                                                       const struct file_operations *f) { return NULL; }
 static inline void svc_proc_unregister(const char *p) {}
 
 static inline void svc_seq_show(struct seq_file *seq,
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/sunrpc/xprt.h b/include/linux/sunrpc/xprt.h
index 6ef99b14ff09..7eebbab7160b 100644
--- a/include/linux/sunrpc/xprt.h
+++ b/include/linux/sunrpc/xprt.h
@@ -114,6 +114,7 @@ struct rpc_xprt_ops {
         void            (*release_request)(struct rpc_task *task);
         void            (*close)(struct rpc_xprt *xprt);
         void            (*destroy)(struct rpc_xprt *xprt);
+        void            (*print_stats)(struct rpc_xprt *xprt, struct seq_file *seq);
 };
 
 struct rpc_xprt {
@@ -187,6 +188,18 @@ struct rpc_xprt {
 
         struct list_head        recv;
 
+        struct {
+                unsigned long           bind_count,     /* total number of binds */
+                                        connect_count,  /* total number of connects */
+                                        connect_start,  /* connect start timestamp */
+                                        connect_time,   /* jiffies waiting for connect */
+                                        sends,          /* how many complete requests */
+                                        recvs,          /* how many complete requests */
+                                        bad_xids;       /* lookup_rqst didn't find XID */
+
+                unsigned long long      req_u,          /* average requests on the wire */
+                                        bklog_u;        /* backlog queue utilization */
+        } stat;
 
         void                    (*old_data_ready)(struct sock *, int);
         void                    (*old_state_change)(struct sock *);
diff --git a/include/linux/swap.h b/include/linux/swap.h
index d572b19afb7d..54eac8a39a4c 100644
--- a/include/linux/swap.h
+++ b/include/linux/swap.h
@@ -172,9 +172,24 @@ extern int rotate_reclaimable_page(struct page *page);
 extern void swap_setup(void);
 
 /* linux/mm/vmscan.c */
-extern int try_to_free_pages(struct zone **, gfp_t);
-extern int shrink_all_memory(int);
+extern unsigned long try_to_free_pages(struct zone **, gfp_t);
+extern unsigned long shrink_all_memory(unsigned long nr_pages);
 extern int vm_swappiness;
+extern int remove_mapping(struct address_space *mapping, struct page *page);
+
+/* possible outcome of pageout() */
+typedef enum {
+        /* failed to write page out, page is locked */
+        PAGE_KEEP,
+        /* move page to the active list, page is locked */
+        PAGE_ACTIVATE,
+        /* page has been sent to the disk successfully, page is unlocked */
+        PAGE_SUCCESS,
+        /* page is clean and locked */
+        PAGE_CLEAN,
+} pageout_t;
+
+extern pageout_t pageout(struct page *page, struct address_space *mapping);
 
 #ifdef CONFIG_NUMA
 extern int zone_reclaim_mode;
@@ -188,25 +203,6 @@ static inline int zone_reclaim(struct zone *z, gfp_t mask, unsigned int order)
 }
 #endif
 
-#ifdef CONFIG_MIGRATION
-extern int isolate_lru_page(struct page *p);
-extern int putback_lru_pages(struct list_head *l);
-extern int migrate_page(struct page *, struct page *);
-extern void migrate_page_copy(struct page *, struct page *);
-extern int migrate_page_remove_references(struct page *, struct page *, int);
-extern int migrate_pages(struct list_head *l, struct list_head *t,
-                struct list_head *moved, struct list_head *failed);
-extern int fail_migrate_page(struct page *, struct page *);
-#else
-static inline int isolate_lru_page(struct page *p) { return -ENOSYS; }
-static inline int putback_lru_pages(struct list_head *l) { return 0; }
-static inline int migrate_pages(struct list_head *l, struct list_head *t,
-        struct list_head *moved, struct list_head *failed) { return -ENOSYS; }
-/* Possible settings for the migrate_page() method in address_operations */
-#define migrate_page NULL
-#define fail_migrate_page NULL
-#endif
-
 #ifdef CONFIG_MMU
 /* linux/mm/shmem.c */
 extern int shmem_unuse(swp_entry_t entry, struct page *page);
@@ -238,14 +234,15 @@ extern struct page * read_swap_cache_async(swp_entry_t, struct vm_area_struct *v
 /* linux/mm/swapfile.c */
 extern long total_swap_pages;
 extern unsigned int nr_swapfiles;
-extern struct swap_info_struct swap_info[];
 extern void si_swapinfo(struct sysinfo *);
 extern swp_entry_t get_swap_page(void);
-extern swp_entry_t get_swap_page_of_type(int type);
+extern swp_entry_t get_swap_page_of_type(int);
 extern int swap_duplicate(swp_entry_t);
 extern int valid_swaphandles(swp_entry_t, unsigned long *);
 extern void swap_free(swp_entry_t);
 extern void free_swap_and_cache(swp_entry_t);
+extern int swap_type_of(dev_t);
+extern unsigned int count_swap_pages(int, int);
 extern sector_t map_swap_page(struct swap_info_struct *, pgoff_t);
 extern struct swap_info_struct *get_swap_info_struct(unsigned);
 extern int can_share_swap_page(struct page *);
diff --git a/include/linux/synclink.h b/include/linux/synclink.h
index 1b7cd8d1a71b..2993302f7923 100644
--- a/include/linux/synclink.h
+++ b/include/linux/synclink.h
@@ -1,7 +1,7 @@
 /*
  * SyncLink Multiprotocol Serial Adapter Driver
  *
- * $Id: synclink.h,v 3.10 2005/11/08 19:50:54 paulkf Exp $
+ * $Id: synclink.h,v 3.11 2006/02/06 21:20:29 paulkf Exp $
  *
  * Copyright (C) 1998-2000 by Microgate Corporation
  *
@@ -221,6 +221,12 @@ struct mgsl_icount {
         __u32   rxidle;
 };
 
+struct gpio_desc {
+        __u32 state;
+        __u32 smask;
+        __u32 dir;
+        __u32 dmask;
+};
 
 #define DEBUG_LEVEL_DATA        1
 #define DEBUG_LEVEL_ERROR       2
@@ -276,5 +282,8 @@ struct mgsl_icount {
 #define MGSL_IOCLOOPTXDONE      _IO(MGSL_MAGIC_IOC,9)
 #define MGSL_IOCSIF             _IO(MGSL_MAGIC_IOC,10)
 #define MGSL_IOCGIF             _IO(MGSL_MAGIC_IOC,11)
+#define MGSL_IOCSGPIO           _IOW(MGSL_MAGIC_IOC,16,struct gpio_desc)
+#define MGSL_IOCGGPIO           _IOR(MGSL_MAGIC_IOC,17,struct gpio_desc)
+#define MGSL_IOCWAITGPIO        _IOWR(MGSL_MAGIC_IOC,18,struct gpio_desc)
 
 #endif /* _SYNCLINK_H_ */
diff --git a/include/linux/syscalls.h b/include/linux/syscalls.h
index b9ea44ac0ddb..e487e3b60f60 100644
--- a/include/linux/syscalls.h
+++ b/include/linux/syscalls.h
@@ -568,5 +568,6 @@ asmlinkage long compat_sys_newfstatat(unsigned int dfd, char __user * filename,
                                       int flag);
 asmlinkage long compat_sys_openat(unsigned int dfd, const char __user *filename,
                                    int flags, int mode);
+asmlinkage long sys_unshare(unsigned long unshare_flags);
 
 #endif
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 d9cdba54b789..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;
@@ -101,6 +95,7 @@ extern long do_utimes(int dfd, char __user *filename, struct timeval *times);
 struct itimerval;
 extern int do_setitimer(int which, struct itimerval *value,
                         struct itimerval *ovalue);
+extern unsigned int alarm_setitimer(unsigned int seconds);
 extern int do_getitimer(int which, struct itimerval *value);
 extern void getnstimeofday(struct timespec *tv);
 
@@ -113,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;
 }
 
 /**
@@ -125,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;
 }
 
@@ -137,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
@@ -145,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 9b9877fd2505..b5caabca553c 100644
--- a/include/linux/timer.h
+++ b/include/linux/timer.h
@@ -69,13 +69,13 @@ extern unsigned long next_timer_interrupt(void);
  * @timer: the timer to be added
  *
  * The kernel will do a ->function(->data) callback from the
- * timer interrupt at the ->expired point in the future. The
+ * timer interrupt at the ->expires point in the future. The
  * current time is 'jiffies'.
  *
- * The timer's ->expired, ->function (and if the handler uses it, ->data)
+ * The timer's ->expires, ->function (and if the handler uses it, ->data)
  * fields must be set prior calling this function.
  *
- * Timers with an ->expired field in the past will be executed in the next
+ * Timers with an ->expires field in the past will be executed in the next
  * timer tick.
  */
 static inline void add_timer(struct timer_list *timer)
@@ -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 b7ca1204e42a..03914b7e41b1 100644
--- a/include/linux/timex.h
+++ b/include/linux/timex.h
@@ -97,38 +97,11 @@
 
 #define MAXPHASE 512000L        /* max phase error (us) */
 #define MAXFREQ (512L << SHIFT_USEC)  /* max frequency error (ppm) */
-#define MAXTIME (200L << PPS_AVG) /* max PPS error (jitter) (200 us) */
 #define MINSEC 16L              /* min interval between updates (s) */
 #define MAXSEC 1200L            /* max interval between updates (s) */
 #define NTP_PHASE_LIMIT (MAXPHASE << 5) /* beyond max. dispersion */
 
 /*
- * The following defines are used only if a pulse-per-second (PPS)
- * signal is available and connected via a modem control lead, such as
- * produced by the optional ppsclock feature incorporated in the Sun
- * asynch driver. They establish the design parameters of the frequency-
- * lock loop used to discipline the CPU clock oscillator to the PPS
- * signal.
- *
- * PPS_AVG is the averaging factor for the frequency loop, as well as
- * the time and frequency dispersion.
- *
- * PPS_SHIFT and PPS_SHIFTMAX specify the minimum and maximum
- * calibration intervals, respectively, in seconds as a power of two.
- *
- * PPS_VALID is the maximum interval before the PPS signal is considered
- * invalid and protocol updates used directly instead.
- *
- * MAXGLITCH is the maximum interval before a time offset of more than
- * MAXTIME is believed.
- */
-#define PPS_AVG 2               /* pps averaging constant (shift) */
-#define PPS_SHIFT 2             /* min interval duration (s) (shift) */
-#define PPS_SHIFTMAX 8          /* max interval duration (s) (shift) */
-#define PPS_VALID 120           /* pps signal watchdog max (s) */
-#define MAXGLITCH 30            /* pps signal glitch max (s) */
-
-/*
  * syscall interface - used (mainly by NTP daemon)
  * to discipline kernel clock oscillator
  */
@@ -246,20 +219,6 @@ extern long time_reftime;	/* time at last adjustment (s) */
 extern long time_adjust;        /* The amount of adjtime left */
 extern long time_next_adjust;   /* Value for time_adjust at next tick */
 
-/* interface variables pps->timer interrupt */
-extern long pps_offset;         /* pps time offset (us) */
-extern long pps_jitter;         /* time dispersion (jitter) (us) */
-extern long pps_freq;           /* frequency offset (scaled ppm) */
-extern long pps_stabil;         /* frequency dispersion (scaled ppm) */
-extern long pps_valid;          /* pps signal watchdog counter */
-
-/* interface variables pps->adjtimex */
-extern int pps_shift;           /* interval duration (s) (shift) */
-extern long pps_jitcnt;         /* jitter limit exceeded */
-extern long pps_calcnt;         /* calibration intervals */
-extern long pps_errcnt;         /* calibration errors */
-extern long pps_stbcnt;         /* stability limit exceeded */
-
 /**
  * ntp_clear - Clears the NTP state variables
  *
@@ -348,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/tty.h b/include/linux/tty.h
index f45cd74e6f24..f13f49afe198 100644
--- a/include/linux/tty.h
+++ b/include/linux/tty.h
@@ -24,6 +24,7 @@
 #include <linux/tty_driver.h>
 #include <linux/tty_ldisc.h>
 #include <linux/screen_info.h>
+#include <linux/mutex.h>
 
 #include <asm/system.h>
 
@@ -231,8 +232,8 @@ struct tty_struct {
         int canon_data;
         unsigned long canon_head;
         unsigned int canon_column;
-        struct semaphore atomic_read;
-        struct semaphore atomic_write;
+        struct mutex atomic_read_lock;
+        struct mutex atomic_write_lock;
         unsigned char *write_buf;
         int write_cnt;
         spinlock_t read_lock;
@@ -319,8 +320,7 @@ extern void tty_ldisc_put(int);
 extern void tty_wakeup(struct tty_struct *tty);
 extern void tty_ldisc_flush(struct tty_struct *tty);
 
-struct semaphore;
-extern struct semaphore tty_sem;
+extern struct mutex tty_mutex;
 
 /* n_tty.c */
 extern struct tty_ldisc tty_ldisc_N_TTY;
diff --git a/include/linux/tty_flip.h b/include/linux/tty_flip.h
index 222faf97d5f9..0976a163b459 100644
--- a/include/linux/tty_flip.h
+++ b/include/linux/tty_flip.h
@@ -2,19 +2,13 @@
 #define _LINUX_TTY_FLIP_H
 
 extern int tty_buffer_request_room(struct tty_struct *tty, size_t size);
-extern int tty_insert_flip_string(struct tty_struct *tty, unsigned char *chars, size_t size);
-extern int tty_insert_flip_string_flags(struct tty_struct *tty, unsigned char *chars, char *flags, size_t size);
+extern int tty_insert_flip_string(struct tty_struct *tty, const unsigned char *chars, size_t size);
+extern int tty_insert_flip_string_flags(struct tty_struct *tty, const unsigned char *chars, const char *flags, size_t size);
 extern int tty_prepare_flip_string(struct tty_struct *tty, unsigned char **chars, size_t size);
 extern int tty_prepare_flip_string_flags(struct tty_struct *tty, unsigned char **chars, char **flags, size_t size);
 
-#ifdef INCLUDE_INLINE_FUNCS
-#define _INLINE_ extern
-#else
-#define _INLINE_ static __inline__
-#endif
-
-_INLINE_ int tty_insert_flip_char(struct tty_struct *tty,
-                                   unsigned char ch, char flag)
+static inline int tty_insert_flip_char(struct tty_struct *tty,
+                                       unsigned char ch, char flag)
 {
         struct tty_buffer *tb = tty->buf.tail;
         if (tb && tb->active && tb->used < tb->size) {
@@ -25,7 +19,7 @@ _INLINE_ int tty_insert_flip_char(struct tty_struct *tty,
         return tty_insert_flip_string_flags(tty, &ch, &flag, 1);
 }
 
-_INLINE_ void tty_schedule_flip(struct tty_struct *tty)
+static inline void tty_schedule_flip(struct tty_struct *tty)
 {
         unsigned long flags;
         spin_lock_irqsave(&tty->buf.lock, flags);
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/udf_fs_i.h b/include/linux/udf_fs_i.h
index 1e7508420fcf..ffaf05679ffb 100644
--- a/include/linux/udf_fs_i.h
+++ b/include/linux/udf_fs_i.h
@@ -15,27 +15,6 @@
 
 #ifdef __KERNEL__
 
-#ifndef _ECMA_167_H
-typedef struct
-{
-        __u32                   logicalBlockNum;
-        __u16                   partitionReferenceNum;
-} __attribute__ ((packed)) lb_addr;
-
-typedef struct
-{
-        __u32                   extLength;
-        __u32                   extPosition;
-} __attribute__ ((packed)) short_ad;
-
-typedef struct
-{
-        __u32                   extLength;
-        lb_addr                 extLocation;
-        __u8                    impUse[6];
-} __attribute__ ((packed)) long_ad;
-#endif
-
 struct udf_inode_info
 {
         struct timespec         i_crtime;
diff --git a/include/linux/udf_fs_sb.h b/include/linux/udf_fs_sb.h
index b15ff2e99c91..80ae9ef940dc 100644
--- a/include/linux/udf_fs_sb.h
+++ b/include/linux/udf_fs_sb.h
@@ -13,7 +13,7 @@
 #ifndef _UDF_FS_SB_H
 #define _UDF_FS_SB_H 1
 
-#include <asm/semaphore.h>
+#include <linux/mutex.h>
 
 #pragma pack(1)
 
@@ -111,7 +111,7 @@ struct udf_sb_info
         /* VAT inode */
         struct inode            *s_vat;
 
-        struct semaphore        s_alloc_sem;
+        struct mutex            s_alloc_mutex;
 };
 
 #endif /* _UDF_FS_SB_H */
diff --git a/include/linux/ufs_fs.h b/include/linux/ufs_fs.h
index b0ffe4356e5a..843aeaaa79d4 100644
--- a/include/linux/ufs_fs.h
+++ b/include/linux/ufs_fs.h
@@ -895,7 +895,7 @@ extern void ufs_set_link(struct inode *, struct ufs_dir_entry *, struct buffer_h
 
 /* file.c */
 extern struct inode_operations ufs_file_inode_operations;
-extern struct file_operations ufs_file_operations;
+extern const struct file_operations ufs_file_operations;
 
 extern struct address_space_operations ufs_aops;
 
@@ -915,7 +915,7 @@ extern struct buffer_head * ufs_bread (struct inode *, unsigned, int, int *);
 extern int ufs_getfrag_block (struct inode *inode, sector_t fragment, struct buffer_head *bh_result, int create);
 
 /* namei.c */
-extern struct file_operations ufs_dir_operations;
+extern const struct file_operations ufs_dir_operations;
         
 /* super.c */
 extern void ufs_warning (struct super_block *, const char *, const char *, ...) __attribute__ ((format (printf, 3, 4)));
diff --git a/include/linux/usb.h b/include/linux/usb.h
index 130d125fda12..e34e5e3dce52 100644
--- a/include/linux/usb.h
+++ b/include/linux/usb.h
@@ -615,7 +615,7 @@ extern struct bus_type usb_bus_type;
  */
 struct usb_class_driver {
         char *name;
-        struct file_operations *fops;
+        const struct file_operations *fops;
         int minor_base;
 };
 
diff --git a/include/linux/videodev2.h b/include/linux/videodev2.h
index 724cfbf54b8a..af2d6155d3fe 100644
--- a/include/linux/videodev2.h
+++ b/include/linux/videodev2.h
@@ -75,7 +75,7 @@ struct video_device
         int minor;
 
         /* device ops + callbacks */
-        struct file_operations *fops;
+        const struct file_operations *fops;
         void (*release)(struct video_device *vfd);
 
 
@@ -883,6 +883,7 @@ struct v4l2_modulator
 #define V4L2_TUNER_MODE_LANG2           0x0002
 #define V4L2_TUNER_MODE_SAP             0x0002
 #define V4L2_TUNER_MODE_LANG1           0x0003
+#define V4L2_TUNER_MODE_LANG1_LANG2     0x0004
 
 struct v4l2_frequency
 {
diff --git a/include/linux/vt_kern.h b/include/linux/vt_kern.h
index fab5aed8ca31..530ae3f4248c 100644
--- a/include/linux/vt_kern.h
+++ b/include/linux/vt_kern.h
@@ -73,6 +73,11 @@ int con_copy_unimap(struct vc_data *dst_vc, struct vc_data *src_vc);
 int vt_waitactive(int vt);
 void change_console(struct vc_data *new_vc);
 void reset_vc(struct vc_data *vc);
+#ifdef CONFIG_VT
+int is_console_suspend_safe(void);
+#else
+static inline int is_console_suspend_safe(void) { return 1; }
+#endif
 
 /*
  * vc_screen.c shares this temporary buffer with the console write code so that
diff --git a/include/linux/wireless.h b/include/linux/wireless.h
index a555a0f7a7b4..13588564b42b 100644
--- a/include/linux/wireless.h
+++ b/include/linux/wireless.h
@@ -1,10 +1,10 @@
 /*
  * This file define a set of standard wireless extensions
  *
- * Version :    19      18.3.05
+ * Version :    20      17.2.06
  *
  * Authors :    Jean Tourrilhes - HPL - <jt@hpl.hp.com>
- * Copyright (c) 1997-2005 Jean Tourrilhes, All Rights Reserved.
+ * Copyright (c) 1997-2006 Jean Tourrilhes, All Rights Reserved.
  */
 
 #ifndef _LINUX_WIRELESS_H
@@ -80,7 +80,7 @@
  * (there is some stuff that will be added in the future...)
  * I just plan to increment with each new version.
  */
-#define WIRELESS_EXT    19
+#define WIRELESS_EXT    20
 
 /*
  * Changes :
@@ -204,6 +204,10 @@
  *      - Add IW_QUAL_ALL_UPDATED and IW_QUAL_ALL_INVALID macros
  *      - Add explicit flag to tell stats are in dBm : IW_QUAL_DBM
  *      - Add IW_IOCTL_IDX() and IW_EVENT_IDX() macros
+ *
+ * V19 to V20
+ * ----------
+ *      - RtNetlink requests support (SET/GET)
  */
 
 /**************************** CONSTANTS ****************************/
diff --git a/include/linux/workqueue.h b/include/linux/workqueue.h
index 86b111300231..957c21c16d62 100644
--- a/include/linux/workqueue.h
+++ b/include/linux/workqueue.h
@@ -20,6 +20,10 @@ struct work_struct {
         struct timer_list timer;
 };
 
+struct execute_work {
+        struct work_struct work;
+};
+
 #define __WORK_INITIALIZER(n, f, d) {                           \
         .entry  = { &(n).entry, &(n).entry },                   \
         .func = (f),                                            \
@@ -74,6 +78,8 @@ extern void init_workqueues(void);
 void cancel_rearming_delayed_work(struct work_struct *work);
 void cancel_rearming_delayed_workqueue(struct workqueue_struct *,
                                        struct work_struct *);
+int execute_in_process_context(void (*fn)(void *), void *,
+                               struct execute_work *);
 
 /*
  * Kill off a pending schedule_delayed_work().  Note that the work callback
diff --git a/include/linux/writeback.h b/include/linux/writeback.h
index beaef5c7a0ea..56f92fcbe94a 100644
--- a/include/linux/writeback.h
+++ b/include/linux/writeback.h
@@ -88,8 +88,8 @@ void throttle_vm_writeout(void);
 /* These are exported to sysctl. */
 extern int dirty_background_ratio;
 extern int vm_dirty_ratio;
-extern int dirty_writeback_centisecs;
-extern int dirty_expire_centisecs;
+extern int dirty_writeback_interval;
+extern int dirty_expire_interval;
 extern int block_dump;
 extern int laptop_mode;
 
@@ -99,7 +99,15 @@ int dirty_writeback_centisecs_handler(struct ctl_table *, int, struct file *,
                                       void __user *, size_t *, loff_t *);
 
 void page_writeback_init(void);
-void balance_dirty_pages_ratelimited(struct address_space *mapping);
+void balance_dirty_pages_ratelimited_nr(struct address_space *mapping,
+                                        unsigned long nr_pages_dirtied);
+
+static inline void
+balance_dirty_pages_ratelimited(struct address_space *mapping)
+{
+        balance_dirty_pages_ratelimited_nr(mapping, 1);
+}
+
 int pdflush_operation(void (*fn)(unsigned long), unsigned long arg0);
 int do_writepages(struct address_space *mapping, struct writeback_control *wbc);
 int sync_page_range(struct inode *inode, struct address_space *mapping,
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/linux/x25.h b/include/linux/x25.h
index 16d44931afa0..d035e4e87d07 100644
--- a/include/linux/x25.h
+++ b/include/linux/x25.h
@@ -11,6 +11,8 @@
 #ifndef X25_KERNEL_H
 #define X25_KERNEL_H
 
+#include <linux/types.h>
+
 #define SIOCX25GSUBSCRIP        (SIOCPROTOPRIVATE + 0)
 #define SIOCX25SSUBSCRIP        (SIOCPROTOPRIVATE + 1)
 #define SIOCX25GFACILITIES      (SIOCPROTOPRIVATE + 2)
@@ -21,6 +23,8 @@
 #define SIOCX25SCUDMATCHLEN     (SIOCPROTOPRIVATE + 7)
 #define SIOCX25CALLACCPTAPPRV   (SIOCPROTOPRIVATE + 8)
 #define SIOCX25SENDCALLACCPT    (SIOCPROTOPRIVATE + 9)
+#define SIOCX25GDTEFACILITIES (SIOCPROTOPRIVATE + 10)
+#define SIOCX25SDTEFACILITIES (SIOCPROTOPRIVATE + 11)
 
 /*
  *      Values for {get,set}sockopt.
@@ -77,6 +81,8 @@ struct x25_subscrip_struct {
 #define X25_MASK_PACKET_SIZE    0x04
 #define X25_MASK_WINDOW_SIZE    0x08
 
+#define X25_MASK_CALLING_AE 0x10
+#define X25_MASK_CALLED_AE 0x20
 
 
 /*
@@ -99,6 +105,26 @@ struct x25_facilities {
 };
 
 /*
+* ITU DTE facilities
+* Only the called and calling address
+* extension are currently implemented.
+* The rest are in place to avoid the struct
+* changing size if someone needs them later
+*/
+
+struct x25_dte_facilities {
+        __u16 delay_cumul;
+        __u16 delay_target;
+        __u16 delay_max;
+        __u8 min_throughput;
+        __u8 expedited;
+        __u8 calling_len;
+        __u8 called_len;
+        __u8 calling_ae[20];
+        __u8 called_ae[20];
+};
+
+/*
  *      Call User Data structure.
  */
 struct x25_calluserdata {
diff --git a/include/linux/zorro.h b/include/linux/zorro.h
index ba5b72768bbe..2f135cf6eef1 100644
--- a/include/linux/zorro.h
+++ b/include/linux/zorro.h
@@ -271,39 +271,6 @@ static inline void zorro_set_drvdata (struct zorro_dev *z, void *data)
 }
 
 
-/*
- * A helper function which helps ensure correct zorro_driver
- * setup and cleanup for commonly-encountered hotplug/modular cases
- *
- * This MUST stay in a header, as it checks for -DMODULE
- */
-static inline int zorro_module_init(struct zorro_driver *drv)
-{
-        int rc = zorro_register_driver(drv);
-
-        if (rc > 0)
-                return 0;
-
-        /* iff CONFIG_HOTPLUG and built into kernel, we should
-         * leave the driver around for future hotplug events.
-         * For the module case, a hotplug daemon of some sort
-         * should load a module in response to an insert event. */
-#if defined(CONFIG_HOTPLUG) && !defined(MODULE)
-        if (rc == 0)
-                return 0;
-#else
-        if (rc == 0)
-                rc = -ENODEV;
-#endif
-
-        /* if we get here, we need to clean up Zorro driver instance
-         * and return some sort of error */
-        zorro_unregister_driver(drv);
-
-        return rc;
-}
-
-
     /*
      *  Bitmask indicating portions of available Zorro II RAM that are unused
      *  by the system. Every bit represents a 64K chunk, for a maximum of 8MB