Merge branch 'master' of git://git.kernel.org/pub/scm/linux/kernel/git/torvalds/linux-2.6

237 files changed, 3653 insertions, 1532 deletions

diff --git a/include/linux/Kbuild b/include/linux/Kbuild
index afae306b177c..bcf875e844fe 100644
--- a/include/linux/Kbuild
+++ b/include/linux/Kbuild
@@ -91,7 +91,6 @@ header-y += in6.h
 header-y += in_route.h
 header-y += ioctl.h
 header-y += ipmi_msgdefs.h
-header-y += ip_mp_alg.h
 header-y += ipsec.h
 header-y += ipx.h
 header-y += irda.h
@@ -226,6 +225,7 @@ unifdef-y += if_fddi.h
 unifdef-y += if_frad.h
 unifdef-y += if_ltalk.h
 unifdef-y += if_link.h
+unifdef-y += if_pppol2tp.h
 unifdef-y += if_pppox.h
 unifdef-y += if_shaper.h
 unifdef-y += if_tr.h
@@ -247,7 +247,6 @@ unifdef-y += isdn.h
 unifdef-y += isdnif.h
 unifdef-y += isdn_divertif.h
 unifdef-y += isdn_ppp.h
-unifdef-y += isicom.h
 unifdef-y += jbd.h
 unifdef-y += joystick.h
 unifdef-y += kdev_t.h
diff --git a/include/linux/acpi.h b/include/linux/acpi.h
index fccd8b548d93..d5680cd7746a 100644
--- a/include/linux/acpi.h
+++ b/include/linux/acpi.h
@@ -88,10 +88,8 @@ int acpi_table_parse (char *id, acpi_table_handler handler);
 int __init acpi_table_parse_entries(char *id, unsigned long table_size,
         int entry_id, acpi_table_entry_handler handler, unsigned int max_entries);
 int acpi_table_parse_madt (enum acpi_madt_type id, acpi_table_entry_handler handler, unsigned int max_entries);
-int acpi_table_parse_srat (enum acpi_srat_type id, acpi_table_entry_handler handler, unsigned int max_entries);
 int acpi_parse_mcfg (struct acpi_table_header *header);
 void acpi_table_print_madt_entry (struct acpi_subtable_header *madt);
-void acpi_table_print_srat_entry (struct acpi_subtable_header *srat);
 
 /* the following four functions are architecture-dependent */
 #ifdef CONFIG_HAVE_ARCH_PARSE_SRAT
@@ -122,7 +120,7 @@ extern struct acpi_mcfg_allocation *pci_mmcfg_config;
 extern int pci_mmcfg_config_num;
 
 extern int sbf_port;
-extern unsigned long acpi_video_flags;
+extern unsigned long acpi_realmode_flags;
 
 #else   /* !CONFIG_ACPI */
 
@@ -233,6 +231,9 @@ extern int acpi_paddr_to_node(u64 start_addr, u64 size);
 
 extern int pnpacpi_disabled;
 
+#define PXM_INVAL       (-1)
+#define NID_INVAL       (-1)
+
 #else   /* CONFIG_ACPI */
 
 static inline int acpi_boot_init(void)
diff --git a/include/linux/aer.h b/include/linux/aer.h
index 402e178b38eb..509656286e53 100644
--- a/include/linux/aer.h
+++ b/include/linux/aer.h
@@ -13,11 +13,13 @@ extern int pci_enable_pcie_error_reporting(struct pci_dev *dev);
 extern int pci_find_aer_capability(struct pci_dev *dev);
 extern int pci_disable_pcie_error_reporting(struct pci_dev *dev);
 extern int pci_cleanup_aer_uncorrect_error_status(struct pci_dev *dev);
+extern int pci_cleanup_aer_correct_error_status(struct pci_dev *dev);
 #else
-#define pci_enable_pcie_error_reporting(dev)            do { } while (0)
-#define pci_find_aer_capability(dev)                    do { } while (0)
-#define pci_disable_pcie_error_reporting(dev)           do { } while (0)
-#define pci_cleanup_aer_uncorrect_error_status(dev)     do { } while (0)
+#define pci_enable_pcie_error_reporting(dev)            (-EINVAL)
+#define pci_find_aer_capability(dev)                    (0)
+#define pci_disable_pcie_error_reporting(dev)           (-EINVAL)
+#define pci_cleanup_aer_uncorrect_error_status(dev)     (-EINVAL)
+#define pci_cleanup_aer_correct_error_status(dev)       (-EINVAL)
 #endif
 
 #endif //_AER_H_
diff --git a/include/linux/aio.h b/include/linux/aio.h
index b903fc02bdb7..d10e608f232d 100644
--- a/include/linux/aio.h
+++ b/include/linux/aio.h
@@ -86,7 +86,7 @@ struct kioctx;
  */
 struct kiocb {
         struct list_head        ki_run_list;
-        long                    ki_flags;
+        unsigned long           ki_flags;
         int                     ki_users;
         unsigned                ki_key;         /* id of this request */
 
diff --git a/include/linux/async_tx.h b/include/linux/async_tx.h
new file mode 100644
index 000000000000..bdca3f1b3213
--- /dev/null
+++ b/include/linux/async_tx.h
@@ -0,0 +1,150 @@
+/*
+ * Copyright © 2006, Intel Corporation.
+ *
+ * This program is free software; you can redistribute it and/or modify it
+ * under the terms and conditions of the GNU General Public License,
+ * version 2, as published by the Free Software Foundation.
+ *
+ * This program is distributed in the hope it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License for
+ * more details.
+ *
+ * You should have received a copy of the GNU General Public License along with
+ * this program; if not, write to the Free Software Foundation, Inc.,
+ * 51 Franklin St - Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ */
+#ifndef _ASYNC_TX_H_
+#define _ASYNC_TX_H_
+#include <linux/dmaengine.h>
+#include <linux/spinlock.h>
+#include <linux/interrupt.h>
+
+/**
+ * dma_chan_ref - object used to manage dma channels received from the
+ *   dmaengine core.
+ * @chan - the channel being tracked
+ * @node - node for the channel to be placed on async_tx_master_list
+ * @rcu - for list_del_rcu
+ * @count - number of times this channel is listed in the pool
+ *      (for channels with multiple capabiities)
+ */
+struct dma_chan_ref {
+        struct dma_chan *chan;
+        struct list_head node;
+        struct rcu_head rcu;
+        atomic_t count;
+};
+
+/**
+ * async_tx_flags - modifiers for the async_* calls
+ * @ASYNC_TX_XOR_ZERO_DST: this flag must be used for xor operations where the
+ * the destination address is not a source.  The asynchronous case handles this
+ * implicitly, the synchronous case needs to zero the destination block.
+ * @ASYNC_TX_XOR_DROP_DST: this flag must be used if the destination address is
+ * also one of the source addresses.  In the synchronous case the destination
+ * address is an implied source, whereas the asynchronous case it must be listed
+ * as a source.  The destination address must be the first address in the source
+ * array.
+ * @ASYNC_TX_ASSUME_COHERENT: skip cache maintenance operations
+ * @ASYNC_TX_ACK: immediately ack the descriptor, precludes setting up a
+ * dependency chain
+ * @ASYNC_TX_DEP_ACK: ack the dependency descriptor.  Useful for chaining.
+ */
+enum async_tx_flags {
+        ASYNC_TX_XOR_ZERO_DST    = (1 << 0),
+        ASYNC_TX_XOR_DROP_DST    = (1 << 1),
+        ASYNC_TX_ASSUME_COHERENT = (1 << 2),
+        ASYNC_TX_ACK             = (1 << 3),
+        ASYNC_TX_DEP_ACK         = (1 << 4),
+};
+
+#ifdef CONFIG_DMA_ENGINE
+void async_tx_issue_pending_all(void);
+enum dma_status dma_wait_for_async_tx(struct dma_async_tx_descriptor *tx);
+void async_tx_run_dependencies(struct dma_async_tx_descriptor *tx);
+struct dma_chan *
+async_tx_find_channel(struct dma_async_tx_descriptor *depend_tx,
+        enum dma_transaction_type tx_type);
+#else
+static inline void async_tx_issue_pending_all(void)
+{
+        do { } while (0);
+}
+
+static inline enum dma_status
+dma_wait_for_async_tx(struct dma_async_tx_descriptor *tx)
+{
+        return DMA_SUCCESS;
+}
+
+static inline void
+async_tx_run_dependencies(struct dma_async_tx_descriptor *tx,
+        struct dma_chan *host_chan)
+{
+        do { } while (0);
+}
+
+static inline struct dma_chan *
+async_tx_find_channel(struct dma_async_tx_descriptor *depend_tx,
+        enum dma_transaction_type tx_type)
+{
+        return NULL;
+}
+#endif
+
+/**
+ * async_tx_sync_epilog - actions to take if an operation is run synchronously
+ * @flags: async_tx flags
+ * @depend_tx: transaction depends on depend_tx
+ * @cb_fn: function to call when the transaction completes
+ * @cb_fn_param: parameter to pass to the callback routine
+ */
+static inline void
+async_tx_sync_epilog(unsigned long flags,
+        struct dma_async_tx_descriptor *depend_tx,
+        dma_async_tx_callback cb_fn, void *cb_fn_param)
+{
+        if (cb_fn)
+                cb_fn(cb_fn_param);
+
+        if (depend_tx && (flags & ASYNC_TX_DEP_ACK))
+                async_tx_ack(depend_tx);
+}
+
+void
+async_tx_submit(struct dma_chan *chan, struct dma_async_tx_descriptor *tx,
+        enum async_tx_flags flags, struct dma_async_tx_descriptor *depend_tx,
+        dma_async_tx_callback cb_fn, void *cb_fn_param);
+
+struct dma_async_tx_descriptor *
+async_xor(struct page *dest, struct page **src_list, unsigned int offset,
+        int src_cnt, size_t len, enum async_tx_flags flags,
+        struct dma_async_tx_descriptor *depend_tx,
+        dma_async_tx_callback cb_fn, void *cb_fn_param);
+
+struct dma_async_tx_descriptor *
+async_xor_zero_sum(struct page *dest, struct page **src_list,
+        unsigned int offset, int src_cnt, size_t len,
+        u32 *result, enum async_tx_flags flags,
+        struct dma_async_tx_descriptor *depend_tx,
+        dma_async_tx_callback cb_fn, void *cb_fn_param);
+
+struct dma_async_tx_descriptor *
+async_memcpy(struct page *dest, struct page *src, unsigned int dest_offset,
+        unsigned int src_offset, size_t len, enum async_tx_flags flags,
+        struct dma_async_tx_descriptor *depend_tx,
+        dma_async_tx_callback cb_fn, void *cb_fn_param);
+
+struct dma_async_tx_descriptor *
+async_memset(struct page *dest, int val, unsigned int offset,
+        size_t len, enum async_tx_flags flags,
+        struct dma_async_tx_descriptor *depend_tx,
+        dma_async_tx_callback cb_fn, void *cb_fn_param);
+
+struct dma_async_tx_descriptor *
+async_trigger_callback(enum async_tx_flags flags,
+        struct dma_async_tx_descriptor *depend_tx,
+        dma_async_tx_callback cb_fn, void *cb_fn_param);
+#endif /* _ASYNC_TX_H_ */
diff --git a/include/linux/ata.h b/include/linux/ata.h
index 407dc7e098bc..23a22df039d8 100644
--- a/include/linux/ata.h
+++ b/include/linux/ata.h
@@ -64,6 +64,15 @@ enum {
         ATA_ID_PROD_LEN         = 40,
 
         ATA_PCI_CTL_OFS         = 2,
+
+        ATA_PIO0                = (1 << 0),
+        ATA_PIO1                = ATA_PIO0 | (1 << 1),
+        ATA_PIO2                = ATA_PIO1 | (1 << 2),
+        ATA_PIO3                = ATA_PIO2 | (1 << 3),
+        ATA_PIO4                = ATA_PIO3 | (1 << 4),
+        ATA_PIO5                = ATA_PIO4 | (1 << 5),
+        ATA_PIO6                = ATA_PIO5 | (1 << 6),
+
         ATA_UDMA0               = (1 << 0),
         ATA_UDMA1               = ATA_UDMA0 | (1 << 1),
         ATA_UDMA2               = ATA_UDMA1 | (1 << 2),
@@ -164,6 +173,8 @@ enum {
         ATA_CMD_SET_MAX         = 0xF9,
         ATA_CMD_SET_MAX_EXT     = 0x37,
         ATA_CMD_READ_LOG_EXT    = 0x2f,
+        ATA_CMD_PMP_READ        = 0xE4,
+        ATA_CMD_PMP_WRITE       = 0xE8,
 
         /* READ_LOG_EXT pages */
         ATA_LOG_SATA_NCQ        = 0x10,
@@ -212,6 +223,28 @@ enum {
                                                    0=to device, 1=to host */
         ATAPI_CDB_LEN           = 16,
 
+        /* PMP stuff */
+        SATA_PMP_MAX_PORTS      = 15,
+        SATA_PMP_CTRL_PORT      = 15,
+
+        SATA_PMP_GSCR_DWORDS    = 128,
+        SATA_PMP_GSCR_PROD_ID   = 0,
+        SATA_PMP_GSCR_REV       = 1,
+        SATA_PMP_GSCR_PORT_INFO = 2,
+        SATA_PMP_GSCR_ERROR     = 32,
+        SATA_PMP_GSCR_ERROR_EN  = 33,
+        SATA_PMP_GSCR_FEAT      = 64,
+        SATA_PMP_GSCR_FEAT_EN   = 96,
+
+        SATA_PMP_PSCR_STATUS    = 0,
+        SATA_PMP_PSCR_ERROR     = 1,
+        SATA_PMP_PSCR_CONTROL   = 2,
+
+        SATA_PMP_FEAT_BIST      = (1 << 0),
+        SATA_PMP_FEAT_PMREQ     = (1 << 1),
+        SATA_PMP_FEAT_DYNSSC    = (1 << 2),
+        SATA_PMP_FEAT_NOTIFY    = (1 << 3),
+
         /* cable types */
         ATA_CBL_NONE            = 0,
         ATA_CBL_PATA40          = 1,
@@ -418,4 +451,9 @@ static inline int lba_48_ok(u64 block, u32 n_block)
         return ((block + n_block - 1) < ((u64)1 << 48)) && (n_block <= 65536);
 }
 
+#define sata_pmp_gscr_vendor(gscr)      ((gscr)[SATA_PMP_GSCR_PROD_ID] & 0xffff)
+#define sata_pmp_gscr_devid(gscr)       ((gscr)[SATA_PMP_GSCR_PROD_ID] >> 16)
+#define sata_pmp_gscr_rev(gscr)         (((gscr)[SATA_PMP_GSCR_REV] >> 8) & 0xff)
+#define sata_pmp_gscr_ports(gscr)       ((gscr)[SATA_PMP_GSCR_PORT_INFO] & 0xf)
+
 #endif /* __LINUX_ATA_H__ */
diff --git a/include/linux/attribute_container.h b/include/linux/attribute_container.h
index 93bfb0beb62a..8ff274933948 100644
--- a/include/linux/attribute_container.h
+++ b/include/linux/attribute_container.h
@@ -12,7 +12,6 @@
 #include <linux/device.h>
 #include <linux/list.h>
 #include <linux/klist.h>
-#include <linux/spinlock.h>
 
 struct attribute_container {
         struct list_head        node;
diff --git a/include/linux/audit.h b/include/linux/audit.h
index fccc6e50298a..4bbd8601b8f0 100644
--- a/include/linux/audit.h
+++ b/include/linux/audit.h
@@ -63,9 +63,12 @@
 #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_TTY_GET           1014    /* Get TTY auditing status */
+#define AUDIT_TTY_SET           1015    /* Set TTY auditing status */
 
 #define AUDIT_FIRST_USER_MSG    1100    /* Userspace messages mostly uninteresting to kernel */
 #define AUDIT_USER_AVC          1107    /* We filter this differently */
+#define AUDIT_USER_TTY          1124    /* Non-ICANON TTY input meaning */
 #define AUDIT_LAST_USER_MSG     1199
 #define AUDIT_FIRST_USER_MSG2   2100    /* More user space messages */
 #define AUDIT_LAST_USER_MSG2    2999
@@ -92,6 +95,7 @@
 #define AUDIT_KERNEL_OTHER      1316    /* For use by 3rd party modules */
 #define AUDIT_FD_PAIR           1317    /* audit record for pipe/socketpair */
 #define AUDIT_OBJ_PID           1318    /* ptrace target */
+#define AUDIT_TTY               1319    /* Input on an administrative TTY */
 
 #define AUDIT_AVC               1400    /* SE Linux avc denial or grant */
 #define AUDIT_SELINUX_ERR       1401    /* Internal SE Linux Errors */
@@ -157,7 +161,7 @@
  * 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
+#define AUDIT_UNUSED_BITS       0x07FFFC00
 
 
 /* Rule fields */
@@ -209,25 +213,29 @@
 #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
+ *      4  2  1  8
+ *      =  >  <  ?
+ *      ----------
+ *      0  0  0  0      00      nonsense
+ *      0  0  0  1      08      &  bit mask
+ *      0  0  1  0      10      <
+ *      0  1  0  0      20      >
+ *      0  1  1  0      30      !=
+ *      1  0  0  0      40      =
+ *      1  0  0  1      48      &=  bit test
+ *      1  0  1  0      50      <=
+ *      1  1  0  0      60      >=
+ *      1  1  1  1      78      all operators
  */
+#define AUDIT_BIT_MASK                  0x08000000
 #define AUDIT_LESS_THAN                 0x10000000
 #define AUDIT_GREATER_THAN              0x20000000
 #define AUDIT_NOT_EQUAL                 0x30000000
 #define AUDIT_EQUAL                     0x40000000
+#define AUDIT_BIT_TEST                  (AUDIT_BIT_MASK|AUDIT_EQUAL)
 #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)
+#define AUDIT_OPERATORS                 (AUDIT_EQUAL|AUDIT_NOT_EQUAL|AUDIT_BIT_MASK)
 
 /* Status symbols */
                                 /* Mask values */
@@ -289,6 +297,10 @@ struct audit_status {
         __u32           backlog;        /* messages waiting in queue */
 };
 
+struct audit_tty_status {
+        __u32           enabled; /* 1 = enabled, 0 = disabled */
+};
+
 /* 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.
@@ -399,7 +411,6 @@ extern int audit_bprm(struct linux_binprm *bprm);
 extern int audit_socketcall(int nargs, unsigned long *args);
 extern int audit_sockaddr(int len, void *addr);
 extern int __audit_fd_pair(int fd1, int fd2);
-extern int audit_avc_path(struct dentry *dentry, struct vfsmount *mnt);
 extern int audit_set_macxattr(const char *name);
 extern int __audit_mq_open(int oflag, mode_t mode, struct mq_attr __user *u_attr);
 extern int __audit_mq_timedsend(mqd_t mqdes, size_t msg_len, unsigned int msg_prio, const struct timespec __user *u_abs_timeout);
@@ -479,7 +490,6 @@ extern int audit_signals;
 #define audit_socketcall(n,a) ({ 0; })
 #define audit_fd_pair(n,a) ({ 0; })
 #define audit_sockaddr(len, addr) ({ 0; })
-#define audit_avc_path(dentry, mnt) ({ 0; })
 #define audit_set_macxattr(n) do { ; } while (0)
 #define audit_mq_open(o,m,a) ({ 0; })
 #define audit_mq_timedsend(d,l,p,t) ({ 0; })
@@ -515,11 +525,13 @@ extern void		    audit_log_d_path(struct audit_buffer *ab,
                                              const char *prefix,
                                              struct dentry *dentry,
                                              struct vfsmount *vfsmnt);
+extern void                 audit_log_lost(const char *message);
                                 /* 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, u32 sid);
+extern int audit_enabled;
 #else
 #define audit_log(c,g,t,f,...) do { ; } while (0)
 #define audit_log_start(c,g,t) ({ NULL; })
@@ -530,6 +542,7 @@ extern int  audit_receive_filter(int type, int pid, int uid, int seq,
 #define audit_log_untrustedstring(a,s) do { ; } while (0)
 #define audit_log_n_untrustedstring(a,n,s) do { ; } while (0)
 #define audit_log_d_path(b,p,d,v) do { ; } while (0)
+#define audit_enabled 0
 #endif
 #endif
 #endif
diff --git a/include/linux/backing-dev.h b/include/linux/backing-dev.h
index f2542c24b328..7011d6255593 100644
--- a/include/linux/backing-dev.h
+++ b/include/linux/backing-dev.h
@@ -93,7 +93,6 @@ static inline int bdi_rw_congested(struct backing_dev_info *bdi)
 void clear_bdi_congested(struct backing_dev_info *bdi, int rw);
 void set_bdi_congested(struct backing_dev_info *bdi, int rw);
 long congestion_wait(int rw, long timeout);
-long congestion_wait_interruptible(int rw, long timeout);
 void congestion_end(int rw);
 
 #define bdi_cap_writeback_dirty(bdi) \
diff --git a/include/linux/backlight.h b/include/linux/backlight.h
index 1023ba0d6e55..c897c7b03858 100644
--- a/include/linux/backlight.h
+++ b/include/linux/backlight.h
@@ -69,8 +69,8 @@ struct backlight_device {
 
         /* The framebuffer notifier block */
         struct notifier_block fb_notif;
-        /* The class device structure */
-        struct class_device class_dev;
+
+        struct device dev;
 };
 
 static inline void backlight_update_status(struct backlight_device *bd)
@@ -85,6 +85,11 @@ extern struct backlight_device *backlight_device_register(const char *name,
         struct device *dev, void *devdata, struct backlight_ops *ops);
 extern void backlight_device_unregister(struct backlight_device *bd);
 
-#define to_backlight_device(obj) container_of(obj, struct backlight_device, class_dev)
+#define to_backlight_device(obj) container_of(obj, struct backlight_device, dev)
+
+static inline void * bl_get_data(struct backlight_device *bl_dev)
+{
+        return dev_get_drvdata(&bl_dev->dev);
+}
 
 #endif
diff --git a/include/linux/binfmts.h b/include/linux/binfmts.h
index e1a708337be3..91c8c07fe8b7 100644
--- a/include/linux/binfmts.h
+++ b/include/linux/binfmts.h
@@ -6,11 +6,13 @@
 struct pt_regs;
 
 /*
- * MAX_ARG_PAGES defines the number of pages allocated for arguments
- * and envelope for the new program. 32 should suffice, this gives
- * a maximum env+arg of 128kB w/4KB pages!
+ * These are the maximum length and maximum number of strings passed to the
+ * execve() system call.  MAX_ARG_STRLEN is essentially random but serves to
+ * prevent the kernel from being unduly impacted by misaddressed pointers.
+ * MAX_ARG_STRINGS is chosen to fit in a signed 32-bit integer.
  */
-#define MAX_ARG_PAGES 32
+#define MAX_ARG_STRLEN (PAGE_SIZE * 32)
+#define MAX_ARG_STRINGS 0x7FFFFFFF
 
 /* sizeof(linux_binprm->buf) */
 #define BINPRM_BUF_SIZE 128
@@ -24,7 +26,12 @@ struct pt_regs;
  */
 struct linux_binprm{
         char buf[BINPRM_BUF_SIZE];
+#ifdef CONFIG_MMU
+        struct vm_area_struct *vma;
+#else
+# define MAX_ARG_PAGES  32
         struct page *page[MAX_ARG_PAGES];
+#endif
         struct mm_struct *mm;
         unsigned long p; /* current top of mem */
         int sh_bang;
@@ -40,6 +47,7 @@ struct linux_binprm{
         unsigned interp_flags;
         unsigned interp_data;
         unsigned long loader, exec;
+        unsigned long argv_len;
 };
 
 #define BINPRM_FLAGS_ENFORCE_NONDUMP_BIT 0
@@ -68,7 +76,7 @@ extern int register_binfmt(struct linux_binfmt *);
 extern int unregister_binfmt(struct linux_binfmt *);
 
 extern int prepare_binprm(struct linux_binprm *);
-extern void remove_arg_zero(struct linux_binprm *);
+extern int __must_check remove_arg_zero(struct linux_binprm *);
 extern int search_binary_handler(struct linux_binprm *,struct pt_regs *);
 extern int flush_old_exec(struct linux_binprm * bprm);
 
@@ -85,6 +93,7 @@ extern int suid_dumpable;
 extern int setup_arg_pages(struct linux_binprm * bprm,
                            unsigned long stack_top,
                            int executable_stack);
+extern int bprm_mm_init(struct linux_binprm *bprm);
 extern int copy_strings_kernel(int argc,char ** argv,struct linux_binprm *bprm);
 extern void compute_creds(struct linux_binprm *binprm);
 extern int do_coredump(long signr, int exit_code, struct pt_regs * regs);
diff --git a/include/linux/blkdev.h b/include/linux/blkdev.h
index fae138bd2207..695e34964cb7 100644
--- a/include/linux/blkdev.h
+++ b/include/linux/blkdev.h
@@ -14,6 +14,7 @@
 #include <linux/bio.h>
 #include <linux/module.h>
 #include <linux/stringify.h>
+#include <linux/bsg.h>
 
 #include <asm/scatterlist.h>
 
@@ -41,6 +42,8 @@ struct elevator_queue;
 typedef struct elevator_queue elevator_t;
 struct request_pm_state;
 struct blk_trace;
+struct request;
+struct sg_io_hdr;
 
 #define BLKDEV_MIN_RQ   4
 #define BLKDEV_MAX_RQ   128     /* Default maximum */
@@ -314,6 +317,9 @@ struct request {
          */
         rq_end_io_fn *end_io;
         void *end_io_data;
+
+        /* for bidi */
+        struct request *next_rq;
 };
 
 /*
@@ -468,6 +474,10 @@ struct request_queue
         unsigned int            bi_size;
 
         struct mutex            sysfs_lock;
+
+#if defined(CONFIG_BLK_DEV_BSG)
+        struct bsg_class_device bsg_dev;
+#endif
 };
 
 #define QUEUE_FLAG_CLUSTER      0       /* cluster several segments into 1 */
@@ -479,6 +489,7 @@ struct request_queue
 #define QUEUE_FLAG_REENTER      6       /* Re-entrancy avoidance */
 #define QUEUE_FLAG_PLUGGED      7       /* queue is plugged */
 #define QUEUE_FLAG_ELVSWITCH    8       /* don't use elevator, just do FIFO */
+#define QUEUE_FLAG_BIDI         9       /* queue supports bidi requests */
 
 enum {
         /*
@@ -543,6 +554,7 @@ enum {
 #define blk_sorted_rq(rq)       ((rq)->cmd_flags & REQ_SORTED)
 #define blk_barrier_rq(rq)      ((rq)->cmd_flags & REQ_HARDBARRIER)
 #define blk_fua_rq(rq)          ((rq)->cmd_flags & REQ_FUA)
+#define blk_bidi_rq(rq)         ((rq)->next_rq != NULL)
 
 #define list_entry_rq(ptr)      list_entry((ptr), struct request, queuelist)
 
@@ -607,7 +619,12 @@ extern unsigned long blk_max_low_pfn, blk_max_pfn;
 #define BLK_BOUNCE_ANY          ((u64)blk_max_pfn << PAGE_SHIFT)
 #define BLK_BOUNCE_ISA          (ISA_DMA_THRESHOLD)
 
-#ifdef CONFIG_MMU
+/*
+ * default timeout for SG_IO if none specified
+ */
+#define BLK_DEFAULT_SG_TIMEOUT  (60 * HZ)
+
+#ifdef CONFIG_BOUNCE
 extern int init_emergency_isa_pool(void);
 extern void blk_queue_bounce(request_queue_t *q, struct bio **bio);
 #else
@@ -637,7 +654,8 @@ extern void blk_requeue_request(request_queue_t *, struct request *);
 extern void blk_plug_device(request_queue_t *);
 extern int blk_remove_plug(request_queue_t *);
 extern void blk_recount_segments(request_queue_t *, struct bio *);
-extern int scsi_cmd_ioctl(struct file *, struct gendisk *, unsigned int, void __user *);
+extern int scsi_cmd_ioctl(struct file *, struct request_queue *,
+                          struct gendisk *, unsigned int, void __user *);
 extern int sg_scsi_ioctl(struct file *, struct request_queue *,
                 struct gendisk *, struct scsi_ioctl_command __user *);
 
@@ -680,6 +698,7 @@ extern int blk_execute_rq(request_queue_t *, struct gendisk *,
                           struct request *, int);
 extern void blk_execute_rq_nowait(request_queue_t *, struct gendisk *,
                                   struct request *, int, rq_end_io_fn *);
+extern int blk_verify_command(unsigned char *, int);
 
 static inline request_queue_t *bdev_get_queue(struct block_device *bdev)
 {
diff --git a/include/linux/bsg.h b/include/linux/bsg.h
new file mode 100644
index 000000000000..f415f89e0ac8
--- /dev/null
+++ b/include/linux/bsg.h
@@ -0,0 +1,69 @@
+#ifndef BSG_H
+#define BSG_H
+
+#define BSG_PROTOCOL_SCSI               0
+
+#define BSG_SUB_PROTOCOL_SCSI_CMD       0
+#define BSG_SUB_PROTOCOL_SCSI_TMF       1
+#define BSG_SUB_PROTOCOL_SCSI_TRANSPORT 2
+
+struct sg_io_v4 {
+        __s32 guard;            /* [i] 'Q' to differentiate from v3 */
+        __u32 protocol;         /* [i] 0 -> SCSI , .... */
+        __u32 subprotocol;      /* [i] 0 -> SCSI command, 1 -> SCSI task
+                                   management function, .... */
+
+        __u32 request_len;      /* [i] in bytes */
+        __u64 request;          /* [i], [*i] {SCSI: cdb} */
+        __u32 request_attr;     /* [i] {SCSI: task attribute} */
+        __u32 request_tag;      /* [i] {SCSI: task tag (only if flagged)} */
+        __u32 request_priority; /* [i] {SCSI: task priority} */
+        __u32 max_response_len; /* [i] in bytes */
+        __u64 response;         /* [i], [*o] {SCSI: (auto)sense data} */
+
+        /* "din_" for data in (from device); "dout_" for data out (to device) */
+        __u32 dout_xfer_len;    /* [i] bytes to be transferred to device */
+        __u32 din_xfer_len;     /* [i] bytes to be transferred from device */
+        __u64 dout_xferp;       /* [i], [*i] */
+        __u64 din_xferp;        /* [i], [*o] */
+
+        __u32 timeout;          /* [i] units: millisecond */
+        __u32 flags;            /* [i] bit mask */
+        __u64 usr_ptr;          /* [i->o] unused internally */
+        __u32 spare_in;         /* [i] */
+
+        __u32 driver_status;    /* [o] 0 -> ok */
+        __u32 transport_status; /* [o] 0 -> ok */
+        __u32 device_status;    /* [o] {SCSI: command completion status} */
+        __u32 retry_delay;      /* [o] {SCSI: status auxiliary information} */
+        __u32 info;             /* [o] additional information */
+        __u32 duration;         /* [o] time to complete, in milliseconds */
+        __u32 response_len;     /* [o] bytes of response actually written */
+        __s32 din_resid;        /* [o] actual_din_xfer_len - din_xfer_len */
+        __u32 generated_tag;    /* [o] {SCSI: task tag that transport chose} */
+        __u32 spare_out;        /* [o] */
+
+        __u32 padding;
+};
+
+#ifdef __KERNEL__
+
+#if defined(CONFIG_BLK_DEV_BSG)
+struct bsg_class_device {
+        struct class_device *class_dev;
+        struct device *dev;
+        int minor;
+        struct list_head list;
+        struct request_queue *queue;
+};
+
+extern int bsg_register_queue(struct request_queue *, struct device *, const char *);
+extern void bsg_unregister_queue(struct request_queue *);
+#else
+#define bsg_register_queue(disk, dev, name)             (0)
+#define bsg_unregister_queue(disk)      do { } while (0)
+#endif
+
+#endif /* __KERNEL__ */
+
+#endif
diff --git a/include/linux/buffer_head.h b/include/linux/buffer_head.h
index 5c6e12853a9b..35cadad84b14 100644
--- a/include/linux/buffer_head.h
+++ b/include/linux/buffer_head.h
@@ -209,6 +209,8 @@ 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_page_mkwrite(struct vm_area_struct *vma, struct page *page,
+                                get_block_t get_block);
 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);
diff --git a/include/linux/bug.h b/include/linux/bug.h
index 42aa0a54b6f4..54398d2c6d8d 100644
--- a/include/linux/bug.h
+++ b/include/linux/bug.h
@@ -10,6 +10,8 @@ enum bug_trap_type {
         BUG_TRAP_TYPE_BUG = 2,
 };
 
+struct pt_regs;
+
 #ifdef CONFIG_GENERIC_BUG
 #include <asm-generic/bug.h>
 
@@ -20,7 +22,7 @@ static inline int is_warning_bug(const struct bug_entry *bug)
 
 const struct bug_entry *find_bug(unsigned long bugaddr);
 
-enum bug_trap_type report_bug(unsigned long bug_addr);
+enum bug_trap_type report_bug(unsigned long bug_addr, struct pt_regs *regs);
 
 int  module_bug_finalize(const Elf_Ehdr *, const Elf_Shdr *,
                          struct module *);
@@ -31,7 +33,8 @@ int is_valid_bugaddr(unsigned long addr);
 
 #else   /* !CONFIG_GENERIC_BUG */
 
-static inline enum bug_trap_type report_bug(unsigned long bug_addr)
+static inline enum bug_trap_type report_bug(unsigned long bug_addr,
+                                            struct pt_regs *regs)
 {
         return BUG_TRAP_TYPE_BUG;
 }
diff --git a/include/linux/capability.h b/include/linux/capability.h
index bbf8df7de28f..2dfa58555934 100644
--- a/include/linux/capability.h
+++ b/include/linux/capability.h
@@ -44,7 +44,6 @@ typedef struct __user_cap_data_struct {
   
 #ifdef __KERNEL__
 
-#include <linux/spinlock.h>
 #include <asm/current.h>
 
 /* #define STRICT_CAP_T_TYPECHECKS */
diff --git a/include/linux/cdrom.h b/include/linux/cdrom.h
index f50f04bdbc16..2b641b176e7f 100644
--- a/include/linux/cdrom.h
+++ b/include/linux/cdrom.h
@@ -414,8 +414,8 @@ struct cdrom_generic_command
 #define CDO_CHECK_TYPE          0x10    /* check type on open for data */
 
 /* Special codes used when specifying changer slots. */
-#define CDSL_NONE               ((int) (~0U>>1)-1)
-#define CDSL_CURRENT            ((int) (~0U>>1))
+#define CDSL_NONE               (INT_MAX-1)
+#define CDSL_CURRENT            INT_MAX
 
 /* For partition based multisession access. IDE can handle 64 partitions
  * per drive - SCSI CD-ROM's use minors to differentiate between the
diff --git a/include/linux/clockchips.h b/include/linux/clockchips.h
index 8486e78f7335..e0bd46eb2414 100644
--- a/include/linux/clockchips.h
+++ b/include/linux/clockchips.h
@@ -23,6 +23,7 @@ enum clock_event_mode {
         CLOCK_EVT_MODE_SHUTDOWN,
         CLOCK_EVT_MODE_PERIODIC,
         CLOCK_EVT_MODE_ONESHOT,
+        CLOCK_EVT_MODE_RESUME,
 };
 
 /* Clock event notification values */
@@ -119,10 +120,6 @@ extern void clockevents_register_device(struct clock_event_device *dev);
 
 extern void clockevents_exchange_device(struct clock_event_device *old,
                                         struct clock_event_device *new);
-extern
-struct clock_event_device *clockevents_request_device(unsigned int features,
-                                                      cpumask_t cpumask);
-extern void clockevents_release_device(struct clock_event_device *dev);
 extern void clockevents_set_mode(struct clock_event_device *dev,
                                  enum clock_event_mode mode);
 extern int clockevents_register_notifier(struct notifier_block *nb);
diff --git a/include/linux/clocksource.h b/include/linux/clocksource.h
index bf297b03a4e4..16ea3374dddf 100644
--- a/include/linux/clocksource.h
+++ b/include/linux/clocksource.h
@@ -67,6 +67,12 @@ struct clocksource {
         unsigned long flags;
         cycle_t (*vread)(void);
         void (*resume)(void);
+#ifdef CONFIG_IA64
+        void *fsys_mmio;        /* used by fsyscall asm code */
+#define CLKSRC_FSYS_MMIO_SET(mmio, addr)      ((mmio) = (addr))
+#else
+#define CLKSRC_FSYS_MMIO_SET(mmio, addr)      do { } while (0)
+#endif
 
         /* timekeeping specific data, ignore */
         cycle_t cycle_interval;
diff --git a/include/linux/cobalt-nvram.h b/include/linux/cobalt-nvram.h
deleted file mode 100644
index ea429562ff36..000000000000
--- a/include/linux/cobalt-nvram.h
+++ /dev/null
@@ -1,109 +0,0 @@
-/*
- * $Id: cobalt-nvram.h,v 1.20 2001/10/17 23:16:55 thockin Exp $
- * cobalt-nvram.h : defines for the various fields in the cobalt NVRAM
- *
- * Copyright 2001,2002 Sun Microsystems, Inc.
- */
-
-#ifndef COBALT_NVRAM_H
-#define COBALT_NVRAM_H
-
-#include <linux/nvram.h>
-
-#define COBT_CMOS_INFO_MAX              0x7f    /* top address allowed */
-#define COBT_CMOS_BIOS_DRIVE_INFO       0x12    /* drive info would go here */
-
-#define COBT_CMOS_CKS_START             NVRAM_OFFSET(0x0e)
-#define COBT_CMOS_CKS_END               NVRAM_OFFSET(0x7f)
-
-/* flag bytes - 16 flags for now, leave room for more */
-#define COBT_CMOS_FLAG_BYTE_0           NVRAM_OFFSET(0x10)
-#define COBT_CMOS_FLAG_BYTE_1           NVRAM_OFFSET(0x11)
-
-/* flags in flag bytes - up to 16 */
-#define COBT_CMOS_FLAG_MIN              0x0001
-#define COBT_CMOS_CONSOLE_FLAG          0x0001 /* console on/off */
-#define COBT_CMOS_DEBUG_FLAG            0x0002 /* ROM debug messages */
-#define COBT_CMOS_AUTO_PROMPT_FLAG      0x0004 /* boot to ROM prompt? */
-#define COBT_CMOS_CLEAN_BOOT_FLAG       0x0008 /* set by a clean shutdown */
-#define COBT_CMOS_HW_NOPROBE_FLAG       0x0010 /* go easy on the probing */
-#define COBT_CMOS_SYSFAULT_FLAG         0x0020 /* system fault detected */
-#define COBT_CMOS_OOPSPANIC_FLAG        0x0040 /* panic on oops */
-#define COBT_CMOS_DELAY_CACHE_FLAG      0x0080 /* delay cache initialization */
-#define COBT_CMOS_NOLOGO_FLAG           0x0100 /* hide "C" logo @ boot */
-#define COBT_CMOS_VERSION_FLAG          0x0200 /* the version field is valid */
-#define COBT_CMOS_FLAG_MAX              0x0200
-
-/* leave byte 0x12 blank - Linux looks for drive info here */
-
-/* CMOS structure version, valid if COBT_CMOS_VERSION_FLAG is true */
-#define COBT_CMOS_VERSION               NVRAM_OFFSET(0x13)
-#define COBT_CMOS_VER_BTOCODE           1 /* min. version needed for btocode */
-
-/* index of default boot method */
-#define COBT_CMOS_BOOT_METHOD           NVRAM_OFFSET(0x20)
-#define COBT_CMOS_BOOT_METHOD_DISK      0
-#define COBT_CMOS_BOOT_METHOD_ROM       1
-#define COBT_CMOS_BOOT_METHOD_NET       2
-
-#define COBT_CMOS_BOOT_DEV_MIN          NVRAM_OFFSET(0x21)
-/* major #, minor # of first through fourth boot device */
-#define COBT_CMOS_BOOT_DEV0_MAJ         NVRAM_OFFSET(0x21)
-#define COBT_CMOS_BOOT_DEV0_MIN         NVRAM_OFFSET(0x22)
-#define COBT_CMOS_BOOT_DEV1_MAJ         NVRAM_OFFSET(0x23)
-#define COBT_CMOS_BOOT_DEV1_MIN         NVRAM_OFFSET(0x24)
-#define COBT_CMOS_BOOT_DEV2_MAJ         NVRAM_OFFSET(0x25)
-#define COBT_CMOS_BOOT_DEV2_MIN         NVRAM_OFFSET(0x26)
-#define COBT_CMOS_BOOT_DEV3_MAJ         NVRAM_OFFSET(0x27)
-#define COBT_CMOS_BOOT_DEV3_MIN         NVRAM_OFFSET(0x28)
-#define COBT_CMOS_BOOT_DEV_MAX          NVRAM_OFFSET(0x28)
-
-/* checksum of bytes 0xe-0x7f */
-#define COBT_CMOS_CHECKSUM              NVRAM_OFFSET(0x2e)
-
-/* running uptime counter, units of 5 minutes (32 bits =~ 41000 years) */
-#define COBT_CMOS_UPTIME_0              NVRAM_OFFSET(0x30)
-#define COBT_CMOS_UPTIME_1              NVRAM_OFFSET(0x31)
-#define COBT_CMOS_UPTIME_2              NVRAM_OFFSET(0x32)
-#define COBT_CMOS_UPTIME_3              NVRAM_OFFSET(0x33)
-
-/* count of successful boots (32 bits) */
-#define COBT_CMOS_BOOTCOUNT_0           NVRAM_OFFSET(0x38)
-#define COBT_CMOS_BOOTCOUNT_1           NVRAM_OFFSET(0x39)
-#define COBT_CMOS_BOOTCOUNT_2           NVRAM_OFFSET(0x3a)
-#define COBT_CMOS_BOOTCOUNT_3           NVRAM_OFFSET(0x3b)
-
-/* 13 bytes: system serial number, same as on the back of the system */
-#define COBT_CMOS_SYS_SERNUM_LEN        13
-#define COBT_CMOS_SYS_SERNUM_0          NVRAM_OFFSET(0x40)
-#define COBT_CMOS_SYS_SERNUM_1          NVRAM_OFFSET(0x41)
-#define COBT_CMOS_SYS_SERNUM_2          NVRAM_OFFSET(0x42)
-#define COBT_CMOS_SYS_SERNUM_3          NVRAM_OFFSET(0x43)
-#define COBT_CMOS_SYS_SERNUM_4          NVRAM_OFFSET(0x44)
-#define COBT_CMOS_SYS_SERNUM_5          NVRAM_OFFSET(0x45)
-#define COBT_CMOS_SYS_SERNUM_6          NVRAM_OFFSET(0x46)
-#define COBT_CMOS_SYS_SERNUM_7          NVRAM_OFFSET(0x47)
-#define COBT_CMOS_SYS_SERNUM_8          NVRAM_OFFSET(0x48)
-#define COBT_CMOS_SYS_SERNUM_9          NVRAM_OFFSET(0x49)
-#define COBT_CMOS_SYS_SERNUM_10         NVRAM_OFFSET(0x4a)
-#define COBT_CMOS_SYS_SERNUM_11         NVRAM_OFFSET(0x4b)
-#define COBT_CMOS_SYS_SERNUM_12         NVRAM_OFFSET(0x4c)
-/* checksum for serial num - 1 byte */
-#define COBT_CMOS_SYS_SERNUM_CSUM       NVRAM_OFFSET(0x4f)
-
-#define COBT_CMOS_ROM_REV_MAJ           NVRAM_OFFSET(0x50)
-#define COBT_CMOS_ROM_REV_MIN           NVRAM_OFFSET(0x51)
-#define COBT_CMOS_ROM_REV_REV           NVRAM_OFFSET(0x52)
-
-#define COBT_CMOS_BTO_CODE_0            NVRAM_OFFSET(0x53)
-#define COBT_CMOS_BTO_CODE_1            NVRAM_OFFSET(0x54)
-#define COBT_CMOS_BTO_CODE_2            NVRAM_OFFSET(0x55)
-#define COBT_CMOS_BTO_CODE_3            NVRAM_OFFSET(0x56)
-
-#define COBT_CMOS_BTO_IP_CSUM           NVRAM_OFFSET(0x57)
-#define COBT_CMOS_BTO_IP_0              NVRAM_OFFSET(0x58)
-#define COBT_CMOS_BTO_IP_1              NVRAM_OFFSET(0x59)
-#define COBT_CMOS_BTO_IP_2              NVRAM_OFFSET(0x5a)
-#define COBT_CMOS_BTO_IP_3              NVRAM_OFFSET(0x5b)
-
-#endif /* COBALT_NVRAM_H */
diff --git a/include/linux/coda_linux.h b/include/linux/coda_linux.h
index e4ac016ad272..1c47a34aa794 100644
--- a/include/linux/coda_linux.h
+++ b/include/linux/coda_linux.h
@@ -36,16 +36,12 @@ extern const struct file_operations coda_ioctl_operations;
 
 /* operations shared over more than one file */
 int coda_open(struct inode *i, struct file *f);
-int coda_flush(struct file *f, fl_owner_t id);
 int coda_release(struct inode *i, struct file *f);
 int coda_permission(struct inode *inode, int mask, struct nameidata *nd);
 int coda_revalidate_inode(struct dentry *);
 int coda_getattr(struct vfsmount *, struct dentry *, struct kstat *);
 int coda_setattr(struct dentry *, struct iattr *);
 
-/* global variables */
-extern int coda_fake_statfs;
-
 /* this file:  heloers */
 static __inline__ struct CodaFid *coda_i2f(struct inode *);
 static __inline__ char *coda_i2s(struct inode *);
diff --git a/include/linux/coda_proc.h b/include/linux/coda_proc.h
deleted file mode 100644
index 0dc1b0458e75..000000000000
--- a/include/linux/coda_proc.h
+++ /dev/null
@@ -1,76 +0,0 @@
-/*
- * coda_statis.h
- * 
- * CODA operation statistics
- *
- * (c) March, 1998
- * by Michihiro Kuramochi, Zhenyu Xia and Zhanyong Wan
- * zhanyong.wan@yale.edu
- *
- */
-
-#ifndef _CODA_PROC_H
-#define _CODA_PROC_H
-
-void coda_sysctl_init(void);
-void coda_sysctl_clean(void);
-
-#include <linux/sysctl.h>
-#include <linux/coda_fs_i.h>
-#include <linux/coda.h>
-
-/* these four files are presented to show the result of the statistics:
- *
- *      /proc/fs/coda/vfs_stats
- *                    cache_inv_stats
- *
- * these four files are presented to reset the statistics to 0:
- *
- *      /proc/sys/coda/vfs_stats
- *                     cache_inv_stats
- */
-
-/* VFS operation statistics */
-struct coda_vfs_stats 
-{
-        /* file operations */
-        int open;
-        int flush;
-        int release;
-        int fsync;
-
-        /* dir operations */
-        int readdir;
-  
-        /* inode operations */
-        int create;
-        int lookup;
-        int link;
-        int unlink;
-        int symlink;
-        int mkdir;
-        int rmdir;
-        int rename;
-        int permission;
-
-        /* symlink operatoins*/
-        int follow_link;
-        int readlink;
-};
-
-/* cache invalidation statistics */
-struct coda_cache_inv_stats
-{
-        int flush;
-        int purge_user;
-        int zap_dir;
-        int zap_file;
-        int zap_vnode;
-        int purge_fid;
-        int replace;
-};
-
-/* these global variables hold the actual statistics data */
-extern struct coda_vfs_stats            coda_vfs_stat;
-
-#endif /* _CODA_PROC_H */
diff --git a/include/linux/coda_psdev.h b/include/linux/coda_psdev.h
index b541bb3d1f4b..07ae8f846055 100644
--- a/include/linux/coda_psdev.h
+++ b/include/linux/coda_psdev.h
@@ -8,11 +8,6 @@
 
 struct kstatfs;
 
-struct coda_sb_info
-{
-        struct venus_comm *sbi_vcomm;
-};
-
 /* communication pending/processing queues */
 struct venus_comm {
         u_long              vc_seq;
@@ -24,9 +19,9 @@ struct venus_comm {
 };
 
 
-static inline struct coda_sb_info *coda_sbp(struct super_block *sb)
+static inline struct venus_comm *coda_vcp(struct super_block *sb)
 {
-    return ((struct coda_sb_info *)((sb)->s_fs_info));
+        return (struct venus_comm *)((sb)->s_fs_info);
 }
 
 
@@ -38,9 +33,6 @@ int venus_setattr(struct super_block *, struct CodaFid *, struct coda_vattr *);
 int venus_lookup(struct super_block *sb, struct CodaFid *fid, 
                  const char *name, int length, int *type, 
                  struct CodaFid *resfid);
-int venus_store(struct super_block *sb, struct CodaFid *fid, int flags,
-                vuid_t uid);
-int venus_release(struct super_block *sb, struct CodaFid *fid, int flags);
 int venus_close(struct super_block *sb, struct CodaFid *fid, int flags,
                 vuid_t uid);
 int venus_open(struct super_block *sb, struct CodaFid *fid, int flags,
@@ -74,8 +66,6 @@ int venus_statfs(struct dentry *dentry, struct kstatfs *sfs);
 
 
 /* messages between coda filesystem in kernel and Venus */
-extern int coda_hard;
-extern unsigned long coda_timeout;
 struct upc_req {
         struct list_head    uc_chain;
         caddr_t             uc_data;
@@ -85,7 +75,6 @@ struct upc_req {
         u_short             uc_opcode;  /* copied from data to save lookup */
         int                 uc_unique;
         wait_queue_head_t   uc_sleep;   /* process' wait queue */
-        unsigned long       uc_posttime;
 };
 
 #define REQ_ASYNC  0x1
diff --git a/include/linux/compiler-gcc4.h b/include/linux/compiler-gcc4.h
index a03e9398a6c2..14f7494280f0 100644
--- a/include/linux/compiler-gcc4.h
+++ b/include/linux/compiler-gcc4.h
@@ -23,3 +23,21 @@
  * code
  */
 #define uninitialized_var(x) x = x
+
+#if !(__GNUC__ == 4 && __GNUC_MINOR__ < 3)
+/* Mark functions as cold. gcc will assume any path leading to a call
+   to them will be unlikely.  This means a lot of manual unlikely()s
+   are unnecessary now for any paths leading to the usual suspects
+   like BUG(), printk(), panic() etc. [but let's keep them for now for
+   older compilers]
+
+   Early snapshots of gcc 4.3 don't support this and we can't detect this
+   in the preprocessor, but we can live with this because they're unreleased.
+   Maketime probing would be overkill here.
+
+   gcc also has a __attribute__((__hot__)) to move hot functions into
+   a special section, but I don't see any sense in this right now in
+   the kernel context */
+#define __cold                  __attribute__((__cold__))
+
+#endif
diff --git a/include/linux/compiler.h b/include/linux/compiler.h
index 8287a72bb6a9..12a1291855e2 100644
--- a/include/linux/compiler.h
+++ b/include/linux/compiler.h
@@ -174,4 +174,13 @@ extern void __chk_io_ptr(const void __iomem *);
 # define __attribute_const__    /* unimplemented */
 #endif
 
+/*
+ * Tell gcc if a function is cold. The compiler will assume any path
+ * directly leading to the call is unlikely.
+ */
+
+#ifndef __cold
+#define __cold
+#endif
+
 #endif /* __LINUX_COMPILER_H */
diff --git a/include/linux/configfs.h b/include/linux/configfs.h
index fef6f3d0a4a7..8c6967f3fb11 100644
--- a/include/linux/configfs.h
+++ b/include/linux/configfs.h
@@ -40,9 +40,9 @@
 #include <linux/types.h>
 #include <linux/list.h>
 #include <linux/kref.h>
+#include <linux/mutex.h>
 
 #include <asm/atomic.h>
-#include <asm/semaphore.h>
 
 #define CONFIGFS_ITEM_NAME_LEN  20
 
@@ -75,7 +75,6 @@ extern void config_item_init(struct config_item *);
 extern void config_item_init_type_name(struct config_item *item,
                                        const char *name,
                                        struct config_item_type *type);
-extern void config_item_cleanup(struct config_item *);
 
 extern struct config_item * config_item_get(struct config_item *);
 extern void config_item_put(struct config_item *);
@@ -87,12 +86,10 @@ struct config_item_type {
         struct configfs_attribute               **ct_attrs;
 };
 
-
 /**
  *      group - a group of config_items of a specific type, belonging
  *      to a specific subsystem.
  */
-
 struct config_group {
         struct config_item              cg_item;
         struct list_head                cg_children;
@@ -100,13 +97,11 @@ struct config_group {
         struct config_group             **default_groups;
 };
 
-
 extern void config_group_init(struct config_group *group);
 extern void config_group_init_type_name(struct config_group *group,
                                         const char *name,
                                         struct config_item_type *type);
 
-
 static inline struct config_group *to_config_group(struct config_item *item)
 {
         return item ? container_of(item,struct config_group,cg_item) : NULL;
@@ -122,7 +117,8 @@ static inline void config_group_put(struct config_group *group)
         config_item_put(&group->cg_item);
 }
 
-extern struct config_item *config_group_find_obj(struct config_group *, const char *);
+extern struct config_item *config_group_find_item(struct config_group *,
+                                                  const char *);
 
 
 struct configfs_attribute {
@@ -131,6 +127,22 @@ struct configfs_attribute {
         mode_t                  ca_mode;
 };
 
+/*
+ * Users often need to create attribute structures for their configurable
+ * attributes, containing a configfs_attribute member and function pointers
+ * for the show() and store() operations on that attribute. They can use
+ * this macro (similar to sysfs' __ATTR) to make defining attributes easier.
+ */
+#define __CONFIGFS_ATTR(_name, _mode, _show, _store)                    \
+{                                                                       \
+        .attr   = {                                                     \
+                        .ca_name = __stringify(_name),                  \
+                        .ca_mode = _mode,                               \
+                        .ca_owner = THIS_MODULE,                        \
+        },                                                              \
+        .show   = _show,                                                \
+        .store  = _store,                                               \
+}
 
 /*
  * If allow_link() exists, the item can symlink(2) out to other
@@ -157,12 +169,13 @@ struct configfs_group_operations {
         struct config_item *(*make_item)(struct config_group *group, const char *name);
         struct config_group *(*make_group)(struct config_group *group, const char *name);
         int (*commit_item)(struct config_item *item);
+        void (*disconnect_notify)(struct config_group *group, struct config_item *item);
         void (*drop_item)(struct config_group *group, struct config_item *item);
 };
 
 struct configfs_subsystem {
         struct config_group     su_group;
-        struct semaphore        su_sem;
+        struct mutex            su_mutex;
 };
 
 static inline struct configfs_subsystem *to_configfs_subsystem(struct config_group *group)
@@ -175,6 +188,11 @@ static inline struct configfs_subsystem *to_configfs_subsystem(struct config_gro
 int configfs_register_subsystem(struct configfs_subsystem *subsys);
 void configfs_unregister_subsystem(struct configfs_subsystem *subsys);
 
+/* These functions can sleep and can alloc with GFP_KERNEL */
+/* WARNING: These cannot be called underneath configfs callbacks!! */
+int configfs_depend_item(struct configfs_subsystem *subsys, struct config_item *target);
+void configfs_undepend_item(struct configfs_subsystem *subsys, struct config_item *target);
+
 #endif  /* __KERNEL__ */
 
 #endif /* _CONFIGFS_H_ */
diff --git a/include/linux/console.h b/include/linux/console.h
index 62ef6e11d0d2..56a7bcda49cb 100644
--- a/include/linux/console.h
+++ b/include/linux/console.h
@@ -15,7 +15,6 @@
 #define _LINUX_CONSOLE_H_ 1
 
 #include <linux/types.h>
-#include <linux/spinlock.h>
 
 struct vc_data;
 struct console_font_op;
@@ -99,6 +98,7 @@ struct console {
         struct tty_driver *(*device)(struct console *, int *);
         void    (*unblank)(void);
         int     (*setup)(struct console *, char *);
+        int     (*early_setup)(void);
         short   flags;
         short   index;
         int     cflag;
@@ -107,6 +107,7 @@ struct console {
 };
 
 extern int add_preferred_console(char *name, int idx, char *options);
+extern int update_console_cmdline(char *name, int idx, char *name_new, int idx_new, char *options);
 extern void register_console(struct console *);
 extern int unregister_console(struct console *);
 extern struct console *console_drivers;
diff --git a/include/linux/consolemap.h b/include/linux/consolemap.h
index 82c9a1f11020..06b2768c603f 100644
--- a/include/linux/consolemap.h
+++ b/include/linux/consolemap.h
@@ -8,9 +8,12 @@
 #define IBMPC_MAP 2
 #define USER_MAP 3
 
+#include <linux/types.h>
+
 struct vc_data;
 
-extern unsigned char inverse_translate(struct vc_data *conp, int glyph);
+extern u16 inverse_translate(struct vc_data *conp, int glyph, int use_unicode);
 extern unsigned short *set_translate(int m, struct vc_data *vc);
 extern int conv_uni_to_pc(struct vc_data *conp, long ucs);
+extern u32 conv_8bit_to_uni(unsigned char c);
 void console_map_init(void);
diff --git a/include/linux/cpu.h b/include/linux/cpu.h
index 3b2df2523f1d..c2236bbff412 100644
--- a/include/linux/cpu.h
+++ b/include/linux/cpu.h
@@ -120,7 +120,6 @@ static inline void cpuhotplug_mutex_unlock(struct mutex *cpu_hp_mutex)
 
 #define lock_cpu_hotplug()      do { } while (0)
 #define unlock_cpu_hotplug()    do { } while (0)
-#define lock_cpu_hotplug_interruptible() 0
 #define hotcpu_notifier(fn, pri)        do { (void)(fn); } while (0)
 #define register_hotcpu_notifier(nb)    do { (void)(nb); } while (0)
 #define unregister_hotcpu_notifier(nb)  do { (void)(nb); } while (0)
diff --git a/include/linux/crc7.h b/include/linux/crc7.h
new file mode 100644
index 000000000000..1786e772d5c6
--- /dev/null
+++ b/include/linux/crc7.h
@@ -0,0 +1,14 @@
+#ifndef _LINUX_CRC7_H
+#define _LINUX_CRC7_H
+#include <linux/types.h>
+
+extern const u8 crc7_syndrome_table[256];
+
+static inline u8 crc7_byte(u8 crc, u8 data)
+{
+        return crc7_syndrome_table[(crc << 1) ^ data];
+}
+
+extern u8 crc7(u8 crc, const u8 *buffer, size_t len);
+
+#endif
diff --git a/include/linux/crypto.h b/include/linux/crypto.h
index 0de7e2ace822..357e8cfedc37 100644
--- a/include/linux/crypto.h
+++ b/include/linux/crypto.h
@@ -295,28 +295,8 @@ struct blkcipher_tfm {
 };
 
 struct cipher_tfm {
-        void *cit_iv;
-        unsigned int cit_ivsize;
-        u32 cit_mode;
         int (*cit_setkey)(struct crypto_tfm *tfm,
                           const u8 *key, unsigned int keylen);
-        int (*cit_encrypt)(struct crypto_tfm *tfm,
-                           struct scatterlist *dst,
-                           struct scatterlist *src,
-                           unsigned int nbytes);
-        int (*cit_encrypt_iv)(struct crypto_tfm *tfm,
-                              struct scatterlist *dst,
-                              struct scatterlist *src,
-                              unsigned int nbytes, u8 *iv);
-        int (*cit_decrypt)(struct crypto_tfm *tfm,
-                           struct scatterlist *dst,
-                           struct scatterlist *src,
-                           unsigned int nbytes);
-        int (*cit_decrypt_iv)(struct crypto_tfm *tfm,
-                           struct scatterlist *dst,
-                           struct scatterlist *src,
-                           unsigned int nbytes, u8 *iv);
-        void (*cit_xor_block)(u8 *dst, const u8 *src);
         void (*cit_encrypt_one)(struct crypto_tfm *tfm, u8 *dst, const u8 *src);
         void (*cit_decrypt_one)(struct crypto_tfm *tfm, u8 *dst, const u8 *src);
 };
diff --git a/include/linux/dcookies.h b/include/linux/dcookies.h
index 0fe7cdf326f7..98c69ab80c84 100644
--- a/include/linux/dcookies.h
+++ b/include/linux/dcookies.h
@@ -12,6 +12,7 @@
 
 #ifdef CONFIG_PROFILING
  
+#include <linux/dcache.h>
 #include <linux/types.h>
  
 struct dcookie_user;
diff --git a/include/linux/debugfs.h b/include/linux/debugfs.h
index 5a9c49534d08..104e51e20e14 100644
--- a/include/linux/debugfs.h
+++ b/include/linux/debugfs.h
@@ -38,6 +38,9 @@ struct dentry *debugfs_create_symlink(const char *name, struct dentry *parent,
 
 void debugfs_remove(struct dentry *dentry);
 
+struct dentry *debugfs_rename(struct dentry *old_dir, struct dentry *old_dentry,
+                struct dentry *new_dir, const char *new_name);
+
 struct dentry *debugfs_create_u8(const char *name, mode_t mode,
                                  struct dentry *parent, u8 *value);
 struct dentry *debugfs_create_u16(const char *name, mode_t mode,
@@ -85,6 +88,12 @@ static inline struct dentry *debugfs_create_symlink(const char *name,
 static inline void debugfs_remove(struct dentry *dentry)
 { }
 
+static inline struct dentry *debugfs_rename(struct dentry *old_dir, struct dentry *old_dentry,
+                struct dentry *new_dir, char *new_name)
+{
+        return ERR_PTR(-ENODEV);
+}
+
 static inline struct dentry *debugfs_create_u8(const char *name, mode_t mode,
                                                struct dentry *parent,
                                                u8 *value)
diff --git a/include/linux/device.h b/include/linux/device.h
index 2e1a2988b7e1..d9f0a57f5a2f 100644
--- a/include/linux/device.h
+++ b/include/linux/device.h
@@ -238,7 +238,6 @@ extern int __must_check class_device_create_file(struct class_device *,
  * @devt: for internal use by the driver core only.
  * @node: for internal use by the driver core only.
  * @kobj: for internal use by the driver core only.
- * @devt_attr: for internal use by the driver core only.
  * @groups: optional additional groups to be created
  * @dev: if set, a symlink to the struct device is created in the sysfs
  * directory for this struct class device.
@@ -263,8 +262,6 @@ struct class_device {
         struct kobject          kobj;
         struct class            * class;        /* required */
         dev_t                   devt;           /* dev_t, creates the sysfs "dev" */
-        struct class_device_attribute *devt_attr;
-        struct class_device_attribute uevent_attr;
         struct device           * dev;          /* not necessary, but nice to have */
         void                    * class_data;   /* class-specific data */
         struct class_device     *parent;        /* parent of this child device, if there is one */
@@ -419,8 +416,6 @@ struct device {
         struct device_type      *type;
         unsigned                is_registered:1;
         unsigned                uevent_suppress:1;
-        struct device_attribute uevent_attr;
-        struct device_attribute *devt_attr;
 
         struct semaphore        sem;    /* semaphore to synchronize calls to
                                          * its driver.
@@ -577,6 +572,16 @@ dev_dbg(struct device * dev, const char * fmt, ...)
 }
 #endif
 
+#ifdef VERBOSE_DEBUG
+#define dev_vdbg        dev_dbg
+#else
+static inline int __attribute__ ((format (printf, 2, 3)))
+dev_vdbg(struct device * dev, const char * fmt, ...)
+{
+        return 0;
+}
+#endif
+
 #define dev_err(dev, format, arg...)            \
         dev_printk(KERN_ERR , dev , format , ## arg)
 #define dev_info(dev, format, arg...)           \
diff --git a/include/linux/dma-mapping.h b/include/linux/dma-mapping.h
index 9a663c6db16a..2dc21cbeb304 100644
--- a/include/linux/dma-mapping.h
+++ b/include/linux/dma-mapping.h
@@ -31,7 +31,11 @@ static inline int valid_dma_direction(int dma_direction)
                 (dma_direction == DMA_FROM_DEVICE));
 }
 
+#ifdef CONFIG_HAS_DMA
 #include <asm/dma-mapping.h>
+#else
+#include <asm-generic/dma-mapping-broken.h>
+#endif
 
 /* Backwards compat, remove in 2.7.x */
 #define dma_sync_single         dma_sync_single_for_cpu
diff --git a/include/linux/dmaengine.h b/include/linux/dmaengine.h
index c94d8f1d62e5..a3b6035b6c86 100644
--- a/include/linux/dmaengine.h
+++ b/include/linux/dmaengine.h
@@ -21,29 +21,40 @@
 #ifndef DMAENGINE_H
 #define DMAENGINE_H
 
-#ifdef CONFIG_DMA_ENGINE
-
 #include <linux/device.h>
 #include <linux/uio.h>
 #include <linux/kref.h>
 #include <linux/completion.h>
 #include <linux/rcupdate.h>
+#include <linux/dma-mapping.h>
 
 /**
- * enum dma_event - resource PNP/power managment events
+ * enum dma_state - resource PNP/power managment state
  * @DMA_RESOURCE_SUSPEND: DMA device going into low power state
  * @DMA_RESOURCE_RESUME: DMA device returning to full power
- * @DMA_RESOURCE_ADDED: DMA device added to the system
+ * @DMA_RESOURCE_AVAILABLE: DMA device available to the system
  * @DMA_RESOURCE_REMOVED: DMA device removed from the system
  */
-enum dma_event {
+enum dma_state {
         DMA_RESOURCE_SUSPEND,
         DMA_RESOURCE_RESUME,
-        DMA_RESOURCE_ADDED,
+        DMA_RESOURCE_AVAILABLE,
         DMA_RESOURCE_REMOVED,
 };
 
 /**
+ * enum dma_state_client - state of the channel in the client
+ * @DMA_ACK: client would like to use, or was using this channel
+ * @DMA_DUP: client has already seen this channel, or is not using this channel
+ * @DMA_NAK: client does not want to see any more channels
+ */
+enum dma_state_client {
+        DMA_ACK,
+        DMA_DUP,
+        DMA_NAK,
+};
+
+/**
  * typedef dma_cookie_t - an opaque DMA cookie
  *
  * if dma_cookie_t is >0 it's a DMA request cookie, <0 it's an error code
@@ -65,6 +76,31 @@ enum dma_status {
 };
 
 /**
+ * enum dma_transaction_type - DMA transaction types/indexes
+ */
+enum dma_transaction_type {
+        DMA_MEMCPY,
+        DMA_XOR,
+        DMA_PQ_XOR,
+        DMA_DUAL_XOR,
+        DMA_PQ_UPDATE,
+        DMA_ZERO_SUM,
+        DMA_PQ_ZERO_SUM,
+        DMA_MEMSET,
+        DMA_MEMCPY_CRC32C,
+        DMA_INTERRUPT,
+};
+
+/* last transaction type for creation of the capabilities mask */
+#define DMA_TX_TYPE_END (DMA_INTERRUPT + 1)
+
+/**
+ * dma_cap_mask_t - capabilities bitmap modeled after cpumask_t.
+ * See linux/cpumask.h
+ */
+typedef struct { DECLARE_BITMAP(bits, DMA_TX_TYPE_END); } dma_cap_mask_t;
+
+/**
  * struct dma_chan_percpu - the per-CPU part of struct dma_chan
  * @refcount: local_t used for open-coded "bigref" counting
  * @memcpy_count: transaction counter
@@ -80,7 +116,6 @@ struct dma_chan_percpu {
 
 /**
  * struct dma_chan - devices supply DMA channels, clients use them
- * @client: ptr to the client user of this chan, will be %NULL when unused
  * @device: ptr to the dma device who supplies this channel, always !%NULL
  * @cookie: last cookie value returned to client
  * @chan_id: channel ID for sysfs
@@ -88,12 +123,10 @@ struct dma_chan_percpu {
  * @refcount: kref, used in "bigref" slow-mode
  * @slow_ref: indicates that the DMA channel is free
  * @rcu: the DMA channel's RCU head
- * @client_node: used to add this to the client chan list
  * @device_node: used to add this to the device chan list
  * @local: per-cpu pointer to a struct dma_chan_percpu
  */
 struct dma_chan {
-        struct dma_client *client;
         struct dma_device *device;
         dma_cookie_t cookie;
 
@@ -105,11 +138,11 @@ struct dma_chan {
         int slow_ref;
         struct rcu_head rcu;
 
-        struct list_head client_node;
         struct list_head device_node;
         struct dma_chan_percpu *local;
 };
 
+
 void dma_chan_cleanup(struct kref *kref);
 
 static inline void dma_chan_get(struct dma_chan *chan)
@@ -134,169 +167,206 @@ static inline void dma_chan_put(struct dma_chan *chan)
 
 /*
  * typedef dma_event_callback - function pointer to a DMA event callback
+ * For each channel added to the system this routine is called for each client.
+ * If the client would like to use the channel it returns '1' to signal (ack)
+ * the dmaengine core to take out a reference on the channel and its
+ * corresponding device.  A client must not 'ack' an available channel more
+ * than once.  When a channel is removed all clients are notified.  If a client
+ * is using the channel it must 'ack' the removal.  A client must not 'ack' a
+ * removed channel more than once.
+ * @client - 'this' pointer for the client context
+ * @chan - channel to be acted upon
+ * @state - available or removed
  */
-typedef void (*dma_event_callback) (struct dma_client *client,
-                struct dma_chan *chan, enum dma_event event);
+struct dma_client;
+typedef enum dma_state_client (*dma_event_callback) (struct dma_client *client,
+                struct dma_chan *chan, enum dma_state state);
 
 /**
  * struct dma_client - info on the entity making use of DMA services
  * @event_callback: func ptr to call when something happens
- * @chan_count: number of chans allocated
- * @chans_desired: number of chans requested. Can be +/- chan_count
- * @lock: protects access to the channels list
- * @channels: the list of DMA channels allocated
+ * @cap_mask: only return channels that satisfy the requested capabilities
+ *  a value of zero corresponds to any capability
  * @global_node: list_head for global dma_client_list
  */
 struct dma_client {
         dma_event_callback      event_callback;
-        unsigned int            chan_count;
-        unsigned int            chans_desired;
-
-        spinlock_t              lock;
-        struct list_head        channels;
+        dma_cap_mask_t          cap_mask;
         struct list_head        global_node;
 };
 
+typedef void (*dma_async_tx_callback)(void *dma_async_param);
+/**
+ * struct dma_async_tx_descriptor - async transaction descriptor
+ * ---dma generic offload fields---
+ * @cookie: tracking cookie for this transaction, set to -EBUSY if
+ *      this tx is sitting on a dependency list
+ * @ack: the descriptor can not be reused until the client acknowledges
+ *      receipt, i.e. has has a chance to establish any dependency chains
+ * @phys: physical address of the descriptor
+ * @tx_list: driver common field for operations that require multiple
+ *      descriptors
+ * @chan: target channel for this operation
+ * @tx_submit: set the prepared descriptor(s) to be executed by the engine
+ * @tx_set_dest: set a destination address in a hardware descriptor
+ * @tx_set_src: set a source address in a hardware descriptor
+ * @callback: routine to call after this operation is complete
+ * @callback_param: general parameter to pass to the callback routine
+ * ---async_tx api specific fields---
+ * @depend_list: at completion this list of transactions are submitted
+ * @depend_node: allow this transaction to be executed after another
+ *      transaction has completed, possibly on another channel
+ * @parent: pointer to the next level up in the dependency chain
+ * @lock: protect the dependency list
+ */
+struct dma_async_tx_descriptor {
+        dma_cookie_t cookie;
+        int ack;
+        dma_addr_t phys;
+        struct list_head tx_list;
+        struct dma_chan *chan;
+        dma_cookie_t (*tx_submit)(struct dma_async_tx_descriptor *tx);
+        void (*tx_set_dest)(dma_addr_t addr,
+                struct dma_async_tx_descriptor *tx, int index);
+        void (*tx_set_src)(dma_addr_t addr,
+                struct dma_async_tx_descriptor *tx, int index);
+        dma_async_tx_callback callback;
+        void *callback_param;
+        struct list_head depend_list;
+        struct list_head depend_node;
+        struct dma_async_tx_descriptor *parent;
+        spinlock_t lock;
+};
+
 /**
  * struct dma_device - info on the entity supplying DMA services
  * @chancnt: how many DMA channels are supported
  * @channels: the list of struct dma_chan
  * @global_node: list_head for global dma_device_list
+ * @cap_mask: one or more dma_capability flags
+ * @max_xor: maximum number of xor sources, 0 if no capability
  * @refcount: reference count
  * @done: IO completion struct
  * @dev_id: unique device ID
+ * @dev: struct device reference for dma mapping api
  * @device_alloc_chan_resources: allocate resources and return the
  *      number of allocated descriptors
  * @device_free_chan_resources: release DMA channel's resources
- * @device_memcpy_buf_to_buf: memcpy buf pointer to buf pointer
- * @device_memcpy_buf_to_pg: memcpy buf pointer to struct page
- * @device_memcpy_pg_to_pg: memcpy struct page/offset to struct page/offset
- * @device_memcpy_complete: poll the status of an IOAT DMA transaction
- * @device_memcpy_issue_pending: push appended descriptors to hardware
+ * @device_prep_dma_memcpy: prepares a memcpy operation
+ * @device_prep_dma_xor: prepares a xor operation
+ * @device_prep_dma_zero_sum: prepares a zero_sum operation
+ * @device_prep_dma_memset: prepares a memset operation
+ * @device_prep_dma_interrupt: prepares an end of chain interrupt operation
+ * @device_dependency_added: async_tx notifies the channel about new deps
+ * @device_issue_pending: push pending transactions to hardware
  */
 struct dma_device {
 
         unsigned int chancnt;
         struct list_head channels;
         struct list_head global_node;
+        dma_cap_mask_t  cap_mask;
+        int max_xor;
 
         struct kref refcount;
         struct completion done;
 
         int dev_id;
+        struct device *dev;
 
         int (*device_alloc_chan_resources)(struct dma_chan *chan);
         void (*device_free_chan_resources)(struct dma_chan *chan);
-        dma_cookie_t (*device_memcpy_buf_to_buf)(struct dma_chan *chan,
-                        void *dest, void *src, size_t len);
-        dma_cookie_t (*device_memcpy_buf_to_pg)(struct dma_chan *chan,
-                        struct page *page, unsigned int offset, void *kdata,
-                        size_t len);
-        dma_cookie_t (*device_memcpy_pg_to_pg)(struct dma_chan *chan,
-                        struct page *dest_pg, unsigned int dest_off,
-                        struct page *src_pg, unsigned int src_off, size_t len);
-        enum dma_status (*device_memcpy_complete)(struct dma_chan *chan,
+
+        struct dma_async_tx_descriptor *(*device_prep_dma_memcpy)(
+                struct dma_chan *chan, size_t len, int int_en);
+        struct dma_async_tx_descriptor *(*device_prep_dma_xor)(
+                struct dma_chan *chan, unsigned int src_cnt, size_t len,
+                int int_en);
+        struct dma_async_tx_descriptor *(*device_prep_dma_zero_sum)(
+                struct dma_chan *chan, unsigned int src_cnt, size_t len,
+                u32 *result, int int_en);
+        struct dma_async_tx_descriptor *(*device_prep_dma_memset)(
+                struct dma_chan *chan, int value, size_t len, int int_en);
+        struct dma_async_tx_descriptor *(*device_prep_dma_interrupt)(
+                struct dma_chan *chan);
+
+        void (*device_dependency_added)(struct dma_chan *chan);
+        enum dma_status (*device_is_tx_complete)(struct dma_chan *chan,
                         dma_cookie_t cookie, dma_cookie_t *last,
                         dma_cookie_t *used);
-        void (*device_memcpy_issue_pending)(struct dma_chan *chan);
+        void (*device_issue_pending)(struct dma_chan *chan);
 };
 
 /* --- public DMA engine API --- */
 
-struct dma_client *dma_async_client_register(dma_event_callback event_callback);
+void dma_async_client_register(struct dma_client *client);
 void dma_async_client_unregister(struct dma_client *client);
-void dma_async_client_chan_request(struct dma_client *client,
-                unsigned int number);
+void dma_async_client_chan_request(struct dma_client *client);
+dma_cookie_t dma_async_memcpy_buf_to_buf(struct dma_chan *chan,
+        void *dest, void *src, size_t len);
+dma_cookie_t dma_async_memcpy_buf_to_pg(struct dma_chan *chan,
+        struct page *page, unsigned int offset, void *kdata, size_t len);
+dma_cookie_t dma_async_memcpy_pg_to_pg(struct dma_chan *chan,
+        struct page *dest_pg, unsigned int dest_off, struct page *src_pg,
+        unsigned int src_off, size_t len);
+void dma_async_tx_descriptor_init(struct dma_async_tx_descriptor *tx,
+        struct dma_chan *chan);
 
-/**
- * dma_async_memcpy_buf_to_buf - offloaded copy between virtual addresses
- * @chan: DMA channel to offload copy to
- * @dest: destination address (virtual)
- * @src: source address (virtual)
- * @len: length
- *
- * Both @dest and @src must be mappable to a bus address according to the
- * DMA mapping API rules for streaming mappings.
- * Both @dest and @src must stay memory resident (kernel memory or locked
- * user space pages).
- */
-static inline dma_cookie_t dma_async_memcpy_buf_to_buf(struct dma_chan *chan,
-        void *dest, void *src, size_t len)
+static inline void
+async_tx_ack(struct dma_async_tx_descriptor *tx)
 {
-        int cpu = get_cpu();
-        per_cpu_ptr(chan->local, cpu)->bytes_transferred += len;
-        per_cpu_ptr(chan->local, cpu)->memcpy_count++;
-        put_cpu();
-
-        return chan->device->device_memcpy_buf_to_buf(chan, dest, src, len);
+        tx->ack = 1;
 }
 
-/**
- * dma_async_memcpy_buf_to_pg - offloaded copy from address to page
- * @chan: DMA channel to offload copy to
- * @page: destination page
- * @offset: offset in page to copy to
- * @kdata: source address (virtual)
- * @len: length
- *
- * Both @page/@offset and @kdata must be mappable to a bus address according
- * to the DMA mapping API rules for streaming mappings.
- * Both @page/@offset and @kdata must stay memory resident (kernel memory or
- * locked user space pages)
- */
-static inline dma_cookie_t dma_async_memcpy_buf_to_pg(struct dma_chan *chan,
-        struct page *page, unsigned int offset, void *kdata, size_t len)
+#define first_dma_cap(mask) __first_dma_cap(&(mask))
+static inline int __first_dma_cap(const dma_cap_mask_t *srcp)
 {
-        int cpu = get_cpu();
-        per_cpu_ptr(chan->local, cpu)->bytes_transferred += len;
-        per_cpu_ptr(chan->local, cpu)->memcpy_count++;
-        put_cpu();
+        return min_t(int, DMA_TX_TYPE_END,
+                find_first_bit(srcp->bits, DMA_TX_TYPE_END));
+}
 
-        return chan->device->device_memcpy_buf_to_pg(chan, page, offset,
-                                                     kdata, len);
+#define next_dma_cap(n, mask) __next_dma_cap((n), &(mask))
+static inline int __next_dma_cap(int n, const dma_cap_mask_t *srcp)
+{
+        return min_t(int, DMA_TX_TYPE_END,
+                find_next_bit(srcp->bits, DMA_TX_TYPE_END, n+1));
 }
 
-/**
- * dma_async_memcpy_pg_to_pg - offloaded copy from page to page
- * @chan: DMA channel to offload copy to
- * @dest_pg: destination page
- * @dest_off: offset in page to copy to
- * @src_pg: source page
- * @src_off: offset in page to copy from
- * @len: length
- *
- * Both @dest_page/@dest_off and @src_page/@src_off must be mappable to a bus
- * address according to the DMA mapping API rules for streaming mappings.
- * Both @dest_page/@dest_off and @src_page/@src_off must stay memory resident
- * (kernel memory or locked user space pages).
- */
-static inline dma_cookie_t dma_async_memcpy_pg_to_pg(struct dma_chan *chan,
-        struct page *dest_pg, unsigned int dest_off, struct page *src_pg,
-        unsigned int src_off, size_t len)
+#define dma_cap_set(tx, mask) __dma_cap_set((tx), &(mask))
+static inline void
+__dma_cap_set(enum dma_transaction_type tx_type, dma_cap_mask_t *dstp)
 {
-        int cpu = get_cpu();
-        per_cpu_ptr(chan->local, cpu)->bytes_transferred += len;
-        per_cpu_ptr(chan->local, cpu)->memcpy_count++;
-        put_cpu();
+        set_bit(tx_type, dstp->bits);
+}
 
-        return chan->device->device_memcpy_pg_to_pg(chan, dest_pg, dest_off,
-                                                    src_pg, src_off, len);
+#define dma_has_cap(tx, mask) __dma_has_cap((tx), &(mask))
+static inline int
+__dma_has_cap(enum dma_transaction_type tx_type, dma_cap_mask_t *srcp)
+{
+        return test_bit(tx_type, srcp->bits);
 }
 
+#define for_each_dma_cap_mask(cap, mask) \
+        for ((cap) = first_dma_cap(mask);       \
+                (cap) < DMA_TX_TYPE_END;        \
+                (cap) = next_dma_cap((cap), (mask)))
+
 /**
- * dma_async_memcpy_issue_pending - flush pending copies to HW
+ * dma_async_issue_pending - flush pending transactions to HW
  * @chan: target DMA channel
  *
  * This allows drivers to push copies to HW in batches,
  * reducing MMIO writes where possible.
  */
-static inline void dma_async_memcpy_issue_pending(struct dma_chan *chan)
+static inline void dma_async_issue_pending(struct dma_chan *chan)
 {
-        return chan->device->device_memcpy_issue_pending(chan);
+        return chan->device->device_issue_pending(chan);
 }
 
+#define dma_async_memcpy_issue_pending(chan) dma_async_issue_pending(chan)
+
 /**
- * dma_async_memcpy_complete - poll for transaction completion
+ * dma_async_is_tx_complete - poll for transaction completion
  * @chan: DMA channel
  * @cookie: transaction identifier to check status of
  * @last: returns last completed cookie, can be NULL
@@ -306,12 +376,15 @@ static inline void dma_async_memcpy_issue_pending(struct dma_chan *chan)
  * internal state and can be used with dma_async_is_complete() to check
  * the status of multiple cookies without re-checking hardware state.
  */
-static inline enum dma_status dma_async_memcpy_complete(struct dma_chan *chan,
+static inline enum dma_status dma_async_is_tx_complete(struct dma_chan *chan,
         dma_cookie_t cookie, dma_cookie_t *last, dma_cookie_t *used)
 {
-        return chan->device->device_memcpy_complete(chan, cookie, last, used);
+        return chan->device->device_is_tx_complete(chan, cookie, last, used);
 }
 
+#define dma_async_memcpy_complete(chan, cookie, last, used)\
+        dma_async_is_tx_complete(chan, cookie, last, used)
+
 /**
  * dma_async_is_complete - test a cookie against chan state
  * @cookie: transaction identifier to test status of
@@ -334,6 +407,7 @@ static inline enum dma_status dma_async_is_complete(dma_cookie_t cookie,
         return DMA_IN_PROGRESS;
 }
 
+enum dma_status dma_sync_wait(struct dma_chan *chan, dma_cookie_t cookie);
 
 /* --- DMA device --- */
 
@@ -362,5 +436,4 @@ dma_cookie_t dma_memcpy_pg_to_iovec(struct dma_chan *chan, struct iovec *iov,
         struct dma_pinned_list *pinned_list, struct page *page,
         unsigned int offset, size_t len);
 
-#endif /* CONFIG_DMA_ENGINE */
 #endif /* DMAENGINE_H */
diff --git a/include/linux/dmi.h b/include/linux/dmi.h
index 904bf3d2d90b..b8ac7b01c45e 100644
--- a/include/linux/dmi.h
+++ b/include/linux/dmi.h
@@ -12,9 +12,17 @@ enum dmi_field {
         DMI_PRODUCT_NAME,
         DMI_PRODUCT_VERSION,
         DMI_PRODUCT_SERIAL,
+        DMI_PRODUCT_UUID,
         DMI_BOARD_VENDOR,
         DMI_BOARD_NAME,
         DMI_BOARD_VERSION,
+        DMI_BOARD_SERIAL,
+        DMI_BOARD_ASSET_TAG,
+        DMI_CHASSIS_VENDOR,
+        DMI_CHASSIS_TYPE,
+        DMI_CHASSIS_VERSION,
+        DMI_CHASSIS_SERIAL,
+        DMI_CHASSIS_ASSET_TAG,
         DMI_STRING_MAX,
 };
 
diff --git a/include/linux/ds17287rtc.h b/include/linux/ds17287rtc.h
index c281ba42e28f..d85d3f497b96 100644
--- a/include/linux/ds17287rtc.h
+++ b/include/linux/ds17287rtc.h
@@ -11,7 +11,6 @@
 #define __LINUX_DS17287RTC_H
 
 #include <linux/rtc.h>                  /* get the user-level API */
-#include <linux/spinlock.h>             /* spinlock_t */
 #include <linux/mc146818rtc.h>
 
 /* Register A */
diff --git a/include/linux/edac.h b/include/linux/edac.h
new file mode 100644
index 000000000000..eab451e69a91
--- /dev/null
+++ b/include/linux/edac.h
@@ -0,0 +1,29 @@
+/*
+ * Generic EDAC defs
+ *
+ * Author: Dave Jiang <djiang@mvista.com>
+ *
+ * 2006-2007 (c) MontaVista Software, Inc. This file is licensed under
+ * the terms of the GNU General Public License version 2. This program
+ * is licensed "as is" without any warranty of any kind, whether express
+ * or implied.
+ *
+ */
+#ifndef _LINUX_EDAC_H_
+#define _LINUX_EDAC_H_
+
+#include <asm/atomic.h>
+
+#define EDAC_OPSTATE_INVAL      -1
+#define EDAC_OPSTATE_POLL       0
+#define EDAC_OPSTATE_NMI        1
+#define EDAC_OPSTATE_INT        2
+
+extern int edac_op_state;
+extern int edac_err_assert;
+extern atomic_t edac_handlers;
+
+extern int edac_handler_set(void);
+extern void edac_atomic_assert_error(void);
+
+#endif
diff --git a/include/linux/edd.h b/include/linux/edd.h
index b2b3e68aa512..7b647822d6dc 100644
--- a/include/linux/edd.h
+++ b/include/linux/edd.h
@@ -49,10 +49,6 @@
 #define EDD_MBR_SIG_MAX 16        /* max number of signatures to store */
 #define EDD_MBR_SIG_NR_BUF 0x1ea  /* addr of number of MBR signtaures at EDD_MBR_SIG_BUF
                                      in boot_params - treat this as 1 byte  */
-#define EDD_CL_EQUALS   0x3d646465     /* "edd=" */
-#define EDD_CL_OFF      0x666f         /* "of" for off  */
-#define EDD_CL_SKIP     0x6b73         /* "sk" for skipmbr */
-#define EDD_CL_ON       0x6e6f         /* "on" for on */
 
 #ifndef __ASSEMBLY__
 
diff --git a/include/linux/efs_fs.h b/include/linux/efs_fs.h
index dfed8009ebff..16cb25cbf7c5 100644
--- a/include/linux/efs_fs.h
+++ b/include/linux/efs_fs.h
@@ -45,6 +45,7 @@ extern efs_block_t efs_map_block(struct inode *, efs_block_t);
 extern int efs_get_block(struct inode *, sector_t, struct buffer_head *, int);
 
 extern struct dentry *efs_lookup(struct inode *, struct dentry *, struct nameidata *);
+extern struct dentry *efs_get_dentry(struct super_block *sb, void *vobjp);
 extern struct dentry *efs_get_parent(struct dentry *);
 extern int efs_bmap(struct inode *, int);
 
diff --git a/include/linux/elf-em.h b/include/linux/elf-em.h
index 0311bad838b1..5834e843a946 100644
--- a/include/linux/elf-em.h
+++ b/include/linux/elf-em.h
@@ -20,7 +20,8 @@
 #define EM_PARISC       15      /* HPPA */
 #define EM_SPARC32PLUS  18      /* Sun's "v8plus" */
 #define EM_PPC          20      /* PowerPC */
-#define EM_PPC64        21       /* PowerPC64 */
+#define EM_PPC64        21       /* PowerPC64 */
+#define EM_SPU          23      /* Cell BE SPU */
 #define EM_SH           42      /* SuperH */
 #define EM_SPARCV9      43      /* SPARC v9 64-bit */
 #define EM_IA_64        50      /* HP/Intel IA-64 */
diff --git a/include/linux/elfnote.h b/include/linux/elfnote.h
index 9a1e0674e56c..e831759b2fb5 100644
--- a/include/linux/elfnote.h
+++ b/include/linux/elfnote.h
@@ -38,17 +38,25 @@
  * e.g. ELFNOTE(XYZCo, 42, .asciz, "forty-two")
  *      ELFNOTE(XYZCo, 12, .long, 0xdeadbeef)
  */
-#define ELFNOTE(name, type, desctype, descdata) \
-.pushsection .note.name, "",@note       ;       \
-  .align 4                              ;       \
+#define ELFNOTE_START(name, type, flags)        \
+.pushsection .note.name, flags,@note    ;       \
+  .balign 4                             ;       \
   .long 2f - 1f         /* namesz */    ;       \
-  .long 4f - 3f         /* descsz */    ;       \
+  .long 4484f - 3f      /* descsz */    ;       \
   .long type                            ;       \
 1:.asciz #name                          ;       \
-2:.align 4                              ;       \
-3:desctype descdata                     ;       \
-4:.align 4                              ;       \
+2:.balign 4                             ;       \
+3:
+
+#define ELFNOTE_END                             \
+4484:.balign 4                          ;       \
 .popsection                             ;
+
+#define ELFNOTE(name, type, desc)               \
+        ELFNOTE_START(name, type, "")           \
+                desc                    ;       \
+        ELFNOTE_END
+
 #else   /* !__ASSEMBLER__ */
 #include <linux/elf.h>
 /*
diff --git a/include/linux/etherdevice.h b/include/linux/etherdevice.h
index 071c67abed86..6cdb97365e47 100644
--- a/include/linux/etherdevice.h
+++ b/include/linux/etherdevice.h
@@ -39,13 +39,8 @@ extern void		eth_header_cache_update(struct hh_cache *hh, struct net_device *dev
 extern int              eth_header_cache(struct neighbour *neigh,
                                          struct hh_cache *hh);
 
-extern struct net_device *alloc_etherdev(int sizeof_priv);
-static inline void eth_copy_and_sum (struct sk_buff *dest, 
-                                     const unsigned char *src, 
-                                     int len, int base)
-{
-        memcpy (dest->data, src, len);
-}
+extern struct net_device *alloc_etherdev_mq(int sizeof_priv, unsigned int queue_count);
+#define alloc_etherdev(sizeof_priv) alloc_etherdev_mq(sizeof_priv, 1)
 
 /**
  * is_zero_ether_addr - Determine if give Ethernet address is all zeros.
diff --git a/include/linux/ethtool.h b/include/linux/ethtool.h
index f2d248f8cc92..3a632244f31b 100644
--- a/include/linux/ethtool.h
+++ b/include/linux/ethtool.h
@@ -265,6 +265,7 @@ u32 ethtool_op_get_link(struct net_device *dev);
 u32 ethtool_op_get_tx_csum(struct net_device *dev);
 int ethtool_op_set_tx_csum(struct net_device *dev, u32 data);
 int ethtool_op_set_tx_hw_csum(struct net_device *dev, u32 data);
+int ethtool_op_set_tx_ipv6_csum(struct net_device *dev, u32 data);
 u32 ethtool_op_get_sg(struct net_device *dev);
 int ethtool_op_set_sg(struct net_device *dev, u32 data);
 u32 ethtool_op_get_tso(struct net_device *dev);
diff --git a/include/linux/exportfs.h b/include/linux/exportfs.h
new file mode 100644
index 000000000000..8872fe8392d6
--- /dev/null
+++ b/include/linux/exportfs.h
@@ -0,0 +1,126 @@
+#ifndef LINUX_EXPORTFS_H
+#define LINUX_EXPORTFS_H 1
+
+#include <linux/types.h>
+
+struct dentry;
+struct super_block;
+struct vfsmount;
+
+
+/**
+ * struct export_operations - for nfsd to communicate with file systems
+ * @decode_fh:      decode a file handle fragment and return a &struct dentry
+ * @encode_fh:      encode a file handle fragment from a dentry
+ * @get_name:       find the name for a given inode in a given directory
+ * @get_parent:     find the parent of a given directory
+ * @get_dentry:     find a dentry for the inode given a file handle sub-fragment
+ * @find_exported_dentry:
+ *      set by the exporting module to a standard helper function.
+ *
+ * Description:
+ *    The export_operations structure provides a means for nfsd to communicate
+ *    with a particular exported file system  - particularly enabling nfsd and
+ *    the filesystem to co-operate when dealing with file handles.
+ *
+ *    export_operations contains two basic operation for dealing with file
+ *    handles, decode_fh() and encode_fh(), and allows for some other
+ *    operations to be defined which standard helper routines use to get
+ *    specific information from the filesystem.
+ *
+ *    nfsd encodes information use to determine which filesystem a filehandle
+ *    applies to in the initial part of the file handle.  The remainder, termed
+ *    a file handle fragment, is controlled completely by the filesystem.  The
+ *    standard helper routines assume that this fragment will contain one or
+ *    two sub-fragments, one which identifies the file, and one which may be
+ *    used to identify the (a) directory containing the file.
+ *
+ *    In some situations, nfsd needs to get a dentry which is connected into a
+ *    specific part of the file tree.  To allow for this, it passes the
+ *    function acceptable() together with a @context which can be used to see
+ *    if the dentry is acceptable.  As there can be multiple dentrys for a
+ *    given file, the filesystem should check each one for acceptability before
+ *    looking for the next.  As soon as an acceptable one is found, it should
+ *    be returned.
+ *
+ * decode_fh:
+ *    @decode_fh is given a &struct super_block (@sb), a file handle fragment
+ *    (@fh, @fh_len) and an acceptability testing function (@acceptable,
+ *    @context).  It should return a &struct dentry which refers to the same
+ *    file that the file handle fragment refers to,  and which passes the
+ *    acceptability test.  If it cannot, it should return a %NULL pointer if
+ *    the file was found but no acceptable &dentries were available, or a
+ *    %ERR_PTR error code indicating why it couldn't be found (e.g. %ENOENT or
+ *    %ENOMEM).
+ *
+ * encode_fh:
+ *    @encode_fh should store in the file handle fragment @fh (using at most
+ *    @max_len bytes) information that can be used by @decode_fh to recover the
+ *    file refered to by the &struct dentry @de.  If the @connectable flag is
+ *    set, the encode_fh() should store sufficient information so that a good
+ *    attempt can be made to find not only the file but also it's place in the
+ *    filesystem.   This typically means storing a reference to de->d_parent in
+ *    the filehandle fragment.  encode_fh() should return the number of bytes
+ *    stored or a negative error code such as %-ENOSPC
+ *
+ * get_name:
+ *    @get_name should find a name for the given @child in the given @parent
+ *    directory.  The name should be stored in the @name (with the
+ *    understanding that it is already pointing to a a %NAME_MAX+1 sized
+ *    buffer.   get_name() should return %0 on success, a negative error code
+ *    or error.  @get_name will be called without @parent->i_mutex held.
+ *
+ * get_parent:
+ *    @get_parent should find the parent directory for the given @child which
+ *    is also a directory.  In the event that it cannot be found, or storage
+ *    space cannot be allocated, a %ERR_PTR should be returned.
+ *
+ * get_dentry:
+ *    Given a &super_block (@sb) and a pointer to a file-system specific inode
+ *    identifier, possibly an inode number, (@inump) get_dentry() should find
+ *    the identified inode and return a dentry for that inode.  Any suitable
+ *    dentry can be returned including, if necessary, a new dentry created with
+ *    d_alloc_root.  The caller can then find any other extant dentrys by
+ *    following the d_alias links.  If a new dentry was created using
+ *    d_alloc_root, DCACHE_NFSD_DISCONNECTED should be set, and the dentry
+ *    should be d_rehash()ed.
+ *
+ *    If the inode cannot be found, either a %NULL pointer or an %ERR_PTR code
+ *    can be returned.  The @inump will be whatever was passed to
+ *    nfsd_find_fh_dentry() in either the @obj or @parent parameters.
+ *
+ * Locking rules:
+ *    get_parent is called with child->d_inode->i_mutex down
+ *    get_name is not (which is possibly inconsistent)
+ */
+
+struct export_operations {
+        struct dentry *(*decode_fh)(struct super_block *sb, __u32 *fh,
+                        int fh_len, int fh_type,
+                        int (*acceptable)(void *context, struct dentry *de),
+                        void *context);
+        int (*encode_fh)(struct dentry *de, __u32 *fh, int *max_len,
+                        int connectable);
+        int (*get_name)(struct dentry *parent, char *name,
+                        struct dentry *child);
+        struct dentry * (*get_parent)(struct dentry *child);
+        struct dentry * (*get_dentry)(struct super_block *sb, void *inump);
+
+        /* This is set by the exporting module to a standard helper */
+        struct dentry * (*find_exported_dentry)(
+                        struct super_block *sb, void *obj, void *parent,
+                        int (*acceptable)(void *context, struct dentry *de),
+                        void *context);
+};
+
+extern struct dentry *find_exported_dentry(struct super_block *sb, void *obj,
+        void *parent, int (*acceptable)(void *context, struct dentry *de),
+        void *context);
+
+extern int exportfs_encode_fh(struct dentry *dentry, __u32 *fh, int *max_len,
+        int connectable);
+extern struct dentry *exportfs_decode_fh(struct vfsmount *mnt, __u32 *fh,
+        int fh_len, int fileid_type, int (*acceptable)(void *, struct dentry *),
+        void *context);
+
+#endif /* LINUX_EXPORTFS_H */
diff --git a/include/linux/ext2_fs_sb.h b/include/linux/ext2_fs_sb.h
index 4eda0ed76a48..d149f2959e67 100644
--- a/include/linux/ext2_fs_sb.h
+++ b/include/linux/ext2_fs_sb.h
@@ -33,6 +33,8 @@ struct ext2_sb_info {
         unsigned long s_gdb_count;      /* Number of group descriptor blocks */
         unsigned long s_desc_per_block; /* Number of group descriptors per block */
         unsigned long s_groups_count;   /* Number of groups in the fs */
+        unsigned long s_overhead_last;  /* Last calculated overhead */
+        unsigned long s_blocks_last;    /* Last seen block count */
         struct buffer_head * s_sbh;     /* Buffer containing the super block */
         struct ext2_super_block * s_es; /* Pointer to the super block in the buffer */
         struct buffer_head ** s_group_desc;
diff --git a/include/linux/ext3_fs_sb.h b/include/linux/ext3_fs_sb.h
index f61309c81cc4..d3c08353edf6 100644
--- a/include/linux/ext3_fs_sb.h
+++ b/include/linux/ext3_fs_sb.h
@@ -38,6 +38,8 @@ struct ext3_sb_info {
         unsigned long s_gdb_count;      /* Number of group descriptor blocks */
         unsigned long s_desc_per_block; /* Number of group descriptors per block */
         unsigned long s_groups_count;   /* Number of groups in the fs */
+        unsigned long s_overhead_last;  /* Last calculated overhead */
+        unsigned long s_blocks_last;    /* Last seen block count */
         struct buffer_head * s_sbh;     /* Buffer containing the super block */
         struct ext3_super_block * s_es; /* Pointer to the super block in the buffer */
         struct buffer_head ** s_group_desc;
diff --git a/include/linux/ext4_fs.h b/include/linux/ext4_fs.h
index de1f9f78625a..cdee7aaa57aa 100644
--- a/include/linux/ext4_fs.h
+++ b/include/linux/ext4_fs.h
@@ -71,7 +71,7 @@
 /*
  * Maximal count of links to a file
  */
-#define EXT4_LINK_MAX           32000
+#define EXT4_LINK_MAX           65000
 
 /*
  * Macro-instructions used to manage several block sizes
@@ -102,6 +102,7 @@
                                  EXT4_GOOD_OLD_FIRST_INO : \
                                  (s)->s_first_ino)
 #endif
+#define EXT4_BLOCK_ALIGN(size, blkbits)         ALIGN((size), (1 << (blkbits)))
 
 /*
  * Macro-instructions used to manage fragments
@@ -201,6 +202,7 @@ struct ext4_group_desc
 #define EXT4_STATE_JDATA                0x00000001 /* journaled data exists */
 #define EXT4_STATE_NEW                  0x00000002 /* inode is newly created */
 #define EXT4_STATE_XATTR                0x00000004 /* has in-inode xattrs */
+#define EXT4_STATE_NO_EXPAND            0x00000008 /* No space for expansion */
 
 /* Used to pass group descriptor data when online resize is done */
 struct ext4_new_group_input {
@@ -225,6 +227,11 @@ struct ext4_new_group_data {
         __u32 free_blocks_count;
 };
 
+/*
+ * Following is used by preallocation code to tell get_blocks() that we
+ * want uninitialzed extents.
+ */
+#define EXT4_CREATE_UNINITIALIZED_EXT           2
 
 /*
  * ioctl commands
@@ -237,7 +244,7 @@ struct ext4_new_group_data {
 #define EXT4_IOC_GROUP_ADD              _IOW('f', 8,struct ext4_new_group_input)
 #define EXT4_IOC_GETVERSION_OLD         FS_IOC_GETVERSION
 #define EXT4_IOC_SETVERSION_OLD         FS_IOC_SETVERSION
-#ifdef CONFIG_JBD_DEBUG
+#ifdef CONFIG_JBD2_DEBUG
 #define EXT4_IOC_WAIT_FOR_READONLY      _IOR('f', 99, long)
 #endif
 #define EXT4_IOC_GETRSVSZ               _IOR('f', 5, long)
@@ -253,7 +260,7 @@ struct ext4_new_group_data {
 #define EXT4_IOC32_GETRSVSZ             _IOR('f', 5, int)
 #define EXT4_IOC32_SETRSVSZ             _IOW('f', 6, int)
 #define EXT4_IOC32_GROUP_EXTEND         _IOW('f', 7, unsigned int)
-#ifdef CONFIG_JBD_DEBUG
+#ifdef CONFIG_JBD2_DEBUG
 #define EXT4_IOC32_WAIT_FOR_READONLY    _IOR('f', 99, int)
 #endif
 #define EXT4_IOC32_GETVERSION_OLD       FS_IOC32_GETVERSION
@@ -282,7 +289,7 @@ struct ext4_inode {
         __le16  i_uid;          /* Low 16 bits of Owner Uid */
         __le32  i_size;         /* Size in bytes */
         __le32  i_atime;        /* Access time */
-        __le32  i_ctime;        /* Creation time */
+        __le32  i_ctime;        /* Inode Change time */
         __le32  i_mtime;        /* Modification time */
         __le32  i_dtime;        /* Deletion Time */
         __le16  i_gid;          /* Low 16 bits of Group Id */
@@ -331,10 +338,85 @@ struct ext4_inode {
         } osd2;                         /* OS dependent 2 */
         __le16  i_extra_isize;
         __le16  i_pad1;
+        __le32  i_ctime_extra;  /* extra Change time      (nsec << 2 | epoch) */
+        __le32  i_mtime_extra;  /* extra Modification time(nsec << 2 | epoch) */
+        __le32  i_atime_extra;  /* extra Access time      (nsec << 2 | epoch) */
+        __le32  i_crtime;       /* File Creation time */
+        __le32  i_crtime_extra; /* extra FileCreationtime (nsec << 2 | epoch) */
 };
 
 #define i_size_high     i_dir_acl
 
+#define EXT4_EPOCH_BITS 2
+#define EXT4_EPOCH_MASK ((1 << EXT4_EPOCH_BITS) - 1)
+#define EXT4_NSEC_MASK  (~0UL << EXT4_EPOCH_BITS)
+
+/*
+ * Extended fields will fit into an inode if the filesystem was formatted
+ * with large inodes (-I 256 or larger) and there are not currently any EAs
+ * consuming all of the available space. For new inodes we always reserve
+ * enough space for the kernel's known extended fields, but for inodes
+ * created with an old kernel this might not have been the case. None of
+ * the extended inode fields is critical for correct filesystem operation.
+ * This macro checks if a certain field fits in the inode. Note that
+ * inode-size = GOOD_OLD_INODE_SIZE + i_extra_isize
+ */
+#define EXT4_FITS_IN_INODE(ext4_inode, einode, field)   \
+        ((offsetof(typeof(*ext4_inode), field) +        \
+          sizeof((ext4_inode)->field))                  \
+        <= (EXT4_GOOD_OLD_INODE_SIZE +                  \
+            (einode)->i_extra_isize))                   \
+
+static inline __le32 ext4_encode_extra_time(struct timespec *time)
+{
+       return cpu_to_le32((sizeof(time->tv_sec) > 4 ?
+                           time->tv_sec >> 32 : 0) |
+                           ((time->tv_nsec << 2) & EXT4_NSEC_MASK));
+}
+
+static inline void ext4_decode_extra_time(struct timespec *time, __le32 extra)
+{
+       if (sizeof(time->tv_sec) > 4)
+               time->tv_sec |= (__u64)(le32_to_cpu(extra) & EXT4_EPOCH_MASK)
+                               << 32;
+       time->tv_nsec = (le32_to_cpu(extra) & EXT4_NSEC_MASK) >> 2;
+}
+
+#define EXT4_INODE_SET_XTIME(xtime, inode, raw_inode)                          \
+do {                                                                           \
+        (raw_inode)->xtime = cpu_to_le32((inode)->xtime.tv_sec);               \
+        if (EXT4_FITS_IN_INODE(raw_inode, EXT4_I(inode), xtime ## _extra))     \
+                (raw_inode)->xtime ## _extra =                                 \
+                                ext4_encode_extra_time(&(inode)->xtime);       \
+} while (0)
+
+#define EXT4_EINODE_SET_XTIME(xtime, einode, raw_inode)                        \
+do {                                                                           \
+        if (EXT4_FITS_IN_INODE(raw_inode, einode, xtime))                      \
+                (raw_inode)->xtime = cpu_to_le32((einode)->xtime.tv_sec);      \
+        if (EXT4_FITS_IN_INODE(raw_inode, einode, xtime ## _extra))            \
+                (raw_inode)->xtime ## _extra =                                 \
+                                ext4_encode_extra_time(&(einode)->xtime);      \
+} while (0)
+
+#define EXT4_INODE_GET_XTIME(xtime, inode, raw_inode)                          \
+do {                                                                           \
+        (inode)->xtime.tv_sec = (signed)le32_to_cpu((raw_inode)->xtime);       \
+        if (EXT4_FITS_IN_INODE(raw_inode, EXT4_I(inode), xtime ## _extra))     \
+                ext4_decode_extra_time(&(inode)->xtime,                        \
+                                       raw_inode->xtime ## _extra);            \
+} while (0)
+
+#define EXT4_EINODE_GET_XTIME(xtime, einode, raw_inode)                        \
+do {                                                                           \
+        if (EXT4_FITS_IN_INODE(raw_inode, einode, xtime))                      \
+                (einode)->xtime.tv_sec =                                       \
+                        (signed)le32_to_cpu((raw_inode)->xtime);               \
+        if (EXT4_FITS_IN_INODE(raw_inode, einode, xtime ## _extra))            \
+                ext4_decode_extra_time(&(einode)->xtime,                       \
+                                       raw_inode->xtime ## _extra);            \
+} while (0)
+
 #if defined(__KERNEL__) || defined(__linux__)
 #define i_reserved1     osd1.linux1.l_i_reserved1
 #define i_frag          osd2.linux2.l_i_frag
@@ -533,6 +615,13 @@ static inline struct ext4_inode_info *EXT4_I(struct inode *inode)
         return container_of(inode, struct ext4_inode_info, vfs_inode);
 }
 
+static inline struct timespec ext4_current_time(struct inode *inode)
+{
+        return (inode->i_sb->s_time_gran < NSEC_PER_SEC) ?
+                current_fs_time(inode->i_sb) : CURRENT_TIME_SEC;
+}
+
+
 static inline int ext4_valid_inum(struct super_block *sb, unsigned long ino)
 {
         return ino == EXT4_ROOT_INO ||
@@ -603,6 +692,8 @@ static inline int ext4_valid_inum(struct super_block *sb, unsigned long ino)
 #define EXT4_FEATURE_RO_COMPAT_SPARSE_SUPER     0x0001
 #define EXT4_FEATURE_RO_COMPAT_LARGE_FILE       0x0002
 #define EXT4_FEATURE_RO_COMPAT_BTREE_DIR        0x0004
+#define EXT4_FEATURE_RO_COMPAT_DIR_NLINK        0x0020
+#define EXT4_FEATURE_RO_COMPAT_EXTRA_ISIZE      0x0040
 
 #define EXT4_FEATURE_INCOMPAT_COMPRESSION       0x0001
 #define EXT4_FEATURE_INCOMPAT_FILETYPE          0x0002
@@ -620,6 +711,8 @@ static inline int ext4_valid_inum(struct super_block *sb, unsigned long ino)
                                          EXT4_FEATURE_INCOMPAT_64BIT)
 #define EXT4_FEATURE_RO_COMPAT_SUPP     (EXT4_FEATURE_RO_COMPAT_SPARSE_SUPER| \
                                          EXT4_FEATURE_RO_COMPAT_LARGE_FILE| \
+                                         EXT4_FEATURE_RO_COMPAT_DIR_NLINK | \
+                                         EXT4_FEATURE_RO_COMPAT_EXTRA_ISIZE | \
                                          EXT4_FEATURE_RO_COMPAT_BTREE_DIR)
 
 /*
@@ -862,6 +955,7 @@ extern int ext4_change_inode_journal_flag(struct inode *, int);
 extern int ext4_get_inode_loc(struct inode *, struct ext4_iloc *);
 extern void ext4_truncate (struct inode *);
 extern void ext4_set_inode_flags(struct inode *);
+extern void ext4_get_inode_flags(struct ext4_inode_info *);
 extern void ext4_set_aops(struct inode *inode);
 extern int ext4_writepage_trans_blocks(struct inode *);
 extern int ext4_block_truncate_page(handle_t *handle, struct page *page,
@@ -983,6 +1077,8 @@ extern int ext4_ext_get_blocks(handle_t *handle, struct inode *inode,
 extern void ext4_ext_truncate(struct inode *, struct page *);
 extern void ext4_ext_init(struct super_block *);
 extern void ext4_ext_release(struct super_block *);
+extern long ext4_fallocate(struct inode *inode, int mode, loff_t offset,
+                          loff_t len);
 static inline int
 ext4_get_blocks_wrap(handle_t *handle, struct inode *inode, sector_t block,
                         unsigned long max_blocks, struct buffer_head *bh,
diff --git a/include/linux/ext4_fs_extents.h b/include/linux/ext4_fs_extents.h
index acfe59740b03..81406f3655d4 100644
--- a/include/linux/ext4_fs_extents.h
+++ b/include/linux/ext4_fs_extents.h
@@ -141,7 +141,25 @@ typedef int (*ext_prepare_callback)(struct inode *, struct ext4_ext_path *,
 
 #define EXT_MAX_BLOCK   0xffffffff
 
-#define EXT_MAX_LEN     ((1UL << 15) - 1)
+/*
+ * EXT_INIT_MAX_LEN is the maximum number of blocks we can have in an
+ * initialized extent. This is 2^15 and not (2^16 - 1), since we use the
+ * MSB of ee_len field in the extent datastructure to signify if this
+ * particular extent is an initialized extent or an uninitialized (i.e.
+ * preallocated).
+ * EXT_UNINIT_MAX_LEN is the maximum number of blocks we can have in an
+ * uninitialized extent.
+ * If ee_len is <= 0x8000, it is an initialized extent. Otherwise, it is an
+ * uninitialized one. In other words, if MSB of ee_len is set, it is an
+ * uninitialized extent with only one special scenario when ee_len = 0x8000.
+ * In this case we can not have an uninitialized extent of zero length and
+ * thus we make it as a special case of initialized extent with 0x8000 length.
+ * This way we get better extent-to-group alignment for initialized extents.
+ * Hence, the maximum number of blocks we can have in an *initialized*
+ * extent is 2^15 (32768) and in an *uninitialized* extent is 2^15-1 (32767).
+ */
+#define EXT_INIT_MAX_LEN        (1UL << 15)
+#define EXT_UNINIT_MAX_LEN      (EXT_INIT_MAX_LEN - 1)
 
 
 #define EXT_FIRST_EXTENT(__hdr__) \
@@ -188,8 +206,31 @@ ext4_ext_invalidate_cache(struct inode *inode)
         EXT4_I(inode)->i_cached_extent.ec_type = EXT4_EXT_CACHE_NO;
 }
 
+static inline void ext4_ext_mark_uninitialized(struct ext4_extent *ext)
+{
+        /* We can not have an uninitialized extent of zero length! */
+        BUG_ON((le16_to_cpu(ext->ee_len) & ~EXT_INIT_MAX_LEN) == 0);
+        ext->ee_len |= cpu_to_le16(EXT_INIT_MAX_LEN);
+}
+
+static inline int ext4_ext_is_uninitialized(struct ext4_extent *ext)
+{
+        /* Extent with ee_len of 0x8000 is treated as an initialized extent */
+        return (le16_to_cpu(ext->ee_len) > EXT_INIT_MAX_LEN);
+}
+
+static inline int ext4_ext_get_actual_len(struct ext4_extent *ext)
+{
+        return (le16_to_cpu(ext->ee_len) <= EXT_INIT_MAX_LEN ?
+                le16_to_cpu(ext->ee_len) :
+                (le16_to_cpu(ext->ee_len) - EXT_INIT_MAX_LEN));
+}
+
 extern int ext4_extent_tree_init(handle_t *, struct inode *);
 extern int ext4_ext_calc_credits_for_insert(struct inode *, struct ext4_ext_path *);
+extern int ext4_ext_try_to_merge(struct inode *inode,
+                                 struct ext4_ext_path *path,
+                                 struct ext4_extent *);
 extern unsigned int ext4_ext_check_overlap(struct inode *, struct ext4_extent *, struct ext4_ext_path *);
 extern int ext4_ext_insert_extent(handle_t *, struct inode *, struct ext4_ext_path *, struct ext4_extent *);
 extern int ext4_ext_walk_space(struct inode *, unsigned long, unsigned long, ext_prepare_callback, void *);
diff --git a/include/linux/ext4_fs_i.h b/include/linux/ext4_fs_i.h
index 9de494406995..1a511e9905aa 100644
--- a/include/linux/ext4_fs_i.h
+++ b/include/linux/ext4_fs_i.h
@@ -153,6 +153,11 @@ struct ext4_inode_info {
 
         unsigned long i_ext_generation;
         struct ext4_ext_cache i_cached_extent;
+        /*
+         * File creation time. Its function is same as that of
+         * struct timespec i_{a,c,m}time in the generic inode.
+         */
+        struct timespec i_crtime;
 };
 
 #endif  /* _LINUX_EXT4_FS_I */
diff --git a/include/linux/ext4_fs_sb.h b/include/linux/ext4_fs_sb.h
index 691a713139ce..1b2ffee12be9 100644
--- a/include/linux/ext4_fs_sb.h
+++ b/include/linux/ext4_fs_sb.h
@@ -39,6 +39,8 @@ struct ext4_sb_info {
         unsigned long s_gdb_count;      /* Number of group descriptor blocks */
         unsigned long s_desc_per_block; /* Number of group descriptors per block */
         unsigned long s_groups_count;   /* Number of groups in the fs */
+        unsigned long s_overhead_last;  /* Last calculated overhead */
+        unsigned long s_blocks_last;    /* Last seen block count */
         struct buffer_head * s_sbh;     /* Buffer containing the super block */
         struct ext4_super_block * s_es; /* Pointer to the super block in the buffer */
         struct buffer_head ** s_group_desc;
@@ -71,7 +73,7 @@ struct ext4_sb_info {
         struct list_head s_orphan;
         unsigned long s_commit_interval;
         struct block_device *journal_bdev;
-#ifdef CONFIG_JBD_DEBUG
+#ifdef CONFIG_JBD2_DEBUG
         struct timer_list turn_ro_timer;        /* For turning read-only (crash simulation) */
         wait_queue_head_t ro_wait_queue;        /* For people waiting for the fs to go read-only */
 #endif
@@ -79,6 +81,7 @@ struct ext4_sb_info {
         char *s_qf_names[MAXQUOTAS];            /* Names of quota files with journalled quota */
         int s_jquota_fmt;                       /* Format of quota to use */
 #endif
+        unsigned int s_want_extra_isize; /* New inodes should reserve # bytes */
 
 #ifdef EXTENTS_STATS
         /* ext4 extents stats */
diff --git a/include/linux/falloc.h b/include/linux/falloc.h
new file mode 100644
index 000000000000..8e912ab6a072
--- /dev/null
+++ b/include/linux/falloc.h
@@ -0,0 +1,6 @@
+#ifndef _FALLOC_H_
+#define _FALLOC_H_
+
+#define FALLOC_FL_KEEP_SIZE     0x01 /* default is extend size */
+
+#endif /* _FALLOC_H_ */
diff --git a/include/linux/fb.h b/include/linux/fb.h
index 66226824ab68..cec54106aa87 100644
--- a/include/linux/fb.h
+++ b/include/linux/fb.h
@@ -119,6 +119,7 @@ struct dentry;
 #define FB_ACCEL_NV_40          46      /* nVidia Arch 40               */
 #define FB_ACCEL_XGI_VOLARI_V   47      /* XGI Volari V3XT, V5, V8      */
 #define FB_ACCEL_XGI_VOLARI_Z   48      /* XGI Volari Z7                */
+#define FB_ACCEL_OMAP1610       49      /* TI OMAP16xx                  */
 #define FB_ACCEL_NEOMAGIC_NM2070 90     /* NeoMagic NM2070              */
 #define FB_ACCEL_NEOMAGIC_NM2090 91     /* NeoMagic NM2090              */
 #define FB_ACCEL_NEOMAGIC_NM2093 92     /* NeoMagic NM2093              */
@@ -529,6 +530,8 @@ struct fb_cursor_user {
 #define FB_EVENT_CONBLANK               0x0C
 /*      Get drawing requirements        */
 #define FB_EVENT_GET_REQ                0x0D
+/*      Unbind from the console if possible */
+#define FB_EVENT_FB_UNBIND              0x0E
 
 struct fb_event {
         struct fb_info *info;
diff --git a/include/linux/file.h b/include/linux/file.h
index a59001e9ea58..0114fbc78061 100644
--- a/include/linux/file.h
+++ b/include/linux/file.h
@@ -73,6 +73,7 @@ extern struct file * FASTCALL(fget_light(unsigned int fd, int *fput_needed));
 extern void FASTCALL(set_close_on_exec(unsigned int fd, int flag));
 extern void put_filp(struct file *);
 extern int get_unused_fd(void);
+extern int get_unused_fd_flags(int flags);
 extern void FASTCALL(put_unused_fd(unsigned int fd));
 struct kmem_cache;
 
diff --git a/include/linux/freezer.h b/include/linux/freezer.h
index 4631086f5060..c8e02de737f6 100644
--- a/include/linux/freezer.h
+++ b/include/linux/freezer.h
@@ -1,5 +1,8 @@
 /* Freezer declarations */
 
+#ifndef FREEZER_H_INCLUDED
+#define FREEZER_H_INCLUDED
+
 #include <linux/sched.h>
 
 #ifdef CONFIG_PM
@@ -22,7 +25,7 @@ static inline int freezing(struct task_struct *p)
 /*
  * Request that a process be frozen
  */
-static inline void freeze(struct task_struct *p)
+static inline void set_freeze_flag(struct task_struct *p)
 {
         set_tsk_thread_flag(p, TIF_FREEZE);
 }
@@ -30,7 +33,7 @@ static inline void freeze(struct task_struct *p)
 /*
  * Sometimes we may need to cancel the previous 'freeze' request
  */
-static inline void do_not_freeze(struct task_struct *p)
+static inline void clear_freeze_flag(struct task_struct *p)
 {
         clear_tsk_thread_flag(p, TIF_FREEZE);
 }
@@ -53,7 +56,7 @@ static inline int thaw_process(struct task_struct *p)
                 wake_up_process(p);
                 return 1;
         }
-        clear_tsk_thread_flag(p, TIF_FREEZE);
+        clear_freeze_flag(p);
         task_unlock(p);
         return 0;
 }
@@ -115,10 +118,19 @@ static inline int freezer_should_skip(struct task_struct *p)
         return !!(p->flags & PF_FREEZER_SKIP);
 }
 
+/*
+ * Tell the freezer that the current task should be frozen by it
+ */
+static inline void set_freezable(void)
+{
+        current->flags &= ~PF_NOFREEZE;
+}
+
 #else
 static inline int frozen(struct task_struct *p) { return 0; }
 static inline int freezing(struct task_struct *p) { return 0; }
-static inline void freeze(struct task_struct *p) { BUG(); }
+static inline void set_freeze_flag(struct task_struct *p) {}
+static inline void clear_freeze_flag(struct task_struct *p) {}
 static inline int thaw_process(struct task_struct *p) { return 1; }
 
 static inline void refrigerator(void) {}
@@ -130,4 +142,7 @@ static inline int try_to_freeze(void) { return 0; }
 static inline void freezer_do_not_count(void) {}
 static inline void freezer_count(void) {}
 static inline int freezer_should_skip(struct task_struct *p) { return 0; }
+static inline void set_freezable(void) {}
 #endif
+
+#endif  /* FREEZER_H_INCLUDED */
diff --git a/include/linux/fs.h b/include/linux/fs.h
index 4f0b3bf5983c..d33beadd9a43 100644
--- a/include/linux/fs.h
+++ b/include/linux/fs.h
@@ -44,7 +44,7 @@ extern int get_max_files(void);
 struct inodes_stat_t {
         int nr_inodes;
         int nr_unused;
-        int dummy[5];
+        int dummy[5];           /* padding for sysctl ABI compatibility */
 };
 extern struct inodes_stat_t inodes_stat;
 
@@ -283,11 +283,14 @@ extern int dir_notify_enable;
 #include <linux/init.h>
 #include <linux/pid.h>
 #include <linux/mutex.h>
+#include <linux/sysctl.h>
+#include <linux/capability.h>
 
 #include <asm/atomic.h>
 #include <asm/semaphore.h>
 #include <asm/byteorder.h>
 
+struct export_operations;
 struct hd_geometry;
 struct iovec;
 struct nameidata;
@@ -694,20 +697,26 @@ struct fown_struct {
  * Track a single file's readahead state
  */
 struct file_ra_state {
-        unsigned long start;            /* Current window */
-        unsigned long size;
-        unsigned long flags;            /* ra flags RA_FLAG_xxx*/
-        unsigned long cache_hit;        /* cache hit count*/
-        unsigned long prev_index;       /* Cache last read() position */
-        unsigned long ahead_start;      /* Ahead window */
-        unsigned long ahead_size;
+        pgoff_t start;                  /* where readahead started */
+        unsigned long size;             /* # of readahead pages */
+        unsigned long async_size;       /* do asynchronous readahead when
+                                           there are only # of pages ahead */
+
         unsigned long ra_pages;         /* Maximum readahead window */
         unsigned long mmap_hit;         /* Cache hit stat for mmap accesses */
         unsigned long mmap_miss;        /* Cache miss stat for mmap accesses */
+        unsigned long prev_index;       /* Cache last read() position */
         unsigned int prev_offset;       /* Offset where last read() ended in a page */
 };
-#define RA_FLAG_MISS 0x01       /* a cache miss occured against this file */
-#define RA_FLAG_INCACHE 0x02    /* file is already in cache */
+
+/*
+ * Check if @index falls in the readahead windows.
+ */
+static inline int ra_has_index(struct file_ra_state *ra, pgoff_t index)
+{
+        return (index >= ra->start &&
+                index <  ra->start + ra->size);
+}
 
 struct file {
         /*
@@ -820,6 +829,10 @@ struct file_lock {
         union {
                 struct nfs_lock_info    nfs_fl;
                 struct nfs4_lock_info   nfs4_fl;
+                struct {
+                        struct list_head link;  /* link in AFS vnode's pending_locks list */
+                        int state;              /* state of grant or error if -ve */
+                } afs;
         } fl_u;
 };
 
@@ -855,7 +868,7 @@ 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 int posix_test_lock(struct file *, struct file_lock *);
+extern void posix_test_lock(struct file *, struct file_lock *);
 extern int posix_lock_file(struct file *, struct file_lock *, struct file_lock *);
 extern int posix_lock_file_wait(struct file *, struct file_lock *);
 extern int posix_unblock_lock(struct file *, struct file_lock *);
@@ -866,6 +879,7 @@ extern int flock_lock_file_wait(struct file *filp, struct file_lock *fl);
 extern int __break_lease(struct inode *inode, unsigned int flags);
 extern void lease_get_mtime(struct inode *, struct timespec *time);
 extern int setlease(struct file *, long, struct file_lock **);
+extern int vfs_setlease(struct file *, long, struct file_lock **);
 extern int lease_modify(struct file_lock **, int);
 extern int lock_may_read(struct inode *, loff_t start, unsigned long count);
 extern int lock_may_write(struct inode *, loff_t start, unsigned long count);
@@ -984,6 +998,9 @@ enum {
 #define put_fs_excl() atomic_dec(&current->fs_excl)
 #define has_fs_excl() atomic_read(&current->fs_excl)
 
+#define is_owner_or_cap(inode)  \
+        ((current->fsuid == (inode)->i_uid) || capable(CAP_FOWNER))
+
 /* not quite ready to be deprecated, but... */
 extern void lock_super(struct super_block *);
 extern void unlock_super(struct super_block *);
@@ -1112,6 +1129,7 @@ struct file_operations {
         int (*flock) (struct file *, int, struct file_lock *);
         ssize_t (*splice_write)(struct pipe_inode_info *, struct file *, loff_t *, size_t, unsigned int);
         ssize_t (*splice_read)(struct file *, loff_t *, struct pipe_inode_info *, size_t, unsigned int);
+        int (*setlease)(struct file *, long, struct file_lock **);
 };
 
 struct inode_operations {
@@ -1137,6 +1155,8 @@ struct inode_operations {
         ssize_t (*listxattr) (struct dentry *, char *, size_t);
         int (*removexattr) (struct dentry *, const char *);
         void (*truncate_range)(struct inode *, loff_t, loff_t);
+        long (*fallocate)(struct inode *inode, int mode, loff_t offset,
+                          loff_t len);
 };
 
 struct seq_file;
@@ -1273,119 +1293,6 @@ static inline void file_accessed(struct file *file)
 
 int sync_inode(struct inode *inode, struct writeback_control *wbc);
 
-/**
- * struct export_operations - for nfsd to communicate with file systems
- * @decode_fh:      decode a file handle fragment and return a &struct dentry
- * @encode_fh:      encode a file handle fragment from a dentry
- * @get_name:       find the name for a given inode in a given directory
- * @get_parent:     find the parent of a given directory
- * @get_dentry:     find a dentry for the inode given a file handle sub-fragment
- * @find_exported_dentry:
- *      set by the exporting module to a standard helper function.
- *
- * Description:
- *    The export_operations structure provides a means for nfsd to communicate
- *    with a particular exported file system  - particularly enabling nfsd and
- *    the filesystem to co-operate when dealing with file handles.
- *
- *    export_operations contains two basic operation for dealing with file
- *    handles, decode_fh() and encode_fh(), and allows for some other
- *    operations to be defined which standard helper routines use to get
- *    specific information from the filesystem.
- *
- *    nfsd encodes information use to determine which filesystem a filehandle
- *    applies to in the initial part of the file handle.  The remainder, termed
- *    a file handle fragment, is controlled completely by the filesystem.  The
- *    standard helper routines assume that this fragment will contain one or
- *    two sub-fragments, one which identifies the file, and one which may be
- *    used to identify the (a) directory containing the file.
- *
- *    In some situations, nfsd needs to get a dentry which is connected into a
- *    specific part of the file tree.  To allow for this, it passes the
- *    function acceptable() together with a @context which can be used to see
- *    if the dentry is acceptable.  As there can be multiple dentrys for a
- *    given file, the filesystem should check each one for acceptability before
- *    looking for the next.  As soon as an acceptable one is found, it should
- *    be returned.
- *
- * decode_fh:
- *    @decode_fh is given a &struct super_block (@sb), a file handle fragment
- *    (@fh, @fh_len) and an acceptability testing function (@acceptable,
- *    @context).  It should return a &struct dentry which refers to the same
- *    file that the file handle fragment refers to,  and which passes the
- *    acceptability test.  If it cannot, it should return a %NULL pointer if
- *    the file was found but no acceptable &dentries were available, or a
- *    %ERR_PTR error code indicating why it couldn't be found (e.g. %ENOENT or
- *    %ENOMEM).
- *
- * encode_fh:
- *    @encode_fh should store in the file handle fragment @fh (using at most
- *    @max_len bytes) information that can be used by @decode_fh to recover the
- *    file refered to by the &struct dentry @de.  If the @connectable flag is
- *    set, the encode_fh() should store sufficient information so that a good
- *    attempt can be made to find not only the file but also it's place in the
- *    filesystem.   This typically means storing a reference to de->d_parent in
- *    the filehandle fragment.  encode_fh() should return the number of bytes
- *    stored or a negative error code such as %-ENOSPC
- *
- * get_name:
- *    @get_name should find a name for the given @child in the given @parent
- *    directory.  The name should be stored in the @name (with the
- *    understanding that it is already pointing to a a %NAME_MAX+1 sized
- *    buffer.   get_name() should return %0 on success, a negative error code
- *    or error.  @get_name will be called without @parent->i_mutex held.
- *
- * get_parent:
- *    @get_parent should find the parent directory for the given @child which
- *    is also a directory.  In the event that it cannot be found, or storage
- *    space cannot be allocated, a %ERR_PTR should be returned.
- *
- * get_dentry:
- *    Given a &super_block (@sb) and a pointer to a file-system specific inode
- *    identifier, possibly an inode number, (@inump) get_dentry() should find
- *    the identified inode and return a dentry for that inode.  Any suitable
- *    dentry can be returned including, if necessary, a new dentry created with
- *    d_alloc_root.  The caller can then find any other extant dentrys by
- *    following the d_alias links.  If a new dentry was created using
- *    d_alloc_root, DCACHE_NFSD_DISCONNECTED should be set, and the dentry
- *    should be d_rehash()ed.
- *
- *    If the inode cannot be found, either a %NULL pointer or an %ERR_PTR code
- *    can be returned.  The @inump will be whatever was passed to
- *    nfsd_find_fh_dentry() in either the @obj or @parent parameters.
- *
- * Locking rules:
- *    get_parent is called with child->d_inode->i_mutex down
- *    get_name is not (which is possibly inconsistent)
- */
-
-struct export_operations {
-        struct dentry *(*decode_fh)(struct super_block *sb, __u32 *fh, int fh_len, int fh_type,
-                         int (*acceptable)(void *context, struct dentry *de),
-                         void *context);
-        int (*encode_fh)(struct dentry *de, __u32 *fh, int *max_len,
-                         int connectable);
-
-        /* the following are only called from the filesystem itself */
-        int (*get_name)(struct dentry *parent, char *name,
-                        struct dentry *child);
-        struct dentry * (*get_parent)(struct dentry *child);
-        struct dentry * (*get_dentry)(struct super_block *sb, void *inump);
-
-        /* This is set by the exporting module to a standard helper */
-        struct dentry * (*find_exported_dentry)(
-                struct super_block *sb, void *obj, void *parent,
-                int (*acceptable)(void *context, struct dentry *de),
-                void *context);
-
-
-};
-
-extern struct dentry *
-find_exported_dentry(struct super_block *sb, void *obj, void *parent,
-                     int (*acceptable)(void *context, struct dentry *de),
-                     void *context);
-
 struct file_system_type {
         const char *name;
         int fs_flags;
@@ -1522,7 +1429,7 @@ extern void putname(const char *name);
 
 #ifdef CONFIG_BLOCK
 extern int register_blkdev(unsigned int, const char *);
-extern int unregister_blkdev(unsigned int, const char *);
+extern void unregister_blkdev(unsigned int, const char *);
 extern struct block_device *bdget(dev_t);
 extern void bd_set_size(struct block_device *, loff_t size);
 extern void bd_forget(struct inode *inode);
@@ -1562,7 +1469,7 @@ 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 *,
                            const struct file_operations *);
-extern int unregister_chrdev(unsigned int, const char *);
+extern void unregister_chrdev(unsigned int, const char *);
 extern void unregister_chrdev_region(dev_t, unsigned);
 extern int chrdev_open(struct inode *, struct file *);
 extern void chrdev_show(struct seq_file *,off_t);
@@ -1610,6 +1517,9 @@ extern int __invalidate_device(struct block_device *);
 extern int invalidate_partition(struct gendisk *, int);
 #endif
 extern int invalidate_inodes(struct super_block *);
+unsigned long __invalidate_mapping_pages(struct address_space *mapping,
+                                        pgoff_t start, pgoff_t end,
+                                        bool be_atomic);
 unsigned long invalidate_mapping_pages(struct address_space *mapping,
                                         pgoff_t start, pgoff_t end);
 
@@ -2043,5 +1953,9 @@ static inline void free_secdata(void *secdata)
 { }
 #endif  /* CONFIG_SECURITY */
 
+int proc_nr_files(ctl_table *table, int write, struct file *filp,
+                  void __user *buffer, size_t *lenp, loff_t *ppos);
+
+
 #endif /* __KERNEL__ */
 #endif /* _LINUX_FS_H */
diff --git a/include/linux/fsl_devices.h b/include/linux/fsl_devices.h
index 73710d617775..1831b196c70a 100644
--- a/include/linux/fsl_devices.h
+++ b/include/linux/fsl_devices.h
@@ -53,6 +53,7 @@ struct gianfar_platform_data {
         u32     bus_id;
         u32     phy_id;
         u8      mac_addr[6];
+        phy_interface_t interface;
 };
 
 struct gianfar_mdio_data {
@@ -112,7 +113,7 @@ struct fsl_usb2_platform_data {
 struct fsl_spi_platform_data {
         u32     initial_spmode; /* initial SPMODE value */
         u16     bus_num;
-
+        bool    qe_mode;
         /* board specific information */
         u16     max_chipselect;
         void    (*activate_cs)(u8 cs, u8 polarity);
@@ -120,5 +121,10 @@ struct fsl_spi_platform_data {
         u32     sysclk;
 };
 
+struct mpc8xx_pcmcia_ops {
+        void(*hw_ctrl)(int slot, int enable);
+        int(*voltage_set)(int slot, int vcc, int vpp);
+};
+
 #endif /* _FSL_DEVICE_H_ */
 #endif /* __KERNEL__ */
diff --git a/include/linux/fuse.h b/include/linux/fuse.h
index 534744efe30d..9fbe9d258e22 100644
--- a/include/linux/fuse.h
+++ b/include/linux/fuse.h
@@ -339,7 +339,7 @@ struct fuse_dirent {
         char name[0];
 };
 
-#define FUSE_NAME_OFFSET ((unsigned) ((struct fuse_dirent *) 0)->name)
+#define FUSE_NAME_OFFSET offsetof(struct fuse_dirent, name)
 #define FUSE_DIRENT_ALIGN(x) (((x) + sizeof(__u64) - 1) & ~(sizeof(__u64) - 1))
 #define FUSE_DIRENT_SIZE(d) \
         FUSE_DIRENT_ALIGN(FUSE_NAME_OFFSET + (d)->namelen)
diff --git a/include/linux/genetlink.h b/include/linux/genetlink.h
index f7a93770e1be..7da02c93002b 100644
--- a/include/linux/genetlink.h
+++ b/include/linux/genetlink.h
@@ -39,6 +39,9 @@ enum {
         CTRL_CMD_NEWOPS,
         CTRL_CMD_DELOPS,
         CTRL_CMD_GETOPS,
+        CTRL_CMD_NEWMCAST_GRP,
+        CTRL_CMD_DELMCAST_GRP,
+        CTRL_CMD_GETMCAST_GRP, /* unused */
         __CTRL_CMD_MAX,
 };
 
@@ -52,6 +55,7 @@ enum {
         CTRL_ATTR_HDRSIZE,
         CTRL_ATTR_MAXATTR,
         CTRL_ATTR_OPS,
+        CTRL_ATTR_MCAST_GROUPS,
         __CTRL_ATTR_MAX,
 };
 
@@ -66,4 +70,13 @@ enum {
 
 #define CTRL_ATTR_OP_MAX (__CTRL_ATTR_OP_MAX - 1)
 
+enum {
+        CTRL_ATTR_MCAST_GRP_UNSPEC,
+        CTRL_ATTR_MCAST_GRP_NAME,
+        CTRL_ATTR_MCAST_GRP_ID,
+        __CTRL_ATTR_MCAST_GRP_MAX,
+};
+
+#define CTRL_ATTR_MCAST_GRP_MAX (__CTRL_ATTR_MCAST_GRP_MAX - 1)
+
 #endif  /* __LINUX_GENERIC_NETLINK_H */
diff --git a/include/linux/gfp.h b/include/linux/gfp.h
index 0d2ef0b082a6..bc68dd9a6d41 100644
--- a/include/linux/gfp.h
+++ b/include/linux/gfp.h
@@ -30,6 +30,9 @@ struct vm_area_struct;
  * cannot handle allocation failures.
  *
  * __GFP_NORETRY: The VM implementation must not retry indefinitely.
+ *
+ * __GFP_MOVABLE: Flag that this page will be movable by the page migration
+ * mechanism or reclaimed
  */
 #define __GFP_WAIT      ((__force gfp_t)0x10u)  /* Can wait and reschedule? */
 #define __GFP_HIGH      ((__force gfp_t)0x20u)  /* Should access emergency pools? */
@@ -45,6 +48,7 @@ struct vm_area_struct;
 #define __GFP_NOMEMALLOC ((__force gfp_t)0x10000u) /* Don't use emergency reserves */
 #define __GFP_HARDWALL   ((__force gfp_t)0x20000u) /* Enforce hardwall cpuset memory allocs */
 #define __GFP_THISNODE  ((__force gfp_t)0x40000u)/* No fallback, no policies */
+#define __GFP_MOVABLE   ((__force gfp_t)0x80000u) /* Page is movable */
 
 #define __GFP_BITS_SHIFT 20     /* Room for 20 __GFP_FOO bits */
 #define __GFP_BITS_MASK ((__force gfp_t)((1 << __GFP_BITS_SHIFT) - 1))
@@ -53,7 +57,8 @@ struct vm_area_struct;
 #define GFP_LEVEL_MASK (__GFP_WAIT|__GFP_HIGH|__GFP_IO|__GFP_FS| \
                         __GFP_COLD|__GFP_NOWARN|__GFP_REPEAT| \
                         __GFP_NOFAIL|__GFP_NORETRY|__GFP_COMP| \
-                        __GFP_NOMEMALLOC|__GFP_HARDWALL|__GFP_THISNODE)
+                        __GFP_NOMEMALLOC|__GFP_HARDWALL|__GFP_THISNODE| \
+                        __GFP_MOVABLE)
 
 /* This equals 0, but use constants in case they ever change */
 #define GFP_NOWAIT      (GFP_ATOMIC & ~__GFP_HIGH)
@@ -65,6 +70,15 @@ struct vm_area_struct;
 #define GFP_USER        (__GFP_WAIT | __GFP_IO | __GFP_FS | __GFP_HARDWALL)
 #define GFP_HIGHUSER    (__GFP_WAIT | __GFP_IO | __GFP_FS | __GFP_HARDWALL | \
                          __GFP_HIGHMEM)
+#define GFP_HIGHUSER_MOVABLE    (__GFP_WAIT | __GFP_IO | __GFP_FS | \
+                                 __GFP_HARDWALL | __GFP_HIGHMEM | \
+                                 __GFP_MOVABLE)
+#define GFP_NOFS_PAGECACHE      (__GFP_WAIT | __GFP_IO | __GFP_MOVABLE)
+#define GFP_USER_PAGECACHE      (__GFP_WAIT | __GFP_IO | __GFP_FS | \
+                                 __GFP_HARDWALL | __GFP_MOVABLE)
+#define GFP_HIGHUSER_PAGECACHE  (__GFP_WAIT | __GFP_IO | __GFP_FS | \
+                                 __GFP_HARDWALL | __GFP_HIGHMEM | \
+                                 __GFP_MOVABLE)
 
 #ifdef CONFIG_NUMA
 #define GFP_THISNODE    (__GFP_THISNODE | __GFP_NOWARN | __GFP_NORETRY)
@@ -92,6 +106,9 @@ static inline enum zone_type gfp_zone(gfp_t flags)
         if (flags & __GFP_DMA32)
                 return ZONE_DMA32;
 #endif
+        if ((flags & (__GFP_HIGHMEM | __GFP_MOVABLE)) ==
+                        (__GFP_HIGHMEM | __GFP_MOVABLE))
+                return ZONE_MOVABLE;
 #ifdef CONFIG_HIGHMEM
         if (flags & __GFP_HIGHMEM)
                 return ZONE_HIGHMEM;
diff --git a/include/linux/highmem.h b/include/linux/highmem.h
index 98e2cce996a4..1fcb0033179e 100644
--- a/include/linux/highmem.h
+++ b/include/linux/highmem.h
@@ -73,10 +73,27 @@ static inline void clear_user_highpage(struct page *page, unsigned long vaddr)
 }
 
 #ifndef __HAVE_ARCH_ALLOC_ZEROED_USER_HIGHPAGE
+/**
+ * __alloc_zeroed_user_highpage - Allocate a zeroed HIGHMEM page for a VMA with caller-specified movable GFP flags
+ * @movableflags: The GFP flags related to the pages future ability to move like __GFP_MOVABLE
+ * @vma: The VMA the page is to be allocated for
+ * @vaddr: The virtual address the page will be inserted into
+ *
+ * This function will allocate a page for a VMA but the caller is expected
+ * to specify via movableflags whether the page will be movable in the
+ * future or not
+ *
+ * An architecture may override this function by defining
+ * __HAVE_ARCH_ALLOC_ZEROED_USER_HIGHPAGE and providing their own
+ * implementation.
+ */
 static inline struct page *
-alloc_zeroed_user_highpage(struct vm_area_struct *vma, unsigned long vaddr)
+__alloc_zeroed_user_highpage(gfp_t movableflags,
+                        struct vm_area_struct *vma,
+                        unsigned long vaddr)
 {
-        struct page *page = alloc_page_vma(GFP_HIGHUSER, vma, vaddr);
+        struct page *page = alloc_page_vma(GFP_HIGHUSER | movableflags,
+                        vma, vaddr);
 
         if (page)
                 clear_user_highpage(page, vaddr);
@@ -85,6 +102,21 @@ alloc_zeroed_user_highpage(struct vm_area_struct *vma, unsigned long vaddr)
 }
 #endif
 
+/**
+ * alloc_zeroed_user_highpage_movable - Allocate a zeroed HIGHMEM page for a VMA that the caller knows can move
+ * @vma: The VMA the page is to be allocated for
+ * @vaddr: The virtual address the page will be inserted into
+ *
+ * This function will allocate a page for a VMA that the caller knows will
+ * be able to migrate in the future using move_pages() or reclaimed
+ */
+static inline struct page *
+alloc_zeroed_user_highpage_movable(struct vm_area_struct *vma,
+                                        unsigned long vaddr)
+{
+        return __alloc_zeroed_user_highpage(__GFP_MOVABLE, vma, vaddr);
+}
+
 static inline void clear_highpage(struct page *page)
 {
         void *kaddr = kmap_atomic(page, KM_USER0);
diff --git a/include/linux/hrtimer.h b/include/linux/hrtimer.h
index 17c29dca8354..540799bc85f8 100644
--- a/include/linux/hrtimer.h
+++ b/include/linux/hrtimer.h
@@ -329,12 +329,13 @@ extern void sysrq_timer_list_show(void);
 #ifdef CONFIG_TIMER_STATS
 
 extern void timer_stats_update_stats(void *timer, pid_t pid, void *startf,
-                                     void *timerf, char * comm);
+                                     void *timerf, char *comm,
+                                     unsigned int timer_flag);
 
 static inline void timer_stats_account_hrtimer(struct hrtimer *timer)
 {
         timer_stats_update_stats(timer, timer->start_pid, timer->start_site,
-                                 timer->function, timer->start_comm);
+                                 timer->function, timer->start_comm, 0);
 }
 
 extern void __timer_stats_hrtimer_set_start_info(struct hrtimer *timer,
diff --git a/include/linux/hugetlb.h b/include/linux/hugetlb.h
index 2c13715e9dde..49b7053043ad 100644
--- a/include/linux/hugetlb.h
+++ b/include/linux/hugetlb.h
@@ -15,6 +15,7 @@ static inline int is_vm_hugetlb_page(struct vm_area_struct *vma)
 }
 
 int hugetlb_sysctl_handler(struct ctl_table *, int, struct file *, void __user *, size_t *, loff_t *);
+int hugetlb_treat_movable_handler(struct ctl_table *, int, struct file *, void __user *, size_t *, loff_t *);
 int copy_hugetlb_page_range(struct mm_struct *, struct mm_struct *, struct vm_area_struct *);
 int follow_hugetlb_page(struct mm_struct *, struct vm_area_struct *, struct page **, struct vm_area_struct **, unsigned long *, int *, int);
 void unmap_hugepage_range(struct vm_area_struct *, unsigned long, unsigned long);
@@ -29,6 +30,7 @@ int hugetlb_reserve_pages(struct inode *inode, long from, long to);
 void hugetlb_unreserve_pages(struct inode *inode, long offset, long freed);
 
 extern unsigned long max_huge_pages;
+extern unsigned long hugepages_treat_as_movable;
 extern const unsigned long hugetlb_zero, hugetlb_infinity;
 extern int sysctl_hugetlb_shm_group;
 
diff --git a/include/linux/i2c-id.h b/include/linux/i2c-id.h
index aa83d4163096..b69014865714 100644
--- a/include/linux/i2c-id.h
+++ b/include/linux/i2c-id.h
@@ -115,9 +115,10 @@
 #define I2C_DRIVERID_KS0127     86      /* Samsung ks0127 video decoder */
 #define I2C_DRIVERID_TLV320AIC23B 87    /* TI TLV320AIC23B audio codec  */
 #define I2C_DRIVERID_ISL1208    88      /* Intersil ISL1208 RTC         */
-#define I2C_DRIVERID_WM8731             89      /* Wolfson WM8731 audio codec */
-#define I2C_DRIVERID_WM8750             90      /* Wolfson WM8750 audio codec */
-#define I2C_DRIVERID_WM8753             91      /* Wolfson WM8753 audio codec */
+#define I2C_DRIVERID_WM8731     89      /* Wolfson WM8731 audio codec */
+#define I2C_DRIVERID_WM8750     90      /* Wolfson WM8750 audio codec */
+#define I2C_DRIVERID_WM8753     91      /* Wolfson WM8753 audio codec */
+#define I2C_DRIVERID_LM4857     92      /* LM4857 Audio Amplifier */
 
 #define I2C_DRIVERID_I2CDEV     900
 #define I2C_DRIVERID_ARP        902    /* SMBus ARP Client              */
diff --git a/include/linux/i2c-isa.h b/include/linux/i2c-isa.h
deleted file mode 100644
index 67e3598c4cec..000000000000
--- a/include/linux/i2c-isa.h
+++ /dev/null
@@ -1,36 +0,0 @@
-/*
- * i2c-isa.h - definitions for the i2c-isa pseudo-i2c-adapter interface
- *
- * Copyright (C) 2005 Jean Delvare <khali@linux-fr.org>
- *
- * This program is free software; you can redistribute it and/or modify
- * it under the terms of the GNU General Public License as published by
- * the Free Software Foundation; either version 2 of the License, or
- * (at your option) any later version.
- *
- * This program is distributed in the hope that it will be useful,
- * but WITHOUT ANY WARRANTY; without even the implied warranty of
- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
- * GNU General Public License for more details.
- *
- * You should have received a copy of the GNU General Public License
- * along with this program; if not, write to the Free Software
- * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
- */
-
-#ifndef _LINUX_I2C_ISA_H
-#define _LINUX_I2C_ISA_H
-
-#include <linux/i2c.h>
-
-extern int i2c_isa_add_driver(struct i2c_driver *driver);
-extern int i2c_isa_del_driver(struct i2c_driver *driver);
-
-/* Detect whether we are on the isa bus. This is only useful to hybrid
-   (i2c+isa) drivers. */
-#define i2c_is_isa_adapter(adapptr) \
-        ((adapptr)->id == I2C_HW_ISA)
-#define i2c_is_isa_client(clientptr) \
-        i2c_is_isa_adapter((clientptr)->adapter)
-
-#endif /* _LINUX_I2C_ISA_H */
diff --git a/include/linux/i2c.h b/include/linux/i2c.h
index cae7d618030c..0c37a737a2b2 100644
--- a/include/linux/i2c.h
+++ b/include/linux/i2c.h
@@ -90,7 +90,7 @@ extern s32 i2c_smbus_write_block_data(struct i2c_client * client,
                                       const u8 *values);
 /* Returns the number of read bytes */
 extern s32 i2c_smbus_read_i2c_block_data(struct i2c_client * client,
-                                         u8 command, u8 *values);
+                                         u8 command, u8 length, u8 *values);
 extern s32 i2c_smbus_write_i2c_block_data(struct i2c_client * client,
                                           u8 command, u8 length,
                                           const u8 *values);
@@ -150,15 +150,20 @@ struct i2c_driver {
 
 /**
  * struct i2c_client - represent an I2C slave device
+ * @flags: I2C_CLIENT_TEN indicates the device uses a ten bit chip address;
+ *      I2C_CLIENT_PEC indicates it uses SMBus Packet Error Checking
  * @addr: Address used on the I2C bus connected to the parent adapter.
  * @name: Indicates the type of the device, usually a chip name that's
  *      generic enough to hide second-sourcing and compatible revisions.
+ * @adapter: manages the bus segment hosting this I2C device
  * @dev: Driver model device node for the slave.
+ * @irq: indicates the IRQ generated by this device (if any)
  * @driver_name: Identifies new-style driver used with this device; also
  *      used as the module name for hotplug/coldplug modprobe support.
  *
  * An i2c_client identifies a single device (i.e. chip) connected to an
- * i2c bus. The behaviour is defined by the routines of the driver.
+ * i2c bus. The behaviour exposed to Linux is defined by the driver
+ * managing the device.
  */
 struct i2c_client {
         unsigned short flags;           /* div., see below              */
@@ -180,7 +185,8 @@ struct i2c_client {
 
 static inline struct i2c_client *kobj_to_i2c_client(struct kobject *kobj)
 {
-        return to_i2c_client(container_of(kobj, struct device, kobj));
+        struct device * const dev = container_of(kobj, struct device, kobj);
+        return to_i2c_client(dev);
 }
 
 static inline void *i2c_get_clientdata (struct i2c_client *dev)
@@ -201,7 +207,7 @@ static inline void i2c_set_clientdata (struct i2c_client *dev, void *data)
  * @addr: stored in i2c_client.addr
  * @platform_data: stored in i2c_client.dev.platform_data
  * @irq: stored in i2c_client.irq
-
+ *
  * I2C doesn't actually support hardware probing, although controllers and
  * devices may be able to use I2C_SMBUS_QUICK to tell whether or not there's
  * a device at a given address.  Drivers commonly need more information than
@@ -210,7 +216,7 @@ static inline void i2c_set_clientdata (struct i2c_client *dev, void *data)
  * i2c_board_info is used to build tables of information listing I2C devices
  * that are present.  This information is used to grow the driver model tree
  * for "new style" I2C drivers.  For mainboards this is done statically using
- * i2c_register_board_info(), where @bus_num represents an adapter that isn't
+ * i2c_register_board_info(); bus numbers identify adapters that aren't
  * yet available.  For add-on boards, i2c_new_device() does this dynamically
  * with the adapter already known.
  */
@@ -362,7 +368,6 @@ struct i2c_client_address_data {
 
 /* The numbers to use to set I2C bus address */
 #define ANY_I2C_BUS             0xffff
-#define ANY_I2C_ISA_BUS         9191
 
 
 /* ----- functions exported by i2c.o */
@@ -518,8 +523,9 @@ union i2c_smbus_data {
 #define I2C_SMBUS_WORD_DATA         3
 #define I2C_SMBUS_PROC_CALL         4
 #define I2C_SMBUS_BLOCK_DATA        5
-#define I2C_SMBUS_I2C_BLOCK_DATA    6
+#define I2C_SMBUS_I2C_BLOCK_BROKEN  6
 #define I2C_SMBUS_BLOCK_PROC_CALL   7           /* SMBus 2.0 */
+#define I2C_SMBUS_I2C_BLOCK_DATA    8
 
 
 /* ----- commands for the ioctl like i2c_command call:
diff --git a/include/linux/i2o.h b/include/linux/i2o.h
index 52f53e2e70c3..9752307d16ba 100644
--- a/include/linux/i2o.h
+++ b/include/linux/i2o.h
@@ -31,6 +31,7 @@
 #include <linux/slab.h>
 #include <linux/workqueue.h>    /* work_struct */
 #include <linux/mempool.h>
+#include <linux/mutex.h>
 
 #include <asm/io.h>
 #include <asm/semaphore.h>      /* Needed for MUTEX init macros */
@@ -425,7 +426,7 @@ struct i2o_device {
 
         struct device device;
 
-        struct semaphore lock;  /* device lock */
+        struct mutex lock;      /* device lock */
 };
 
 /*
@@ -544,7 +545,7 @@ struct i2o_controller {
         struct i2o_dma hrt;     /* HW Resource Table */
         i2o_lct *lct;           /* Logical Config Table */
         struct i2o_dma dlct;    /* Temp LCT */
-        struct semaphore lct_lock;      /* Lock for LCT updates */
+        struct mutex lct_lock;  /* Lock for LCT updates */
         struct i2o_dma status_block;    /* IOP status block */
 
         struct i2o_io base;     /* controller messaging unit */
@@ -945,8 +946,7 @@ static inline int i2o_pool_alloc(struct i2o_pool *pool, const char *name,
         strcpy(pool->name, name);
 
         pool->slab =
-            kmem_cache_create(pool->name, size, 0, SLAB_HWCACHE_ALIGN, NULL,
-                              NULL);
+            kmem_cache_create(pool->name, size, 0, SLAB_HWCACHE_ALIGN, NULL);
         if (!pool->slab)
                 goto free_name;
 
diff --git a/include/linux/ide.h b/include/linux/ide.h
index 19ab25804056..5f5daad8bc54 100644
--- a/include/linux/ide.h
+++ b/include/linux/ide.h
@@ -681,6 +681,10 @@ typedef struct hwif_s {
         u8 straight8;   /* Alan's straight 8 check */
         u8 bus_state;   /* power state of the IDE bus */
 
+        u8 host_flags;
+
+        u8 pio_mask;
+
         u8 atapi_dma;   /* host supports atapi_dma */
         u8 ultra_mask;
         u8 mwdma_mask;
@@ -1244,7 +1248,13 @@ typedef struct ide_pci_enablebit_s {
 
 enum {
         /* Uses ISA control ports not PCI ones. */
-        IDEPCI_FLAG_ISA_PORTS           = (1 << 0),
+        IDE_HFLAG_ISA_PORTS             = (1 << 0),
+        /* single port device */
+        IDE_HFLAG_SINGLE                = (1 << 1),
+        /* don't use legacy PIO blacklist */
+        IDE_HFLAG_PIO_NO_BLACKLIST      = (1 << 2),
+        /* don't use conservative PIO "downgrade" */
+        IDE_HFLAG_PIO_NO_DOWNGRADE      = (1 << 3),
 };
 
 typedef struct ide_pci_device_s {
@@ -1256,13 +1266,13 @@ typedef struct ide_pci_device_s {
         void                    (*init_hwif)(ide_hwif_t *);
         void                    (*init_dma)(ide_hwif_t *, unsigned long);
         void                    (*fixup)(ide_hwif_t *);
-        u8                      channels;
         u8                      autodma;
         ide_pci_enablebit_t     enablebits[2];
         u8                      bootable;
         unsigned int            extra;
         struct ide_pci_device_s *next;
-        u8                      flags;
+        u8                      host_flags;
+        u8                      pio_mask;
         u8                      udma_mask;
 } ide_pci_device_t;
 
@@ -1363,6 +1373,11 @@ extern void ide_toggle_bounce(ide_drive_t *drive, int on);
 extern int ide_set_xfer_rate(ide_drive_t *drive, u8 rate);
 int ide_use_fast_pio(ide_drive_t *);
 
+static inline int ide_dev_has_iordy(struct hd_driveid *id)
+{
+        return ((id->field_valid & 2) && (id->capability & 8)) ? 1 : 0;
+}
+
 u8 ide_dump_status(ide_drive_t *, const char *, u8);
 
 typedef struct ide_pio_timings_s {
@@ -1372,14 +1387,8 @@ typedef struct ide_pio_timings_s {
                                 /* active + recovery (+ setup for some chips) */
 } ide_pio_timings_t;
 
-typedef struct ide_pio_data_s {
-        u8 pio_mode;
-        u8 use_iordy;
-        u8 overridden;
-        unsigned int cycle_time;
-} ide_pio_data_t;
-
-extern u8 ide_get_best_pio_mode (ide_drive_t *drive, u8 mode_wanted, u8 max_mode, ide_pio_data_t *d);
+unsigned int ide_pio_cycle_time(ide_drive_t *, u8);
+u8 ide_get_best_pio_mode(ide_drive_t *, u8, u8);
 extern const ide_pio_timings_t ide_pio_timings[6];
 
 
diff --git a/include/linux/idr.h b/include/linux/idr.h
index 826803449db7..0edda411959c 100644
--- a/include/linux/idr.h
+++ b/include/linux/idr.h
@@ -78,9 +78,41 @@ void *idr_find(struct idr *idp, int id);
 int idr_pre_get(struct idr *idp, gfp_t gfp_mask);
 int idr_get_new(struct idr *idp, void *ptr, int *id);
 int idr_get_new_above(struct idr *idp, void *ptr, int starting_id, int *id);
+int idr_for_each(struct idr *idp,
+                 int (*fn)(int id, void *p, void *data), void *data);
 void *idr_replace(struct idr *idp, void *ptr, int id);
 void idr_remove(struct idr *idp, int id);
+void idr_remove_all(struct idr *idp);
 void idr_destroy(struct idr *idp);
 void idr_init(struct idr *idp);
 
+
+/*
+ * IDA - IDR based id allocator, use when translation from id to
+ * pointer isn't necessary.
+ */
+#define IDA_CHUNK_SIZE          128     /* 128 bytes per chunk */
+#define IDA_BITMAP_LONGS        (128 / sizeof(long) - 1)
+#define IDA_BITMAP_BITS         (IDA_BITMAP_LONGS * sizeof(long) * 8)
+
+struct ida_bitmap {
+        long                    nr_busy;
+        unsigned long           bitmap[IDA_BITMAP_LONGS];
+};
+
+struct ida {
+        struct idr              idr;
+        struct ida_bitmap       *free_bitmap;
+};
+
+#define IDA_INIT(name)          { .idr = IDR_INIT(name), .free_bitmap = NULL, }
+#define DEFINE_IDA(name)        struct ida name = IDA_INIT(name)
+
+int ida_pre_get(struct ida *ida, gfp_t gfp_mask);
+int ida_get_new_above(struct ida *ida, int starting_id, int *p_id);
+int ida_get_new(struct ida *ida, int *p_id);
+void ida_remove(struct ida *ida, int id);
+void ida_destroy(struct ida *ida);
+void ida_init(struct ida *ida);
+
 #endif /* __IDR_H__ */
diff --git a/include/linux/ieee80211.h b/include/linux/ieee80211.h
index ecd61e8438a5..272f8c8c90da 100644
--- a/include/linux/ieee80211.h
+++ b/include/linux/ieee80211.h
@@ -227,6 +227,17 @@ struct ieee80211_cts {
 #define WLAN_CAPABILITY_SHORT_SLOT_TIME (1<<10)
 #define WLAN_CAPABILITY_DSSS_OFDM       (1<<13)
 
+/* 802.11g ERP information element */
+#define WLAN_ERP_NON_ERP_PRESENT (1<<0)
+#define WLAN_ERP_USE_PROTECTION (1<<1)
+#define WLAN_ERP_BARKER_PREAMBLE (1<<2)
+
+/* WLAN_ERP_BARKER_PREAMBLE values */
+enum {
+        WLAN_ERP_PREAMBLE_SHORT = 0,
+        WLAN_ERP_PREAMBLE_LONG = 1,
+};
+
 /* Status codes */
 enum ieee80211_statuscode {
         WLAN_STATUS_SUCCESS = 0,
diff --git a/include/linux/if_link.h b/include/linux/if_link.h
index 604c2434f71c..422084d18ce1 100644
--- a/include/linux/if_link.h
+++ b/include/linux/if_link.h
@@ -76,6 +76,8 @@ enum
 #define IFLA_WEIGHT IFLA_WEIGHT
         IFLA_OPERSTATE,
         IFLA_LINKMODE,
+        IFLA_LINKINFO,
+#define IFLA_LINKINFO IFLA_LINKINFO
         __IFLA_MAX
 };
 
@@ -140,4 +142,49 @@ struct ifla_cacheinfo
         __u32   retrans_time;
 };
 
+enum
+{
+        IFLA_INFO_UNSPEC,
+        IFLA_INFO_KIND,
+        IFLA_INFO_DATA,
+        IFLA_INFO_XSTATS,
+        __IFLA_INFO_MAX,
+};
+
+#define IFLA_INFO_MAX   (__IFLA_INFO_MAX - 1)
+
+/* VLAN section */
+
+enum
+{
+        IFLA_VLAN_UNSPEC,
+        IFLA_VLAN_ID,
+        IFLA_VLAN_FLAGS,
+        IFLA_VLAN_EGRESS_QOS,
+        IFLA_VLAN_INGRESS_QOS,
+        __IFLA_VLAN_MAX,
+};
+
+#define IFLA_VLAN_MAX   (__IFLA_VLAN_MAX - 1)
+
+struct ifla_vlan_flags {
+        __u32   flags;
+        __u32   mask;
+};
+
+enum
+{
+        IFLA_VLAN_QOS_UNSPEC,
+        IFLA_VLAN_QOS_MAPPING,
+        __IFLA_VLAN_QOS_MAX
+};
+
+#define IFLA_VLAN_QOS_MAX       (__IFLA_VLAN_QOS_MAX - 1)
+
+struct ifla_vlan_qos_mapping
+{
+        __u32 from;
+        __u32 to;
+};
+
 #endif /* _LINUX_IF_LINK_H */
diff --git a/include/linux/if_macvlan.h b/include/linux/if_macvlan.h
new file mode 100644
index 000000000000..0d9d7ea2c1cc
--- /dev/null
+++ b/include/linux/if_macvlan.h
@@ -0,0 +1,9 @@
+#ifndef _LINUX_IF_MACVLAN_H
+#define _LINUX_IF_MACVLAN_H
+
+#ifdef __KERNEL__
+
+extern struct sk_buff *(*macvlan_handle_frame_hook)(struct sk_buff *);
+
+#endif /* __KERNEL__ */
+#endif /* _LINUX_IF_MACVLAN_H */
diff --git a/include/linux/if_ppp.h b/include/linux/if_ppp.h
index 768372f07caa..0f2f70d4e48c 100644
--- a/include/linux/if_ppp.h
+++ b/include/linux/if_ppp.h
@@ -110,6 +110,21 @@ struct ifpppcstatsreq {
         struct ppp_comp_stats stats;
 };
 
+/* For PPPIOCGL2TPSTATS */
+struct pppol2tp_ioc_stats {
+        __u16           tunnel_id;      /* redundant */
+        __u16           session_id;     /* if zero, get tunnel stats */
+        __u32           using_ipsec:1;  /* valid only for session_id == 0 */
+        aligned_u64     tx_packets;
+        aligned_u64     tx_bytes;
+        aligned_u64     tx_errors;
+        aligned_u64     rx_packets;
+        aligned_u64     rx_bytes;
+        aligned_u64     rx_seq_discards;
+        aligned_u64     rx_oos_packets;
+        aligned_u64     rx_errors;
+};
+
 #define ifr__name       b.ifr_ifrn.ifrn_name
 #define stats_ptr       b.ifr_ifru.ifru_data
 
@@ -146,6 +161,7 @@ struct ifpppcstatsreq {
 #define PPPIOCDISCONN   _IO('t', 57)            /* disconnect channel */
 #define PPPIOCATTCHAN   _IOW('t', 56, int)      /* attach to ppp channel */
 #define PPPIOCGCHAN     _IOR('t', 55, int)      /* get ppp channel number */
+#define PPPIOCGL2TPSTATS _IOR('t', 54, struct pppol2tp_ioc_stats)
 
 #define SIOCGPPPSTATS   (SIOCDEVPRIVATE + 0)
 #define SIOCGPPPVER     (SIOCDEVPRIVATE + 1)    /* NEVER change this!! */
diff --git a/include/linux/if_pppol2tp.h b/include/linux/if_pppol2tp.h
new file mode 100644
index 000000000000..516203b6fdeb
--- /dev/null
+++ b/include/linux/if_pppol2tp.h
@@ -0,0 +1,69 @@
+/***************************************************************************
+ * Linux PPP over L2TP (PPPoL2TP) Socket Implementation (RFC 2661)
+ *
+ * This file supplies definitions required by the PPP over L2TP driver
+ * (pppol2tp.c).  All version information wrt this file is located in pppol2tp.c
+ *
+ * License:
+ *              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_IF_PPPOL2TP_H
+#define __LINUX_IF_PPPOL2TP_H
+
+#include <asm/types.h>
+
+#ifdef __KERNEL__
+#include <linux/in.h>
+#endif
+
+/* Structure used to connect() the socket to a particular tunnel UDP
+ * socket.
+ */
+struct pppol2tp_addr
+{
+        pid_t   pid;                    /* pid that owns the fd.
+                                         * 0 => current */
+        int     fd;                     /* FD of UDP socket to use */
+
+        struct sockaddr_in addr;        /* IP address and port to send to */
+
+        __be16 s_tunnel, s_session;     /* For matching incoming packets */
+        __be16 d_tunnel, d_session;     /* For sending outgoing packets */
+};
+
+/* Socket options:
+ * DEBUG        - bitmask of debug message categories
+ * SENDSEQ      - 0 => don't send packets with sequence numbers
+ *                1 => send packets with sequence numbers
+ * RECVSEQ      - 0 => receive packet sequence numbers are optional
+ *                1 => drop receive packets without sequence numbers
+ * LNSMODE      - 0 => act as LAC.
+ *                1 => act as LNS.
+ * REORDERTO    - reorder timeout (in millisecs). If 0, don't try to reorder.
+ */
+enum {
+        PPPOL2TP_SO_DEBUG       = 1,
+        PPPOL2TP_SO_RECVSEQ     = 2,
+        PPPOL2TP_SO_SENDSEQ     = 3,
+        PPPOL2TP_SO_LNSMODE     = 4,
+        PPPOL2TP_SO_REORDERTO   = 5,
+};
+
+/* Debug message categories for the DEBUG socket option */
+enum {
+        PPPOL2TP_MSG_DEBUG      = (1 << 0),     /* verbose debug (if
+                                                 * compiled in) */
+        PPPOL2TP_MSG_CONTROL    = (1 << 1),     /* userspace - kernel
+                                                 * interface */
+        PPPOL2TP_MSG_SEQ        = (1 << 2),     /* sequence numbers */
+        PPPOL2TP_MSG_DATA       = (1 << 3),     /* data packets */
+};
+
+
+
+#endif
diff --git a/include/linux/if_pppox.h b/include/linux/if_pppox.h
index 6f987be60fe2..25652545ba6e 100644
--- a/include/linux/if_pppox.h
+++ b/include/linux/if_pppox.h
@@ -27,6 +27,7 @@
 #include <asm/semaphore.h>
 #include <linux/ppp_channel.h>
 #endif /* __KERNEL__ */
+#include <linux/if_pppol2tp.h>
 
 /* For user-space programs to pick up these definitions
  * which they wouldn't get otherwise without defining __KERNEL__
@@ -50,8 +51,9 @@ struct pppoe_addr{
  * Protocols supported by AF_PPPOX 
  */ 
 #define PX_PROTO_OE    0 /* Currently just PPPoE */
-#define PX_MAX_PROTO   1        
- 
+#define PX_PROTO_OL2TP 1 /* Now L2TP also */
+#define PX_MAX_PROTO   2
+
 struct sockaddr_pppox { 
        sa_family_t     sa_family;            /* address family, AF_PPPOX */ 
        unsigned int    sa_protocol;          /* protocol identifier */ 
@@ -60,6 +62,16 @@ struct sockaddr_pppox {
        }sa_addr; 
 }__attribute__ ((packed)); 
 
+/* The use of the above union isn't viable because the size of this
+ * struct must stay fixed over time -- applications use sizeof(struct
+ * sockaddr_pppox) to fill it. We use a protocol specific sockaddr
+ * type instead.
+ */
+struct sockaddr_pppol2tp {
+        sa_family_t     sa_family;      /* address family, AF_PPPOX */
+        unsigned int    sa_protocol;    /* protocol identifier */
+        struct pppol2tp_addr pppol2tp;
+}__attribute__ ((packed));
 
 /*********************************************************************
  *
diff --git a/include/linux/if_tun.h b/include/linux/if_tun.h
index 88aef7b86ef4..42eb6945b93e 100644
--- a/include/linux/if_tun.h
+++ b/include/linux/if_tun.h
@@ -36,6 +36,7 @@ struct tun_struct {
         unsigned long           flags;
         int                     attached;
         uid_t                   owner;
+        gid_t                   group;
 
         wait_queue_head_t       read_wait;
         struct sk_buff_head     readq;
@@ -78,6 +79,7 @@ struct tun_struct {
 #define TUNSETPERSIST _IOW('T', 203, int) 
 #define TUNSETOWNER   _IOW('T', 204, int)
 #define TUNSETLINK    _IOW('T', 205, int)
+#define TUNSETGROUP   _IOW('T', 206, int)
 
 /* TUNSETIFF ifr flags */
 #define IFF_TUN         0x0001
diff --git a/include/linux/if_vlan.h b/include/linux/if_vlan.h
index 81e9bc93569b..f8443fdb124a 100644
--- a/include/linux/if_vlan.h
+++ b/include/linux/if_vlan.h
@@ -99,7 +99,7 @@ static inline void vlan_group_set_device(struct vlan_group *vg, int vlan_id,
 }
 
 struct vlan_priority_tci_mapping {
-        unsigned long priority;
+        u32 priority;
         unsigned short vlan_qos; /* This should be shifted when first set, so we only do it
                                   * at provisioning time.
                                   * ((skb->priority << 13) & 0xE000)
@@ -112,7 +112,10 @@ struct vlan_dev_info {
         /** This will be the mapping that correlates skb->priority to
          * 3 bits of VLAN QOS tags...
          */
-        unsigned long ingress_priority_map[8];
+        unsigned int nr_ingress_mappings;
+        u32 ingress_priority_map[8];
+
+        unsigned int nr_egress_mappings;
         struct vlan_priority_tci_mapping *egress_priority_map[16]; /* hash table */
 
         unsigned short vlan_id;        /*  The VLAN Identifier for this interface. */
@@ -124,14 +127,8 @@ struct vlan_dev_info {
                                         *   like DHCP that use packet-filtering and don't understand
                                         *   802.1Q
                                         */
-        struct dev_mc_list *old_mc_list;  /* old multi-cast list for the VLAN interface..
-                                           * we save this so we can tell what changes were
-                                           * made, in order to feed the right changes down
-                                           * to the real hardware...
-                                           */
-        int old_allmulti;               /* similar to above. */
-        int old_promiscuity;            /* similar to above. */
         struct net_device *real_dev;    /* the underlying device/interface */
+        unsigned char real_dev_addr[ETH_ALEN];
         struct proc_dir_entry *dent;    /* Holds the proc data */
         unsigned long cnt_inc_headroom_on_tx; /* How many times did we have to grow the skb on TX. */
         unsigned long cnt_encap_on_xmit;      /* How many times did we have to encapsulate the skb on TX. */
@@ -395,6 +392,10 @@ enum vlan_ioctl_cmds {
         GET_VLAN_VID_CMD /* Get the VID of this VLAN (specified by name) */
 };
 
+enum vlan_flags {
+        VLAN_FLAG_REORDER_HDR   = 0x1,
+};
+
 enum vlan_name_types {
         VLAN_NAME_TYPE_PLUS_VID, /* Name will look like:  vlan0005 */
         VLAN_NAME_TYPE_RAW_PLUS_VID, /* name will look like:  eth1.0005 */
diff --git a/include/linux/init.h b/include/linux/init.h
index 56ec4c62eee0..f0d0e3295a9b 100644
--- a/include/linux/init.h
+++ b/include/linux/init.h
@@ -40,10 +40,10 @@
 
 /* These are for everybody (although not all archs will actually
    discard it in modules) */
-#define __init          __attribute__ ((__section__ (".init.text")))
+#define __init          __attribute__ ((__section__ (".init.text"))) __cold
 #define __initdata      __attribute__ ((__section__ (".init.data")))
 #define __exitdata      __attribute__ ((__section__(".exit.data")))
-#define __exit_call     __attribute_used__ __attribute__ ((__section__ (".exitcall.exit")))
+#define __exit_call     __attribute_used__ __attribute__ ((__section__ (".exitcall.exit"))) __cold
 
 /* modpost check for section mismatches during the kernel build.
  * A section mismatch happens when there are references from a
@@ -59,9 +59,9 @@
 #define __initdata_refok          __attribute__ ((__section__ (".data.init.refok")))
 
 #ifdef MODULE
-#define __exit          __attribute__ ((__section__(".exit.text")))
+#define __exit          __attribute__ ((__section__(".exit.text"))) __cold
 #else
-#define __exit          __attribute_used__ __attribute__ ((__section__(".exit.text")))
+#define __exit          __attribute_used__ __attribute__ ((__section__(".exit.text"))) __cold
 #endif
 
 /* For assembly routines */
@@ -171,9 +171,6 @@ struct obs_kernel_param {
 #define __setup(str, fn)                                        \
         __setup_param(str, fn, fn, 0)
 
-#define __obsolete_setup(str)                                   \
-        __setup_null_param(str, __LINE__)
-
 /* NOTE: fn is as per module_param, not __setup!  Emits warning if fn
  * returns non-zero. */
 #define early_param(str, fn)                                    \
@@ -239,7 +236,6 @@ void __init parse_early_param(void);
 #define __setup_param(str, unique_id, fn)       /* nothing */
 #define __setup_null_param(str, unique_id)      /* nothing */
 #define __setup(str, func)                      /* nothing */
-#define __obsolete_setup(str)                   /* nothing */
 #endif
 
 /* Data marked not to be saved by software suspend */
diff --git a/include/linux/init_task.h b/include/linux/init_task.h
index 276ccaa2670c..cab741c2d603 100644
--- a/include/linux/init_task.h
+++ b/include/linux/init_task.h
@@ -8,6 +8,7 @@
 #include <linux/lockdep.h>
 #include <linux/ipc.h>
 #include <linux/pid_namespace.h>
+#include <linux/user_namespace.h>
 
 #define INIT_FDTABLE \
 {                                                       \
@@ -78,6 +79,7 @@ extern struct nsproxy init_nsproxy;
         .uts_ns         = &init_uts_ns,                                 \
         .mnt_ns         = NULL,                                         \
         INIT_IPC_NS(ipc_ns)                                             \
+        .user_ns        = &init_user_ns,                                \
 }
 
 #define INIT_SIGHAND(sighand) {                                         \
diff --git a/include/linux/input.h b/include/linux/input.h
index 18c98b543030..e02c6a66b2ba 100644
--- a/include/linux/input.h
+++ b/include/linux/input.h
@@ -344,7 +344,8 @@ struct input_absinfo {
 #define KEY_BRIGHTNESSUP        225
 #define KEY_MEDIA               226
 
-#define KEY_SWITCHVIDEOMODE     227
+#define KEY_SWITCHVIDEOMODE     227     /* Cycle between available video
+                                           outputs (Monitor/LCD/TV-out/etc) */
 #define KEY_KBDILLUMTOGGLE      228
 #define KEY_KBDILLUMDOWN        229
 #define KEY_KBDILLUMUP          230
diff --git a/include/linux/interrupt.h b/include/linux/interrupt.h
index 5323f6275854..0a3c2ebf2008 100644
--- a/include/linux/interrupt.h
+++ b/include/linux/interrupt.h
@@ -120,11 +120,11 @@ extern void devm_free_irq(struct device *dev, unsigned int irq, void *dev_id);
 # define local_irq_enable_in_hardirq()  local_irq_enable()
 #endif
 
-#ifdef CONFIG_GENERIC_HARDIRQS
 extern void disable_irq_nosync(unsigned int irq);
 extern void disable_irq(unsigned int irq);
 extern void enable_irq(unsigned int irq);
 
+#ifdef CONFIG_GENERIC_HARDIRQS
 /*
  * Special lockdep variants of irq disabling/enabling.
  * These should be used for locking constructs that
diff --git a/include/linux/io.h b/include/linux/io.h
index 8423dd376514..e3b2dda6c8eb 100644
--- a/include/linux/io.h
+++ b/include/linux/io.h
@@ -63,32 +63,7 @@ void __iomem * devm_ioremap(struct device *dev, unsigned long offset,
 void __iomem * devm_ioremap_nocache(struct device *dev, unsigned long offset,
                                     unsigned long size);
 void devm_iounmap(struct device *dev, void __iomem *addr);
-
-/**
- *      check_signature         -       find BIOS signatures
- *      @io_addr: mmio address to check
- *      @signature:  signature block
- *      @length: length of signature
- *
- *      Perform a signature comparison with the mmio address io_addr. This
- *      address should have been obtained by ioremap.
- *      Returns 1 on a match.
- */
-
-static inline int check_signature(const volatile void __iomem *io_addr,
-        const unsigned char *signature, int length)
-{
-        int retval = 0;
-        do {
-                if (readb(io_addr) != *signature)
-                        goto out;
-                io_addr++;
-                signature++;
-                length--;
-        } while (length);
-        retval = 1;
-out:
-        return retval;
-}
+int check_signature(const volatile void __iomem *io_addr,
+                        const unsigned char *signature, int length);
 
 #endif /* _LINUX_IO_H */
diff --git a/include/linux/ioprio.h b/include/linux/ioprio.h
index 2eaa142cd061..baf29387cab4 100644
--- a/include/linux/ioprio.h
+++ b/include/linux/ioprio.h
@@ -53,6 +53,14 @@ static inline int task_ioprio(struct task_struct *task)
         return IOPRIO_NORM;
 }
 
+static inline int task_ioprio_class(struct task_struct *task)
+{
+        if (ioprio_valid(task->ioprio))
+                return IOPRIO_PRIO_CLASS(task->ioprio);
+
+        return IOPRIO_CLASS_BE;
+}
+
 static inline int task_nice_ioprio(struct task_struct *task)
 {
         return (task_nice(task) + 20) / 5;
diff --git a/include/linux/ip_mp_alg.h b/include/linux/ip_mp_alg.h
deleted file mode 100644
index e234e2008f5d..000000000000
--- a/include/linux/ip_mp_alg.h
+++ /dev/null
@@ -1,22 +0,0 @@
-/* ip_mp_alg.h: IPV4 multipath algorithm support, user-visible values.
- *
- * Copyright (C) 2004, 2005 Einar Lueck <elueck@de.ibm.com>
- * Copyright (C) 2005 David S. Miller <davem@davemloft.net>
- */
-
-#ifndef _LINUX_IP_MP_ALG_H
-#define _LINUX_IP_MP_ALG_H
-
-enum ip_mp_alg {
-        IP_MP_ALG_NONE,
-        IP_MP_ALG_RR,
-        IP_MP_ALG_DRR,
-        IP_MP_ALG_RANDOM,
-        IP_MP_ALG_WRANDOM,
-        __IP_MP_ALG_MAX
-};
-
-#define IP_MP_ALG_MAX (__IP_MP_ALG_MAX - 1)
-
-#endif /* _LINUX_IP_MP_ALG_H */
-
diff --git a/include/linux/ipc.h b/include/linux/ipc.h
index 1980867a64a4..3fd3ddd5f0d9 100644
--- a/include/linux/ipc.h
+++ b/include/linux/ipc.h
@@ -52,6 +52,7 @@ struct ipc_perm
 #ifdef __KERNEL__
 
 #include <linux/kref.h>
+#include <linux/spinlock.h>
 
 #define IPCMNI 32768  /* <= MAX_INT limit for ipc arrays (including sysctl changes) */
 
@@ -92,6 +93,7 @@ extern struct ipc_namespace init_ipc_ns;
 
 #ifdef CONFIG_SYSVIPC
 #define INIT_IPC_NS(ns)         .ns             = &init_ipc_ns,
+extern void free_ipc_ns(struct kref *kref);
 extern struct ipc_namespace *copy_ipcs(unsigned long flags,
                                                 struct ipc_namespace *ns);
 #else
@@ -103,13 +105,9 @@ static inline struct ipc_namespace *copy_ipcs(unsigned long flags,
 }
 #endif
 
-#ifdef CONFIG_IPC_NS
-extern void free_ipc_ns(struct kref *kref);
-#endif
-
 static inline struct ipc_namespace *get_ipc_ns(struct ipc_namespace *ns)
 {
-#ifdef CONFIG_IPC_NS
+#ifdef CONFIG_SYSVIPC
         if (ns)
                 kref_get(&ns->kref);
 #endif
@@ -118,7 +116,7 @@ static inline struct ipc_namespace *get_ipc_ns(struct ipc_namespace *ns)
 
 static inline void put_ipc_ns(struct ipc_namespace *ns)
 {
-#ifdef CONFIG_IPC_NS
+#ifdef CONFIG_SYSVIPC
         kref_put(&ns->kref, free_ipc_ns);
 #endif
 }
@@ -126,5 +124,3 @@ static inline void put_ipc_ns(struct ipc_namespace *ns)
 #endif /* __KERNEL__ */
 
 #endif /* _LINUX_IPC_H */
-
-
diff --git a/include/linux/ipv6.h b/include/linux/ipv6.h
index 648bd1f0912d..97983dc9df13 100644
--- a/include/linux/ipv6.h
+++ b/include/linux/ipv6.h
@@ -27,8 +27,8 @@ struct in6_ifreq {
         int             ifr6_ifindex; 
 };
 
-#define IPV6_SRCRT_STRICT       0x01    /* this hop must be a neighbor  */
-#define IPV6_SRCRT_TYPE_0       0       /* IPv6 type 0 Routing Header   */
+#define IPV6_SRCRT_STRICT       0x01    /* Deprecated; will be removed */
+#define IPV6_SRCRT_TYPE_0       0       /* Deprecated; will be removed */
 #define IPV6_SRCRT_TYPE_2       2       /* IPv6 type 2 Routing Header   */
 
 /*
@@ -247,7 +247,7 @@ struct inet6_skb_parm {
         __u16                   lastopt;
         __u32                   nhoff;
         __u16                   flags;
-#ifdef CONFIG_IPV6_MIP6
+#if defined(CONFIG_IPV6_MIP6) || defined(CONFIG_IPV6_MIP6_MODULE)
         __u16                   dsthao;
 #endif
 
@@ -299,8 +299,8 @@ struct ipv6_pinfo {
         /* pktoption flags */
         union {
                 struct {
-                        __u16   srcrt:2,
-                                osrcrt:2,
+                        __u16   srcrt:1,
+                                osrcrt:1,
                                 rxinfo:1,
                                 rxoinfo:1,
                                 rxhlim:1,
diff --git a/include/linux/irda.h b/include/linux/irda.h
index 945ba3110874..28f88ecba344 100644
--- a/include/linux/irda.h
+++ b/include/linux/irda.h
@@ -77,6 +77,7 @@ typedef enum {
         IRDA_ACT200L_DONGLE      = 10,
         IRDA_MA600_DONGLE        = 11,
         IRDA_TOIM3232_DONGLE     = 12,
+        IRDA_EP7211_DONGLE       = 13,
 } IRDA_DONGLE;
 
 /* Protocol types to be used for SOCK_DGRAM */
@@ -216,6 +217,34 @@ struct if_irda_req {
 #define ifr_dtr       ifr_ifru.ifru_line.dtr
 #define ifr_rts       ifr_ifru.ifru_line.rts
 
+
+/* IrDA netlink definitions */
+#define IRDA_NL_NAME "irda"
+#define IRDA_NL_VERSION 1
+
+enum irda_nl_commands {
+        IRDA_NL_CMD_UNSPEC,
+        IRDA_NL_CMD_SET_MODE,
+        IRDA_NL_CMD_GET_MODE,
+
+        __IRDA_NL_CMD_AFTER_LAST
+};
+#define IRDA_NL_CMD_MAX (__IRDA_NL_CMD_AFTER_LAST - 1)
+
+enum nl80211_attrs {
+        IRDA_NL_ATTR_UNSPEC,
+        IRDA_NL_ATTR_IFNAME,
+        IRDA_NL_ATTR_MODE,
+
+        __IRDA_NL_ATTR_AFTER_LAST
+};
+#define IRDA_NL_ATTR_MAX (__IRDA_NL_ATTR_AFTER_LAST - 1)
+
+/* IrDA modes */
+#define IRDA_MODE_PRIMARY   0x1
+#define IRDA_MODE_SECONDARY 0x2
+#define IRDA_MODE_MONITOR   0x4
+
 #endif /* KERNEL_IRDA_H */
 
 
diff --git a/include/linux/irq.h b/include/linux/irq.h
index 1695054e8c63..44657197fcb0 100644
--- a/include/linux/irq.h
+++ b/include/linux/irq.h
@@ -161,6 +161,7 @@ struct irq_desc {
         unsigned int            wake_depth;     /* nested wake enables */
         unsigned int            irq_count;      /* For detecting broken IRQs */
         unsigned int            irqs_unhandled;
+        unsigned long           last_unhandled; /* Aging timer for unhandled count */
         spinlock_t              lock;
 #ifdef CONFIG_SMP
         cpumask_t               affinity;
diff --git a/include/linux/jbd2.h b/include/linux/jbd2.h
index 0e0fedd2039a..260d6d76c5f3 100644
--- a/include/linux/jbd2.h
+++ b/include/linux/jbd2.h
@@ -50,14 +50,14 @@
  */
 #define JBD_DEFAULT_MAX_COMMIT_AGE 5
 
-#ifdef CONFIG_JBD_DEBUG
+#ifdef CONFIG_JBD2_DEBUG
 /*
  * Define JBD_EXPENSIVE_CHECKING to enable more expensive internal
  * consistency checks.  By default we don't do this unless
- * CONFIG_JBD_DEBUG is on.
+ * CONFIG_JBD2_DEBUG is on.
  */
 #define JBD_EXPENSIVE_CHECKING
-extern int jbd2_journal_enable_debug;
+extern u8 jbd2_journal_enable_debug;
 
 #define jbd_debug(n, f, a...)                                           \
         do {                                                            \
diff --git a/include/linux/kallsyms.h b/include/linux/kallsyms.h
index 5f06527dca21..f73de6fb5c68 100644
--- a/include/linux/kallsyms.h
+++ b/include/linux/kallsyms.h
@@ -7,9 +7,9 @@
 
 #include <linux/errno.h>
 
-#define KSYM_NAME_LEN 127
-#define KSYM_SYMBOL_LEN (sizeof("%s+%#lx/%#lx [%s]") + KSYM_NAME_LEN +  \
-                         2*(BITS_PER_LONG*3/10) + MODULE_NAME_LEN + 1)
+#define KSYM_NAME_LEN 128
+#define KSYM_SYMBOL_LEN (sizeof("%s+%#lx/%#lx [%s]") + (KSYM_NAME_LEN - 1) + \
+                         2*(BITS_PER_LONG*3/10) + (MODULE_NAME_LEN - 1) + 1)
 
 #ifdef CONFIG_KALLSYMS
 /* Lookup the address for a symbol. Returns 0 if not found. */
diff --git a/include/linux/kernel.h b/include/linux/kernel.h
index 7a4852505914..4300bb462d29 100644
--- a/include/linux/kernel.h
+++ b/include/linux/kernel.h
@@ -106,7 +106,7 @@ extern int cond_resched(void);
 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)));
+        __attribute__ ((NORET_AND format (printf, 1, 2))) __cold;
 extern void oops_enter(void);
 extern void oops_exit(void);
 extern int oops_may_print(void);
@@ -155,14 +155,14 @@ extern void dump_thread(struct pt_regs *regs, struct user *dump);
 asmlinkage int vprintk(const char *fmt, va_list args)
         __attribute__ ((format (printf, 1, 0)));
 asmlinkage int printk(const char * fmt, ...)
-        __attribute__ ((format (printf, 1, 2)));
+        __attribute__ ((format (printf, 1, 2))) __cold;
 #else
 static inline int vprintk(const char *s, va_list args)
         __attribute__ ((format (printf, 1, 0)));
 static inline int vprintk(const char *s, va_list args) { return 0; }
 static inline int printk(const char *s, ...)
         __attribute__ ((format (printf, 1, 2)));
-static inline int printk(const char *s, ...) { return 0; }
+static inline int __cold printk(const char *s, ...) { return 0; }
 #endif
 
 unsigned long int_sqrt(unsigned long);
@@ -210,8 +210,9 @@ extern enum system_states {
 #define TAINT_MACHINE_CHECK             (1<<4)
 #define TAINT_BAD_PAGE                  (1<<5)
 #define TAINT_USER                      (1<<6)
+#define TAINT_DIE                       (1<<7)
 
-extern void dump_stack(void);
+extern void dump_stack(void) __cold;
 
 enum {
         DUMP_PREFIX_NONE,
diff --git a/include/linux/kernelcapi.h b/include/linux/kernelcapi.h
index aea34e74c496..8c4350a9ed87 100644
--- a/include/linux/kernelcapi.h
+++ b/include/linux/kernelcapi.h
@@ -64,7 +64,7 @@ struct capi20_appl {
         unsigned long nrecvdatapkt;
         unsigned long nsentctlpkt;
         unsigned long nsentdatapkt;
-        struct semaphore recv_sem;
+        struct mutex recv_mtx;
         struct sk_buff_head recv_queue;
         struct work_struct recv_work;
         int release_in_progress;
diff --git a/include/linux/kmod.h b/include/linux/kmod.h
index 10f505c8431d..5dc13848891b 100644
--- a/include/linux/kmod.h
+++ b/include/linux/kmod.h
@@ -36,13 +36,57 @@ static inline int request_module(const char * name, ...) { return -ENOSYS; }
 #define try_then_request_module(x, mod...) ((x) ?: (request_module(mod), (x)))
 
 struct key;
-extern int call_usermodehelper_keys(char *path, char *argv[], char *envp[],
-                                    struct key *session_keyring, int wait);
+struct file;
+struct subprocess_info;
+
+/* Allocate a subprocess_info structure */
+struct subprocess_info *call_usermodehelper_setup(char *path,
+                                                  char **argv, char **envp);
+
+/* Set various pieces of state into the subprocess_info structure */
+void call_usermodehelper_setkeys(struct subprocess_info *info,
+                                 struct key *session_keyring);
+int call_usermodehelper_stdinpipe(struct subprocess_info *sub_info,
+                                  struct file **filp);
+void call_usermodehelper_setcleanup(struct subprocess_info *info,
+                                    void (*cleanup)(char **argv, char **envp));
+
+enum umh_wait {
+        UMH_NO_WAIT = -1,       /* don't wait at all */
+        UMH_WAIT_EXEC = 0,      /* wait for the exec, but not the process */
+        UMH_WAIT_PROC = 1,      /* wait for the process to complete */
+};
+
+/* Actually execute the sub-process */
+int call_usermodehelper_exec(struct subprocess_info *info, enum umh_wait wait);
+
+/* Free the subprocess_info. This is only needed if you're not going
+   to call call_usermodehelper_exec */
+void call_usermodehelper_freeinfo(struct subprocess_info *info);
 
 static inline int
-call_usermodehelper(char *path, char **argv, char **envp, int wait)
+call_usermodehelper(char *path, char **argv, char **envp, enum umh_wait wait)
 {
-        return call_usermodehelper_keys(path, argv, envp, NULL, wait);
+        struct subprocess_info *info;
+
+        info = call_usermodehelper_setup(path, argv, envp);
+        if (info == NULL)
+                return -ENOMEM;
+        return call_usermodehelper_exec(info, wait);
+}
+
+static inline int
+call_usermodehelper_keys(char *path, char **argv, char **envp,
+                         struct key *session_keyring, enum umh_wait wait)
+{
+        struct subprocess_info *info;
+
+        info = call_usermodehelper_setup(path, argv, envp);
+        if (info == NULL)
+                return -ENOMEM;
+
+        call_usermodehelper_setkeys(info, session_keyring);
+        return call_usermodehelper_exec(info, wait);
 }
 
 extern void usermodehelper_init(void);
diff --git a/include/linux/kobject.h b/include/linux/kobject.h
index c288e41ba331..aa2fe22b1baa 100644
--- a/include/linux/kobject.h
+++ b/include/linux/kobject.h
@@ -36,15 +36,24 @@ extern char uevent_helper[];
 /* counter to tag the uevent, read only except for the kobject core */
 extern u64 uevent_seqnum;
 
-/* the actions here must match the proper string in lib/kobject_uevent.c */
-typedef int __bitwise kobject_action_t;
+/*
+ * The actions here must match the index to the string array
+ * in lib/kobject_uevent.c
+ *
+ * Do not add new actions here without checking with the driver-core
+ * maintainers. Action strings are not meant to express subsystem
+ * or device specific properties. In most cases you want to send a
+ * kobject_uevent_env(kobj, KOBJ_CHANGE, env) with additional event
+ * specific variables added to the event environment.
+ */
 enum kobject_action {
-        KOBJ_ADD        = (__force kobject_action_t) 0x01,      /* exclusive to core */
-        KOBJ_REMOVE     = (__force kobject_action_t) 0x02,      /* exclusive to core */
-        KOBJ_CHANGE     = (__force kobject_action_t) 0x03,      /* device state change */
-        KOBJ_OFFLINE    = (__force kobject_action_t) 0x04,      /* device offline */
-        KOBJ_ONLINE     = (__force kobject_action_t) 0x05,      /* device online */
-        KOBJ_MOVE       = (__force kobject_action_t) 0x06,      /* device move */
+        KOBJ_ADD,
+        KOBJ_REMOVE,
+        KOBJ_CHANGE,
+        KOBJ_MOVE,
+        KOBJ_ONLINE,
+        KOBJ_OFFLINE,
+        KOBJ_MAX
 };
 
 struct kobject {
@@ -55,7 +64,7 @@ struct kobject {
         struct kobject          * parent;
         struct kset             * kset;
         struct kobj_type        * ktype;
-        struct dentry           * dentry;
+        struct sysfs_dirent     * sd;
         wait_queue_head_t       poll;
 };
 
@@ -71,13 +80,14 @@ extern void kobject_init(struct kobject *);
 extern void kobject_cleanup(struct kobject *);
 
 extern int __must_check kobject_add(struct kobject *);
-extern int __must_check kobject_shadow_add(struct kobject *, struct dentry *);
+extern int __must_check kobject_shadow_add(struct kobject *kobj,
+                                           struct sysfs_dirent *shadow_parent);
 extern void kobject_del(struct kobject *);
 
 extern int __must_check kobject_rename(struct kobject *, const char *new_name);
 extern int __must_check kobject_shadow_rename(struct kobject *kobj,
-                                                struct dentry *new_parent,
-                                                const char *new_name);
+                                              struct sysfs_dirent *new_parent,
+                                              const char *new_name);
 extern int __must_check kobject_move(struct kobject *, struct kobject *);
 
 extern int __must_check kobject_register(struct kobject *);
diff --git a/include/linux/kprobes.h b/include/linux/kprobes.h
index 23adf6075ae4..51464d12a4e5 100644
--- a/include/linux/kprobes.h
+++ b/include/linux/kprobes.h
@@ -116,9 +116,12 @@ struct kprobe {
  */
 struct jprobe {
         struct kprobe kp;
-        kprobe_opcode_t *entry; /* probe handling code to jump to */
+        void *entry;    /* probe handling code to jump to */
 };
 
+/* For backward compatibility with old code using JPROBE_ENTRY() */
+#define JPROBE_ENTRY(handler)   (handler)
+
 DECLARE_PER_CPU(struct kprobe *, current_kprobe);
 DECLARE_PER_CPU(struct kprobe_ctlblk, kprobe_ctlblk);
 
@@ -211,6 +214,7 @@ int longjmp_break_handler(struct kprobe *, struct pt_regs *);
 int register_jprobe(struct jprobe *p);
 void unregister_jprobe(struct jprobe *p);
 void jprobe_return(void);
+unsigned long arch_deref_entry_point(void *);
 
 int register_kretprobe(struct kretprobe *rp);
 void unregister_kretprobe(struct kretprobe *rp);
diff --git a/include/linux/ktime.h b/include/linux/ktime.h
index 2b139f66027f..dae7143644fe 100644
--- a/include/linux/ktime.h
+++ b/include/linux/ktime.h
@@ -279,6 +279,16 @@ static inline s64 ktime_to_us(const ktime_t kt)
         return (s64) tv.tv_sec * USEC_PER_SEC + tv.tv_usec;
 }
 
+static inline s64 ktime_us_delta(const ktime_t later, const ktime_t earlier)
+{
+       return ktime_to_us(ktime_sub(later, earlier));
+}
+
+static inline ktime_t ktime_add_us(const ktime_t kt, const u64 usec)
+{
+        return ktime_add_ns(kt, usec * 1000);
+}
+
 /*
  * The resolution of the clocks. The resolution value is returned in
  * the clock_getres() system call to give application programmers an
diff --git a/include/linux/lcd.h b/include/linux/lcd.h
index 598793c0745b..1d379787f2e7 100644
--- a/include/linux/lcd.h
+++ b/include/linux/lcd.h
@@ -62,8 +62,8 @@ struct lcd_device {
         struct mutex update_lock;
         /* The framebuffer notifier block */
         struct notifier_block fb_notif;
-        /* The class device structure */
-        struct class_device class_dev;
+
+        struct device dev;
 };
 
 static inline void lcd_set_power(struct lcd_device *ld, int power)
@@ -75,9 +75,15 @@ static inline void lcd_set_power(struct lcd_device *ld, int power)
 }
 
 extern struct lcd_device *lcd_device_register(const char *name,
-        void *devdata, struct lcd_ops *ops);
+        struct device *parent, void *devdata, struct lcd_ops *ops);
 extern void lcd_device_unregister(struct lcd_device *ld);
 
-#define to_lcd_device(obj) container_of(obj, struct lcd_device, class_dev)
+#define to_lcd_device(obj) container_of(obj, struct lcd_device, dev)
+
+static inline void * lcd_get_data(struct lcd_device *ld_dev)
+{
+        return dev_get_drvdata(&ld_dev->dev);
+}
+
 
 #endif
diff --git a/include/linux/leds.h b/include/linux/leds.h
index 88afceffb7cb..421175092ee2 100644
--- a/include/linux/leds.h
+++ b/include/linux/leds.h
@@ -13,10 +13,8 @@
 #define __LINUX_LEDS_H_INCLUDED
 
 #include <linux/list.h>
-#include <linux/spinlock.h>
 
 struct device;
-struct class_device;
 /*
  * LED Core
  */
@@ -38,7 +36,7 @@ struct led_classdev {
         void            (*brightness_set)(struct led_classdev *led_cdev,
                                           enum led_brightness brightness);
 
-        struct class_device     *class_dev;
+        struct device           *dev;
         struct list_head         node;                  /* LED Device list */
         char                    *default_trigger;       /* Trigger to use */
 
@@ -110,4 +108,18 @@ extern void ledtrig_ide_activity(void);
 #define ledtrig_ide_activity() do {} while(0)
 #endif
 
+/* For the leds-gpio driver */
+struct gpio_led {
+        const char *name;
+        char *default_trigger;
+        unsigned        gpio;
+        u8              active_low;
+};
+
+struct gpio_led_platform_data {
+        int             num_leds;
+        struct gpio_led *leds;
+};
+
+
 #endif          /* __LINUX_LEDS_H_INCLUDED */
diff --git a/include/linux/lguest.h b/include/linux/lguest.h
new file mode 100644
index 000000000000..500aace21ca7
--- /dev/null
+++ b/include/linux/lguest.h
@@ -0,0 +1,85 @@
+/* Things the lguest guest needs to know.  Note: like all lguest interfaces,
+ * this is subject to wild and random change between versions. */
+#ifndef _ASM_LGUEST_H
+#define _ASM_LGUEST_H
+
+#ifndef __ASSEMBLY__
+#include <asm/irq.h>
+
+#define LHCALL_FLUSH_ASYNC      0
+#define LHCALL_LGUEST_INIT      1
+#define LHCALL_CRASH            2
+#define LHCALL_LOAD_GDT         3
+#define LHCALL_NEW_PGTABLE      4
+#define LHCALL_FLUSH_TLB        5
+#define LHCALL_LOAD_IDT_ENTRY   6
+#define LHCALL_SET_STACK        7
+#define LHCALL_TS               8
+#define LHCALL_SET_CLOCKEVENT   9
+#define LHCALL_HALT             10
+#define LHCALL_GET_WALLCLOCK    11
+#define LHCALL_BIND_DMA         12
+#define LHCALL_SEND_DMA         13
+#define LHCALL_SET_PTE          14
+#define LHCALL_SET_PMD          15
+#define LHCALL_LOAD_TLS         16
+
+#define LG_CLOCK_MIN_DELTA      100UL
+#define LG_CLOCK_MAX_DELTA      ULONG_MAX
+
+#define LGUEST_TRAP_ENTRY 0x1F
+
+static inline unsigned long
+hcall(unsigned long call,
+      unsigned long arg1, unsigned long arg2, unsigned long arg3)
+{
+        asm volatile("int $" __stringify(LGUEST_TRAP_ENTRY)
+                     : "=a"(call)
+                     : "a"(call), "d"(arg1), "b"(arg2), "c"(arg3)
+                     : "memory");
+        return call;
+}
+
+void async_hcall(unsigned long call,
+                 unsigned long arg1, unsigned long arg2, unsigned long arg3);
+
+/* Can't use our min() macro here: needs to be a constant */
+#define LGUEST_IRQS (NR_IRQS < 32 ? NR_IRQS: 32)
+
+#define LHCALL_RING_SIZE 64
+struct hcall_ring
+{
+        u32 eax, edx, ebx, ecx;
+};
+
+/* All the good stuff happens here: guest registers it with LGUEST_INIT */
+struct lguest_data
+{
+/* Fields which change during running: */
+        /* 512 == enabled (same as eflags) */
+        unsigned int irq_enabled;
+        /* Interrupts blocked by guest. */
+        DECLARE_BITMAP(blocked_interrupts, LGUEST_IRQS);
+
+        /* Virtual address of page fault. */
+        unsigned long cr2;
+
+        /* Async hypercall ring.  0xFF == done, 0 == pending. */
+        u8 hcall_status[LHCALL_RING_SIZE];
+        struct hcall_ring hcalls[LHCALL_RING_SIZE];
+
+/* Fields initialized by the hypervisor at boot: */
+        /* Memory not to try to access */
+        unsigned long reserve_mem;
+        /* ID of this guest (used by network driver to set ethernet address) */
+        u16 guestid;
+        /* KHz for the TSC clock. */
+        u32 tsc_khz;
+
+/* Fields initialized by the guest at boot: */
+        /* Instruction range to suppress interrupts even if enabled */
+        unsigned long noirq_start, noirq_end;
+};
+extern struct lguest_data lguest_data;
+#endif /* __ASSEMBLY__ */
+#endif  /* _ASM_LGUEST_H */
diff --git a/include/linux/lguest_bus.h b/include/linux/lguest_bus.h
new file mode 100644
index 000000000000..c9b4e05fee49
--- /dev/null
+++ b/include/linux/lguest_bus.h
@@ -0,0 +1,48 @@
+#ifndef _ASM_LGUEST_DEVICE_H
+#define _ASM_LGUEST_DEVICE_H
+/* Everything you need to know about lguest devices. */
+#include <linux/device.h>
+#include <linux/lguest.h>
+#include <linux/lguest_launcher.h>
+
+struct lguest_device {
+        /* Unique busid, and index into lguest_page->devices[] */
+        unsigned int index;
+
+        struct device dev;
+
+        /* Driver can hang data off here. */
+        void *private;
+};
+
+/* By convention, each device can use irq index+1 if it wants to. */
+static inline int lgdev_irq(const struct lguest_device *dev)
+{
+        return dev->index + 1;
+}
+
+/* dma args must not be vmalloced! */
+void lguest_send_dma(unsigned long key, struct lguest_dma *dma);
+int lguest_bind_dma(unsigned long key, struct lguest_dma *dmas,
+                    unsigned int num, u8 irq);
+void lguest_unbind_dma(unsigned long key, struct lguest_dma *dmas);
+
+/* Map the virtual device space */
+void *lguest_map(unsigned long phys_addr, unsigned long pages);
+void lguest_unmap(void *);
+
+struct lguest_driver {
+        const char *name;
+        struct module *owner;
+        u16 device_type;
+        int (*probe)(struct lguest_device *dev);
+        void (*remove)(struct lguest_device *dev);
+
+        struct device_driver drv;
+};
+
+extern int register_lguest_driver(struct lguest_driver *drv);
+extern void unregister_lguest_driver(struct lguest_driver *drv);
+
+extern struct lguest_device_desc *lguest_devices; /* Just past max_pfn */
+#endif /* _ASM_LGUEST_DEVICE_H */
diff --git a/include/linux/lguest_launcher.h b/include/linux/lguest_launcher.h
new file mode 100644
index 000000000000..0ba414a40c80
--- /dev/null
+++ b/include/linux/lguest_launcher.h
@@ -0,0 +1,73 @@
+#ifndef _ASM_LGUEST_USER
+#define _ASM_LGUEST_USER
+/* Everything the "lguest" userspace program needs to know. */
+/* They can register up to 32 arrays of lguest_dma. */
+#define LGUEST_MAX_DMA          32
+/* At most we can dma 16 lguest_dma in one op. */
+#define LGUEST_MAX_DMA_SECTIONS 16
+
+/* How many devices?  Assume each one wants up to two dma arrays per device. */
+#define LGUEST_MAX_DEVICES (LGUEST_MAX_DMA/2)
+
+struct lguest_dma
+{
+        /* 0 if free to be used, filled by hypervisor. */
+        u32 used_len;
+        unsigned long addr[LGUEST_MAX_DMA_SECTIONS];
+        u16 len[LGUEST_MAX_DMA_SECTIONS];
+};
+
+struct lguest_block_page
+{
+        /* 0 is a read, 1 is a write. */
+        int type;
+        u32 sector;     /* Offset in device = sector * 512. */
+        u32 bytes;      /* Length expected to be read/written in bytes */
+        /* 0 = pending, 1 = done, 2 = done, error */
+        int result;
+        u32 num_sectors; /* Disk length = num_sectors * 512 */
+};
+
+/* There is a shared page of these. */
+struct lguest_net
+{
+        /* Simply the mac address (with multicast bit meaning promisc). */
+        unsigned char mac[6];
+};
+
+/* Where the Host expects the Guest to SEND_DMA console output to. */
+#define LGUEST_CONSOLE_DMA_KEY 0
+
+/* We have a page of these descriptors in the lguest_device page. */
+struct lguest_device_desc {
+        u16 type;
+#define LGUEST_DEVICE_T_CONSOLE 1
+#define LGUEST_DEVICE_T_NET     2
+#define LGUEST_DEVICE_T_BLOCK   3
+
+        u16 features;
+#define LGUEST_NET_F_NOCSUM             0x4000 /* Don't bother checksumming */
+#define LGUEST_DEVICE_F_RANDOMNESS      0x8000 /* IRQ is fairly random */
+
+        u16 status;
+/* 256 and above are device specific. */
+#define LGUEST_DEVICE_S_ACKNOWLEDGE     1 /* We have seen device. */
+#define LGUEST_DEVICE_S_DRIVER          2 /* We have found a driver */
+#define LGUEST_DEVICE_S_DRIVER_OK       4 /* Driver says OK! */
+#define LGUEST_DEVICE_S_REMOVED         8 /* Device has gone away. */
+#define LGUEST_DEVICE_S_REMOVED_ACK     16 /* Driver has been told. */
+#define LGUEST_DEVICE_S_FAILED          128 /* Something actually failed */
+
+        u16 num_pages;
+        u32 pfn;
+};
+
+/* Write command first word is a request. */
+enum lguest_req
+{
+        LHREQ_INITIALIZE, /* + pfnlimit, pgdir, start, pageoffset */
+        LHREQ_GETDMA, /* + addr (returns &lguest_dma, irq in ->used_len) */
+        LHREQ_IRQ, /* + irq */
+        LHREQ_BREAK, /* + on/off flag (on blocks until someone does off) */
+};
+#endif /* _ASM_LGUEST_USER */
diff --git a/include/linux/libata.h b/include/linux/libata.h
index a3df64677ac3..9aa6c10f7bb1 100644
--- a/include/linux/libata.h
+++ b/include/linux/libata.h
@@ -196,7 +196,6 @@ enum {
         ATA_PFLAG_SCSI_HOTPLUG  = (1 << 6), /* SCSI hotplug scheduled */
         ATA_PFLAG_INITIALIZING  = (1 << 7), /* being initialized, don't touch */
 
-        ATA_PFLAG_FLUSH_PORT_TASK = (1 << 16), /* flush port task */
         ATA_PFLAG_SUSPENDED     = (1 << 17), /* port is suspended (power) */
         ATA_PFLAG_PM_PENDING    = (1 << 18), /* PM operation pending */
         ATA_PFLAG_GTM_VALID     = (1 << 19), /* acpi_gtm data valid */
@@ -324,6 +323,7 @@ enum ata_completion_errors {
         AC_ERR_INVALID          = (1 << 7), /* invalid argument */
         AC_ERR_OTHER            = (1 << 8), /* unknown */
         AC_ERR_NODEV_HINT       = (1 << 9), /* polling device detection hint */
+        AC_ERR_NCQ              = (1 << 10), /* marker for offending NCQ qc */
 };
 
 /* forward declarations */
@@ -412,6 +412,7 @@ struct ata_queued_cmd {
         ata_qc_cb_t             complete_fn;
 
         void                    *private_data;
+        void                    *lldd_task;
 };
 
 struct ata_port_stats {
@@ -435,6 +436,7 @@ struct ata_device {
         struct ata_port         *ap;
         unsigned int            devno;          /* 0 or 1 */
         unsigned long           flags;          /* ATA_DFLAG_xxx */
+        unsigned int            horkage;        /* List of broken features */
         struct scsi_device      *sdev;          /* attached SCSI device */
 #ifdef CONFIG_ATA_ACPI
         acpi_handle             acpi_handle;
@@ -466,7 +468,6 @@ struct ata_device {
         /* error history */
         struct ata_ering        ering;
         int                     spdn_cnt;
-        unsigned int            horkage;        /* List of broken features */
 };
 
 /* Offset into struct ata_device.  Fields above it are maintained
@@ -531,6 +532,7 @@ struct ata_port {
         unsigned int            cbl;    /* cable type; ATA_CBL_xxx */
         unsigned int            hw_sata_spd_limit;
         unsigned int            sata_spd_limit; /* SATA PHY speed limit */
+        unsigned int            sata_spd;       /* current SATA PHY speed */
 
         /* record runtime error info, protected by host lock */
         struct ata_eh_info      eh_info;
@@ -564,6 +566,9 @@ struct ata_port {
         pm_message_t            pm_mesg;
         int                     *pm_result;
 
+        struct timer_list       fastdrain_timer;
+        unsigned long           fastdrain_cnt;
+
         void                    *private_data;
 
 #ifdef CONFIG_ATA_ACPI
@@ -620,9 +625,8 @@ struct ata_port_operations {
         u8 (*irq_on) (struct ata_port *);
         u8 (*irq_ack) (struct ata_port *ap, unsigned int chk_drq);
 
-        u32 (*scr_read) (struct ata_port *ap, unsigned int sc_reg);
-        void (*scr_write) (struct ata_port *ap, unsigned int sc_reg,
-                           u32 val);
+        int (*scr_read) (struct ata_port *ap, unsigned int sc_reg, u32 *val);
+        int (*scr_write) (struct ata_port *ap, unsigned int sc_reg, u32 val);
 
         int (*port_suspend) (struct ata_port *ap, pm_message_t mesg);
         int (*port_resume) (struct ata_port *ap);
@@ -765,7 +769,8 @@ extern unsigned int ata_dev_try_classify(struct ata_port *, unsigned int, u8 *);
  */
 extern void ata_tf_load(struct ata_port *ap, const struct ata_taskfile *tf);
 extern void ata_tf_read(struct ata_port *ap, struct ata_taskfile *tf);
-extern void ata_tf_to_fis(const struct ata_taskfile *tf, u8 *fis, u8 pmp);
+extern void ata_tf_to_fis(const struct ata_taskfile *tf,
+                          u8 pmp, int is_cmd, u8 *fis);
 extern void ata_tf_from_fis(const u8 *fis, struct ata_taskfile *tf);
 extern void ata_noop_dev_select (struct ata_port *ap, unsigned int device);
 extern void ata_std_dev_select (struct ata_port *ap, unsigned int device);
@@ -794,7 +799,6 @@ extern void ata_id_string(const u16 *id, unsigned char *s,
 extern void ata_id_c_string(const u16 *id, unsigned char *s,
                             unsigned int ofs, unsigned int len);
 extern void ata_id_to_dma_mode(struct ata_device *dev, u8 unknown);
-extern unsigned long ata_device_blacklisted(const struct ata_device *dev);
 extern void ata_bmdma_setup (struct ata_queued_cmd *qc);
 extern void ata_bmdma_start (struct ata_queued_cmd *qc);
 extern void ata_bmdma_stop(struct ata_queued_cmd *qc);
@@ -871,11 +875,11 @@ struct pci_bits {
         unsigned long           val;
 };
 
-extern int ata_pci_init_native_host(struct ata_host *host);
+extern int ata_pci_init_sff_host(struct ata_host *host);
 extern int ata_pci_init_bmdma(struct ata_host *host);
-extern int ata_pci_prepare_native_host(struct pci_dev *pdev,
-                                const struct ata_port_info * const * ppi,
-                                struct ata_host **r_host);
+extern int ata_pci_prepare_sff_host(struct pci_dev *pdev,
+                                    const struct ata_port_info * const * ppi,
+                                    struct ata_host **r_host);
 extern int pci_test_config_bits(struct pci_dev *pdev, const struct pci_bits *bits);
 extern unsigned long ata_pci_default_filter(struct ata_device *, unsigned long);
 #endif /* CONFIG_PCI */
@@ -911,27 +915,21 @@ extern void ata_do_eh(struct ata_port *ap, ata_prereset_fn_t prereset,
 /*
  * ata_eh_info helpers
  */
-#define ata_ehi_push_desc(ehi, fmt, args...) do { \
-        (ehi)->desc_len += scnprintf((ehi)->desc + (ehi)->desc_len, \
-                                     ATA_EH_DESC_LEN - (ehi)->desc_len, \
-                                     fmt , ##args); \
-} while (0)
-
-#define ata_ehi_clear_desc(ehi) do { \
-        (ehi)->desc[0] = '\0'; \
-        (ehi)->desc_len = 0; \
-} while (0)
-
-static inline void __ata_ehi_hotplugged(struct ata_eh_info *ehi)
+extern void __ata_ehi_push_desc(struct ata_eh_info *ehi, const char *fmt, ...);
+extern void ata_ehi_push_desc(struct ata_eh_info *ehi, const char *fmt, ...);
+extern void ata_ehi_clear_desc(struct ata_eh_info *ehi);
+
+static inline void ata_ehi_schedule_probe(struct ata_eh_info *ehi)
 {
-        ehi->flags |= ATA_EHI_HOTPLUGGED | ATA_EHI_RESUME_LINK;
+        ehi->flags |= ATA_EHI_RESUME_LINK;
         ehi->action |= ATA_EH_SOFTRESET;
         ehi->probe_mask |= (1 << ATA_MAX_DEVICES) - 1;
 }
 
 static inline void ata_ehi_hotplugged(struct ata_eh_info *ehi)
 {
-        __ata_ehi_hotplugged(ehi);
+        ata_ehi_schedule_probe(ehi);
+        ehi->flags |= ATA_EHI_HOTPLUGGED;
         ehi->err_mask |= AC_ERR_ATA_BUS;
 }
 
diff --git a/include/linux/limits.h b/include/linux/limits.h
index eaf2e099f125..2d0f94162fb3 100644
--- a/include/linux/limits.h
+++ b/include/linux/limits.h
@@ -5,8 +5,6 @@
 
 #define NGROUPS_MAX    65536    /* supplemental group IDs are available */
 #define ARG_MAX       131072    /* # bytes of args + environ for exec() */
-#define CHILD_MAX        999    /* no limit :-) */
-#define OPEN_MAX         256    /* # open files a process may have */
 #define LINK_MAX         127    /* # links a file may have */
 #define MAX_CANON        255    /* size of the canonical input queue */
 #define MAX_INPUT        255    /* size of the type-ahead buffer */
diff --git a/include/linux/linux_logo.h b/include/linux/linux_logo.h
index 9c01bde5bf1b..08a92969c76e 100644
--- a/include/linux/linux_logo.h
+++ b/include/linux/linux_logo.h
@@ -33,5 +33,13 @@ struct linux_logo {
 };
 
 extern const struct linux_logo *fb_find_logo(int depth);
+#ifdef CONFIG_FB_LOGO_EXTRA
+extern void fb_append_extra_logo(const struct linux_logo *logo,
+                                 unsigned int n);
+#else
+static inline void fb_append_extra_logo(const struct linux_logo *logo,
+                                        unsigned int n)
+{}
+#endif
 
 #endif /* _LINUX_LINUX_LOGO_H */
diff --git a/include/linux/lockd/bind.h b/include/linux/lockd/bind.h
index 246de1d84a26..6f1637c61e10 100644
--- a/include/linux/lockd/bind.h
+++ b/include/linux/lockd/bind.h
@@ -27,6 +27,7 @@ struct nlmsvc_binding {
                                                 struct nfs_fh *,
                                                 struct file **);
         void                    (*fclose)(struct file *);
+        unsigned long           (*get_grace_period)(void);
 };
 
 extern struct nlmsvc_binding *  nlmsvc_ops;
@@ -38,4 +39,12 @@ extern int	nlmclnt_proc(struct inode *, int, struct file_lock *);
 extern int      lockd_up(int proto);
 extern void     lockd_down(void);
 
+unsigned long get_nfs_grace_period(void);
+
+#ifdef CONFIG_NFSD_V4
+unsigned long get_nfs4_grace_period(void);
+#else
+static inline unsigned long get_nfs4_grace_period(void) {return 0;}
+#endif
+
 #endif /* LINUX_LOCKD_BIND_H */
diff --git a/include/linux/lockd/lockd.h b/include/linux/lockd/lockd.h
index 05707e2fccae..e2d1ce36b367 100644
--- a/include/linux/lockd/lockd.h
+++ b/include/linux/lockd/lockd.h
@@ -39,6 +39,7 @@
 struct nlm_host {
         struct hlist_node       h_hash;         /* doubly linked list */
         struct sockaddr_in      h_addr;         /* peer address */
+        struct sockaddr_in      h_saddr;        /* our address (optional) */
         struct rpc_clnt *       h_rpcclnt;      /* RPC client to talk to peer */
         char *                  h_name;         /* remote hostname */
         u32                     h_version;      /* interface version */
diff --git a/include/linux/lockdep.h b/include/linux/lockdep.h
index 14c937d345cb..0e843bf65877 100644
--- a/include/linux/lockdep.h
+++ b/include/linux/lockdep.h
@@ -1,7 +1,8 @@
 /*
  * Runtime locking correctness validator
  *
- *  Copyright (C) 2006 Red Hat, Inc., Ingo Molnar <mingo@redhat.com>
+ *  Copyright (C) 2006,2007 Red Hat, Inc., Ingo Molnar <mingo@redhat.com>
+ *  Copyright (C) 2007 Red Hat, Inc., Peter Zijlstra <pzijlstr@redhat.com>
  *
  * see Documentation/lockdep-design.txt for more details.
  */
@@ -9,6 +10,7 @@
 #define __LINUX_LOCKDEP_H
 
 struct task_struct;
+struct lockdep_map;
 
 #ifdef CONFIG_LOCKDEP
 
@@ -114,8 +116,44 @@ struct lock_class {
 
         const char                      *name;
         int                             name_version;
+
+#ifdef CONFIG_LOCK_STAT
+        unsigned long                   contention_point[4];
+#endif
+};
+
+#ifdef CONFIG_LOCK_STAT
+struct lock_time {
+        s64                             min;
+        s64                             max;
+        s64                             total;
+        unsigned long                   nr;
+};
+
+enum bounce_type {
+        bounce_acquired_write,
+        bounce_acquired_read,
+        bounce_contended_write,
+        bounce_contended_read,
+        nr_bounce_types,
+
+        bounce_acquired = bounce_acquired_write,
+        bounce_contended = bounce_contended_write,
 };
 
+struct lock_class_stats {
+        unsigned long                   contention_point[4];
+        struct lock_time                read_waittime;
+        struct lock_time                write_waittime;
+        struct lock_time                read_holdtime;
+        struct lock_time                write_holdtime;
+        unsigned long                   bounces[nr_bounce_types];
+};
+
+struct lock_class_stats lock_stats(struct lock_class *class);
+void clear_lock_stats(struct lock_class *class);
+#endif
+
 /*
  * Map the lock object (the lock instance) to the lock-class object.
  * This is embedded into specific lock instances:
@@ -124,6 +162,9 @@ struct lockdep_map {
         struct lock_class_key           *key;
         struct lock_class               *class_cache;
         const char                      *name;
+#ifdef CONFIG_LOCK_STAT
+        int                             cpu;
+#endif
 };
 
 /*
@@ -165,6 +206,10 @@ struct held_lock {
         unsigned long                   acquire_ip;
         struct lockdep_map              *instance;
 
+#ifdef CONFIG_LOCK_STAT
+        u64                             waittime_stamp;
+        u64                             holdtime_stamp;
+#endif
         /*
          * The lock-stack is unified in that the lock chains of interrupt
          * contexts nest ontop of process context chains, but we 'separate'
@@ -281,6 +326,30 @@ struct lock_class_key { };
 
 #endif /* !LOCKDEP */
 
+#ifdef CONFIG_LOCK_STAT
+
+extern void lock_contended(struct lockdep_map *lock, unsigned long ip);
+extern void lock_acquired(struct lockdep_map *lock);
+
+#define LOCK_CONTENDED(_lock, try, lock)                        \
+do {                                                            \
+        if (!try(_lock)) {                                      \
+                lock_contended(&(_lock)->dep_map, _RET_IP_);    \
+                lock(_lock);                                    \
+        }                                                       \
+        lock_acquired(&(_lock)->dep_map);                       \
+} while (0)
+
+#else /* CONFIG_LOCK_STAT */
+
+#define lock_contended(lockdep_map, ip) do {} while (0)
+#define lock_acquired(lockdep_map) do {} while (0)
+
+#define LOCK_CONTENDED(_lock, try, lock) \
+        lock(_lock)
+
+#endif /* CONFIG_LOCK_STAT */
+
 #if defined(CONFIG_TRACE_IRQFLAGS) && defined(CONFIG_GENERIC_HARDIRQS)
 extern void early_init_irq_lock_class(void);
 #else
diff --git a/include/linux/lzo.h b/include/linux/lzo.h
index 582d8b711a13..d793497ec1ca 100644
--- a/include/linux/lzo.h
+++ b/include/linux/lzo.h
@@ -17,7 +17,7 @@
 #define LZO1X_MEM_COMPRESS      (16384 * sizeof(unsigned char *))
 #define LZO1X_1_MEM_COMPRESS    LZO1X_MEM_COMPRESS
 
-#define lzo1x_worst_compress(x) (x + (x / 64) + 16 + 3)
+#define lzo1x_worst_compress(x) ((x) + ((x) / 16) + 64 + 3)
 
 /* This requires 'workmem' of size LZO1X_1_MEM_COMPRESS */
 int lzo1x_1_compress(const unsigned char *src, size_t src_len,
diff --git a/include/linux/magic.h b/include/linux/magic.h
index 9d713c03e3da..36cc20dfd142 100644
--- a/include/linux/magic.h
+++ b/include/linux/magic.h
@@ -13,7 +13,6 @@
 #define HPFS_SUPER_MAGIC        0xf995e849
 #define ISOFS_SUPER_MAGIC       0x9660
 #define JFFS2_SUPER_MAGIC       0x72b6
-#define KVMFS_SUPER_MAGIC       0x19700426
 #define ANON_INODE_FS_MAGIC     0x09041934
 
 #define MINIX_SUPER_MAGIC       0x137F          /* original minix fs */
diff --git a/include/linux/major.h b/include/linux/major.h
index 7e7c9093919a..0cb98053537a 100644
--- a/include/linux/major.h
+++ b/include/linux/major.h
@@ -158,6 +158,8 @@
 #define VXSPEC_MAJOR            200     /* VERITAS volume config driver */
 #define VXDMP_MAJOR             201     /* VERITAS volume multipath driver */
 
+#define XENVBD_MAJOR            202     /* Xen virtual block device */
+
 #define MSR_MAJOR               202
 #define CPUID_MAJOR             203
 
diff --git a/include/linux/mempolicy.h b/include/linux/mempolicy.h
index daabb3aa1ec6..e147cf50529f 100644
--- a/include/linux/mempolicy.h
+++ b/include/linux/mempolicy.h
@@ -159,7 +159,7 @@ extern void mpol_fix_fork_child_flag(struct task_struct *p);
 
 extern struct mempolicy default_policy;
 extern struct zonelist *huge_zonelist(struct vm_area_struct *vma,
-                unsigned long addr);
+                unsigned long addr, gfp_t gfp_flags);
 extern unsigned slab_node(struct mempolicy *policy);
 
 extern enum zone_type policy_zone;
@@ -256,9 +256,9 @@ 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,
-                unsigned long addr)
+                unsigned long addr, gfp_t gfp_flags)
 {
-        return NODE_DATA(0)->node_zonelists + gfp_zone(GFP_HIGHUSER);
+        return NODE_DATA(0)->node_zonelists + gfp_zone(gfp_flags);
 }
 
 static inline int do_migrate_pages(struct mm_struct *mm,
diff --git a/include/linux/mlx4/device.h b/include/linux/mlx4/device.h
index b372f5910fc1..cfb78fb2c046 100644
--- a/include/linux/mlx4/device.h
+++ b/include/linux/mlx4/device.h
@@ -172,6 +172,7 @@ struct mlx4_caps {
         int                     num_pds;
         int                     reserved_pds;
         int                     mtt_entry_sz;
+        u32                     max_msg_sz;
         u32                     page_size_cap;
         u32                     flags;
         u16                     stat_rate_support;
@@ -322,6 +323,7 @@ int mlx4_srq_alloc(struct mlx4_dev *dev, u32 pdn, struct mlx4_mtt *mtt,
                    u64 db_rec, struct mlx4_srq *srq);
 void mlx4_srq_free(struct mlx4_dev *dev, struct mlx4_srq *srq);
 int mlx4_srq_arm(struct mlx4_dev *dev, struct mlx4_srq *srq, int limit_watermark);
+int mlx4_srq_query(struct mlx4_dev *dev, struct mlx4_srq *srq, int *limit_watermark);
 
 int mlx4_INIT_PORT(struct mlx4_dev *dev, int port);
 int mlx4_CLOSE_PORT(struct mlx4_dev *dev, int port);
diff --git a/include/linux/mlx4/qp.h b/include/linux/mlx4/qp.h
index 10c57d279144..3968b943259a 100644
--- a/include/linux/mlx4/qp.h
+++ b/include/linux/mlx4/qp.h
@@ -282,6 +282,9 @@ int mlx4_qp_modify(struct mlx4_dev *dev, struct mlx4_mtt *mtt,
                    struct mlx4_qp_context *context, enum mlx4_qp_optpar optpar,
                    int sqd_event, struct mlx4_qp *qp);
 
+int mlx4_qp_query(struct mlx4_dev *dev, struct mlx4_qp *qp,
+                  struct mlx4_qp_context *context);
+
 static inline struct mlx4_qp *__mlx4_qp_lookup(struct mlx4_dev *dev, u32 qpn)
 {
         return radix_tree_lookup(&dev->qp_table_tree, qpn & (dev->caps.num_qps - 1));
diff --git a/include/linux/mm.h b/include/linux/mm.h
index 1c1207472bb4..c456c3a1c28e 100644
--- a/include/linux/mm.h
+++ b/include/linux/mm.h
@@ -2,7 +2,6 @@
 #define _LINUX_MM_H
 
 #include <linux/errno.h>
-#include <linux/capability.h>
 
 #ifdef __KERNEL__
 
@@ -27,7 +26,6 @@ extern unsigned long max_mapnr;
 
 extern unsigned long num_physpages;
 extern void * high_memory;
-extern unsigned long vmalloc_earlyreserve;
 extern int page_cluster;
 
 #ifdef CONFIG_SYSCTL
@@ -170,6 +168,8 @@ extern unsigned int kobjsize(const void *objp);
 #define VM_INSERTPAGE   0x02000000      /* The vma has had "vm_insert_page()" done on it */
 #define VM_ALWAYSDUMP   0x04000000      /* Always include in core dumps */
 
+#define VM_CAN_NONLINEAR 0x08000000     /* Has ->fault & does nonlinear pages */
+
 #ifndef VM_STACK_DEFAULT_FLAGS          /* arch can override this */
 #define VM_STACK_DEFAULT_FLAGS VM_DATA_DEFAULT_FLAGS
 #endif
@@ -192,6 +192,30 @@ extern unsigned int kobjsize(const void *objp);
  */
 extern pgprot_t protection_map[16];
 
+#define FAULT_FLAG_WRITE        0x01    /* Fault was a write access */
+#define FAULT_FLAG_NONLINEAR    0x02    /* Fault was via a nonlinear mapping */
+
+
+/*
+ * vm_fault is filled by the the pagefault handler and passed to the vma's
+ * ->fault function. The vma's ->fault is responsible for returning a bitmask
+ * of VM_FAULT_xxx flags that give details about how the fault was handled.
+ *
+ * pgoff should be used in favour of virtual_address, if possible. If pgoff
+ * is used, one may set VM_CAN_NONLINEAR in the vma->vm_flags to get nonlinear
+ * mapping support.
+ */
+struct vm_fault {
+        unsigned int flags;             /* FAULT_FLAG_xxx flags */
+        pgoff_t pgoff;                  /* Logical page offset based on vma */
+        void __user *virtual_address;   /* Faulting virtual address */
+
+        struct page *page;              /* ->fault handlers should return a
+                                         * page here, unless VM_FAULT_NOPAGE
+                                         * is set (which is also implied by
+                                         * VM_FAULT_ERROR).
+                                         */
+};
 
 /*
  * These are the virtual MM functions - opening of an area, closing and
@@ -201,9 +225,11 @@ extern pgprot_t protection_map[16];
 struct vm_operations_struct {
         void (*open)(struct vm_area_struct * area);
         void (*close)(struct vm_area_struct * area);
-        struct page * (*nopage)(struct vm_area_struct * area, unsigned long address, int *type);
-        unsigned long (*nopfn)(struct vm_area_struct * area, unsigned long address);
-        int (*populate)(struct vm_area_struct * area, unsigned long address, unsigned long len, pgprot_t prot, unsigned long pgoff, int nonblock);
+        int (*fault)(struct vm_area_struct *vma, struct vm_fault *vmf);
+        struct page *(*nopage)(struct vm_area_struct *area,
+                        unsigned long address, int *type);
+        unsigned long (*nopfn)(struct vm_area_struct *area,
+                        unsigned long address);
 
         /* notification that a previously read-only page is about to become
          * writable, if an error is returned it will cause a SIGBUS */
@@ -601,6 +627,7 @@ static inline struct address_space *page_mapping(struct page *page)
 {
         struct address_space *mapping = page->mapping;
 
+        VM_BUG_ON(PageSlab(page));
         if (unlikely(PageSwapCache(page)))
                 mapping = &swapper_space;
 #ifdef CONFIG_SLUB
@@ -656,7 +683,6 @@ static inline int page_mapped(struct page *page)
  */
 #define NOPAGE_SIGBUS   (NULL)
 #define NOPAGE_OOM      ((struct page *) (-1))
-#define NOPAGE_REFAULT  ((struct page *) (-2))  /* Return to userspace, rerun */
 
 /*
  * Error return values for the *_nopfn functions
@@ -670,16 +696,18 @@ static inline int page_mapped(struct page *page)
  * Used to decide whether a process gets delivered SIGBUS or
  * just gets major/minor fault counters bumped up.
  */
-#define VM_FAULT_OOM    0x00
-#define VM_FAULT_SIGBUS 0x01
-#define VM_FAULT_MINOR  0x02
-#define VM_FAULT_MAJOR  0x03
-
-/* 
- * Special case for get_user_pages.
- * Must be in a distinct bit from the above VM_FAULT_ flags.
- */
-#define VM_FAULT_WRITE  0x10
+
+#define VM_FAULT_MINOR  0 /* For backwards compat. Remove me quickly. */
+
+#define VM_FAULT_OOM    0x0001
+#define VM_FAULT_SIGBUS 0x0002
+#define VM_FAULT_MAJOR  0x0004
+#define VM_FAULT_WRITE  0x0008  /* Special case for get_user_pages */
+
+#define VM_FAULT_NOPAGE 0x0100  /* ->fault installed the pte, not return page */
+#define VM_FAULT_LOCKED 0x0200  /* ->fault locked the returned page */
+
+#define VM_FAULT_ERROR  (VM_FAULT_OOM | VM_FAULT_SIGBUS)
 
 #define offset_in_page(p)       ((unsigned long)(p) & ~PAGE_MASK)
 
@@ -763,20 +791,10 @@ static inline void unmap_shared_mapping_range(struct address_space *mapping,
 
 extern int vmtruncate(struct inode * inode, loff_t offset);
 extern int vmtruncate_range(struct inode * inode, loff_t offset, loff_t end);
-extern int install_page(struct mm_struct *mm, struct vm_area_struct *vma, unsigned long addr, struct page *page, pgprot_t prot);
-extern int install_file_pte(struct mm_struct *mm, struct vm_area_struct *vma, unsigned long addr, unsigned long pgoff, pgprot_t prot);
 
 #ifdef CONFIG_MMU
-extern int __handle_mm_fault(struct mm_struct *mm,struct vm_area_struct *vma,
+extern int handle_mm_fault(struct mm_struct *mm, struct vm_area_struct *vma,
                         unsigned long address, int write_access);
-
-static inline int handle_mm_fault(struct mm_struct *mm,
-                        struct vm_area_struct *vma, unsigned long address,
-                        int write_access)
-{
-        return __handle_mm_fault(mm, vma, address, write_access) &
-                                (~VM_FAULT_WRITE);
-}
 #else
 static inline int handle_mm_fault(struct mm_struct *mm,
                         struct vm_area_struct *vma, unsigned long address,
@@ -790,7 +808,6 @@ static inline int handle_mm_fault(struct mm_struct *mm,
 
 extern int make_pages_present(unsigned long addr, unsigned long end);
 extern int access_process_vm(struct task_struct *tsk, unsigned long addr, void *buf, int len, int write);
-void install_arg_page(struct vm_area_struct *, struct page *, unsigned long);
 
 int get_user_pages(struct task_struct *tsk, struct mm_struct *mm, unsigned long start,
                 int len, int write, int force, struct page **pages, struct vm_area_struct **vmas);
@@ -807,32 +824,42 @@ int FASTCALL(set_page_dirty(struct page *page));
 int set_page_dirty_lock(struct page *page);
 int clear_page_dirty_for_io(struct page *page);
 
+extern unsigned long move_page_tables(struct vm_area_struct *vma,
+                unsigned long old_addr, struct vm_area_struct *new_vma,
+                unsigned long new_addr, unsigned long len);
 extern unsigned long do_mremap(unsigned long addr,
                                unsigned long old_len, unsigned long new_len,
                                unsigned long flags, unsigned long new_addr);
+extern int mprotect_fixup(struct vm_area_struct *vma,
+                          struct vm_area_struct **pprev, unsigned long start,
+                          unsigned long end, unsigned long newflags);
 
 /*
- * Prototype to add a shrinker callback for ageable caches.
- * 
- * These functions are passed a count `nr_to_scan' and a gfpmask.  They should
- * scan `nr_to_scan' objects, attempting to free them.
+ * A callback you can register to apply pressure to ageable caches.
  *
- * The callback must return the number of objects which remain in the cache.
+ * 'shrink' is passed a count 'nr_to_scan' and a 'gfpmask'.  It should
+ * look through the least-recently-used 'nr_to_scan' entries and
+ * attempt to free them up.  It should return the number of objects
+ * which remain in the cache.  If it returns -1, it means it cannot do
+ * any scanning at this time (eg. there is a risk of deadlock).
  *
- * The callback will be passed nr_to_scan == 0 when the VM is querying the
- * cache size, so a fastpath for that case is appropriate.
- */
-typedef int (*shrinker_t)(int nr_to_scan, gfp_t gfp_mask);
-
-/*
- * Add an aging callback.  The int is the number of 'seeks' it takes
- * to recreate one of the objects that these functions age.
+ * The 'gfpmask' refers to the allocation we are currently trying to
+ * fulfil.
+ *
+ * Note that 'shrink' will be passed nr_to_scan == 0 when the VM is
+ * querying the cache size, so a fastpath for that case is appropriate.
  */
+struct shrinker {
+        int (*shrink)(int nr_to_scan, gfp_t gfp_mask);
+        int seeks;      /* seeks to recreate an obj */
 
-#define DEFAULT_SEEKS 2
-struct shrinker;
-extern struct shrinker *set_shrinker(int, shrinker_t);
-extern void remove_shrinker(struct shrinker *shrinker);
+        /* These are for internal use */
+        struct list_head list;
+        long nr;        /* objs pending delete */
+};
+#define DEFAULT_SEEKS 2 /* A good number if you don't know better. */
+extern void register_shrinker(struct shrinker *);
+extern void unregister_shrinker(struct shrinker *);
 
 /*
  * Some shared mappigns will want the pages marked read-only
@@ -1072,6 +1099,10 @@ extern unsigned long get_unmapped_area(struct file *, unsigned long, unsigned lo
 extern unsigned long do_mmap_pgoff(struct file *file, unsigned long addr,
         unsigned long len, unsigned long prot,
         unsigned long flag, unsigned long pgoff);
+extern unsigned long mmap_region(struct file *file, unsigned long addr,
+        unsigned long len, unsigned long flags,
+        unsigned int vm_flags, unsigned long pgoff,
+        int accountable);
 
 static inline unsigned long do_mmap(struct file *file, unsigned long addr,
         unsigned long len, unsigned long prot,
@@ -1097,9 +1128,7 @@ extern void truncate_inode_pages_range(struct address_space *,
                                        loff_t lstart, loff_t lend);
 
 /* generic vm_area_ops exported for stackable file systems */
-extern struct page *filemap_nopage(struct vm_area_struct *, unsigned long, int *);
-extern int filemap_populate(struct vm_area_struct *, unsigned long,
-                unsigned long, pgprot_t, unsigned long, int);
+extern int filemap_fault(struct vm_area_struct *, struct vm_fault *);
 
 /* mm/page-writeback.c */
 int write_one_page(struct page *page, int wait);
@@ -1114,13 +1143,20 @@ int do_page_cache_readahead(struct address_space *mapping, struct file *filp,
                         pgoff_t offset, unsigned long nr_to_read);
 int force_page_cache_readahead(struct address_space *mapping, struct file *filp,
                         pgoff_t offset, unsigned long nr_to_read);
-unsigned long page_cache_readahead(struct address_space *mapping,
-                          struct file_ra_state *ra,
-                          struct file *filp,
-                          pgoff_t offset,
-                          unsigned long size);
-void handle_ra_miss(struct address_space *mapping, 
-                    struct file_ra_state *ra, pgoff_t offset);
+
+void page_cache_sync_readahead(struct address_space *mapping,
+                               struct file_ra_state *ra,
+                               struct file *filp,
+                               pgoff_t offset,
+                               unsigned long size);
+
+void page_cache_async_readahead(struct address_space *mapping,
+                                struct file_ra_state *ra,
+                                struct file *filp,
+                                struct page *pg,
+                                pgoff_t offset,
+                                unsigned long size);
+
 unsigned long max_sane_readahead(unsigned long nr);
 
 /* Do stack extension */
@@ -1128,6 +1164,8 @@ extern int expand_stack(struct vm_area_struct *vma, unsigned long address);
 #ifdef CONFIG_IA64
 extern int expand_upwards(struct vm_area_struct *vma, unsigned long address);
 #endif
+extern int expand_stack_downwards(struct vm_area_struct *vma,
+                                  unsigned long address);
 
 /* Look up the first VMA which satisfies  addr < vm_end,  NULL if none. */
 extern struct vm_area_struct * find_vma(struct mm_struct * mm, unsigned long addr);
diff --git a/include/linux/mmzone.h b/include/linux/mmzone.h
index d09b1345a3a1..da8eb8ad9e9b 100644
--- a/include/linux/mmzone.h
+++ b/include/linux/mmzone.h
@@ -24,6 +24,14 @@
 #endif
 #define MAX_ORDER_NR_PAGES (1 << (MAX_ORDER - 1))
 
+/*
+ * PAGE_ALLOC_COSTLY_ORDER is the order at which allocations are deemed
+ * costly to service.  That is between allocation orders which should
+ * coelesce naturally under reasonable reclaim pressure and those which
+ * will not.
+ */
+#define PAGE_ALLOC_COSTLY_ORDER 3
+
 struct free_area {
         struct list_head        free_list;
         unsigned long           nr_free;
@@ -146,6 +154,7 @@ enum zone_type {
          */
         ZONE_HIGHMEM,
 #endif
+        ZONE_MOVABLE,
         MAX_NR_ZONES
 };
 
@@ -167,6 +176,7 @@ enum zone_type {
         + defined(CONFIG_ZONE_DMA32)    \
         + 1                             \
         + defined(CONFIG_HIGHMEM)       \
+        + 1                             \
 )
 #if __ZONE_COUNT < 2
 #define ZONES_SHIFT 0
@@ -499,10 +509,22 @@ static inline int populated_zone(struct zone *zone)
         return (!!zone->present_pages);
 }
 
+extern int movable_zone;
+
+static inline int zone_movable_is_highmem(void)
+{
+#if defined(CONFIG_HIGHMEM) && defined(CONFIG_ARCH_POPULATES_NODE_MAP)
+        return movable_zone == ZONE_HIGHMEM;
+#else
+        return 0;
+#endif
+}
+
 static inline int is_highmem_idx(enum zone_type idx)
 {
 #ifdef CONFIG_HIGHMEM
-        return (idx == ZONE_HIGHMEM);
+        return (idx == ZONE_HIGHMEM ||
+                (idx == ZONE_MOVABLE && zone_movable_is_highmem()));
 #else
         return 0;
 #endif
@@ -522,7 +544,9 @@ static inline int is_normal_idx(enum zone_type idx)
 static inline int is_highmem(struct zone *zone)
 {
 #ifdef CONFIG_HIGHMEM
-        return zone == zone->zone_pgdat->node_zones + ZONE_HIGHMEM;
+        int zone_idx = zone - zone->zone_pgdat->node_zones;
+        return zone_idx == ZONE_HIGHMEM ||
+                (zone_idx == ZONE_MOVABLE && zone_movable_is_highmem());
 #else
         return 0;
 #endif
@@ -566,6 +590,11 @@ int sysctl_min_unmapped_ratio_sysctl_handler(struct ctl_table *, int,
 int sysctl_min_slab_ratio_sysctl_handler(struct ctl_table *, int,
                         struct file *, void __user *, size_t *, loff_t *);
 
+extern int numa_zonelist_order_handler(struct ctl_table *, int,
+                        struct file *, void __user *, size_t *, loff_t *);
+extern char numa_zonelist_order[];
+#define NUMA_ZONELIST_ORDER_LEN 16      /* string buffer size */
+
 #include <linux/topology.h>
 /* Returns the number of the current Node. */
 #ifndef numa_node_id
diff --git a/include/linux/mnt_namespace.h b/include/linux/mnt_namespace.h
index 1fa4d9813b31..8eed44f8ca73 100644
--- a/include/linux/mnt_namespace.h
+++ b/include/linux/mnt_namespace.h
@@ -14,7 +14,7 @@ struct mnt_namespace {
         int event;
 };
 
-extern struct mnt_namespace *copy_mnt_ns(int, struct mnt_namespace *,
+extern struct mnt_namespace *copy_mnt_ns(unsigned long, struct mnt_namespace *,
                 struct fs_struct *);
 extern void __put_mnt_ns(struct mnt_namespace *ns);
 
diff --git a/include/linux/module.h b/include/linux/module.h
index e6e0f86ef5fc..b6a646cea1cb 100644
--- a/include/linux/module.h
+++ b/include/linux/module.h
@@ -6,7 +6,6 @@
  * Rewritten by Richard Henderson <rth@tamu.edu> Dec 1996
  * Rewritten again by Rusty Russell, 2002
  */
-#include <linux/spinlock.h>
 #include <linux/list.h>
 #include <linux/stat.h>
 #include <linux/compiler.h>
diff --git a/include/linux/msdos_fs.h b/include/linux/msdos_fs.h
index 0e09c005dda8..f950921523f5 100644
--- a/include/linux/msdos_fs.h
+++ b/include/linux/msdos_fs.h
@@ -146,7 +146,7 @@ struct fat_boot_fsinfo {
 };
 
 struct msdos_dir_entry {
-        __u8    name[8],ext[3]; /* name and extension */
+        __u8    name[MSDOS_NAME];/* name and extension */
         __u8    attr;           /* attribute bits */
         __u8    lcase;          /* Case for base and extension */
         __u8    ctime_cs;       /* Creation time, centiseconds (0-199) */
diff --git a/include/linux/namei.h b/include/linux/namei.h
index b7dd24917f0d..6c38efbd810f 100644
--- a/include/linux/namei.h
+++ b/include/linux/namei.h
@@ -69,8 +69,8 @@ extern int FASTCALL(__user_walk_fd(int dfd, const char __user *, unsigned, struc
 #define user_path_walk_link(name,nd) \
         __user_walk_fd(AT_FDCWD, name, 0, nd)
 extern int FASTCALL(path_lookup(const char *, unsigned, struct nameidata *));
-extern int FASTCALL(path_walk(const char *, struct nameidata *));
-extern int FASTCALL(link_path_walk(const char *, struct nameidata *));
+extern int vfs_path_lookup(struct dentry *, struct vfsmount *,
+                           const char *, unsigned int, struct nameidata *);
 extern void path_release(struct nameidata *);
 extern void path_release_on_umount(struct nameidata *);
 
diff --git a/include/linux/ncp_fs.h b/include/linux/ncp_fs.h
index 83e39eb054d3..88766e43e121 100644
--- a/include/linux/ncp_fs.h
+++ b/include/linux/ncp_fs.h
@@ -148,8 +148,6 @@ struct ncp_nls_ioctl
 #include <linux/ncp_fs_i.h>
 #include <linux/ncp_fs_sb.h>
 
-/* undef because public define in umsdos_fs.h (ncp_fs.h isn't public) */
-#undef PRINTK
 /* define because it is easy to change PRINTK to {*}PRINTK */
 #define PRINTK(format, args...) printk(KERN_DEBUG format , ## args)
 
diff --git a/include/linux/netdevice.h b/include/linux/netdevice.h
index 3a70f553b28f..4a616d73cc25 100644
--- a/include/linux/netdevice.h
+++ b/include/linux/netdevice.h
@@ -108,6 +108,14 @@ struct wireless_dev;
 #define MAX_HEADER (LL_MAX_HEADER + 48)
 #endif
 
+struct net_device_subqueue
+{
+        /* Give a control state for each queue.  This struct may contain
+         * per-queue locks in the future.
+         */
+        unsigned long   state;
+};
+
 /*
  *      Network device statistics. Akin to the 2.0 ether stats but
  *      with byte counters.
@@ -177,19 +185,25 @@ struct netif_rx_stats
 
 DECLARE_PER_CPU(struct netif_rx_stats, netdev_rx_stat);
 
+struct dev_addr_list
+{
+        struct dev_addr_list    *next;
+        u8                      da_addr[MAX_ADDR_LEN];
+        u8                      da_addrlen;
+        u8                      da_synced;
+        int                     da_users;
+        int                     da_gusers;
+};
 
 /*
  *      We tag multicasts with these structures.
  */
- 
-struct dev_mc_list
-{       
-        struct dev_mc_list      *next;
-        __u8                    dmi_addr[MAX_ADDR_LEN];
-        unsigned char           dmi_addrlen;
-        int                     dmi_users;
-        int                     dmi_gusers;
-};
+
+#define dev_mc_list     dev_addr_list
+#define dmi_addr        da_addr
+#define dmi_addrlen     da_addrlen
+#define dmi_users       da_users
+#define dmi_gusers      da_gusers
 
 struct hh_cache
 {
@@ -314,9 +328,10 @@ struct net_device
         /* Net device features */
         unsigned long           features;
 #define NETIF_F_SG              1       /* Scatter/gather IO. */
-#define NETIF_F_IP_CSUM         2       /* Can checksum only TCP/UDP over IPv4. */
+#define NETIF_F_IP_CSUM         2       /* Can checksum TCP/UDP over IPv4. */
 #define NETIF_F_NO_CSUM         4       /* Does not require checksum. F.e. loopack. */
 #define NETIF_F_HW_CSUM         8       /* Can checksum all the packets. */
+#define NETIF_F_IPV6_CSUM       16      /* Can checksum TCP/UDP over IPV6 */
 #define NETIF_F_HIGHDMA         32      /* Can DMA to high memory. */
 #define NETIF_F_FRAGLIST        64      /* Scatter/gather IO. */
 #define NETIF_F_HW_VLAN_TX      128     /* Transmit VLAN hw acceleration */
@@ -325,6 +340,7 @@ struct net_device
 #define NETIF_F_VLAN_CHALLENGED 1024    /* Device cannot handle VLAN packets */
 #define NETIF_F_GSO             2048    /* Enable software GSO. */
 #define NETIF_F_LLTX            4096    /* LockLess TX */
+#define NETIF_F_MULTI_QUEUE     16384   /* Has multiple TX/RX queues */
 
         /* Segmentation offload features */
 #define NETIF_F_GSO_SHIFT       16
@@ -338,8 +354,11 @@ struct net_device
         /* List of features with software fallbacks. */
 #define NETIF_F_GSO_SOFTWARE    (NETIF_F_TSO | NETIF_F_TSO_ECN | NETIF_F_TSO6)
 
+
 #define NETIF_F_GEN_CSUM        (NETIF_F_NO_CSUM | NETIF_F_HW_CSUM)
-#define NETIF_F_ALL_CSUM        (NETIF_F_IP_CSUM | NETIF_F_GEN_CSUM)
+#define NETIF_F_V4_CSUM         (NETIF_F_GEN_CSUM | NETIF_F_IP_CSUM)
+#define NETIF_F_V6_CSUM         (NETIF_F_GEN_CSUM | NETIF_F_IPV6_CSUM)
+#define NETIF_F_ALL_CSUM        (NETIF_F_V4_CSUM | NETIF_F_V6_CSUM)
 
         struct net_device       *next_sched;
 
@@ -388,7 +407,10 @@ struct net_device
         unsigned char           addr_len;       /* hardware address length      */
         unsigned short          dev_id;         /* for shared network cards */
 
-        struct dev_mc_list      *mc_list;       /* Multicast mac addresses      */
+        struct dev_addr_list    *uc_list;       /* Secondary unicast mac addresses */
+        int                     uc_count;       /* Number of installed ucasts   */
+        int                     uc_promisc;
+        struct dev_addr_list    *mc_list;       /* Multicast mac addresses      */
         int                     mc_count;       /* Number of installed mcasts   */
         int                     promiscuity;
         int                     allmulti;
@@ -493,6 +515,11 @@ struct net_device
                                                 void *saddr,
                                                 unsigned len);
         int                     (*rebuild_header)(struct sk_buff *skb);
+#define HAVE_CHANGE_RX_FLAGS
+        void                    (*change_rx_flags)(struct net_device *dev,
+                                                   int flags);
+#define HAVE_SET_RX_MODE
+        void                    (*set_rx_mode)(struct net_device *dev);
 #define HAVE_MULTICAST                   
         void                    (*set_multicast_list)(struct net_device *dev);
 #define HAVE_SET_MAC_ADDR                
@@ -535,22 +562,29 @@ struct net_device
 
         /* bridge stuff */
         struct net_bridge_port  *br_port;
+        /* macvlan */
+        struct macvlan_port     *macvlan_port;
 
         /* class/net/name entry */
         struct device           dev;
         /* space for optional statistics and wireless sysfs groups */
         struct attribute_group  *sysfs_groups[3];
+
+        /* rtnetlink link ops */
+        const struct rtnl_link_ops *rtnl_link_ops;
+
+        /* The TX queue control structures */
+        unsigned int                    egress_subqueue_count;
+        struct net_device_subqueue      egress_subqueue[1];
 };
 #define to_net_dev(d) container_of(d, struct net_device, dev)
 
 #define NETDEV_ALIGN            32
 #define NETDEV_ALIGN_CONST      (NETDEV_ALIGN - 1)
 
-static inline void *netdev_priv(struct net_device *dev)
+static inline void *netdev_priv(const struct net_device *dev)
 {
-        return (char *)dev + ((sizeof(struct net_device)
-                                        + NETDEV_ALIGN_CONST)
-                                & ~NETDEV_ALIGN_CONST);
+        return dev->priv;
 }
 
 #define SET_MODULE_OWNER(dev) do { } while (0)
@@ -702,6 +736,62 @@ static inline int netif_running(const struct net_device *dev)
         return test_bit(__LINK_STATE_START, &dev->state);
 }
 
+/*
+ * Routines to manage the subqueues on a device.  We only need start
+ * stop, and a check if it's stopped.  All other device management is
+ * done at the overall netdevice level.
+ * Also test the device if we're multiqueue.
+ */
+static inline void netif_start_subqueue(struct net_device *dev, u16 queue_index)
+{
+#ifdef CONFIG_NETDEVICES_MULTIQUEUE
+        clear_bit(__LINK_STATE_XOFF, &dev->egress_subqueue[queue_index].state);
+#endif
+}
+
+static inline void netif_stop_subqueue(struct net_device *dev, u16 queue_index)
+{
+#ifdef CONFIG_NETDEVICES_MULTIQUEUE
+#ifdef CONFIG_NETPOLL_TRAP
+        if (netpoll_trap())
+                return;
+#endif
+        set_bit(__LINK_STATE_XOFF, &dev->egress_subqueue[queue_index].state);
+#endif
+}
+
+static inline int netif_subqueue_stopped(const struct net_device *dev,
+                                         u16 queue_index)
+{
+#ifdef CONFIG_NETDEVICES_MULTIQUEUE
+        return test_bit(__LINK_STATE_XOFF,
+                        &dev->egress_subqueue[queue_index].state);
+#else
+        return 0;
+#endif
+}
+
+static inline void netif_wake_subqueue(struct net_device *dev, u16 queue_index)
+{
+#ifdef CONFIG_NETDEVICES_MULTIQUEUE
+#ifdef CONFIG_NETPOLL_TRAP
+        if (netpoll_trap())
+                return;
+#endif
+        if (test_and_clear_bit(__LINK_STATE_XOFF,
+                               &dev->egress_subqueue[queue_index].state))
+                __netif_schedule(dev);
+#endif
+}
+
+static inline int netif_is_multiqueue(const struct net_device *dev)
+{
+#ifdef CONFIG_NETDEVICES_MULTIQUEUE
+        return (!!(NETIF_F_MULTI_QUEUE & dev->features));
+#else
+        return 0;
+#endif
+}
 
 /* Use this variant when it is known for sure that it
  * is executing from interrupt context.
@@ -992,15 +1082,24 @@ static inline void netif_tx_disable(struct net_device *dev)
 extern void             ether_setup(struct net_device *dev);
 
 /* Support for loadable net-drivers */
-extern struct net_device *alloc_netdev(int sizeof_priv, const char *name,
-                                       void (*setup)(struct net_device *));
+extern struct net_device *alloc_netdev_mq(int sizeof_priv, const char *name,
+                                       void (*setup)(struct net_device *),
+                                       unsigned int queue_count);
+#define alloc_netdev(sizeof_priv, name, setup) \
+        alloc_netdev_mq(sizeof_priv, name, setup, 1)
 extern int              register_netdev(struct net_device *dev);
 extern void             unregister_netdev(struct net_device *dev);
-/* Functions used for multicast support */
-extern void             dev_mc_upload(struct net_device *dev);
+/* Functions used for secondary unicast and multicast support */
+extern void             dev_set_rx_mode(struct net_device *dev);
+extern void             __dev_set_rx_mode(struct net_device *dev);
+extern int              dev_unicast_delete(struct net_device *dev, void *addr, int alen);
+extern int              dev_unicast_add(struct net_device *dev, void *addr, int alen);
 extern int              dev_mc_delete(struct net_device *dev, void *addr, int alen, int all);
 extern int              dev_mc_add(struct net_device *dev, void *addr, int alen, int newonly);
-extern void             dev_mc_discard(struct net_device *dev);
+extern int              dev_mc_sync(struct net_device *to, struct net_device *from);
+extern void             dev_mc_unsync(struct net_device *to, struct net_device *from);
+extern int              __dev_addr_delete(struct dev_addr_list **list, int *count, void *addr, int alen, int all);
+extern int              __dev_addr_add(struct dev_addr_list **list, int *count, void *addr, int alen, int newonly);
 extern void             dev_set_promiscuity(struct net_device *dev, int inc);
 extern void             dev_set_allmulti(struct net_device *dev, int inc);
 extern void             netdev_state_change(struct net_device *dev);
diff --git a/include/linux/netfilter.h b/include/linux/netfilter.h
index 10b5c6275706..0eed0b7ab2df 100644
--- a/include/linux/netfilter.h
+++ b/include/linux/netfilter.h
@@ -275,7 +275,8 @@ struct nf_queue_handler {
 };
 extern int nf_register_queue_handler(int pf, 
                                      struct nf_queue_handler *qh);
-extern int nf_unregister_queue_handler(int pf);
+extern int nf_unregister_queue_handler(int pf,
+                                       struct nf_queue_handler *qh);
 extern void nf_unregister_queue_handlers(struct nf_queue_handler *qh);
 extern void nf_reinject(struct sk_buff *skb,
                         struct nf_info *info,
diff --git a/include/linux/netfilter/nf_conntrack_pptp.h b/include/linux/netfilter/nf_conntrack_pptp.h
index 9d8144a488cd..c93061f33144 100644
--- a/include/linux/netfilter/nf_conntrack_pptp.h
+++ b/include/linux/netfilter/nf_conntrack_pptp.h
@@ -4,6 +4,8 @@
 
 #include <linux/netfilter/nf_conntrack_common.h>
 
+extern const char *pptp_msg_name[];
+
 /* state of the control session */
 enum pptp_ctrlsess_state {
         PPTP_SESSION_NONE,                      /* no session present */
diff --git a/include/linux/netfilter/x_tables.h b/include/linux/netfilter/x_tables.h
index 7e733a6ba4f6..64f425a855bb 100644
--- a/include/linux/netfilter/x_tables.h
+++ b/include/linux/netfilter/x_tables.h
@@ -141,22 +141,22 @@ struct xt_match
         /* Arguments changed since 2.6.9, as this must now handle
            non-linear skb, using skb_header_pointer and
            skb_ip_make_writable. */
-        int (*match)(const struct sk_buff *skb,
-                     const struct net_device *in,
-                     const struct net_device *out,
-                     const struct xt_match *match,
-                     const void *matchinfo,
-                     int offset,
-                     unsigned int protoff,
-                     int *hotdrop);
+        bool (*match)(const struct sk_buff *skb,
+                      const struct net_device *in,
+                      const struct net_device *out,
+                      const struct xt_match *match,
+                      const void *matchinfo,
+                      int offset,
+                      unsigned int protoff,
+                      bool *hotdrop);
 
         /* Called when user tries to insert an entry of this type. */
         /* Should return true or false. */
-        int (*checkentry)(const char *tablename,
-                          const void *ip,
-                          const struct xt_match *match,
-                          void *matchinfo,
-                          unsigned int hook_mask);
+        bool (*checkentry)(const char *tablename,
+                           const void *ip,
+                           const struct xt_match *match,
+                           void *matchinfo,
+                           unsigned int hook_mask);
 
         /* Called when entry of this type deleted. */
         void (*destroy)(const struct xt_match *match, void *matchinfo);
@@ -202,11 +202,11 @@ struct xt_target
            hook_mask is a bitmask of hooks from which it can be
            called. */
         /* Should return true or false. */
-        int (*checkentry)(const char *tablename,
-                          const void *entry,
-                          const struct xt_target *target,
-                          void *targinfo,
-                          unsigned int hook_mask);
+        bool (*checkentry)(const char *tablename,
+                           const void *entry,
+                           const struct xt_target *target,
+                           void *targinfo,
+                           unsigned int hook_mask);
 
         /* Called when entry of this type deleted. */
         void (*destroy)(const struct xt_target *target, void *targinfo);
diff --git a/include/linux/netfilter/xt_connlimit.h b/include/linux/netfilter/xt_connlimit.h
new file mode 100644
index 000000000000..90ae8b474cb8
--- /dev/null
+++ b/include/linux/netfilter/xt_connlimit.h
@@ -0,0 +1,17 @@
+#ifndef _XT_CONNLIMIT_H
+#define _XT_CONNLIMIT_H
+
+struct xt_connlimit_data;
+
+struct xt_connlimit_info {
+        union {
+                u_int32_t v4_mask;
+                u_int32_t v6_mask[4];
+        };
+        unsigned int limit, inverse;
+
+        /* this needs to be at the end */
+        struct xt_connlimit_data *data __attribute__((aligned(8)));
+};
+
+#endif /* _XT_CONNLIMIT_H */
diff --git a/include/linux/netfilter/xt_u32.h b/include/linux/netfilter/xt_u32.h
new file mode 100644
index 000000000000..9947f56cdbdd
--- /dev/null
+++ b/include/linux/netfilter/xt_u32.h
@@ -0,0 +1,40 @@
+#ifndef _XT_U32_H
+#define _XT_U32_H 1
+
+enum xt_u32_ops {
+        XT_U32_AND,
+        XT_U32_LEFTSH,
+        XT_U32_RIGHTSH,
+        XT_U32_AT,
+};
+
+struct xt_u32_location_element {
+        u_int32_t number;
+        u_int8_t nextop;
+};
+
+struct xt_u32_value_element {
+        u_int32_t min;
+        u_int32_t max;
+};
+
+/*
+ * Any way to allow for an arbitrary number of elements?
+ * For now, I settle with a limit of 10 each.
+ */
+#define XT_U32_MAXSIZE 10
+
+struct xt_u32_test {
+        struct xt_u32_location_element location[XT_U32_MAXSIZE+1];
+        struct xt_u32_value_element value[XT_U32_MAXSIZE+1];
+        u_int8_t nnums;
+        u_int8_t nvalues;
+};
+
+struct xt_u32 {
+        struct xt_u32_test tests[XT_U32_MAXSIZE+1];
+        u_int8_t ntests;
+        u_int8_t invert;
+};
+
+#endif /* _XT_U32_H */
diff --git a/include/linux/netfilter_ipv4/ipt_CLUSTERIP.h b/include/linux/netfilter_ipv4/ipt_CLUSTERIP.h
index d9bceedfb3dc..daf50be22c9d 100644
--- a/include/linux/netfilter_ipv4/ipt_CLUSTERIP.h
+++ b/include/linux/netfilter_ipv4/ipt_CLUSTERIP.h
@@ -18,13 +18,13 @@ struct clusterip_config;
 struct ipt_clusterip_tgt_info {
 
         u_int32_t flags;
-        
+
         /* only relevant for new ones */
         u_int8_t clustermac[6];
         u_int16_t num_total_nodes;
         u_int16_t num_local_nodes;
         u_int16_t local_nodes[CLUSTERIP_MAX_NODES];
-        enum clusterip_hashmode hash_mode;
+        u_int32_t hash_mode;
         u_int32_t hash_initval;
 
         struct clusterip_config *config;
diff --git a/include/linux/netfilter_ipv4/ipt_iprange.h b/include/linux/netfilter_ipv4/ipt_iprange.h
index 34ab0fb736e2..a92fefc3c7ec 100644
--- a/include/linux/netfilter_ipv4/ipt_iprange.h
+++ b/include/linux/netfilter_ipv4/ipt_iprange.h
@@ -1,6 +1,8 @@
 #ifndef _IPT_IPRANGE_H
 #define _IPT_IPRANGE_H
 
+#include <linux/types.h>
+
 #define IPRANGE_SRC             0x01    /* Match source IP address */
 #define IPRANGE_DST             0x02    /* Match destination IP address */
 #define IPRANGE_SRC_INV         0x10    /* Negate the condition */
diff --git a/include/linux/netfilter_ipv6/ip6_tables.h b/include/linux/netfilter_ipv6/ip6_tables.h
index 4686f8342cbd..9a720f05888f 100644
--- a/include/linux/netfilter_ipv6/ip6_tables.h
+++ b/include/linux/netfilter_ipv6/ip6_tables.h
@@ -44,8 +44,14 @@ struct ip6t_ip6 {
         char iniface[IFNAMSIZ], outiface[IFNAMSIZ];
         unsigned char iniface_mask[IFNAMSIZ], outiface_mask[IFNAMSIZ];
 
-        /* ARGH, HopByHop uses 0, so can't do 0 = ANY,
-           instead IP6T_F_NOPROTO must be set */
+        /* Upper protocol number
+         * - The allowed value is 0 (any) or protocol number of last parsable
+         *   header, which is 50 (ESP), 59 (No Next Header), 135 (MH), or
+         *   the non IPv6 extension headers.
+         * - The protocol numbers of IPv6 extension headers except of ESP and
+         *   MH do not match any packets.
+         * - You also need to set IP6T_FLAGS_PROTO to "flags" to check protocol.
+         */
         u_int16_t proto;
         /* TOS to match iff flags & IP6T_F_TOS */
         u_int8_t tos;
diff --git a/include/linux/netlink.h b/include/linux/netlink.h
index 2e23353c28a5..83d8239f0cce 100644
--- a/include/linux/netlink.h
+++ b/include/linux/netlink.h
@@ -161,6 +161,8 @@ extern struct sock *netlink_kernel_create(int unit, unsigned int groups,
                                           void (*input)(struct sock *sk, int len),
                                           struct mutex *cb_mutex,
                                           struct module *module);
+extern int netlink_change_ngroups(struct sock *sk, unsigned int groups);
+extern void netlink_clear_multicast_users(struct sock *sk, unsigned int group);
 extern void netlink_ack(struct sk_buff *in_skb, struct nlmsghdr *nlh, int err);
 extern int netlink_has_listeners(struct sock *sk, unsigned int group);
 extern int netlink_unicast(struct sock *ssk, struct sk_buff *skb, __u32 pid, int nonblock);
diff --git a/include/linux/nfs4.h b/include/linux/nfs4.h
index 7e7f33a38fc0..8726491de154 100644
--- a/include/linux/nfs4.h
+++ b/include/linux/nfs4.h
@@ -15,6 +15,7 @@
 
 #include <linux/types.h>
 
+#define NFS4_BITMAP_SIZE        2
 #define NFS4_VERIFIER_SIZE      8
 #define NFS4_STATEID_SIZE       16
 #define NFS4_FHSIZE             128
diff --git a/include/linux/nfs4_mount.h b/include/linux/nfs4_mount.h
index 26b4c83f831d..a0dcf6655657 100644
--- a/include/linux/nfs4_mount.h
+++ b/include/linux/nfs4_mount.h
@@ -65,6 +65,7 @@ struct nfs4_mount_data {
 #define NFS4_MOUNT_NOCTO        0x0010  /* 1 */
 #define NFS4_MOUNT_NOAC         0x0020  /* 1 */
 #define NFS4_MOUNT_STRICTLOCK   0x1000  /* 1 */
-#define NFS4_MOUNT_FLAGMASK     0xFFFF
+#define NFS4_MOUNT_UNSHARED     0x8000  /* 1 */
+#define NFS4_MOUNT_FLAGMASK     0x9033
 
 #endif
diff --git a/include/linux/nfs_fs.h b/include/linux/nfs_fs.h
index 0543439a97af..9ba4aec37c50 100644
--- a/include/linux/nfs_fs.h
+++ b/include/linux/nfs_fs.h
@@ -30,7 +30,9 @@
 #ifdef __KERNEL__
 
 #include <linux/in.h>
+#include <linux/kref.h>
 #include <linux/mm.h>
+#include <linux/namei.h>
 #include <linux/pagemap.h>
 #include <linux/rbtree.h>
 #include <linux/rwsem.h>
@@ -69,9 +71,8 @@ struct nfs_access_entry {
 
 struct nfs4_state;
 struct nfs_open_context {
-        atomic_t count;
-        struct vfsmount *vfsmnt;
-        struct dentry *dentry;
+        struct kref kref;
+        struct path path;
         struct rpc_cred *cred;
         struct nfs4_state *state;
         fl_owner_t lockowner;
@@ -155,13 +156,9 @@ struct nfs_inode {
         /*
          * This is the list of dirty unwritten pages.
          */
-        spinlock_t              req_lock;
-        struct list_head        dirty;
-        struct list_head        commit;
         struct radix_tree_root  nfs_page_tree;
 
-        unsigned int            ndirty,
-                                ncommit,
+        unsigned long           ncommit,
                                 npages;
 
         /* Open contexts for shared mmap writes */
@@ -187,6 +184,7 @@ struct nfs_inode {
 #define NFS_INO_INVALID_ACCESS  0x0008          /* cached access cred invalid */
 #define NFS_INO_INVALID_ACL     0x0010          /* cached acls are invalid */
 #define NFS_INO_REVAL_PAGECACHE 0x0020          /* must revalidate pagecache */
+#define NFS_INO_REVAL_FORCED    0x0040          /* force revalidation ignoring a delegation */
 
 /*
  * Bit offsets in flags field
@@ -409,8 +407,8 @@ extern void nfs_release_automount_timer(void);
 /*
  * linux/fs/nfs/unlink.c
  */
-extern int  nfs_async_unlink(struct dentry *);
-extern void nfs_complete_unlink(struct dentry *);
+extern int  nfs_async_unlink(struct inode *dir, struct dentry *dentry);
+extern void nfs_complete_unlink(struct dentry *dentry, struct inode *);
 
 /*
  * linux/fs/nfs/write.c
@@ -496,21 +494,18 @@ static inline void nfs3_forget_cached_acls(struct inode *inode)
 
 /*
  * linux/fs/mount_clnt.c
- * (Used only by nfsroot module)
  */
-extern int  nfsroot_mount(struct sockaddr_in *, char *, struct nfs_fh *,
-                int, int);
+extern int  nfs_mount(struct sockaddr *, size_t, char *, char *,
+                      int, int, struct nfs_fh *);
 
 /*
  * inline functions
  */
 
-static inline loff_t
-nfs_size_to_loff_t(__u64 size)
+static inline loff_t nfs_size_to_loff_t(__u64 size)
 {
-        loff_t maxsz = (((loff_t) ULONG_MAX) << PAGE_CACHE_SHIFT) + PAGE_CACHE_SIZE - 1;
-        if (size > maxsz)
-                return maxsz;
+        if (size > (__u64) OFFSET_MAX - 1)
+                return OFFSET_MAX - 1;
         return (loff_t) size;
 }
 
@@ -557,6 +552,7 @@ extern void * nfs_root_data(void);
 #define NFSDBG_ROOT             0x0080
 #define NFSDBG_CALLBACK         0x0100
 #define NFSDBG_CLIENT           0x0200
+#define NFSDBG_MOUNT            0x0400
 #define NFSDBG_ALL              0xFFFF
 
 #ifdef __KERNEL__
diff --git a/include/linux/nfs_fs_sb.h b/include/linux/nfs_fs_sb.h
index 52b4378311c8..0cac49bc0955 100644
--- a/include/linux/nfs_fs_sb.h
+++ b/include/linux/nfs_fs_sb.h
@@ -16,7 +16,6 @@ struct nfs_client {
 #define NFS_CS_INITING          1               /* busy initialising */
         int                     cl_nfsversion;  /* NFS protocol version */
         unsigned long           cl_res_state;   /* NFS resources state */
-#define NFS_CS_RPCIOD           0               /* - rpciod started */
 #define NFS_CS_CALLBACK         1               /* - callback started */
 #define NFS_CS_IDMAP            2               /* - idmap started */
 #define NFS_CS_RENEWD           3               /* - renewd started */
@@ -35,7 +34,8 @@ struct nfs_client {
         nfs4_verifier           cl_confirm;
         unsigned long           cl_state;
 
-        u32                     cl_lockowner_id;
+        struct rb_root          cl_openowner_id;
+        struct rb_root          cl_lockowner_id;
 
         /*
          * The following rwsem ensures exclusive access to the server
@@ -44,9 +44,7 @@ struct nfs_client {
         struct rw_semaphore     cl_sem;
 
         struct list_head        cl_delegations;
-        struct list_head        cl_state_owners;
-        struct list_head        cl_unused;
-        int                     cl_nunused;
+        struct rb_root          cl_state_owners;
         spinlock_t              cl_lock;
 
         unsigned long           cl_lease_time;
diff --git a/include/linux/nfs_mount.h b/include/linux/nfs_mount.h
index cc8b9c59acb8..a3ade89a64d2 100644
--- a/include/linux/nfs_mount.h
+++ b/include/linux/nfs_mount.h
@@ -37,7 +37,7 @@ struct nfs_mount_data {
         int             acdirmin;               /* 1 */
         int             acdirmax;               /* 1 */
         struct sockaddr_in addr;                /* 1 */
-        char            hostname[256];          /* 1 */
+        char            hostname[NFS_MAXNAMLEN + 1];            /* 1 */
         int             namlen;                 /* 2 */
         unsigned int    bsize;                  /* 3 */
         struct nfs3_fh  root;                   /* 4 */
@@ -62,6 +62,7 @@ struct nfs_mount_data {
 #define NFS_MOUNT_STRICTLOCK    0x1000  /* reserved for NFSv4 */
 #define NFS_MOUNT_SECFLAVOUR    0x2000  /* 5 */
 #define NFS_MOUNT_NORDIRPLUS    0x4000  /* 5 */
+#define NFS_MOUNT_UNSHARED      0x8000  /* 5 */
 #define NFS_MOUNT_FLAGMASK      0xFFFF
 
 #endif
diff --git a/include/linux/nfs_page.h b/include/linux/nfs_page.h
index bd193af80162..78e60798d10e 100644
--- a/include/linux/nfs_page.h
+++ b/include/linux/nfs_page.h
@@ -16,12 +16,13 @@
 #include <linux/sunrpc/auth.h>
 #include <linux/nfs_xdr.h>
 
-#include <asm/atomic.h>
+#include <linux/kref.h>
 
 /*
  * Valid flags for the radix tree
  */
-#define NFS_PAGE_TAG_WRITEBACK  0
+#define NFS_PAGE_TAG_LOCKED     0
+#define NFS_PAGE_TAG_COMMIT     1
 
 /*
  * Valid flags for a dirty buffer
@@ -33,8 +34,7 @@
 
 struct nfs_inode;
 struct nfs_page {
-        struct list_head        wb_list,        /* Defines state of page: */
-                                *wb_list_head;  /*      read/write/commit */
+        struct list_head        wb_list;        /* Defines state of page: */
         struct page             *wb_page;       /* page to read in/write out */
         struct nfs_open_context *wb_context;    /* File state context info */
         atomic_t                wb_complete;    /* i/os we're waiting for */
@@ -42,7 +42,7 @@ struct nfs_page {
         unsigned int            wb_offset,      /* Offset & ~PAGE_CACHE_MASK */
                                 wb_pgbase,      /* Start of page data */
                                 wb_bytes;       /* Length of request */
-        atomic_t                wb_count;       /* reference count */
+        struct kref             wb_kref;        /* reference count */
         unsigned long           wb_flags;
         struct nfs_writeverf    wb_verf;        /* Commit cookie */
 };
@@ -71,8 +71,8 @@ extern	void nfs_clear_request(struct nfs_page *req);
 extern  void nfs_release_request(struct nfs_page *req);
 
 
-extern  int nfs_scan_list(struct nfs_inode *nfsi, struct list_head *head, struct list_head *dst,
-                          pgoff_t idx_start, unsigned int npages);
+extern  int nfs_scan_list(struct nfs_inode *nfsi, struct list_head *dst,
+                          pgoff_t idx_start, unsigned int npages, int tag);
 extern  void nfs_pageio_init(struct nfs_pageio_descriptor *desc,
                              struct inode *inode,
                              int (*doio)(struct inode *, struct list_head *, unsigned int, size_t, int),
@@ -84,12 +84,11 @@ extern	void nfs_pageio_complete(struct nfs_pageio_descriptor *desc);
 extern  void nfs_pageio_cond_complete(struct nfs_pageio_descriptor *, pgoff_t);
 extern  int nfs_wait_on_request(struct nfs_page *);
 extern  void nfs_unlock_request(struct nfs_page *req);
-extern  int nfs_set_page_writeback_locked(struct nfs_page *req);
-extern  void nfs_clear_page_writeback(struct nfs_page *req);
+extern  void nfs_clear_page_tag_locked(struct nfs_page *req);
 
 
 /*
- * Lock the page of an asynchronous request without incrementing the wb_count
+ * Lock the page of an asynchronous request without getting a new reference
  */
 static inline int
 nfs_lock_request_dontget(struct nfs_page *req)
@@ -98,14 +97,14 @@ nfs_lock_request_dontget(struct nfs_page *req)
 }
 
 /*
- * Lock the page of an asynchronous request
+ * Lock the page of an asynchronous request and take a reference
  */
 static inline int
 nfs_lock_request(struct nfs_page *req)
 {
         if (test_and_set_bit(PG_BUSY, &req->wb_flags))
                 return 0;
-        atomic_inc(&req->wb_count);
+        kref_get(&req->wb_kref);
         return 1;
 }
 
@@ -118,7 +117,6 @@ static inline void
 nfs_list_add_request(struct nfs_page *req, struct list_head *head)
 {
         list_add_tail(&req->wb_list, head);
-        req->wb_list_head = head;
 }
 
 
@@ -132,7 +130,6 @@ nfs_list_remove_request(struct nfs_page *req)
         if (list_empty(&req->wb_list))
                 return;
         list_del_init(&req->wb_list);
-        req->wb_list_head = NULL;
 }
 
 static inline struct nfs_page *
diff --git a/include/linux/nfs_xdr.h b/include/linux/nfs_xdr.h
index 10c26ed0db71..cf74a4db84a5 100644
--- a/include/linux/nfs_xdr.h
+++ b/include/linux/nfs_xdr.h
@@ -119,7 +119,7 @@ struct nfs_openargs {
         struct nfs_seqid *      seqid;
         int                     open_flags;
         __u64                   clientid;
-        __u32                   id;
+        __u64                   id;
         union {
                 struct iattr *  attrs;    /* UNCHECKED, GUARDED */
                 nfs4_verifier   verifier; /* EXCLUSIVE */
@@ -144,6 +144,7 @@ struct nfs_openres {
         nfs4_stateid            delegation;
         __u32                   do_recall;
         __u64                   maxsize;
+        __u32                   attrset[NFS4_BITMAP_SIZE];
 };
 
 /*
@@ -180,7 +181,7 @@ struct nfs_closeres {
  *   */
 struct nfs_lowner {
         __u64                   clientid;
-        u32                     id;
+        __u64                   id;
 };
 
 struct nfs_lock_args {
@@ -277,6 +278,21 @@ struct nfs_writeres {
 };
 
 /*
+ * Common arguments to the unlink call
+ */
+struct nfs_removeargs {
+        const struct nfs_fh     *fh;
+        struct qstr             name;
+        const u32 *             bitmask;
+};
+
+struct nfs_removeres {
+        const struct nfs_server *server;
+        struct nfs4_change_info cinfo;
+        struct nfs_fattr        dir_attr;
+};
+
+/*
  * Argument struct for decode_entry function
  */
 struct nfs_entry {
@@ -630,18 +646,6 @@ struct nfs4_readlink {
         struct page **                  pages;   /* zero-copy data */
 };
 
-struct nfs4_remove_arg {
-        const struct nfs_fh *           fh;
-        const struct qstr *             name;
-        const u32 *                     bitmask;
-};
-
-struct nfs4_remove_res {
-        const struct nfs_server *       server;
-        struct nfs4_change_info         cinfo;
-        struct nfs_fattr *              dir_attr;
-};
-
 struct nfs4_rename_arg {
         const struct nfs_fh *           old_dir;
         const struct nfs_fh *           new_dir;
@@ -787,9 +791,8 @@ struct nfs_rpc_ops {
         int     (*create)  (struct inode *, struct dentry *,
                             struct iattr *, int, struct nameidata *);
         int     (*remove)  (struct inode *, struct qstr *);
-        int     (*unlink_setup)  (struct rpc_message *,
-                            struct dentry *, struct qstr *);
-        int     (*unlink_done) (struct dentry *, struct rpc_task *);
+        void    (*unlink_setup)  (struct rpc_message *, struct inode *dir);
+        int     (*unlink_done) (struct rpc_task *, struct inode *);
         int     (*rename)  (struct inode *, struct qstr *,
                             struct inode *, struct qstr *);
         int     (*link)    (struct inode *, struct inode *, struct qstr *);
diff --git a/include/linux/nfsd/export.h b/include/linux/nfsd/export.h
index 9f62d6182d32..5cd192469096 100644
--- a/include/linux/nfsd/export.h
+++ b/include/linux/nfsd/export.h
@@ -42,6 +42,9 @@
 #define NFSEXP_NOACL            0x8000  /* reserved for possible ACL related use */
 #define NFSEXP_ALLFLAGS         0xFE3F
 
+/* The flags that may vary depending on security flavor: */
+#define NFSEXP_SECINFO_FLAGS    (NFSEXP_READONLY | NFSEXP_ROOTSQUASH \
+                                        | NFSEXP_ALLSQUASH)
 
 #ifdef __KERNEL__
 
@@ -64,6 +67,19 @@ struct nfsd4_fs_locations {
         int migrated;
 };
 
+/*
+ * We keep an array of pseudoflavors with the export, in order from most
+ * to least preferred.  For the forseeable future, we don't expect more
+ * than the eight pseudoflavors null, unix, krb5, krb5i, krb5p, skpm3,
+ * spkm3i, and spkm3p (and using all 8 at once should be rare).
+ */
+#define MAX_SECINFO_LIST        8
+
+struct exp_flavor_info {
+        u32     pseudoflavor;
+        u32     flags;
+};
+
 struct svc_export {
         struct cache_head       h;
         struct auth_domain *    ex_client;
@@ -76,6 +92,8 @@ struct svc_export {
         int                     ex_fsid;
         unsigned char *         ex_uuid; /* 16 byte fsid */
         struct nfsd4_fs_locations ex_fslocs;
+        int                     ex_nflavors;
+        struct exp_flavor_info  ex_flavors[MAX_SECINFO_LIST];
 };
 
 /* an "export key" (expkey) maps a filehandlefragement to an
@@ -95,10 +113,11 @@ struct svc_expkey {
 
 #define EX_SECURE(exp)          (!((exp)->ex_flags & NFSEXP_INSECURE_PORT))
 #define EX_ISSYNC(exp)          (!((exp)->ex_flags & NFSEXP_ASYNC))
-#define EX_RDONLY(exp)          ((exp)->ex_flags & NFSEXP_READONLY)
 #define EX_NOHIDE(exp)          ((exp)->ex_flags & NFSEXP_NOHIDE)
 #define EX_WGATHER(exp)         ((exp)->ex_flags & NFSEXP_GATHERED_WRITES)
 
+int nfsexp_flags(struct svc_rqst *rqstp, struct svc_export *exp);
+__be32 check_nfsd_access(struct svc_export *exp, struct svc_rqst *rqstp);
 
 /*
  * Function declarations
@@ -112,13 +131,19 @@ struct svc_export *	exp_get_by_name(struct auth_domain *clp,
                                         struct vfsmount *mnt,
                                         struct dentry *dentry,
                                         struct cache_req *reqp);
+struct svc_export *     rqst_exp_get_by_name(struct svc_rqst *,
+                                             struct vfsmount *,
+                                             struct dentry *);
 struct svc_export *     exp_parent(struct auth_domain *clp,
                                    struct vfsmount *mnt,
                                    struct dentry *dentry,
                                    struct cache_req *reqp);
+struct svc_export *     rqst_exp_parent(struct svc_rqst *,
+                                        struct vfsmount *mnt,
+                                        struct dentry *dentry);
 int                     exp_rootfh(struct auth_domain *, 
                                         char *path, struct knfsd_fh *, int maxsize);
-__be32                  exp_pseudoroot(struct auth_domain *, struct svc_fh *fhp, struct cache_req *creq);
+__be32                  exp_pseudoroot(struct svc_rqst *, struct svc_fh *);
 __be32                  nfserrno(int errno);
 
 extern struct cache_detail svc_export_cache;
@@ -135,6 +160,7 @@ static inline void exp_get(struct svc_export *exp)
 extern struct svc_export *
 exp_find(struct auth_domain *clp, int fsid_type, u32 *fsidv,
          struct cache_req *reqp);
+struct svc_export * rqst_exp_find(struct svc_rqst *, int, u32 *);
 
 #endif /* __KERNEL__ */
 
diff --git a/include/linux/nfsd/interface.h b/include/linux/nfsd/interface.h
deleted file mode 100644
index af0979704afb..000000000000
--- a/include/linux/nfsd/interface.h
+++ /dev/null
@@ -1,13 +0,0 @@
-/*
- * include/linux/nfsd/interface.h
- *
- * defines interface between nfsd and other bits of
- * the kernel.  Particularly filesystems (eventually).
- *
- * Copyright (C) 2000 Neil Brown <neilb@cse.unsw.edu.au>
- */
-
-#ifndef LINUX_NFSD_INTERFACE_H
-#define LINUX_NFSD_INTERFACE_H
-
-#endif /* LINUX_NFSD_INTERFACE_H */
diff --git a/include/linux/nfsd/nfsd.h b/include/linux/nfsd/nfsd.h
index 72feac581aa3..e452256d3f72 100644
--- a/include/linux/nfsd/nfsd.h
+++ b/include/linux/nfsd/nfsd.h
@@ -22,7 +22,6 @@
 #include <linux/nfsd/export.h>
 #include <linux/nfsd/auth.h>
 #include <linux/nfsd/stats.h>
-#include <linux/nfsd/interface.h>
 /*
  * nfsd version
  */
@@ -72,6 +71,9 @@ int		nfsd_cross_mnt(struct svc_rqst *rqstp, struct dentry **dpp,
                                 struct svc_export **expp);
 __be32          nfsd_lookup(struct svc_rqst *, struct svc_fh *,
                                 const char *, int, struct svc_fh *);
+__be32           nfsd_lookup_dentry(struct svc_rqst *, struct svc_fh *,
+                                const char *, int,
+                                struct svc_export **, struct dentry **);
 __be32          nfsd_setattr(struct svc_rqst *, struct svc_fh *,
                                 struct iattr *, int, time_t);
 #ifdef CONFIG_NFSD_V4
@@ -120,7 +122,8 @@ __be32		nfsd_statfs(struct svc_rqst *, struct svc_fh *,
                                 struct kstatfs *);
 
 int             nfsd_notify_change(struct inode *, struct iattr *);
-__be32          nfsd_permission(struct svc_export *, struct dentry *, int);
+__be32          nfsd_permission(struct svc_rqst *, struct svc_export *,
+                                struct dentry *, int);
 int             nfsd_sync_dir(struct dentry *dp);
 
 #if defined(CONFIG_NFSD_V2_ACL) || defined(CONFIG_NFSD_V3_ACL)
@@ -149,6 +152,7 @@ extern int nfsd_max_blksize;
  * NFSv4 State
  */
 #ifdef CONFIG_NFSD_V4
+extern unsigned int max_delegations;
 void nfs4_state_init(void);
 int nfs4_state_start(void);
 void nfs4_state_shutdown(void);
@@ -236,6 +240,7 @@ void		nfsd_lockd_shutdown(void);
 #define nfserr_badname          __constant_htonl(NFSERR_BADNAME)
 #define nfserr_cb_path_down     __constant_htonl(NFSERR_CB_PATH_DOWN)
 #define nfserr_locked           __constant_htonl(NFSERR_LOCKED)
+#define nfserr_wrongsec         __constant_htonl(NFSERR_WRONGSEC)
 #define nfserr_replay_me        __constant_htonl(NFSERR_REPLAY_ME)
 
 /* error codes for internal use */
diff --git a/include/linux/nfsd/state.h b/include/linux/nfsd/state.h
index ab5c236bd9a7..db348f749376 100644
--- a/include/linux/nfsd/state.h
+++ b/include/linux/nfsd/state.h
@@ -67,7 +67,7 @@ struct nfs4_cb_recall {
         int                     cbr_trunc;
         stateid_t               cbr_stateid;
         u32                     cbr_fhlen;
-        u32                     cbr_fhval[NFS4_FHSIZE];
+        char                    cbr_fhval[NFS4_FHSIZE];
         struct nfs4_delegation  *cbr_dp;
 };
 
@@ -224,6 +224,7 @@ struct nfs4_file {
         struct inode            *fi_inode;
         u32                     fi_id;      /* used with stateowner->so_id 
                                              * for stateid_hashtbl hash */
+        bool                    fi_had_conflict;
 };
 
 /*
diff --git a/include/linux/nfsd/xdr4.h b/include/linux/nfsd/xdr4.h
index 09799bcee0ac..1b653267133a 100644
--- a/include/linux/nfsd/xdr4.h
+++ b/include/linux/nfsd/xdr4.h
@@ -293,6 +293,12 @@ struct nfsd4_rename {
         struct nfsd4_change_info  rn_tinfo; /* response */
 };
 
+struct nfsd4_secinfo {
+        u32 si_namelen;                                 /* request */
+        char *si_name;                                  /* request */
+        struct svc_export *si_exp;                      /* response */
+};
+
 struct nfsd4_setattr {
         stateid_t       sa_stateid;         /* request */
         u32             sa_bmval[2];        /* request */
@@ -365,6 +371,7 @@ struct nfsd4_op {
                 struct nfsd4_remove             remove;
                 struct nfsd4_rename             rename;
                 clientid_t                      renew;
+                struct nfsd4_secinfo            secinfo;
                 struct nfsd4_setattr            setattr;
                 struct nfsd4_setclientid        setclientid;
                 struct nfsd4_setclientid_confirm setclientid_confirm;
diff --git a/include/linux/notifier.h b/include/linux/notifier.h
index 9431101bf876..be3f2bb6fcf3 100644
--- a/include/linux/notifier.h
+++ b/include/linux/notifier.h
@@ -196,6 +196,8 @@ extern int __srcu_notifier_call_chain(struct srcu_notifier_head *nh,
 #define CPU_DEAD                0x0007 /* CPU (unsigned)v dead */
 #define CPU_LOCK_ACQUIRE        0x0008 /* Acquire all hotcpu locks */
 #define CPU_LOCK_RELEASE        0x0009 /* Release all hotcpu locks */
+#define CPU_DYING               0x000A /* CPU (unsigned)v not running any task,
+                                        * not handling interrupts, soon dead */
 
 /* Used for CPU hotplug events occuring while tasks are frozen due to a suspend
  * operation in progress
@@ -208,6 +210,13 @@ extern int __srcu_notifier_call_chain(struct srcu_notifier_head *nh,
 #define CPU_DOWN_PREPARE_FROZEN (CPU_DOWN_PREPARE | CPU_TASKS_FROZEN)
 #define CPU_DOWN_FAILED_FROZEN  (CPU_DOWN_FAILED | CPU_TASKS_FROZEN)
 #define CPU_DEAD_FROZEN         (CPU_DEAD | CPU_TASKS_FROZEN)
+#define CPU_DYING_FROZEN        (CPU_DYING | CPU_TASKS_FROZEN)
+
+/* Hibernation and suspend events */
+#define PM_HIBERNATION_PREPARE  0x0001 /* Going to hibernate */
+#define PM_POST_HIBERNATION     0x0002 /* Hibernation finished */
+#define PM_SUSPEND_PREPARE      0x0003 /* Going to suspend the system */
+#define PM_POST_SUSPEND         0x0004 /* Suspend finished */
 
 #endif /* __KERNEL__ */
 #endif /* _LINUX_NOTIFIER_H */
diff --git a/include/linux/nsproxy.h b/include/linux/nsproxy.h
index 189e0dc993ab..ce06188b7a56 100644
--- a/include/linux/nsproxy.h
+++ b/include/linux/nsproxy.h
@@ -28,10 +28,11 @@ struct nsproxy {
         struct ipc_namespace *ipc_ns;
         struct mnt_namespace *mnt_ns;
         struct pid_namespace *pid_ns;
+        struct user_namespace *user_ns;
 };
 extern struct nsproxy init_nsproxy;
 
-int copy_namespaces(int flags, struct task_struct *tsk);
+int copy_namespaces(unsigned long flags, struct task_struct *tsk);
 void get_task_namespaces(struct task_struct *tsk);
 void free_nsproxy(struct nsproxy *ns);
 int unshare_nsproxy_namespaces(unsigned long, struct nsproxy **,
diff --git a/include/linux/of.h b/include/linux/of.h
new file mode 100644
index 000000000000..47734ffd9745
--- /dev/null
+++ b/include/linux/of.h
@@ -0,0 +1,61 @@
+#ifndef _LINUX_OF_H
+#define _LINUX_OF_H
+/*
+ * Definitions for talking to the Open Firmware PROM on
+ * Power Macintosh and other computers.
+ *
+ * Copyright (C) 1996-2005 Paul Mackerras.
+ *
+ * Updates for PPC64 by Peter Bergner & David Engebretsen, IBM Corp.
+ * Updates for SPARC64 by David S. Miller
+ * Derived from PowerPC and Sparc prom.h files by Stephen Rothwell, IBM Corp.
+ *
+ * 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.
+ */
+#include <linux/types.h>
+
+#include <asm/bitops.h>
+#include <asm/prom.h>
+
+/* flag descriptions */
+#define OF_DYNAMIC      1 /* node and properties were allocated via kmalloc */
+#define OF_DETACHED     2 /* node has been detached from the device tree */
+
+#define OF_BAD_ADDR     ((u64)-1)
+
+extern struct device_node *of_find_node_by_name(struct device_node *from,
+        const char *name);
+#define for_each_node_by_name(dn, name) \
+        for (dn = of_find_node_by_name(NULL, name); dn; \
+             dn = of_find_node_by_name(dn, name))
+extern struct device_node *of_find_node_by_type(struct device_node *from,
+        const char *type);
+#define for_each_node_by_type(dn, type) \
+        for (dn = of_find_node_by_type(NULL, type); dn; \
+             dn = of_find_node_by_type(dn, type))
+extern struct device_node *of_find_compatible_node(struct device_node *from,
+        const char *type, const char *compat);
+#define for_each_compatible_node(dn, type, compatible) \
+        for (dn = of_find_compatible_node(NULL, type, compatible); dn; \
+             dn = of_find_compatible_node(dn, type, compatible))
+extern struct device_node *of_find_node_by_path(const char *path);
+extern struct device_node *of_find_node_by_phandle(phandle handle);
+extern struct device_node *of_get_parent(const struct device_node *node);
+extern struct device_node *of_get_next_child(const struct device_node *node,
+                                             struct device_node *prev);
+extern struct property *of_find_property(const struct device_node *np,
+                                         const char *name,
+                                         int *lenp);
+extern int of_device_is_compatible(const struct device_node *device,
+                                   const char *);
+extern const void *of_get_property(const struct device_node *node,
+                                const char *name,
+                                int *lenp);
+#define get_property(a, b, c)   of_get_property((a), (b), (c))
+extern int of_n_addr_cells(struct device_node *np);
+extern int of_n_size_cells(struct device_node *np);
+
+#endif /* _LINUX_OF_H */
diff --git a/include/linux/of_device.h b/include/linux/of_device.h
new file mode 100644
index 000000000000..91bf84b9d144
--- /dev/null
+++ b/include/linux/of_device.h
@@ -0,0 +1,26 @@
+#ifndef _LINUX_OF_DEVICE_H
+#define _LINUX_OF_DEVICE_H
+#ifdef __KERNEL__
+
+#include <linux/device.h>
+#include <linux/of.h>
+#include <linux/mod_devicetable.h>
+
+#include <asm/of_device.h>
+
+#define to_of_device(d) container_of(d, struct of_device, dev)
+
+extern const struct of_device_id *of_match_node(
+        const struct of_device_id *matches, const struct device_node *node);
+extern const struct of_device_id *of_match_device(
+        const struct of_device_id *matches, const struct of_device *dev);
+
+extern struct of_device *of_dev_get(struct of_device *dev);
+extern void of_dev_put(struct of_device *dev);
+
+extern int of_device_register(struct of_device *ofdev);
+extern void of_device_unregister(struct of_device *ofdev);
+extern void of_release_dev(struct device *dev);
+
+#endif /* __KERNEL__ */
+#endif /* _LINUX_OF_DEVICE_H */
diff --git a/include/linux/of_platform.h b/include/linux/of_platform.h
new file mode 100644
index 000000000000..448f70b30a0c
--- /dev/null
+++ b/include/linux/of_platform.h
@@ -0,0 +1,57 @@
+#ifndef _LINUX_OF_PLATFORM_H
+#define _LINUX_OF_PLATFORM_H
+/*
+ *    Copyright (C) 2006 Benjamin Herrenschmidt, IBM Corp.
+ *                       <benh@kernel.crashing.org>
+ *
+ *  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.
+ *
+ */
+
+#include <linux/module.h>
+#include <linux/device.h>
+#include <linux/mod_devicetable.h>
+#include <linux/pm.h>
+#include <linux/of_device.h>
+
+/*
+ * The of_platform_bus_type is a bus type used by drivers that do not
+ * attach to a macio or similar bus but still use OF probing
+ * mechanism
+ */
+extern struct bus_type of_platform_bus_type;
+
+/*
+ * An of_platform_driver driver is attached to a basic of_device on
+ * the "platform bus" (of_platform_bus_type) (or ISA, EBUS and SBUS
+ * busses on sparc).
+ */
+struct of_platform_driver
+{
+        const char              *name;
+        const struct of_device_id       *match_table;
+        struct module           *owner;
+
+        int     (*probe)(struct of_device* dev,
+                         const struct of_device_id *match);
+        int     (*remove)(struct of_device* dev);
+
+        int     (*suspend)(struct of_device* dev, pm_message_t state);
+        int     (*resume)(struct of_device* dev);
+        int     (*shutdown)(struct of_device* dev);
+
+        struct device_driver    driver;
+};
+#define to_of_platform_driver(drv) \
+        container_of(drv,struct of_platform_driver, driver)
+
+#include <asm/of_platform.h>
+
+extern struct of_device *of_find_device_by_node(struct device_node *np);
+
+extern int of_bus_type_init(struct bus_type *bus, const char *name);
+
+#endif  /* _LINUX_OF_PLATFORM_H */
diff --git a/include/linux/oprofile.h b/include/linux/oprofile.h
index 0d514b252454..041bb31100f4 100644
--- a/include/linux/oprofile.h
+++ b/include/linux/oprofile.h
@@ -17,6 +17,26 @@
 #include <linux/spinlock.h>
 #include <asm/atomic.h>
  
+/* Each escaped entry is prefixed by ESCAPE_CODE
+ * then one of the following codes, then the
+ * relevant data.
+ * These #defines live in this file so that arch-specific
+ * buffer sync'ing code can access them.
+ */
+#define ESCAPE_CODE                     ~0UL
+#define CTX_SWITCH_CODE                 1
+#define CPU_SWITCH_CODE                 2
+#define COOKIE_SWITCH_CODE              3
+#define KERNEL_ENTER_SWITCH_CODE        4
+#define KERNEL_EXIT_SWITCH_CODE         5
+#define MODULE_LOADED_CODE              6
+#define CTX_TGID_CODE                   7
+#define TRACE_BEGIN_CODE                8
+#define TRACE_END_CODE                  9
+#define XEN_ENTER_SWITCH_CODE           10
+#define SPU_PROFILING_CODE              11
+#define SPU_CTX_SWITCH_CODE             12
+
 struct super_block;
 struct dentry;
 struct file_operations;
@@ -35,6 +55,14 @@ struct oprofile_operations {
         int (*start)(void);
         /* Stop delivering interrupts. */
         void (*stop)(void);
+        /* Arch-specific buffer sync functions.
+         * Return value = 0:  Success
+         * Return value = -1: Failure
+         * Return value = 1:  Run generic sync function
+         */
+        int (*sync_start)(void);
+        int (*sync_stop)(void);
+
         /* Initiate a stack backtrace. Optional. */
         void (*backtrace)(struct pt_regs * const regs, unsigned int depth);
         /* CPU identification string. */
@@ -56,6 +84,13 @@ int oprofile_arch_init(struct oprofile_operations * ops);
 void oprofile_arch_exit(void);
 
 /**
+ * Add data to the event buffer.
+ * The data passed is free-form, but typically consists of
+ * file offsets, dcookies, context information, and ESCAPE codes.
+ */
+void add_event_entry(unsigned long data);
+
+/**
  * Add a sample. This may be called from any context. Pass
  * smp_processor_id() as cpu.
  */
diff --git a/include/linux/page-flags.h b/include/linux/page-flags.h
index ae2d79f2107e..209d3a47f50f 100644
--- a/include/linux/page-flags.h
+++ b/include/linux/page-flags.h
@@ -90,8 +90,12 @@
 #define PG_reclaim              17      /* To be reclaimed asap */
 #define PG_buddy                19      /* Page is free, on buddy lists */
 
+/* PG_readahead is only used for file reads; PG_reclaim is only for writes */
+#define PG_readahead            PG_reclaim /* Reminder to do async read-ahead */
+
 /* PG_owner_priv_1 users should have descriptive aliases */
 #define PG_checked              PG_owner_priv_1 /* Used by some filesystems */
+#define PG_pinned               PG_owner_priv_1 /* Xen pinned pagetable */
 
 #if (BITS_PER_LONG > 32)
 /*
@@ -170,6 +174,10 @@ static inline void SetPageUptodate(struct page *page)
 #define SetPageChecked(page)    set_bit(PG_checked, &(page)->flags)
 #define ClearPageChecked(page)  clear_bit(PG_checked, &(page)->flags)
 
+#define PagePinned(page)        test_bit(PG_pinned, &(page)->flags)
+#define SetPagePinned(page)     set_bit(PG_pinned, &(page)->flags)
+#define ClearPagePinned(page)   clear_bit(PG_pinned, &(page)->flags)
+
 #define PageReserved(page)      test_bit(PG_reserved, &(page)->flags)
 #define SetPageReserved(page)   set_bit(PG_reserved, &(page)->flags)
 #define ClearPageReserved(page) clear_bit(PG_reserved, &(page)->flags)
@@ -181,37 +189,15 @@ static inline void SetPageUptodate(struct page *page)
 #define __SetPagePrivate(page)  __set_bit(PG_private, &(page)->flags)
 #define __ClearPagePrivate(page) __clear_bit(PG_private, &(page)->flags)
 
+/*
+ * Only test-and-set exist for PG_writeback.  The unconditional operators are
+ * risky: they bypass page accounting.
+ */
 #define PageWriteback(page)     test_bit(PG_writeback, &(page)->flags)
-#define SetPageWriteback(page)                                          \
-        do {                                                            \
-                if (!test_and_set_bit(PG_writeback,                     \
-                                &(page)->flags))                        \
-                        inc_zone_page_state(page, NR_WRITEBACK);        \
-        } while (0)
-#define TestSetPageWriteback(page)                                      \
-        ({                                                              \
-                int ret;                                                \
-                ret = test_and_set_bit(PG_writeback,                    \
-                                        &(page)->flags);                \
-                if (!ret)                                               \
-                        inc_zone_page_state(page, NR_WRITEBACK);        \
-                ret;                                                    \
-        })
-#define ClearPageWriteback(page)                                        \
-        do {                                                            \
-                if (test_and_clear_bit(PG_writeback,                    \
-                                &(page)->flags))                        \
-                        dec_zone_page_state(page, NR_WRITEBACK);        \
-        } while (0)
-#define TestClearPageWriteback(page)                                    \
-        ({                                                              \
-                int ret;                                                \
-                ret = test_and_clear_bit(PG_writeback,                  \
-                                &(page)->flags);                        \
-                if (ret)                                                \
-                        dec_zone_page_state(page, NR_WRITEBACK);        \
-                ret;                                                    \
-        })
+#define TestSetPageWriteback(page) test_and_set_bit(PG_writeback,       \
+                                                        &(page)->flags)
+#define TestClearPageWriteback(page) test_and_clear_bit(PG_writeback,   \
+                                                        &(page)->flags)
 
 #define PageBuddy(page)         test_bit(PG_buddy, &(page)->flags)
 #define __SetPageBuddy(page)    __set_bit(PG_buddy, &(page)->flags)
@@ -221,6 +207,10 @@ static inline void SetPageUptodate(struct page *page)
 #define SetPageMappedToDisk(page) set_bit(PG_mappedtodisk, &(page)->flags)
 #define ClearPageMappedToDisk(page) clear_bit(PG_mappedtodisk, &(page)->flags)
 
+#define PageReadahead(page)     test_bit(PG_readahead, &(page)->flags)
+#define SetPageReadahead(page)  set_bit(PG_readahead, &(page)->flags)
+#define ClearPageReadahead(page) clear_bit(PG_readahead, &(page)->flags)
+
 #define PageReclaim(page)       test_bit(PG_reclaim, &(page)->flags)
 #define SetPageReclaim(page)    set_bit(PG_reclaim, &(page)->flags)
 #define ClearPageReclaim(page)  clear_bit(PG_reclaim, &(page)->flags)
diff --git a/include/linux/pci.h b/include/linux/pci.h
index 086a0e5a6318..5e84f2e8d54c 100644
--- a/include/linux/pci.h
+++ b/include/linux/pci.h
@@ -111,7 +111,8 @@ enum pcie_reset_state {
 
 typedef unsigned short __bitwise pci_bus_flags_t;
 enum pci_bus_flags {
-        PCI_BUS_FLAGS_NO_MSI = (__force pci_bus_flags_t) 1,
+        PCI_BUS_FLAGS_NO_MSI   = (__force pci_bus_flags_t) 1,
+        PCI_BUS_FLAGS_NO_MMRBC = (__force pci_bus_flags_t) 2,
 };
 
 struct pci_cap_saved_state {
@@ -138,6 +139,7 @@ struct pci_dev {
         unsigned short  subsystem_vendor;
         unsigned short  subsystem_device;
         unsigned int    class;          /* 3 bytes: (base,sub,prog-if) */
+        u8              revision;       /* PCI revision, low byte of class word */
         u8              hdr_type;       /* PCI header type (`multi' flag masked out) */
         u8              rom_base_reg;   /* which config register controls the ROM */
         u8              pin;            /* which interrupt pin this device uses */
@@ -313,7 +315,7 @@ struct pci_dynids {
 
 /* ---------------------------------------------------------------- */
 /** PCI Error Recovery System (PCI-ERS).  If a PCI device driver provides
- *  a set fof callbacks in struct pci_error_handlers, then that device driver
+ *  a set of callbacks in struct pci_error_handlers, then that device driver
  *  will be notified of PCI bus errors, and will be driven to recovery
  *  when an error occurs.
  */
@@ -370,7 +372,6 @@ struct pci_driver {
         int  (*suspend_late) (struct pci_dev *dev, pm_message_t state);
         int  (*resume_early) (struct pci_dev *dev);
         int  (*resume) (struct pci_dev *dev);                   /* Device woken up */
-        int  (*enable_wake) (struct pci_dev *dev, pci_power_t state, int enable);   /* Enable wake event */
         void (*shutdown) (struct pci_dev *dev);
 
         struct pci_error_handlers *err_handler;
@@ -431,6 +432,8 @@ extern struct bus_type pci_bus_type;
  * code, or pci core code. */
 extern struct list_head pci_root_buses; /* list of all known PCI buses */
 extern struct list_head pci_devices;    /* list of all devices */
+/* Some device drivers need know if pci is initiated */
+extern int no_pci_devices(void);
 
 void pcibios_fixup_bus(struct pci_bus *);
 int __must_check pcibios_enable_device(struct pci_dev *, int mask);
@@ -475,7 +478,7 @@ extern void pci_sort_breadthfirst(void);
 /* Generic PCI functions exported to card drivers */
 
 struct pci_dev __deprecated *pci_find_device (unsigned int vendor, unsigned int device, const struct pci_dev *from);
-struct pci_dev *pci_find_slot (unsigned int bus, unsigned int devfn);
+struct pci_dev __deprecated *pci_find_slot (unsigned int bus, unsigned int devfn);
 int pci_find_capability (struct pci_dev *dev, int cap);
 int pci_find_next_capability (struct pci_dev *dev, u8 pos, int cap);
 int pci_find_ext_capability (struct pci_dev *dev, int cap);
@@ -544,11 +547,16 @@ void pci_set_master(struct pci_dev *dev);
 int pci_set_pcie_reset_state(struct pci_dev *dev, enum pcie_reset_state state);
 #define HAVE_PCI_SET_MWI
 int __must_check pci_set_mwi(struct pci_dev *dev);
+int pci_try_set_mwi(struct pci_dev *dev);
 void pci_clear_mwi(struct pci_dev *dev);
 void pci_intx(struct pci_dev *dev, int enable);
 void pci_msi_off(struct pci_dev *dev);
 int pci_set_dma_mask(struct pci_dev *dev, u64 mask);
 int pci_set_consistent_dma_mask(struct pci_dev *dev, u64 mask);
+int pcix_get_max_mmrbc(struct pci_dev *dev);
+int pcix_get_mmrbc(struct pci_dev *dev);
+int pcix_set_mmrbc(struct pci_dev *dev, int mmrbc);
+int pcie_set_readrq(struct pci_dev *dev, int rq);
 void pci_update_resource(struct pci_dev *dev, struct resource *res, int resno);
 int __must_check pci_assign_resource(struct pci_dev *dev, int i);
 int __must_check pci_assign_resource_fixed(struct pci_dev *dev, int i);
@@ -560,6 +568,7 @@ void __iomem __must_check *pci_map_rom(struct pci_dev *pdev, size_t *size);
 void __iomem __must_check *pci_map_rom_copy(struct pci_dev *pdev, size_t *size);
 void pci_unmap_rom(struct pci_dev *pdev, void __iomem *rom);
 void pci_remove_rom(struct pci_dev *pdev);
+size_t pci_get_rom_size(void __iomem *rom, size_t size);
 
 /* Power management related routines */
 int pci_save_state(struct pci_dev *dev);
@@ -717,6 +726,7 @@ static inline struct pci_dev *pci_get_class(unsigned int class, struct pci_dev *
 { return NULL; }
 
 #define pci_dev_present(ids)    (0)
+#define no_pci_devices()        (1)
 #define pci_find_present(ids)   (NULL)
 #define pci_dev_put(dev)        do { } while (0)
 
@@ -876,5 +886,7 @@ extern int pci_pci_problems;
 extern unsigned long pci_cardbus_io_size;
 extern unsigned long pci_cardbus_mem_size;
 
+extern int pcibios_add_platform_entries(struct pci_dev *dev);
+
 #endif /* __KERNEL__ */
 #endif /* LINUX_PCI_H */
diff --git a/include/linux/pci_ids.h b/include/linux/pci_ids.h
index 75c4d4d06892..cbabb9c675c9 100644
--- a/include/linux/pci_ids.h
+++ b/include/linux/pci_ids.h
@@ -133,6 +133,9 @@
 
 /* Vendors and devices.  Sort key: vendor first, device next. */
 
+#define PCI_VENDOR_ID_TTTECH            0x0357
+#define PCI_DEVICE_ID_TTTECH_MC322      0x000a
+
 #define PCI_VENDOR_ID_DYNALINK          0x0675
 #define PCI_DEVICE_ID_DYNALINK_IS64PH   0x1702
 
@@ -371,6 +374,7 @@
 #define PCI_DEVICE_ID_ATI_IXP600_SMBUS  0x4385
 #define PCI_DEVICE_ID_ATI_IXP600_IDE    0x438c
 #define PCI_DEVICE_ID_ATI_IXP700_SATA   0x4390
+#define PCI_DEVICE_ID_ATI_IXP700_SMBUS  0x4395
 #define PCI_DEVICE_ID_ATI_IXP700_IDE    0x439c
 
 #define PCI_VENDOR_ID_VLSI              0x1004
@@ -475,6 +479,9 @@
 #define PCI_DEVICE_ID_IBM_ICOM_V2_ONE_PORT_RVX_ONE_PORT_MDM_PCIE 0x0361
 #define PCI_DEVICE_ID_IBM_ICOM_FOUR_PORT_MODEL  0x252
 
+#define PCI_VENDOR_ID_UNISYS            0x1018
+#define PCI_DEVICE_ID_UNISYS_DMA_DIRECTOR 0x001C
+
 #define PCI_VENDOR_ID_COMPEX2           0x101a /* pci.ids says "AT&T GIS (NCR)" */
 #define PCI_DEVICE_ID_COMPEX2_100VG     0x0005
 
@@ -488,6 +495,8 @@
 
 #define PCI_VENDOR_ID_AMD               0x1022
 #define PCI_DEVICE_ID_AMD_K8_NB         0x1100
+#define PCI_DEVICE_ID_AMD_K8_NB_ADDRMAP 0x1101
+#define PCI_DEVICE_ID_AMD_K8_NB_MEMCTL  0x1102
 #define PCI_DEVICE_ID_AMD_K8_NB_MISC    0x1103
 #define PCI_DEVICE_ID_AMD_LANCE         0x2000
 #define PCI_DEVICE_ID_AMD_LANCE_HOME    0x2001
@@ -732,7 +741,6 @@
 #define PCI_DEVICE_ID_ELSA_MICROLINK    0x1000
 #define PCI_DEVICE_ID_ELSA_QS3000       0x3000
 
-
 #define PCI_VENDOR_ID_BUSLOGIC                0x104B
 #define PCI_DEVICE_ID_BUSLOGIC_MULTIMASTER_NC 0x0140
 #define PCI_DEVICE_ID_BUSLOGIC_MULTIMASTER    0x1040
@@ -778,7 +786,6 @@
 
 #define PCI_VENDOR_ID_SONY              0x104d
 
-
 /* Winbond have two vendor IDs! See 0x10ad as well */
 #define PCI_VENDOR_ID_WINBOND2          0x1050
 #define PCI_DEVICE_ID_WINBOND2_89C940F  0x5a5a
@@ -816,7 +823,6 @@
 #define PCI_DEVICE_ID_PROMISE_20276     0x5275
 #define PCI_DEVICE_ID_PROMISE_20277     0x7275
 
-
 #define PCI_VENDOR_ID_UMC               0x1060
 #define PCI_DEVICE_ID_UMC_UM8673F       0x0101
 #define PCI_DEVICE_ID_UMC_UM8886BF      0x673a
@@ -832,7 +838,6 @@
 #define PCI_DEVICE_ID_MYLEX_DAC960_BA   0xBA56
 #define PCI_DEVICE_ID_MYLEX_DAC960_GEM  0xB166
 
-
 #define PCI_VENDOR_ID_APPLE             0x106b
 #define PCI_DEVICE_ID_APPLE_BANDIT      0x0001
 #define PCI_DEVICE_ID_APPLE_HYDRA       0x000e
@@ -868,7 +873,6 @@
 #define PCI_DEVICE_ID_YAMAHA_744        0x0010
 #define PCI_DEVICE_ID_YAMAHA_754        0x0012
 
-
 #define PCI_VENDOR_ID_QLOGIC            0x1077
 #define PCI_DEVICE_ID_QLOGIC_ISP10160   0x1016
 #define PCI_DEVICE_ID_QLOGIC_ISP1020    0x1020
@@ -899,12 +903,9 @@
 #define PCI_DEVICE_ID_CYRIX_5530_AUDIO  0x0103
 #define PCI_DEVICE_ID_CYRIX_5530_VIDEO  0x0104
 
-
-
 #define PCI_VENDOR_ID_CONTAQ            0x1080
 #define PCI_DEVICE_ID_CONTAQ_82C693     0xc693
 
-
 #define PCI_VENDOR_ID_OLICOM            0x108d
 #define PCI_DEVICE_ID_OLICOM_OC2325     0x0012
 #define PCI_DEVICE_ID_OLICOM_OC2183     0x0013
@@ -936,23 +937,19 @@
 #define PCI_DEVICE_ID_SII_3112          0x3112
 #define PCI_DEVICE_ID_SII_1210SA        0x0240
 
-
 #define PCI_VENDOR_ID_BROOKTREE         0x109e
 #define PCI_DEVICE_ID_BROOKTREE_878     0x0878
 #define PCI_DEVICE_ID_BROOKTREE_879     0x0879
 
-
 #define PCI_VENDOR_ID_SGI               0x10a9
 #define PCI_DEVICE_ID_SGI_IOC3          0x0003
+#define PCI_DEVICE_ID_SGI_LITHIUM       0x1002
 #define PCI_DEVICE_ID_SGI_IOC4          0x100a
-#define PCI_VENDOR_ID_SGI_LITHIUM       0x1002
-
 
 #define PCI_VENDOR_ID_WINBOND           0x10ad
 #define PCI_DEVICE_ID_WINBOND_82C105    0x0105
 #define PCI_DEVICE_ID_WINBOND_83C553    0x0565
 
-
 #define PCI_VENDOR_ID_PLX               0x10b5
 #define PCI_DEVICE_ID_PLX_R685          0x1030
 #define PCI_DEVICE_ID_PLX_ROMULUS       0x106a
@@ -986,7 +983,6 @@
 #define PCI_DEVICE_ID_3COM_3CR990SVR97  0x9909
 #define PCI_DEVICE_ID_3COM_3CR990SVR    0x990a
 
-
 #define PCI_VENDOR_ID_AL                0x10b9
 #define PCI_DEVICE_ID_AL_M1533          0x1533
 #define PCI_DEVICE_ID_AL_M1535          0x1535
@@ -1009,18 +1005,14 @@
 #define PCI_DEVICE_ID_AL_M5451          0x5451
 #define PCI_DEVICE_ID_AL_M7101          0x7101
 
-
-
 #define PCI_VENDOR_ID_NEOMAGIC          0x10c8
 #define PCI_DEVICE_ID_NEOMAGIC_NM256AV_AUDIO 0x8005
 #define PCI_DEVICE_ID_NEOMAGIC_NM256ZX_AUDIO 0x8006
 #define PCI_DEVICE_ID_NEOMAGIC_NM256XL_PLUS_AUDIO 0x8016
 
-
 #define PCI_VENDOR_ID_TCONRAD           0x10da
 #define PCI_DEVICE_ID_TCONRAD_TOKENRING 0x0508
 
-
 #define PCI_VENDOR_ID_NVIDIA                    0x10de
 #define PCI_DEVICE_ID_NVIDIA_TNT                0x0020
 #define PCI_DEVICE_ID_NVIDIA_TNT2               0x0028
@@ -1241,9 +1233,6 @@
 #define PCI_DEVICE_ID_IMS_TT128         0x9128
 #define PCI_DEVICE_ID_IMS_TT3D          0x9135
 
-
-
-
 #define PCI_VENDOR_ID_INTERG            0x10ea
 #define PCI_DEVICE_ID_INTERG_1682       0x1682
 #define PCI_DEVICE_ID_INTERG_2000       0x2000
@@ -1262,7 +1251,6 @@
 #define PCI_DEVICE_ID_XILINX_HAMMERFALL_DSP 0x3fc5
 #define PCI_DEVICE_ID_XILINX_HAMMERFALL_DSP_MADI 0x3fc6
 
-
 #define PCI_VENDOR_ID_INIT              0x1101
 
 #define PCI_VENDOR_ID_CREATIVE          0x1102 /* duplicate: ECTIVA */
@@ -1357,7 +1345,6 @@
 #define PCI_VENDOR_ID_SIEMENS           0x110A
 #define PCI_DEVICE_ID_SIEMENS_DSCC4     0x2102
 
-
 #define PCI_VENDOR_ID_VORTEX            0x1119
 #define PCI_DEVICE_ID_VORTEX_GDT60x0    0x0000
 #define PCI_DEVICE_ID_VORTEX_GDT6000B   0x0001
@@ -1383,8 +1370,8 @@
 #define PCI_VENDOR_ID_EF                0x111a
 #define PCI_DEVICE_ID_EF_ATM_FPGA       0x0000
 #define PCI_DEVICE_ID_EF_ATM_ASIC       0x0002
-#define PCI_VENDOR_ID_EF_ATM_LANAI2     0x0003
-#define PCI_VENDOR_ID_EF_ATM_LANAIHB    0x0005
+#define PCI_DEVICE_ID_EF_ATM_LANAI2     0x0003
+#define PCI_DEVICE_ID_EF_ATM_LANAIHB    0x0005
 
 #define PCI_VENDOR_ID_IDT               0x111d
 #define PCI_DEVICE_ID_IDT_IDT77201      0x0001
@@ -1392,7 +1379,6 @@
 #define PCI_VENDOR_ID_FORE              0x1127
 #define PCI_DEVICE_ID_FORE_PCA200E      0x0300
 
-
 #define PCI_VENDOR_ID_PHILIPS           0x1131
 #define PCI_DEVICE_ID_PHILIPS_SAA7146   0x7146
 #define PCI_DEVICE_ID_PHILIPS_SAA9730   0x9730
@@ -1411,7 +1397,6 @@
 #define PCI_DEVICE_ID_ZIATECH_5550_HC   0x5550
  
 
-
 #define PCI_VENDOR_ID_SYSKONNECT        0x1148
 #define PCI_DEVICE_ID_SYSKONNECT_TR     0x4200
 #define PCI_DEVICE_ID_SYSKONNECT_GE     0x4300
@@ -1419,7 +1404,6 @@
 #define PCI_DEVICE_ID_SYSKONNECT_9DXX   0x4400
 #define PCI_DEVICE_ID_SYSKONNECT_9MXX   0x4500
 
-
 #define PCI_VENDOR_ID_DIGI              0x114f
 #define PCI_DEVICE_ID_DIGI_DF_M_IOM2_E  0x0070
 #define PCI_DEVICE_ID_DIGI_DF_M_E       0x0071
@@ -1430,12 +1414,10 @@
 #define PCI_DEVICE_ID_NEO_2RJ45         0x00CA
 #define PCI_DEVICE_ID_NEO_2RJ45PRI      0x00CB
 
-
 #define PCI_VENDOR_ID_XIRCOM            0x115d
 #define PCI_DEVICE_ID_XIRCOM_RBM56G     0x0101
 #define PCI_DEVICE_ID_XIRCOM_X3201_MDM  0x0103
 
-
 #define PCI_VENDOR_ID_SERVERWORKS         0x1166
 #define PCI_DEVICE_ID_SERVERWORKS_HE      0x0008
 #define PCI_DEVICE_ID_SERVERWORKS_LE      0x0009
@@ -1504,7 +1486,6 @@
 #define PCI_DEVICE_ID_ZEITNET_1221      0x0001
 #define PCI_DEVICE_ID_ZEITNET_1225      0x0002
 
-
 #define PCI_VENDOR_ID_FUJITSU_ME        0x119e
 #define PCI_DEVICE_ID_FUJITSU_FS155     0x0001
 #define PCI_DEVICE_ID_FUJITSU_FS50      0x0003
@@ -1522,28 +1503,23 @@
 #define PCI_DEVICE_ID_V3_V960           0x0001
 #define PCI_DEVICE_ID_V3_V351           0x0002
 
-
 #define PCI_VENDOR_ID_ATT               0x11c1
 #define PCI_DEVICE_ID_ATT_VENUS_MODEM   0x480
 
-
 #define PCI_VENDOR_ID_SPECIALIX         0x11cb
 #define PCI_DEVICE_ID_SPECIALIX_IO8     0x2000
 #define PCI_DEVICE_ID_SPECIALIX_RIO     0x8000
 #define PCI_SUBDEVICE_ID_SPECIALIX_SPEED4 0xa004
 
-
 #define PCI_VENDOR_ID_ANALOG_DEVICES    0x11d4
 #define PCI_DEVICE_ID_AD1889JS          0x1889
 
-
 #define PCI_DEVICE_ID_SEGA_BBA          0x1234
 
 #define PCI_VENDOR_ID_ZORAN             0x11de
 #define PCI_DEVICE_ID_ZORAN_36057       0x6057
 #define PCI_DEVICE_ID_ZORAN_36120       0x6120
 
-
 #define PCI_VENDOR_ID_COMPEX            0x11f6
 #define PCI_DEVICE_ID_COMPEX_ENET100VG4 0x0112
 
@@ -1602,8 +1578,6 @@
 #define PCI_DEVICE_ID_3DFX_VOODOO3      0x0005
 #define PCI_DEVICE_ID_3DFX_VOODOO5      0x0009
 
-
-
 #define PCI_VENDOR_ID_AVM               0x1244
 #define PCI_DEVICE_ID_AVM_B1            0x0700
 #define PCI_DEVICE_ID_AVM_C4            0x0800
@@ -1612,7 +1586,6 @@
 #define PCI_DEVICE_ID_AVM_C2            0x1100
 #define PCI_DEVICE_ID_AVM_T1            0x1200
 
-
 #define PCI_VENDOR_ID_STALLION          0x124d
 
 /* Allied Telesyn */
@@ -1635,7 +1608,6 @@
 #define PCI_VENDOR_ID_SATSAGEM          0x1267
 #define PCI_DEVICE_ID_SATSAGEM_NICCY    0x1016
 
-
 #define PCI_VENDOR_ID_ENSONIQ           0x1274
 #define PCI_DEVICE_ID_ENSONIQ_CT5880    0x5880
 #define PCI_DEVICE_ID_ENSONIQ_ES1370    0x5000
@@ -1658,7 +1630,6 @@
 
 #define PCI_VENDOR_ID_ALTEON            0x12ae
 
-
 #define PCI_SUBVENDOR_ID_CONNECT_TECH                   0x12c4
 #define PCI_SUBDEVICE_ID_CONNECT_TECH_BH8_232           0x0001
 #define PCI_SUBDEVICE_ID_CONNECT_TECH_BH4_232           0x0002
@@ -1689,7 +1660,6 @@
 #define PCI_SUBDEVICE_ID_CONNECT_TECH_PCI_UART_4_485    0x0331
 #define PCI_SUBDEVICE_ID_CONNECT_TECH_PCI_UART_8_485    0x0332
 
-
 #define PCI_VENDOR_ID_NVIDIA_SGS        0x12d2
 #define PCI_DEVICE_ID_NVIDIA_SGS_RIVA128 0x0018
 
@@ -1799,7 +1769,6 @@
 #define PCI_DEVICE_ID_LMC_SSI           0x0005
 #define PCI_DEVICE_ID_LMC_T1            0x0006
 
-
 #define PCI_VENDOR_ID_NETGEAR           0x1385
 #define PCI_DEVICE_ID_NETGEAR_GA620     0x620a
 
@@ -1902,6 +1871,8 @@
 #define PCI_DEVICE_ID_OXSEMI_16PCI952   0x9521
 #define PCI_DEVICE_ID_OXSEMI_16PCI952PP 0x9523
 
+#define PCI_VENDOR_ID_CHELSIO           0x1425
+
 #define PCI_VENDOR_ID_SAMSUNG           0x144d
 
 #define PCI_VENDOR_ID_MYRICOM           0x14c1
@@ -2010,13 +1981,10 @@
 #define PCI_DEVICE_ID_ENE_720           0x1421
 #define PCI_DEVICE_ID_ENE_722           0x1422
 
-#define PCI_VENDOR_ID_CHELSIO           0x1425
-
 #define PCI_SUBVENDOR_ID_PERLE          0x155f
 #define PCI_SUBDEVICE_ID_PCI_RAS4       0xf001
 #define PCI_SUBDEVICE_ID_PCI_RAS8       0xf010
 
-
 #define PCI_VENDOR_ID_SYBA              0x1592
 #define PCI_DEVICE_ID_SYBA_2P_EPP       0x0782
 #define PCI_DEVICE_ID_SYBA_1P_ECP       0x0783
@@ -2035,8 +2003,10 @@
 #define PCI_DEVICE_ID_MELLANOX_SINAI_OLD 0x5e8c
 #define PCI_DEVICE_ID_MELLANOX_SINAI    0x6274
 
-#define PCI_VENDOR_ID_PDC               0x15e9
+#define PCI_VENDOR_ID_QUICKNET          0x15e2
+#define PCI_DEVICE_ID_QUICKNET_XJ       0x0500
 
+#define PCI_VENDOR_ID_PDC               0x15e9
 
 #define PCI_VENDOR_ID_FARSITE           0x1619
 #define PCI_DEVICE_ID_FARSITE_T2P       0x0400
@@ -2049,10 +2019,14 @@
 
 #define PCI_VENDOR_ID_ARIMA             0x161f
 
+#define PCI_VENDOR_ID_BROCADE           0x1657
+
 #define PCI_VENDOR_ID_SIBYTE            0x166d
 #define PCI_DEVICE_ID_BCM1250_PCI       0x0001
 #define PCI_DEVICE_ID_BCM1250_HT        0x0002
 
+#define PCI_VENDOR_ID_ATHEROS           0x168c
+
 #define PCI_VENDOR_ID_NETCELL           0x169c
 #define PCI_DEVICE_ID_REVOLUTION        0x0044
 
@@ -2068,6 +2042,8 @@
 #define PCI_DEVICE_ID_ALTIMA_AC9100     0x03ea
 #define PCI_DEVICE_ID_ALTIMA_AC1003     0x03eb
 
+#define PCI_VENDOR_ID_LENOVO            0x17aa
+
 #define PCI_VENDOR_ID_ARECA             0x17d3
 #define PCI_DEVICE_ID_ARECA_1110        0x1110
 #define PCI_DEVICE_ID_ARECA_1120        0x1120
@@ -2091,7 +2067,6 @@
 #define PCI_DEVICE_ID_HERC_WIN          0x5732
 #define PCI_DEVICE_ID_HERC_UNI          0x5832
 
-
 #define PCI_VENDOR_ID_SITECOM           0x182d
 #define PCI_DEVICE_ID_SITECOM_DC105V2   0x3069
 
@@ -2127,12 +2102,9 @@
 #define PCI_DEVICE_ID_3DLABS_PERMEDIA2  0x0007
 #define PCI_DEVICE_ID_3DLABS_PERMEDIA2V 0x0009
 
-
 #define PCI_VENDOR_ID_AKS               0x416c
 #define PCI_DEVICE_ID_AKS_ALADDINCARD   0x0100
 
-
-
 #define PCI_VENDOR_ID_S3                0x5333
 #define PCI_DEVICE_ID_S3_TRIO           0x8811
 #define PCI_DEVICE_ID_S3_868            0x8880
@@ -2144,7 +2116,6 @@
 #define PCI_VENDOR_ID_DUNORD            0x5544
 #define PCI_DEVICE_ID_DUNORD_I3000      0x0001
 
-
 #define PCI_VENDOR_ID_DCI               0x6666
 #define PCI_DEVICE_ID_DCI_PCCOM4        0x0001
 #define PCI_DEVICE_ID_DCI_PCCOM8        0x0002
@@ -2244,6 +2215,7 @@
 #define PCI_DEVICE_ID_INTEL_82915GM_IG  0x2592
 #define PCI_DEVICE_ID_INTEL_82945G_HB   0x2770
 #define PCI_DEVICE_ID_INTEL_82945G_IG   0x2772
+#define PCI_DEVICE_ID_INTEL_3000_HB     0x2778
 #define PCI_DEVICE_ID_INTEL_82945GM_HB  0x27A0
 #define PCI_DEVICE_ID_INTEL_82945GM_IG  0x27A2
 #define PCI_DEVICE_ID_INTEL_ICH6_0      0x2640
@@ -2388,7 +2360,6 @@
 #define PCI_DEVICE_ID_ADAPTEC2_OBSIDIAN   0x0500
 #define PCI_DEVICE_ID_ADAPTEC2_SCAMP    0x0503
 
-
 #define PCI_VENDOR_ID_HOLTEK            0x9412
 #define PCI_DEVICE_ID_HOLTEK_6565       0x6565
 
@@ -2404,6 +2375,8 @@
 #define PCI_DEVICE_ID_NETMOS_9845       0x9845
 #define PCI_DEVICE_ID_NETMOS_9855       0x9855
 
+#define PCI_VENDOR_ID_3COM_2            0xa727
+
 #define PCI_SUBVENDOR_ID_EXSYS          0xd84d
 #define PCI_SUBDEVICE_ID_EXSYS_4014     0x4014
 #define PCI_SUBDEVICE_ID_EXSYS_4055     0x4055
@@ -2412,13 +2385,7 @@
 #define PCI_DEVICE_ID_TIGERJET_300      0x0001
 #define PCI_DEVICE_ID_TIGERJET_100      0x0002
 
-#define PCI_VENDOR_ID_TTTECH            0x0357
-#define PCI_DEVICE_ID_TTTECH_MC322      0x000A
-
 #define PCI_VENDOR_ID_XILINX_RME        0xea60
 #define PCI_DEVICE_ID_RME_DIGI32        0x9896
 #define PCI_DEVICE_ID_RME_DIGI32_PRO    0x9897
 #define PCI_DEVICE_ID_RME_DIGI32_8      0x9898
-
-#define PCI_VENDOR_ID_QUICKNET          0x15E2
-#define PCI_DEVICE_ID_QUICKNET_XJ       0x0500
diff --git a/include/linux/percpu.h b/include/linux/percpu.h
index b72be2f79e6a..926adaae0f96 100644
--- a/include/linux/percpu.h
+++ b/include/linux/percpu.h
@@ -1,7 +1,7 @@
 #ifndef __LINUX_PERCPU_H
 #define __LINUX_PERCPU_H
 
-#include <linux/spinlock.h> /* For preempt_disable() */
+#include <linux/preempt.h>
 #include <linux/slab.h> /* For kmalloc() */
 #include <linux/smp.h>
 #include <linux/string.h> /* For memset() */
diff --git a/include/linux/percpu_counter.h b/include/linux/percpu_counter.h
index f5aa593ccf32..3d9f70972cdf 100644
--- a/include/linux/percpu_counter.h
+++ b/include/linux/percpu_counter.h
@@ -8,6 +8,7 @@
 
 #include <linux/spinlock.h>
 #include <linux/smp.h>
+#include <linux/list.h>
 #include <linux/threads.h>
 #include <linux/percpu.h>
 #include <linux/types.h>
@@ -17,6 +18,9 @@
 struct percpu_counter {
         spinlock_t lock;
         s64 count;
+#ifdef CONFIG_HOTPLUG_CPU
+        struct list_head list;  /* All percpu_counters are on a list */
+#endif
         s32 *counters;
 };
 
@@ -26,18 +30,8 @@ struct percpu_counter {
 #define FBC_BATCH       (NR_CPUS*4)
 #endif
 
-static inline void percpu_counter_init(struct percpu_counter *fbc, s64 amount)
-{
-        spin_lock_init(&fbc->lock);
-        fbc->count = amount;
-        fbc->counters = alloc_percpu(s32);
-}
-
-static inline void percpu_counter_destroy(struct percpu_counter *fbc)
-{
-        free_percpu(fbc->counters);
-}
-
+void percpu_counter_init(struct percpu_counter *fbc, s64 amount);
+void percpu_counter_destroy(struct percpu_counter *fbc);
 void percpu_counter_mod(struct percpu_counter *fbc, s32 amount);
 s64 percpu_counter_sum(struct percpu_counter *fbc);
 
diff --git a/include/linux/pid_namespace.h b/include/linux/pid_namespace.h
index 169c6c24209b..b9a17e08ff0f 100644
--- a/include/linux/pid_namespace.h
+++ b/include/linux/pid_namespace.h
@@ -29,7 +29,7 @@ static inline void get_pid_ns(struct pid_namespace *ns)
         kref_get(&ns->kref);
 }
 
-extern struct pid_namespace *copy_pid_ns(int flags, struct pid_namespace *ns);
+extern struct pid_namespace *copy_pid_ns(unsigned long flags, struct pid_namespace *ns);
 extern void free_pid_ns(struct kref *kref);
 
 static inline void put_pid_ns(struct pid_namespace *ns)
diff --git a/include/linux/pkt_cls.h b/include/linux/pkt_cls.h
index c3f01b3085a4..30b8571e6b34 100644
--- a/include/linux/pkt_cls.h
+++ b/include/linux/pkt_cls.h
@@ -403,16 +403,13 @@ enum
  *   1..32767           Reserved for ematches inside kernel tree
  *   32768..65535       Free to use, not reliable
  */
-enum
-{
-        TCF_EM_CONTAINER,
-        TCF_EM_CMP,
-        TCF_EM_NBYTE,
-        TCF_EM_U32,
-        TCF_EM_META,
-        TCF_EM_TEXT,
-        __TCF_EM_MAX
-};
+#define TCF_EM_CONTAINER        0
+#define TCF_EM_CMP              1
+#define TCF_EM_NBYTE            2
+#define TCF_EM_U32              3
+#define TCF_EM_META             4
+#define TCF_EM_TEXT             5
+#define TCF_EM_MAX              5
 
 enum
 {
diff --git a/include/linux/pkt_sched.h b/include/linux/pkt_sched.h
index d10f35338507..268c51599eb8 100644
--- a/include/linux/pkt_sched.h
+++ b/include/linux/pkt_sched.h
@@ -101,6 +101,15 @@ struct tc_prio_qopt
         __u8    priomap[TC_PRIO_MAX+1]; /* Map: logical priority -> PRIO band */
 };
 
+enum
+{
+        TCA_PRIO_UNSPEC,
+        TCA_PRIO_MQ,
+        __TCA_PRIO_MAX
+};
+
+#define TCA_PRIO_MAX    (__TCA_PRIO_MAX - 1)
+
 /* TBF section */
 
 struct tc_tbf_qopt
diff --git a/include/linux/pm.h b/include/linux/pm.h
index b2c4fde4e994..ad3cc2eb0d34 100644
--- a/include/linux/pm.h
+++ b/include/linux/pm.h
@@ -101,6 +101,7 @@ struct pm_dev
  */
 extern void (*pm_idle)(void);
 extern void (*pm_power_off)(void);
+extern void (*pm_power_off_prepare)(void);
 
 typedef int __bitwise suspend_state_t;
 
@@ -267,15 +268,10 @@ struct dev_pm_info {
         unsigned                can_wakeup:1;
 #ifdef  CONFIG_PM
         unsigned                should_wakeup:1;
-        pm_message_t            prev_state;
-        void                    * saved_state;
-        struct device           * pm_parent;
         struct list_head        entry;
 #endif
 };
 
-extern void device_pm_set_parent(struct device * dev, struct device * parent);
-
 extern int device_power_down(pm_message_t state);
 extern void device_power_up(void);
 extern void device_resume(void);
@@ -289,8 +285,6 @@ extern int device_prepare_suspend(pm_message_t state);
 #define device_may_wakeup(dev) \
         (device_can_wakeup(dev) && (dev)->power.should_wakeup)
 
-extern int dpm_runtime_suspend(struct device *, pm_message_t);
-extern void dpm_runtime_resume(struct device *);
 extern void __suspend_report_result(const char *function, void *fn, int ret);
 
 #define suspend_report_result(fn, ret)                                  \
@@ -322,15 +316,6 @@ static inline int device_suspend(pm_message_t state)
 #define device_set_wakeup_enable(dev,val)       do{}while(0)
 #define device_may_wakeup(dev)                  (0)
 
-static inline int dpm_runtime_suspend(struct device * dev, pm_message_t state)
-{
-        return 0;
-}
-
-static inline void dpm_runtime_resume(struct device * dev)
-{
-}
-
 #define suspend_report_result(fn, ret) do { } while (0)
 
 static inline int call_platform_enable_wakeup(struct device *dev, int is_on)
diff --git a/include/linux/prctl.h b/include/linux/prctl.h
index 52a9be41250d..e2eff9079fe9 100644
--- a/include/linux/prctl.h
+++ b/include/linux/prctl.h
@@ -59,4 +59,8 @@
 # define PR_ENDIAN_LITTLE       1       /* True little endian mode */
 # define PR_ENDIAN_PPC_LITTLE   2       /* "PowerPC" pseudo little endian */
 
+/* Get/set process seccomp mode */
+#define PR_GET_SECCOMP  21
+#define PR_SET_SECCOMP  22
+
 #endif /* _LINUX_PRCTL_H */
diff --git a/include/linux/prefetch.h b/include/linux/prefetch.h
index fc86f274147f..1adfe668d031 100644
--- a/include/linux/prefetch.h
+++ b/include/linux/prefetch.h
@@ -27,7 +27,7 @@
         
         prefetch(x)     - prefetches the cacheline at "x" for read
         prefetchw(x)    - prefetches the cacheline at "x" for write
-        spin_lock_prefetch(x) - prefectches the spinlock *x for taking
+        spin_lock_prefetch(x) - prefetches the spinlock *x for taking
         
         there is also PREFETCH_STRIDE which is the architecure-prefered 
         "lookahead" size for prefetching streamed operations.
diff --git a/include/linux/proc_fs.h b/include/linux/proc_fs.h
index 3469f96bc8b2..28e3664fdf1b 100644
--- a/include/linux/proc_fs.h
+++ b/include/linux/proc_fs.h
@@ -7,6 +7,8 @@
 #include <linux/magic.h>
 #include <asm/atomic.h>
 
+struct completion;
+
 /*
  * The proc filesystem constants/structures
  */
@@ -56,6 +58,14 @@ struct proc_dir_entry {
         gid_t gid;
         loff_t size;
         const struct inode_operations *proc_iops;
+        /*
+         * NULL ->proc_fops means "PDE is going away RSN" or
+         * "PDE is just created". In either case, e.g. ->read_proc won't be
+         * called because it's too late or too early, respectively.
+         *
+         * If you're allocating ->proc_fops dynamically, save a pointer
+         * somewhere.
+         */
         const struct file_operations *proc_fops;
         get_info_t *get_info;
         struct module *owner;
@@ -66,6 +76,9 @@ struct proc_dir_entry {
         atomic_t count;         /* use count */
         int deleted;            /* delete flag */
         void *set;
+        int pde_users;  /* number of callers into module in progress */
+        spinlock_t pde_unload_lock; /* proc_fops checks and pde_users bumps */
+        struct completion *pde_unload_completion;
 };
 
 struct kcore_list {
diff --git a/include/linux/ptrace.h b/include/linux/ptrace.h
index eeb1976ef7bf..ae8146abd746 100644
--- a/include/linux/ptrace.h
+++ b/include/linux/ptrace.h
@@ -110,6 +110,8 @@ static inline void ptrace_unlink(struct task_struct *child)
                 __ptrace_unlink(child);
 }
 
+int generic_ptrace_peekdata(struct task_struct *tsk, long addr, long data);
+int generic_ptrace_pokedata(struct task_struct *tsk, long addr, long data);
 
 #ifndef force_successful_syscall_return
 /*
diff --git a/include/linux/raid/bitmap.h b/include/linux/raid/bitmap.h
index dd5a05d03d4f..75e17a05540e 100644
--- a/include/linux/raid/bitmap.h
+++ b/include/linux/raid/bitmap.h
@@ -262,7 +262,7 @@ int  bitmap_active(struct bitmap *bitmap);
 
 char *file_path(struct file *file, char *buf, int count);
 void bitmap_print_sb(struct bitmap *bitmap);
-int bitmap_update_sb(struct bitmap *bitmap);
+void bitmap_update_sb(struct bitmap *bitmap);
 
 int  bitmap_setallbits(struct bitmap *bitmap);
 void bitmap_write_all(struct bitmap *bitmap);
@@ -278,8 +278,8 @@ int bitmap_start_sync(struct bitmap *bitmap, sector_t offset, int *blocks, int d
 void bitmap_end_sync(struct bitmap *bitmap, sector_t offset, int *blocks, int aborted);
 void bitmap_close_sync(struct bitmap *bitmap);
 
-int bitmap_unplug(struct bitmap *bitmap);
-int bitmap_daemon_work(struct bitmap *bitmap);
+void bitmap_unplug(struct bitmap *bitmap);
+void bitmap_daemon_work(struct bitmap *bitmap);
 #endif
 
 #endif
diff --git a/include/linux/raid/md_k.h b/include/linux/raid/md_k.h
index de72c49747c8..28ac632b42dd 100644
--- a/include/linux/raid/md_k.h
+++ b/include/linux/raid/md_k.h
@@ -51,7 +51,7 @@ struct mdk_rdev_s
 
         sector_t size;                  /* Device size (in blocks) */
         mddev_t *mddev;                 /* RAID array if running */
-        unsigned long last_events;      /* IO event timestamp */
+        long last_events;               /* IO event timestamp */
 
         struct block_device *bdev;      /* block device handle */
 
diff --git a/include/linux/raid/raid5.h b/include/linux/raid/raid5.h
index d8286db60b96..93678f57ccbe 100644
--- a/include/linux/raid/raid5.h
+++ b/include/linux/raid/raid5.h
@@ -116,13 +116,46 @@
  *  attach a request to an active stripe (add_stripe_bh())
  *     lockdev attach-buffer unlockdev
  *  handle a stripe (handle_stripe())
- *     lockstripe clrSTRIPE_HANDLE ... (lockdev check-buffers unlockdev) .. change-state .. record io needed unlockstripe schedule io
+ *     lockstripe clrSTRIPE_HANDLE ...
+ *              (lockdev check-buffers unlockdev) ..
+ *              change-state ..
+ *              record io/ops needed unlockstripe schedule io/ops
  *  release an active stripe (release_stripe())
  *     lockdev if (!--cnt) { if  STRIPE_HANDLE, add to handle_list else add to inactive-list } unlockdev
  *
  * The refcount counts each thread that have activated the stripe,
  * plus raid5d if it is handling it, plus one for each active request
- * on a cached buffer.
+ * on a cached buffer, and plus one if the stripe is undergoing stripe
+ * operations.
+ *
+ * Stripe operations are performed outside the stripe lock,
+ * the stripe operations are:
+ * -copying data between the stripe cache and user application buffers
+ * -computing blocks to save a disk access, or to recover a missing block
+ * -updating the parity on a write operation (reconstruct write and
+ *  read-modify-write)
+ * -checking parity correctness
+ * -running i/o to disk
+ * These operations are carried out by raid5_run_ops which uses the async_tx
+ * api to (optionally) offload operations to dedicated hardware engines.
+ * When requesting an operation handle_stripe sets the pending bit for the
+ * operation and increments the count.  raid5_run_ops is then run whenever
+ * the count is non-zero.
+ * There are some critical dependencies between the operations that prevent some
+ * from being requested while another is in flight.
+ * 1/ Parity check operations destroy the in cache version of the parity block,
+ *    so we prevent parity dependent operations like writes and compute_blocks
+ *    from starting while a check is in progress.  Some dma engines can perform
+ *    the check without damaging the parity block, in these cases the parity
+ *    block is re-marked up to date (assuming the check was successful) and is
+ *    not re-read from disk.
+ * 2/ When a write operation is requested we immediately lock the affected
+ *    blocks, and mark them as not up to date.  This causes new read requests
+ *    to be held off, as well as parity checks and compute block operations.
+ * 3/ Once a compute block operation has been requested handle_stripe treats
+ *    that block as if it is up to date.  raid5_run_ops guaruntees that any
+ *    operation that is dependent on the compute block result is initiated after
+ *    the compute block completes.
  */
 
 struct stripe_head {
@@ -136,15 +169,46 @@ struct stripe_head {
         spinlock_t              lock;
         int                     bm_seq; /* sequence number for bitmap flushes */
         int                     disks;                  /* disks in stripe */
+        /* stripe_operations
+         * @pending - pending ops flags (set for request->issue->complete)
+         * @ack - submitted ops flags (set for issue->complete)
+         * @complete - completed ops flags (set for complete)
+         * @target - STRIPE_OP_COMPUTE_BLK target
+         * @count - raid5_runs_ops is set to run when this is non-zero
+         */
+        struct stripe_operations {
+                unsigned long      pending;
+                unsigned long      ack;
+                unsigned long      complete;
+                int                target;
+                int                count;
+                u32                zero_sum_result;
+        } ops;
         struct r5dev {
                 struct bio      req;
                 struct bio_vec  vec;
                 struct page     *page;
-                struct bio      *toread, *towrite, *written;
+                struct bio      *toread, *read, *towrite, *written;
                 sector_t        sector;                 /* sector of this page */
                 unsigned long   flags;
         } dev[1]; /* allocated with extra space depending of RAID geometry */
 };
+
+/* stripe_head_state - collects and tracks the dynamic state of a stripe_head
+ *     for handle_stripe.  It is only valid under spin_lock(sh->lock);
+ */
+struct stripe_head_state {
+        int syncing, expanding, expanded;
+        int locked, uptodate, to_read, to_write, failed, written;
+        int to_fill, compute, req_compute, non_overwrite;
+        int failed_num;
+};
+
+/* r6_state - extra state data only relevant to r6 */
+struct r6_state {
+        int p_failed, q_failed, qd_idx, failed_num[2];
+};
+
 /* Flags */
 #define R5_UPTODATE     0       /* page contains current data */
 #define R5_LOCKED       1       /* IO has been submitted on "req" */
@@ -158,6 +222,15 @@ struct stripe_head {
 #define R5_ReWrite      9       /* have tried to over-write the readerror */
 
 #define R5_Expanded     10      /* This block now has post-expand data */
+#define R5_Wantcompute  11 /* compute_block in progress treat as
+                                    * uptodate
+                                    */
+#define R5_Wantfill     12 /* dev->toread contains a bio that needs
+                                    * filling
+                                    */
+#define R5_Wantprexor   13 /* distinguish blocks ready for rmw from
+                                    * other "towrites"
+                                    */
 /*
  * Write method
  */
@@ -180,6 +253,24 @@ struct stripe_head {
 #define STRIPE_EXPAND_SOURCE    10
 #define STRIPE_EXPAND_READY     11
 /*
+ * Operations flags (in issue order)
+ */
+#define STRIPE_OP_BIOFILL       0
+#define STRIPE_OP_COMPUTE_BLK   1
+#define STRIPE_OP_PREXOR        2
+#define STRIPE_OP_BIODRAIN      3
+#define STRIPE_OP_POSTXOR       4
+#define STRIPE_OP_CHECK 5
+#define STRIPE_OP_IO            6
+
+/* modifiers to the base operations
+ * STRIPE_OP_MOD_REPAIR_PD - compute the parity block and write it back
+ * STRIPE_OP_MOD_DMA_CHECK - parity is not corrupted by the check
+ */
+#define STRIPE_OP_MOD_REPAIR_PD 7
+#define STRIPE_OP_MOD_DMA_CHECK 8
+
+/*
  * Plugging:
  *
  * To improve write throughput, we need to delay the handling of some
diff --git a/include/linux/raid/xor.h b/include/linux/raid/xor.h
index f0d67cbdea40..3e120587eada 100644
--- a/include/linux/raid/xor.h
+++ b/include/linux/raid/xor.h
@@ -3,9 +3,10 @@
 
 #include <linux/raid/md.h>
 
-#define MAX_XOR_BLOCKS 5
+#define MAX_XOR_BLOCKS 4
 
-extern void xor_block(unsigned int count, unsigned int bytes, void **ptr);
+extern void xor_blocks(unsigned int count, unsigned int bytes,
+        void *dest, void **srcs);
 
 struct xor_block_template {
         struct xor_block_template *next;
diff --git a/include/linux/reboot.h b/include/linux/reboot.h
index 1dd1c707311f..85ea63f462af 100644
--- a/include/linux/reboot.h
+++ b/include/linux/reboot.h
@@ -67,6 +67,11 @@ extern void kernel_power_off(void);
 
 void ctrl_alt_del(void);
 
+#define POWEROFF_CMD_PATH_LEN   256
+extern char poweroff_cmd[POWEROFF_CMD_PATH_LEN];
+
+extern int orderly_poweroff(bool force);
+
 /*
  * Emergency restart, callable from an interrupt handler.
  */
diff --git a/include/linux/resume-trace.h b/include/linux/resume-trace.h
index 81e9299ca148..f3f4f28c6960 100644
--- a/include/linux/resume-trace.h
+++ b/include/linux/resume-trace.h
@@ -2,6 +2,7 @@
 #define RESUME_TRACE_H
 
 #ifdef CONFIG_PM_TRACE
+#include <asm/resume-trace.h>
 
 extern int pm_trace_enabled;
 
@@ -9,20 +10,10 @@ struct device;
 extern void set_trace_device(struct device *);
 extern void generate_resume_trace(void *tracedata, unsigned int user);
 
-#define TRACE_DEVICE(dev) set_trace_device(dev)
-#define TRACE_RESUME(user) do {                                 \
-        if (pm_trace_enabled) {                                 \
-                void *tracedata;                                \
-                asm volatile("movl $1f,%0\n"                    \
-                        ".section .tracedata,\"a\"\n"           \
-                        "1:\t.word %c1\n"                       \
-                        "\t.long %c2\n"                         \
-                        ".previous"                             \
-                        :"=r" (tracedata)                       \
-                        : "i" (__LINE__), "i" (__FILE__));      \
-                generate_resume_trace(tracedata, user);         \
-        }                                                       \
-} while (0)
+#define TRACE_DEVICE(dev) do { \
+        if (pm_trace_enabled) \
+                set_trace_device(dev); \
+        } while(0)
 
 #else
 
diff --git a/include/linux/rtc/m48t59.h b/include/linux/rtc/m48t59.h
new file mode 100644
index 000000000000..e8c7c21ceb1f
--- /dev/null
+++ b/include/linux/rtc/m48t59.h
@@ -0,0 +1,57 @@
+/*
+ * include/linux/rtc/m48t59.h
+ *
+ * Definitions for the platform data of m48t59 RTC chip driver.
+ *
+ * Copyright (c) 2007 Wind River Systems, Inc.
+ *
+ * Mark Zhan <rongkai.zhan@windriver.com>
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License version 2 as
+ * published by the Free Software Foundation.
+ */
+
+#ifndef _LINUX_RTC_M48T59_H_
+#define _LINUX_RTC_M48T59_H_
+
+/*
+ * M48T59 Register Offset
+ */
+#define M48T59_YEAR             0x1fff
+#define M48T59_MONTH            0x1ffe
+#define M48T59_MDAY             0x1ffd  /* Day of Month */
+#define M48T59_WDAY             0x1ffc  /* Day of Week */
+#define M48T59_WDAY_CB                  0x20    /* Century Bit */
+#define M48T59_WDAY_CEB                 0x10    /* Century Enable Bit */
+#define M48T59_HOUR             0x1ffb
+#define M48T59_MIN              0x1ffa
+#define M48T59_SEC              0x1ff9
+#define M48T59_CNTL             0x1ff8
+#define M48T59_CNTL_READ                0x40
+#define M48T59_CNTL_WRITE               0x80
+#define M48T59_WATCHDOG         0x1ff7
+#define M48T59_INTR             0x1ff6
+#define M48T59_INTR_AFE                 0x80    /* Alarm Interrupt Enable */
+#define M48T59_INTR_ABE                 0x20
+#define M48T59_ALARM_DATE       0x1ff5
+#define M48T59_ALARM_HOUR       0x1ff4
+#define M48T59_ALARM_MIN        0x1ff3
+#define M48T59_ALARM_SEC        0x1ff2
+#define M48T59_UNUSED           0x1ff1
+#define M48T59_FLAGS            0x1ff0
+#define M48T59_FLAGS_WDT                0x80    /* watchdog timer expired */
+#define M48T59_FLAGS_AF                 0x40    /* alarm */
+#define M48T59_FLAGS_BF                 0x10    /* low battery */
+
+#define M48T59_NVRAM_SIZE       0x1ff0
+
+struct m48t59_plat_data {
+        /* The method to access M48T59 registers,
+         * NOTE: The 'ofs' should be 0x00~0x1fff
+         */
+        void (*write_byte)(struct device *dev, u32 ofs, u8 val);
+        unsigned char (*read_byte)(struct device *dev, u32 ofs);
+};
+
+#endif /* _LINUX_RTC_M48T59_H_ */
diff --git a/include/linux/rtnetlink.h b/include/linux/rtnetlink.h
index 1fae30af91f3..c91476ce314a 100644
--- a/include/linux/rtnetlink.h
+++ b/include/linux/rtnetlink.h
@@ -261,7 +261,7 @@ enum rtattr_type_t
         RTA_FLOW,
         RTA_CACHEINFO,
         RTA_SESSION,
-        RTA_MP_ALGO,
+        RTA_MP_ALGO, /* no longer used */
         RTA_TABLE,
         __RTA_MAX
 };
@@ -570,10 +570,16 @@ static __inline__ int rtattr_strcmp(const struct rtattr *rta, const char *str)
 }
 
 extern int rtattr_parse(struct rtattr *tb[], int maxattr, struct rtattr *rta, int len);
+extern int __rtattr_parse_nested_compat(struct rtattr *tb[], int maxattr,
+                                        struct rtattr *rta, int len);
 
 #define rtattr_parse_nested(tb, max, rta) \
         rtattr_parse((tb), (max), RTA_DATA((rta)), RTA_PAYLOAD((rta)))
 
+#define rtattr_parse_nested_compat(tb, max, rta, data, len) \
+({      data = RTA_PAYLOAD(rta) >= len ? RTA_DATA(rta) : NULL; \
+        __rtattr_parse_nested_compat(tb, max, rta, len); })
+
 extern int rtnetlink_send(struct sk_buff *skb, u32 pid, u32 group, int echo);
 extern int rtnl_unicast(struct sk_buff *skb, u32 pid);
 extern int rtnl_notify(struct sk_buff *skb, u32 pid, u32 group,
@@ -638,6 +644,18 @@ extern void __rta_fill(struct sk_buff *skb, int attrtype, int attrlen, const voi
 ({      (start)->rta_len = skb_tail_pointer(skb) - (unsigned char *)(start); \
         (skb)->len; })
 
+#define RTA_NEST_COMPAT(skb, type, attrlen, data) \
+({      struct rtattr *__start = (struct rtattr *)skb_tail_pointer(skb); \
+        RTA_PUT(skb, type, attrlen, data); \
+        RTA_NEST(skb, type); \
+        __start; })
+
+#define RTA_NEST_COMPAT_END(skb, start) \
+({      struct rtattr *__nest = (void *)(start) + NLMSG_ALIGN((start)->rta_len); \
+        (start)->rta_len = skb_tail_pointer(skb) - (unsigned char *)(start); \
+        RTA_NEST_END(skb, __nest); \
+        (skb)->len; })
+
 #define RTA_NEST_CANCEL(skb, start) \
 ({      if (start) \
                 skb_trim(skb, (unsigned char *) (start) - (skb)->data); \
diff --git a/include/linux/sched.h b/include/linux/sched.h
index cfb680585ab8..33b9b4841ee7 100644
--- a/include/linux/sched.h
+++ b/include/linux/sched.h
@@ -26,6 +26,7 @@
 #define CLONE_STOPPED           0x02000000      /* Start in stopped state */
 #define CLONE_NEWUTS            0x04000000      /* New utsname group? */
 #define CLONE_NEWIPC            0x08000000      /* New ipcs */
+#define CLONE_NEWUSER           0x10000000      /* New user namespace */
 
 /*
  * Scheduling policies
@@ -287,6 +288,7 @@ extern signed long schedule_timeout_uninterruptible(signed long timeout);
 asmlinkage void schedule(void);
 
 struct nsproxy;
+struct user_namespace;
 
 /* Maximum number of active map areas.. This is a random (large) number */
 #define DEFAULT_MAX_MAP_COUNT   65536
@@ -343,6 +345,27 @@ typedef unsigned long mm_counter_t;
                 (mm)->hiwater_vm = (mm)->total_vm;      \
 } while (0)
 
+extern void set_dumpable(struct mm_struct *mm, int value);
+extern int get_dumpable(struct mm_struct *mm);
+
+/* mm flags */
+/* dumpable bits */
+#define MMF_DUMPABLE      0  /* core dump is permitted */
+#define MMF_DUMP_SECURELY 1  /* core file is readable only by root */
+#define MMF_DUMPABLE_BITS 2
+
+/* coredump filter bits */
+#define MMF_DUMP_ANON_PRIVATE   2
+#define MMF_DUMP_ANON_SHARED    3
+#define MMF_DUMP_MAPPED_PRIVATE 4
+#define MMF_DUMP_MAPPED_SHARED  5
+#define MMF_DUMP_FILTER_SHIFT   MMF_DUMPABLE_BITS
+#define MMF_DUMP_FILTER_BITS    4
+#define MMF_DUMP_FILTER_MASK \
+        (((1 << MMF_DUMP_FILTER_BITS) - 1) << MMF_DUMP_FILTER_SHIFT)
+#define MMF_DUMP_FILTER_DEFAULT \
+        ((1 << MMF_DUMP_ANON_PRIVATE) | (1 << MMF_DUMP_ANON_SHARED))
+
 struct mm_struct {
         struct vm_area_struct * mmap;           /* list of VMAs */
         struct rb_root mm_rb;
@@ -400,7 +423,7 @@ struct mm_struct {
         unsigned int token_priority;
         unsigned int last_interval;
 
-        unsigned char dumpable:2;
+        unsigned long flags; /* Must use atomic bitops to access the bits */
 
         /* coredumping support */
         int core_waiters;
@@ -529,6 +552,10 @@ struct signal_struct {
 #ifdef CONFIG_TASKSTATS
         struct taskstats *stats;
 #endif
+#ifdef CONFIG_AUDIT
+        unsigned audit_tty;
+        struct tty_audit_buf *tty_audit_buf;
+#endif
 };
 
 /* Context switch must be unlocked if interrupts are to be enabled */
@@ -972,7 +999,8 @@ struct task_struct {
         unsigned int rt_priority;
         cputime_t utime, stime;
         unsigned long nvcsw, nivcsw; /* context switch counts */
-        struct timespec start_time;
+        struct timespec start_time;             /* monotonic time */
+        struct timespec real_start_time;        /* boot based time */
 /* mm fault and swap info: this can arguably be seen as either mm-specific or thread-specific */
         unsigned long min_flt, maj_flt;
 
@@ -1320,6 +1348,13 @@ static inline int set_cpus_allowed(struct task_struct *p, cpumask_t new_mask)
 #endif
 
 extern unsigned long long sched_clock(void);
+
+/*
+ * For kernel-internal use: high-speed (but slightly incorrect) per-cpu
+ * clock constructed from sched_clock():
+ */
+extern unsigned long long cpu_clock(int cpu);
+
 extern unsigned long long
 task_sched_runtime(struct task_struct *task);
 
@@ -1403,7 +1438,7 @@ extern struct task_struct *find_task_by_pid_type(int type, int pid);
 extern void __set_special_pids(pid_t session, pid_t pgrp);
 
 /* per-UID process charging. */
-extern struct user_struct * alloc_uid(uid_t);
+extern struct user_struct * alloc_uid(struct user_namespace *, uid_t);
 static inline struct user_struct *get_uid(struct user_struct *u)
 {
         atomic_inc(&u->__count);
diff --git a/include/linux/screen_info.h b/include/linux/screen_info.h
index b02308ee7667..3ee412bc00ec 100644
--- a/include/linux/screen_info.h
+++ b/include/linux/screen_info.h
@@ -10,7 +10,7 @@
 struct screen_info {
         u8  orig_x;             /* 0x00 */
         u8  orig_y;             /* 0x01 */
-        u16 dontuse1;           /* 0x02 -- EXT_MEM_K sits here */
+        u16 ext_mem_k;          /* 0x02 */
         u16 orig_video_page;    /* 0x04 */
         u8  orig_video_mode;    /* 0x06 */
         u8  orig_video_cols;    /* 0x07 */
@@ -27,7 +27,7 @@ struct screen_info {
         u16 lfb_depth;          /* 0x16 */
         u32 lfb_base;           /* 0x18 */
         u32 lfb_size;           /* 0x1c */
-        u16 dontuse2, dontuse3; /* 0x20 -- CL_MAGIC and CL_OFFSET here */
+        u16 cl_magic, cl_offset; /* 0x20 */
         u16 lfb_linelength;     /* 0x24 */
         u8  red_size;           /* 0x26 */
         u8  red_pos;            /* 0x27 */
@@ -42,9 +42,8 @@ struct screen_info {
         u16 pages;              /* 0x32 */
         u16 vesa_attributes;    /* 0x34 */
         u32 capabilities;       /* 0x36 */
-                                /* 0x3a -- 0x3b reserved for future expansion */
-                                /* 0x3c -- 0x3f micro stack for relocatable kernels */
-};
+        u8  _reserved[6];       /* 0x3a */
+} __attribute__((packed));
 
 extern struct screen_info screen_info;
 
diff --git a/include/linux/scx200_gpio.h b/include/linux/scx200_gpio.h
index 1a82d30c4b17..d2b058130eb1 100644
--- a/include/linux/scx200_gpio.h
+++ b/include/linux/scx200_gpio.h
@@ -1,5 +1,3 @@
-#include <linux/spinlock.h>
-
 u32 scx200_gpio_configure(unsigned index, u32 set, u32 clear);
 
 extern unsigned scx200_gpio_base;
diff --git a/include/linux/seccomp.h b/include/linux/seccomp.h
index 3e8b1cf54303..262a8dccfa81 100644
--- a/include/linux/seccomp.h
+++ b/include/linux/seccomp.h
@@ -4,8 +4,6 @@
 
 #ifdef CONFIG_SECCOMP
 
-#define NR_SECCOMP_MODES 1
-
 #include <linux/thread_info.h>
 #include <asm/seccomp.h>
 
@@ -18,20 +16,23 @@ static inline void secure_computing(int this_syscall)
                 __secure_computing(this_syscall);
 }
 
-static inline int has_secure_computing(struct thread_info *ti)
-{
-        return unlikely(test_ti_thread_flag(ti, TIF_SECCOMP));
-}
+extern long prctl_get_seccomp(void);
+extern long prctl_set_seccomp(unsigned long);
 
 #else /* CONFIG_SECCOMP */
 
 typedef struct { } seccomp_t;
 
 #define secure_computing(x) do { } while (0)
-/* static inline to preserve typechecking */
-static inline int has_secure_computing(struct thread_info *ti)
+
+static inline long prctl_get_seccomp(void)
+{
+        return -EINVAL;
+}
+
+static inline long prctl_set_seccomp(unsigned long arg2)
 {
-        return 0;
+        return -EINVAL;
 }
 
 #endif /* CONFIG_SECCOMP */
diff --git a/include/linux/security.h b/include/linux/security.h
index 9eb9e0fe0331..c11dc8aa0351 100644
--- a/include/linux/security.h
+++ b/include/linux/security.h
@@ -71,6 +71,7 @@ struct xfrm_user_sec_ctx;
 extern int cap_netlink_send(struct sock *sk, struct sk_buff *skb);
 extern int cap_netlink_recv(struct sk_buff *skb, int cap);
 
+extern unsigned long mmap_min_addr;
 /*
  * Values used in the task_security_ops calls
  */
@@ -1241,8 +1242,9 @@ struct security_operations {
         int (*file_ioctl) (struct file * file, unsigned int cmd,
                            unsigned long arg);
         int (*file_mmap) (struct file * file,
-                          unsigned long reqprot,
-                          unsigned long prot, unsigned long flags);
+                          unsigned long reqprot, unsigned long prot,
+                          unsigned long flags, unsigned long addr,
+                          unsigned long addr_only);
         int (*file_mprotect) (struct vm_area_struct * vma,
                               unsigned long reqprot,
                               unsigned long prot);
@@ -1814,9 +1816,12 @@ static inline int security_file_ioctl (struct file *file, unsigned int cmd,
 
 static inline int security_file_mmap (struct file *file, unsigned long reqprot,
                                       unsigned long prot,
-                                      unsigned long flags)
+                                      unsigned long flags,
+                                      unsigned long addr,
+                                      unsigned long addr_only)
 {
-        return security_ops->file_mmap (file, reqprot, prot, flags);
+        return security_ops->file_mmap (file, reqprot, prot, flags, addr,
+                                        addr_only);
 }
 
 static inline int security_file_mprotect (struct vm_area_struct *vma,
@@ -2489,7 +2494,9 @@ static inline int security_file_ioctl (struct file *file, unsigned int cmd,
 
 static inline int security_file_mmap (struct file *file, unsigned long reqprot,
                                       unsigned long prot,
-                                      unsigned long flags)
+                                      unsigned long flags,
+                                      unsigned long addr,
+                                      unsigned long addr_only)
 {
         return 0;
 }
diff --git a/include/linux/serial.h b/include/linux/serial.h
index 33fc8cb8ddfb..deb714314fb1 100644
--- a/include/linux/serial.h
+++ b/include/linux/serial.h
@@ -177,11 +177,5 @@ struct serial_icounter_struct {
 #ifdef __KERNEL__
 #include <linux/compiler.h>
 
-/* Allow architectures to override entries in serial8250_ports[] at run time: */
-struct uart_port;       /* forward declaration */
-extern int early_serial_setup(struct uart_port *port);
-extern int early_serial_console_init(char *options);
-extern int serial8250_start_console(struct uart_port *port, char *options);
-
 #endif /* __KERNEL__ */
 #endif /* _LINUX_SERIAL_H */
diff --git a/include/linux/serial_8250.h b/include/linux/serial_8250.h
index 71310d80c09a..8518fa2a6f89 100644
--- a/include/linux/serial_8250.h
+++ b/include/linux/serial_8250.h
@@ -60,4 +60,10 @@ void serial8250_unregister_port(int line);
 void serial8250_suspend_port(int line);
 void serial8250_resume_port(int line);
 
+extern int early_serial_setup(struct uart_port *port);
+
+extern int serial8250_find_port(struct uart_port *p);
+extern int serial8250_find_port_for_earlycon(void);
+extern int setup_early_serial8250_console(char *cmdline);
+
 #endif
diff --git a/include/linux/serial_core.h b/include/linux/serial_core.h
index 7f2c99d66e9d..773d8d8828ad 100644
--- a/include/linux/serial_core.h
+++ b/include/linux/serial_core.h
@@ -62,8 +62,9 @@
 /* NEC v850.  */
 #define PORT_V850E_UART 40
 
-/* DZ */
-#define PORT_DZ         47
+/* DEC */
+#define PORT_DZ         46
+#define PORT_ZS         47
 
 /* Parisc type numbers. */
 #define PORT_MUX        48
@@ -142,6 +143,9 @@
 /* Micrel KS8695 */
 #define PORT_KS8695     76
 
+/* Broadcom SB1250, etc. SOC */
+#define PORT_SB1250_DUART       77
+
 
 #ifdef __KERNEL__
 
diff --git a/include/linux/serio.h b/include/linux/serio.h
index 1ebf0455e224..9f3825014674 100644
--- a/include/linux/serio.h
+++ b/include/linux/serio.h
@@ -209,5 +209,7 @@ static inline void serio_unpin_driver(struct serio *serio)
 #define SERIO_PENMOUNT  0x31
 #define SERIO_TOUCHRIGHT        0x32
 #define SERIO_TOUCHWIN  0x33
+#define SERIO_TAOSEVM   0x34
+#define SERIO_FUJITSU   0x35
 
 #endif
diff --git a/include/linux/signal.h b/include/linux/signal.h
index 9a5eac508e5e..0ae338866240 100644
--- a/include/linux/signal.h
+++ b/include/linux/signal.h
@@ -6,7 +6,6 @@
 
 #ifdef __KERNEL__
 #include <linux/list.h>
-#include <linux/spinlock.h>
 
 /*
  * Real Time signals may be queued.
@@ -238,12 +237,15 @@ extern int group_send_sig_info(int sig, struct siginfo *info, struct task_struct
 extern int __group_send_sig_info(int, struct siginfo *, struct task_struct *);
 extern long do_sigpending(void __user *, unsigned long);
 extern int sigprocmask(int, sigset_t *, sigset_t *);
+extern int show_unhandled_signals;
 
 struct pt_regs;
 extern int get_signal_to_deliver(siginfo_t *info, struct k_sigaction *return_ka, struct pt_regs *regs, void *cookie);
 
 extern struct kmem_cache *sighand_cachep;
 
+int unhandled_signal(struct task_struct *tsk, int sig);
+
 /*
  * In POSIX a signal is sent either to a specific thread (Linux task)
  * or to the process as a whole (Linux thread group).  How the signal
diff --git a/include/linux/skbuff.h b/include/linux/skbuff.h
index 6f0b2f7d0010..ce256438e619 100644
--- a/include/linux/skbuff.h
+++ b/include/linux/skbuff.h
@@ -65,13 +65,20 @@
  *          is able to produce some skb->csum, it MUST use COMPLETE,
  *          not UNNECESSARY.
  *
+ *      PARTIAL: identical to the case for output below.  This may occur
+ *          on a packet received directly from another Linux OS, e.g.,
+ *          a virtualised Linux kernel on the same host.  The packet can
+ *          be treated in the same way as UNNECESSARY except that on
+ *          output (i.e., forwarding) the checksum must be filled in
+ *          by the OS or the hardware.
+ *
  * B. Checksumming on output.
  *
  *      NONE: skb is checksummed by protocol or csum is not required.
  *
  *      PARTIAL: device is required to csum packet as seen by hard_start_xmit
- *      from skb->transport_header to the end and to record the checksum
- *      at skb->transport_header + skb->csum.
+ *      from skb->csum_start to the end and to record the checksum
+ *      at skb->csum_start + skb->csum_offset.
  *
  *      Device must show its capabilities in dev->features, set
  *      at device setup time.
@@ -82,6 +89,7 @@
  *                        TCP/UDP over IPv4. Sigh. Vendors like this
  *                        way by an unknown reason. Though, see comment above
  *                        about CHECKSUM_UNNECESSARY. 8)
+ *      NETIF_F_IPV6_CSUM about as dumb as the last one but does IPv6 instead.
  *
  *      Any questions? No questions, good.              --ANK
  */
@@ -147,8 +155,8 @@ struct skb_shared_info {
 
 /* We divide dataref into two halves.  The higher 16 bits hold references
  * to the payload part of skb->data.  The lower 16 bits hold references to
- * the entire skb->data.  It is up to the users of the skb to agree on
- * where the payload starts.
+ * the entire skb->data.  A clone of a headerless skb holds the length of
+ * the header in skb->hdr_len.
  *
  * All users must obey the rule that the skb->data reference count must be
  * greater than or equal to the payload reference count.
@@ -196,7 +204,6 @@ typedef unsigned char *sk_buff_data_t;
  *      @sk: Socket we are owned by
  *      @tstamp: Time we arrived
  *      @dev: Device we arrived on/are leaving by
- *      @iif: ifindex of device we arrived on
  *      @transport_header: Transport layer header
  *      @network_header: Network layer header
  *      @mac_header: Link layer header
@@ -206,6 +213,7 @@ typedef unsigned char *sk_buff_data_t;
  *      @len: Length of actual data
  *      @data_len: Data length
  *      @mac_len: Length of link layer header
+ *      @hdr_len: writable header length of cloned skb
  *      @csum: Checksum (must include start/offset pair)
  *      @csum_start: Offset from skb->head where checksumming should start
  *      @csum_offset: Offset from csum_start where checksum should be stored
@@ -227,9 +235,12 @@ typedef unsigned char *sk_buff_data_t;
  *      @mark: Generic packet mark
  *      @nfct: Associated connection, if any
  *      @ipvs_property: skbuff is owned by ipvs
+ *      @nf_trace: netfilter packet trace flag
  *      @nfctinfo: Relationship of this skb to the connection
  *      @nfct_reasm: netfilter conntrack re-assembly pointer
  *      @nf_bridge: Saved data about a bridged frame - see br_netfilter.c
+ *      @iif: ifindex of device we arrived on
+ *      @queue_mapping: Queue mapping for multiqueue devices
  *      @tc_index: Traffic control index
  *      @tc_verd: traffic control verdict
  *      @dma_cookie: a cookie to one of several possible DMA operations
@@ -245,8 +256,6 @@ struct sk_buff {
         struct sock             *sk;
         ktime_t                 tstamp;
         struct net_device       *dev;
-        int                     iif;
-        /* 4 byte hole on 64 bit*/
 
         struct  dst_entry       *dst;
         struct  sec_path        *sp;
@@ -260,8 +269,9 @@ struct sk_buff {
         char                    cb[48];
 
         unsigned int            len,
-                                data_len,
-                                mac_len;
+                                data_len;
+        __u16                   mac_len,
+                                hdr_len;
         union {
                 __wsum          csum;
                 struct {
@@ -277,7 +287,8 @@ struct sk_buff {
                                 nfctinfo:3;
         __u8                    pkt_type:3,
                                 fclone:2,
-                                ipvs_property:1;
+                                ipvs_property:1,
+                                nf_trace:1;
         __be16                  protocol;
 
         void                    (*destructor)(struct sk_buff *skb);
@@ -288,12 +299,18 @@ struct sk_buff {
 #ifdef CONFIG_BRIDGE_NETFILTER
         struct nf_bridge_info   *nf_bridge;
 #endif
+
+        int                     iif;
+        __u16                   queue_mapping;
+
 #ifdef CONFIG_NET_SCHED
         __u16                   tc_index;       /* traffic control index */
 #ifdef CONFIG_NET_CLS_ACT
         __u16                   tc_verd;        /* traffic control verdict */
 #endif
 #endif
+        /* 2 byte hole */
+
 #ifdef CONFIG_NET_DMA
         dma_cookie_t            dma_cookie;
 #endif
@@ -1322,6 +1339,20 @@ static inline struct sk_buff *netdev_alloc_skb(struct net_device *dev,
 }
 
 /**
+ *      skb_clone_writable - is the header of a clone writable
+ *      @skb: buffer to check
+ *      @len: length up to which to write
+ *
+ *      Returns true if modifying the header part of the cloned buffer
+ *      does not requires the data to be copied.
+ */
+static inline int skb_clone_writable(struct sk_buff *skb, int len)
+{
+        return !skb_header_cloned(skb) &&
+               skb_headroom(skb) + len <= skb->hdr_len;
+}
+
+/**
  *      skb_cow - copy header of skb when it is required
  *      @skb: buffer to cow
  *      @headroom: needed headroom
@@ -1608,7 +1639,7 @@ static inline int skb_csum_unnecessary(const struct sk_buff *skb)
  *      if skb->ip_summed is CHECKSUM_UNNECESSARY which indicates that the
  *      hardware has already verified the correctness of the checksum.
  */
-static inline unsigned int skb_checksum_complete(struct sk_buff *skb)
+static inline __sum16 skb_checksum_complete(struct sk_buff *skb)
 {
         return skb_csum_unnecessary(skb) ?
                0 : __skb_checksum_complete(skb);
@@ -1709,6 +1740,20 @@ static inline void skb_init_secmark(struct sk_buff *skb)
 { }
 #endif
 
+static inline void skb_set_queue_mapping(struct sk_buff *skb, u16 queue_mapping)
+{
+#ifdef CONFIG_NETDEVICES_MULTIQUEUE
+        skb->queue_mapping = queue_mapping;
+#endif
+}
+
+static inline void skb_copy_queue_mapping(struct sk_buff *to, const struct sk_buff *from)
+{
+#ifdef CONFIG_NETDEVICES_MULTIQUEUE
+        to->queue_mapping = from->queue_mapping;
+#endif
+}
+
 static inline int skb_is_gso(const struct sk_buff *skb)
 {
         return skb_shinfo(skb)->gso_size;
diff --git a/include/linux/slab.h b/include/linux/slab.h
index cebcd3833c76..d859354b9e51 100644
--- a/include/linux/slab.h
+++ b/include/linux/slab.h
@@ -14,8 +14,6 @@
 #include <linux/gfp.h>
 #include <linux/types.h>
 
-typedef struct kmem_cache kmem_cache_t __deprecated;
-
 /*
  * Flags to pass to kmem_cache_create().
  * The ones marked DEBUG are only valid if CONFIG_SLAB_DEBUG is set.
@@ -33,6 +31,19 @@ typedef struct kmem_cache kmem_cache_t __deprecated;
 #define SLAB_TRACE              0x00200000UL    /* Trace allocations and frees */
 
 /*
+ * ZERO_SIZE_PTR will be returned for zero sized kmalloc requests.
+ *
+ * Dereferencing ZERO_SIZE_PTR will lead to a distinct access fault.
+ *
+ * ZERO_SIZE_PTR can be passed to kfree though in the same way that NULL can.
+ * Both make kfree a no-op.
+ */
+#define ZERO_SIZE_PTR ((void *)16)
+
+#define ZERO_OR_NULL_PTR(x) ((unsigned long)(x) <= \
+                                (unsigned long)ZERO_SIZE_PTR)
+
+/*
  * struct kmem_cache related prototypes
  */
 void __init kmem_cache_init(void);
@@ -40,12 +51,9 @@ int slab_is_available(void);
 
 struct kmem_cache *kmem_cache_create(const char *, size_t, size_t,
                         unsigned long,
-                        void (*)(void *, struct kmem_cache *, unsigned long),
                         void (*)(void *, struct kmem_cache *, unsigned long));
 void kmem_cache_destroy(struct kmem_cache *);
 int kmem_cache_shrink(struct kmem_cache *);
-void *kmem_cache_alloc(struct kmem_cache *, gfp_t);
-void *kmem_cache_zalloc(struct kmem_cache *, gfp_t);
 void kmem_cache_free(struct kmem_cache *, void *);
 unsigned int kmem_cache_size(struct kmem_cache *);
 const char *kmem_cache_name(struct kmem_cache *);
@@ -61,17 +69,7 @@ int kmem_ptr_validate(struct kmem_cache *cachep, const void *ptr);
  */
 #define KMEM_CACHE(__struct, __flags) kmem_cache_create(#__struct,\
                 sizeof(struct __struct), __alignof__(struct __struct),\
-                (__flags), NULL, NULL)
-
-#ifdef CONFIG_NUMA
-extern void *kmem_cache_alloc_node(struct kmem_cache *, gfp_t flags, int node);
-#else
-static inline void *kmem_cache_alloc_node(struct kmem_cache *cachep,
-                                        gfp_t flags, int node)
-{
-        return kmem_cache_alloc(cachep, flags);
-}
-#endif
+                (__flags), NULL)
 
 /*
  * The largest kmalloc size supported by the slab allocators is
@@ -91,59 +89,50 @@ static inline void *kmem_cache_alloc_node(struct kmem_cache *cachep,
 /*
  * Common kmalloc functions provided by all allocators
  */
-void *__kmalloc(size_t, gfp_t);
-void *__kzalloc(size_t, gfp_t);
 void * __must_check krealloc(const void *, size_t, gfp_t);
 void kfree(const void *);
 size_t ksize(const void *);
 
-/**
- * kcalloc - allocate memory for an array. The memory is set to zero.
- * @n: number of elements.
- * @size: element size.
- * @flags: the type of memory to allocate.
- */
-static inline void *kcalloc(size_t n, size_t size, gfp_t flags)
-{
-        if (n != 0 && size > ULONG_MAX / n)
-                return NULL;
-        return __kzalloc(n * size, flags);
-}
-
 /*
  * Allocator specific definitions. These are mainly used to establish optimized
- * ways to convert kmalloc() calls to kmem_cache_alloc() invocations by selecting
- * the appropriate general cache at compile time.
+ * ways to convert kmalloc() calls to kmem_cache_alloc() invocations by
+ * selecting the appropriate general cache at compile time.
+ *
+ * Allocators must define at least:
+ *
+ *      kmem_cache_alloc()
+ *      __kmalloc()
+ *      kmalloc()
+ *
+ * Those wishing to support NUMA must also define:
+ *
+ *      kmem_cache_alloc_node()
+ *      kmalloc_node()
+ *
+ * See each allocator definition file for additional comments and
+ * implementation notes.
  */
-
-#if defined(CONFIG_SLAB) || defined(CONFIG_SLUB)
 #ifdef CONFIG_SLUB
 #include <linux/slub_def.h>
+#elif defined(CONFIG_SLOB)
+#include <linux/slob_def.h>
 #else
 #include <linux/slab_def.h>
-#endif /* !CONFIG_SLUB */
-#else
-
-/*
- * Fallback definitions for an allocator not wanting to provide
- * its own optimized kmalloc definitions (like SLOB).
- */
+#endif
 
 /**
- * kmalloc - allocate memory
- * @size: how many bytes of memory are required.
+ * kcalloc - allocate memory for an array. The memory is set to zero.
+ * @n: number of elements.
+ * @size: element size.
  * @flags: the type of memory to allocate.
  *
- * kmalloc is the normal method of allocating memory
- * in the kernel.
- *
  * The @flags argument may be one of:
  *
  * %GFP_USER - Allocate memory on behalf of user.  May sleep.
  *
  * %GFP_KERNEL - Allocate normal kernel ram.  May sleep.
  *
- * %GFP_ATOMIC - Allocation will not sleep.
+ * %GFP_ATOMIC - Allocation will not sleep.  May use emergency pools.
  *   For example, use this inside interrupt handlers.
  *
  * %GFP_HIGHUSER - Allocate pages from high memory.
@@ -152,18 +141,22 @@ static inline void *kcalloc(size_t n, size_t size, gfp_t flags)
  *
  * %GFP_NOFS - Do not make any fs calls while trying to get memory.
  *
+ * %GFP_NOWAIT - Allocation will not sleep.
+ *
+ * %GFP_THISNODE - Allocate node-local memory only.
+ *
+ * %GFP_DMA - Allocation suitable for DMA.
+ *   Should only be used for kmalloc() caches. Otherwise, use a
+ *   slab created with SLAB_DMA.
+ *
  * Also it is possible to set different flags by OR'ing
  * in one or more of the following additional @flags:
  *
  * %__GFP_COLD - Request cache-cold pages instead of
  *   trying to return cache-warm pages.
  *
- * %__GFP_DMA - Request memory from the DMA-capable zone.
- *
  * %__GFP_HIGH - This allocation has high priority and may use emergency pools.
  *
- * %__GFP_HIGHMEM - Allocated memory may be from highmem.
- *
  * %__GFP_NOFAIL - Indicate that this allocation is in no way allowed to fail
  *   (think twice before using).
  *
@@ -173,24 +166,29 @@ static inline void *kcalloc(size_t n, size_t size, gfp_t flags)
  * %__GFP_NOWARN - If allocation fails, don't issue any warnings.
  *
  * %__GFP_REPEAT - If allocation fails initially, try once more before failing.
+ *
+ * There are other flags available as well, but these are not intended
+ * for general use, and so are not documented here. For a full list of
+ * potential flags, always refer to linux/gfp.h.
  */
-static inline void *kmalloc(size_t size, gfp_t flags)
+static inline void *kcalloc(size_t n, size_t size, gfp_t flags)
 {
-        return __kmalloc(size, flags);
+        if (n != 0 && size > ULONG_MAX / n)
+                return NULL;
+        return __kmalloc(n * size, flags | __GFP_ZERO);
 }
 
+#if !defined(CONFIG_NUMA) && !defined(CONFIG_SLOB)
 /**
- * kzalloc - allocate memory. The memory is set to zero.
+ * kmalloc_node - allocate memory from a specific node
  * @size: how many bytes of memory are required.
- * @flags: the type of memory to allocate (see kmalloc).
+ * @flags: the type of memory to allocate (see kcalloc).
+ * @node: node to allocate from.
+ *
+ * kmalloc() for non-local nodes, used to allocate from a specific node
+ * if available. Equivalent to kmalloc() in the non-NUMA single-node
+ * case.
  */
-static inline void *kzalloc(size_t size, gfp_t flags)
-{
-        return __kzalloc(size, flags);
-}
-#endif
-
-#ifndef CONFIG_NUMA
 static inline void *kmalloc_node(size_t size, gfp_t flags, int node)
 {
         return kmalloc(size, flags);
@@ -200,7 +198,15 @@ static inline void *__kmalloc_node(size_t size, gfp_t flags, int node)
 {
         return __kmalloc(size, flags);
 }
-#endif /* !CONFIG_NUMA */
+
+void *kmem_cache_alloc(struct kmem_cache *, gfp_t);
+
+static inline void *kmem_cache_alloc_node(struct kmem_cache *cachep,
+                                        gfp_t flags, int node)
+{
+        return kmem_cache_alloc(cachep, flags);
+}
+#endif /* !CONFIG_NUMA && !CONFIG_SLOB */
 
 /*
  * kmalloc_track_caller is a special version of kmalloc that records the
@@ -245,6 +251,23 @@ extern void *__kmalloc_node_track_caller(size_t, gfp_t, int, void *);
 
 #endif /* DEBUG_SLAB */
 
+/*
+ * Shortcuts
+ */
+static inline void *kmem_cache_zalloc(struct kmem_cache *k, gfp_t flags)
+{
+        return kmem_cache_alloc(k, flags | __GFP_ZERO);
+}
+
+/**
+ * kzalloc - allocate memory. The memory is set to zero.
+ * @size: how many bytes of memory are required.
+ * @flags: the type of memory to allocate (see kmalloc).
+ */
+static inline void *kzalloc(size_t size, gfp_t flags)
+{
+        return kmalloc(size, flags | __GFP_ZERO);
+}
+
 #endif  /* __KERNEL__ */
 #endif  /* _LINUX_SLAB_H */
-
diff --git a/include/linux/slab_def.h b/include/linux/slab_def.h
index 8d81a60518e4..32bdc2ffd715 100644
--- a/include/linux/slab_def.h
+++ b/include/linux/slab_def.h
@@ -25,10 +25,17 @@ struct cache_sizes {
 };
 extern struct cache_sizes malloc_sizes[];
 
+void *kmem_cache_alloc(struct kmem_cache *, gfp_t);
+void *__kmalloc(size_t size, gfp_t flags);
+
 static inline void *kmalloc(size_t size, gfp_t flags)
 {
         if (__builtin_constant_p(size)) {
                 int i = 0;
+
+                if (!size)
+                        return ZERO_SIZE_PTR;
+
 #define CACHE(x) \
                 if (size <= x) \
                         goto found; \
@@ -51,39 +58,18 @@ found:
         return __kmalloc(size, flags);
 }
 
-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:
-#ifdef CONFIG_ZONE_DMA
-                if (flags & GFP_DMA)
-                        return kmem_cache_zalloc(malloc_sizes[i].cs_dmacachep,
-                                                flags);
-#endif
-                return kmem_cache_zalloc(malloc_sizes[i].cs_cachep, flags);
-        }
-        return __kzalloc(size, flags);
-}
-
 #ifdef CONFIG_NUMA
 extern void *__kmalloc_node(size_t size, gfp_t flags, int node);
+extern void *kmem_cache_alloc_node(struct kmem_cache *, gfp_t flags, int node);
 
 static inline void *kmalloc_node(size_t size, gfp_t flags, int node)
 {
         if (__builtin_constant_p(size)) {
                 int i = 0;
+
+                if (!size)
+                        return ZERO_SIZE_PTR;
+
 #define CACHE(x) \
                 if (size <= x) \
                         goto found; \
diff --git a/include/linux/slob_def.h b/include/linux/slob_def.h
new file mode 100644
index 000000000000..59a3fa476ab9
--- /dev/null
+++ b/include/linux/slob_def.h
@@ -0,0 +1,36 @@
+#ifndef __LINUX_SLOB_DEF_H
+#define __LINUX_SLOB_DEF_H
+
+void *kmem_cache_alloc_node(struct kmem_cache *, gfp_t flags, int node);
+
+static inline void *kmem_cache_alloc(struct kmem_cache *cachep, gfp_t flags)
+{
+        return kmem_cache_alloc_node(cachep, flags, -1);
+}
+
+void *__kmalloc_node(size_t size, gfp_t flags, int node);
+
+static inline void *kmalloc_node(size_t size, gfp_t flags, int node)
+{
+        return __kmalloc_node(size, flags, node);
+}
+
+/**
+ * kmalloc - allocate memory
+ * @size: how many bytes of memory are required.
+ * @flags: the type of memory to allocate (see kcalloc).
+ *
+ * kmalloc is the normal method of allocating memory
+ * in the kernel.
+ */
+static inline void *kmalloc(size_t size, gfp_t flags)
+{
+        return __kmalloc_node(size, flags, -1);
+}
+
+static inline void *__kmalloc(size_t size, gfp_t flags)
+{
+        return kmalloc(size, flags);
+}
+
+#endif /* __LINUX_SLOB_DEF_H */
diff --git a/include/linux/slub_def.h b/include/linux/slub_def.h
index 6207a3d8da71..124270df8734 100644
--- a/include/linux/slub_def.h
+++ b/include/linux/slub_def.h
@@ -16,7 +16,9 @@ struct kmem_cache_node {
         unsigned long nr_partial;
         atomic_long_t nr_slabs;
         struct list_head partial;
+#ifdef CONFIG_SLUB_DEBUG
         struct list_head full;
+#endif
 };
 
 /*
@@ -44,7 +46,9 @@ struct kmem_cache {
         int align;              /* Alignment */
         const char *name;       /* Name (only for display!) */
         struct list_head list;  /* List of slab caches */
+#ifdef CONFIG_SLUB_DEBUG
         struct kobject kobj;    /* For sysfs */
+#endif
 
 #ifdef CONFIG_NUMA
         int defrag_ratio;
@@ -156,20 +160,11 @@ static inline struct kmem_cache *kmalloc_slab(size_t size)
 #define SLUB_DMA __GFP_DMA
 #else
 /* Disable DMA functionality */
-#define SLUB_DMA 0
+#define SLUB_DMA (__force gfp_t)0
 #endif
 
-
-/*
- * ZERO_SIZE_PTR will be returned for zero sized kmalloc requests.
- *
- * Dereferencing ZERO_SIZE_PTR will lead to a distinct access fault.
- *
- * ZERO_SIZE_PTR can be passed to kfree though in the same way that NULL can.
- * Both make kfree a no-op.
- */
-#define ZERO_SIZE_PTR ((void *)16)
-
+void *kmem_cache_alloc(struct kmem_cache *, gfp_t);
+void *__kmalloc(size_t size, gfp_t flags);
 
 static inline void *kmalloc(size_t size, gfp_t flags)
 {
@@ -184,21 +179,9 @@ static inline void *kmalloc(size_t size, gfp_t flags)
                 return __kmalloc(size, flags);
 }
 
-static inline void *kzalloc(size_t size, gfp_t flags)
-{
-        if (__builtin_constant_p(size) && !(flags & SLUB_DMA)) {
-                struct kmem_cache *s = kmalloc_slab(size);
-
-                if (!s)
-                        return ZERO_SIZE_PTR;
-
-                return kmem_cache_zalloc(s, flags);
-        } else
-                return __kzalloc(size, flags);
-}
-
 #ifdef CONFIG_NUMA
-extern void *__kmalloc_node(size_t size, gfp_t flags, int node);
+void *__kmalloc_node(size_t size, gfp_t flags, int node);
+void *kmem_cache_alloc_node(struct kmem_cache *, gfp_t flags, int node);
 
 static inline void *kmalloc_node(size_t size, gfp_t flags, int node)
 {
diff --git a/include/linux/smp.h b/include/linux/smp.h
index 96ac21f8dd73..259a13c3bd98 100644
--- a/include/linux/smp.h
+++ b/include/linux/smp.h
@@ -99,11 +99,14 @@ static inline int up_smp_call_function(void)
 static inline void smp_send_reschedule(int cpu) { }
 #define num_booting_cpus()                      1
 #define smp_prepare_boot_cpu()                  do {} while (0)
-static inline int smp_call_function_single(int cpuid, void (*func) (void *info),
-                                           void *info, int retry, int wait)
-{
-        return -EBUSY;
-}
+#define smp_call_function_single(cpuid, func, info, retry, wait) \
+({ \
+        WARN_ON(cpuid != 0);    \
+        local_irq_disable();    \
+        (func)(info);           \
+        local_irq_enable();     \
+        0;                      \
+})
 
 #endif /* !SMP */
 
diff --git a/include/linux/smp_lock.h b/include/linux/smp_lock.h
index cf715a40d833..58962c51dee1 100644
--- a/include/linux/smp_lock.h
+++ b/include/linux/smp_lock.h
@@ -3,7 +3,6 @@
 
 #ifdef CONFIG_LOCK_KERNEL
 #include <linux/sched.h>
-#include <linux/spinlock.h>
 
 #define kernel_locked()         (current->lock_depth >= 0)
 
diff --git a/include/linux/socket.h b/include/linux/socket.h
index 6e7c9483a6a6..f852e1afd65a 100644
--- a/include/linux/socket.h
+++ b/include/linux/socket.h
@@ -253,6 +253,9 @@ struct ucred {
 
 #define MSG_EOF         MSG_FIN
 
+#define MSG_CMSG_CLOEXEC 0x40000000     /* Set close_on_exit for file
+                                           descriptor received through
+                                           SCM_RIGHTS */
 #if defined(CONFIG_COMPAT)
 #define MSG_CMSG_COMPAT 0x80000000      /* This message needs 32 bit fixups */
 #else
@@ -287,6 +290,7 @@ struct ucred {
 #define SOL_NETLINK     270
 #define SOL_TIPC        271
 #define SOL_RXRPC       272
+#define SOL_PPPOL2TP    273
 
 /* IPX options */
 #define IPX_TYPE        1
diff --git a/include/linux/sonypi.h b/include/linux/sonypi.h
index 34d4b075f7b8..40c7b5d993b9 100644
--- a/include/linux/sonypi.h
+++ b/include/linux/sonypi.h
@@ -153,8 +153,6 @@
 #define SONYPI_COMMAND_GETCAMERAROMVERSION      18      /* obsolete */
 #define SONYPI_COMMAND_GETCAMERAREVISION        19      /* obsolete */
 
-int sonypi_camera_command(int command, u8 value);
-
 #endif                          /* __KERNEL__ */
 
 #endif                          /* _SONYPI_H_ */
diff --git a/include/linux/spi/ads7846.h b/include/linux/spi/ads7846.h
index 3387e44dfd13..334d31411629 100644
--- a/include/linux/spi/ads7846.h
+++ b/include/linux/spi/ads7846.h
@@ -16,6 +16,20 @@ struct ads7846_platform_data {
         u16     vref_delay_usecs;       /* 0 for external vref; etc */
         int     keep_vref_on:1;         /* set to keep vref on for differential
                                          * measurements as well */
+
+        /* Settling time of the analog signals; a function of Vcc and the
+         * capacitance on the X/Y drivers.  If set to non-zero, two samples
+         * are taken with settle_delay us apart, and the second one is used.
+         * ~150 uSec with 0.01uF caps.
+         */
+        u16     settle_delay_usecs;
+
+        /* If set to non-zero, after samples are taken this delay is applied
+         * and penirq is rechecked, to help avoid false events.  This value
+         * is affected by the material used to build the touch layer.
+         */
+        u16     penirq_recheck_delay_usecs;
+
         u16     x_plate_ohms;
         u16     y_plate_ohms;
 
diff --git a/include/linux/spi/spi.h b/include/linux/spi/spi.h
index 1be5ea059477..302b81d1d117 100644
--- a/include/linux/spi/spi.h
+++ b/include/linux/spi/spi.h
@@ -76,6 +76,7 @@ struct spi_device {
 #define SPI_MODE_3      (SPI_CPOL|SPI_CPHA)
 #define SPI_CS_HIGH     0x04                    /* chipselect active high? */
 #define SPI_LSB_FIRST   0x08                    /* per-word bits-on-wire */
+#define SPI_3WIRE       0x10                    /* SI/SO signals shared */
         u8                      bits_per_word;
         int                     irq;
         void                    *controller_state;
diff --git a/include/linux/spi/spi_bitbang.h b/include/linux/spi/spi_bitbang.h
index 9dbca629dcfb..b8db32cea1de 100644
--- a/include/linux/spi/spi_bitbang.h
+++ b/include/linux/spi/spi_bitbang.h
@@ -26,6 +26,7 @@ struct spi_bitbang {
         struct list_head        queue;
         u8                      busy;
         u8                      use_dma;
+        u8                      flags;          /* extra spi->mode support */
 
         struct spi_master       *master;
 
diff --git a/include/linux/spi/tle62x0.h b/include/linux/spi/tle62x0.h
new file mode 100644
index 000000000000..60b59187e590
--- /dev/null
+++ b/include/linux/spi/tle62x0.h
@@ -0,0 +1,24 @@
+/*
+ * tle62x0.h - platform glue to Infineon TLE62x0 driver chips
+ *
+ * Copyright 2007 Simtec Electronics
+ *      Ben Dooks <ben@simtec.co.uk>
+ *
+ * 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.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
+*/
+
+struct tle62x0_pdata {
+        unsigned int            init_state;
+        unsigned int            gpio_count;
+};
diff --git a/include/linux/spinlock.h b/include/linux/spinlock.h
index a946176db638..c376f3b36c89 100644
--- a/include/linux/spinlock.h
+++ b/include/linux/spinlock.h
@@ -282,6 +282,13 @@ do {						\
         1 : ({ local_irq_restore(flags); 0; }); \
 })
 
+#define write_trylock_irqsave(lock, flags) \
+({ \
+        local_irq_save(flags); \
+        write_trylock(lock) ? \
+        1 : ({ local_irq_restore(flags); 0; }); \
+})
+
 /*
  * Locks two spinlocks l1 and l2.
  * l1_first indicates if spinlock l1 should be taken first.
diff --git a/include/linux/spinlock_types.h b/include/linux/spinlock_types.h
index 210549ba4ef4..f6a3a951b79e 100644
--- a/include/linux/spinlock_types.h
+++ b/include/linux/spinlock_types.h
@@ -9,14 +9,14 @@
  * Released under the General Public License (GPL).
  */
 
-#include <linux/lockdep.h>
-
 #if defined(CONFIG_SMP)
 # include <asm/spinlock_types.h>
 #else
 # include <linux/spinlock_types_up.h>
 #endif
 
+#include <linux/lockdep.h>
+
 typedef struct {
         raw_spinlock_t raw_lock;
 #if defined(CONFIG_PREEMPT) && defined(CONFIG_SMP)
diff --git a/include/linux/spinlock_types_up.h b/include/linux/spinlock_types_up.h
index 27644af20b7c..04135b0e198e 100644
--- a/include/linux/spinlock_types_up.h
+++ b/include/linux/spinlock_types_up.h
@@ -12,14 +12,10 @@
  * Released under the General Public License (GPL).
  */
 
-#if defined(CONFIG_DEBUG_SPINLOCK) || \
-        defined(CONFIG_DEBUG_LOCK_ALLOC)
+#ifdef CONFIG_DEBUG_SPINLOCK
 
 typedef struct {
         volatile unsigned int slock;
-#ifdef CONFIG_DEBUG_LOCK_ALLOC
-        struct lockdep_map dep_map;
-#endif
 } raw_spinlock_t;
 
 #define __RAW_SPIN_LOCK_UNLOCKED { 1 }
@@ -34,9 +30,6 @@ typedef struct { } raw_spinlock_t;
 
 typedef struct {
         /* no debug version on UP */
-#ifdef CONFIG_DEBUG_LOCK_ALLOC
-        struct lockdep_map dep_map;
-#endif
 } raw_rwlock_t;
 
 #define __RAW_RW_LOCK_UNLOCKED { }
diff --git a/include/linux/stacktrace.h b/include/linux/stacktrace.h
index 1d2b084c0185..e7fa657d0c49 100644
--- a/include/linux/stacktrace.h
+++ b/include/linux/stacktrace.h
@@ -13,7 +13,7 @@ extern void save_stack_trace(struct stack_trace *trace);
 extern void print_stack_trace(struct stack_trace *trace, int spaces);
 #else
 # define save_stack_trace(trace)                        do { } while (0)
-# define print_stack_trace(trace)                       do { } while (0)
+# define print_stack_trace(trace, spaces)               do { } while (0)
 #endif
 
 #endif
diff --git a/include/linux/string.h b/include/linux/string.h
index 7f2eb6a477f9..836062b7582a 100644
--- a/include/linux/string.h
+++ b/include/linux/string.h
@@ -105,8 +105,12 @@ extern void * memchr(const void *,int,__kernel_size_t);
 #endif
 
 extern char *kstrdup(const char *s, gfp_t gfp);
+extern char *kstrndup(const char *s, size_t len, gfp_t gfp);
 extern void *kmemdup(const void *src, size_t len, gfp_t gfp);
 
+extern char **argv_split(gfp_t gfp, const char *str, int *argcp);
+extern void argv_free(char **argv);
+
 #ifdef __cplusplus
 }
 #endif
diff --git a/include/linux/sunrpc/auth.h b/include/linux/sunrpc/auth.h
index 534cdc7be58d..7a69ca3bebaf 100644
--- a/include/linux/sunrpc/auth.h
+++ b/include/linux/sunrpc/auth.h
@@ -16,6 +16,7 @@
 #include <linux/sunrpc/xdr.h>
 
 #include <asm/atomic.h>
+#include <linux/rcupdate.h>
 
 /* size of the nodename buffer */
 #define UNX_MAXNODENAME 32
@@ -30,22 +31,28 @@ struct auth_cred {
 /*
  * Client user credentials
  */
+struct rpc_auth;
+struct rpc_credops;
 struct rpc_cred {
         struct hlist_node       cr_hash;        /* hash chain */
-        struct rpc_credops *    cr_ops;
-        unsigned long           cr_expire;      /* when to gc */
-        atomic_t                cr_count;       /* ref count */
-        unsigned short          cr_flags;       /* various flags */
+        struct list_head        cr_lru;         /* lru garbage collection */
+        struct rcu_head         cr_rcu;
+        struct rpc_auth *       cr_auth;
+        const struct rpc_credops *cr_ops;
 #ifdef RPC_DEBUG
         unsigned long           cr_magic;       /* 0x0f4aa4f0 */
 #endif
+        unsigned long           cr_expire;      /* when to gc */
+        unsigned long           cr_flags;       /* various flags */
+        atomic_t                cr_count;       /* ref count */
 
         uid_t                   cr_uid;
 
         /* per-flavor data */
 };
-#define RPCAUTH_CRED_NEW        0x0001
-#define RPCAUTH_CRED_UPTODATE   0x0002
+#define RPCAUTH_CRED_NEW        0
+#define RPCAUTH_CRED_UPTODATE   1
+#define RPCAUTH_CRED_HASHED     2
 
 #define RPCAUTH_CRED_MAGIC      0x0f4aa4f0
 
@@ -56,10 +63,10 @@ struct rpc_cred {
 #define RPC_CREDCACHE_MASK      (RPC_CREDCACHE_NR - 1)
 struct rpc_cred_cache {
         struct hlist_head       hashtable[RPC_CREDCACHE_NR];
-        unsigned long           nextgc;         /* next garbage collection */
-        unsigned long           expire;         /* cache expiry interval */
+        spinlock_t              lock;
 };
 
+struct rpc_authops;
 struct rpc_auth {
         unsigned int            au_cslack;      /* call cred size estimate */
                                 /* guess at number of u32's auth adds before
@@ -69,7 +76,7 @@ struct rpc_auth {
         unsigned int            au_verfsize;
 
         unsigned int            au_flags;       /* various flags */
-        struct rpc_authops *    au_ops;         /* operations */
+        const struct rpc_authops *au_ops;               /* operations */
         rpc_authflavor_t        au_flavor;      /* pseudoflavor (note may
                                                  * differ from the flavor in
                                                  * au_ops->au_flavor in gss
@@ -115,17 +122,19 @@ struct rpc_credops {
                                                 void *, __be32 *, void *);
 };
 
-extern struct rpc_authops       authunix_ops;
-extern struct rpc_authops       authnull_ops;
-#ifdef CONFIG_SUNRPC_SECURE
-extern struct rpc_authops       authdes_ops;
-#endif
+extern const struct rpc_authops authunix_ops;
+extern const struct rpc_authops authnull_ops;
+
+void __init             rpc_init_authunix(void);
+void __init             rpcauth_init_module(void);
+void __exit             rpcauth_remove_module(void);
 
-int                     rpcauth_register(struct rpc_authops *);
-int                     rpcauth_unregister(struct rpc_authops *);
+int                     rpcauth_register(const struct rpc_authops *);
+int                     rpcauth_unregister(const struct rpc_authops *);
 struct rpc_auth *       rpcauth_create(rpc_authflavor_t, struct rpc_clnt *);
-void                    rpcauth_destroy(struct rpc_auth *);
+void                    rpcauth_release(struct rpc_auth *);
 struct rpc_cred *       rpcauth_lookup_credcache(struct rpc_auth *, struct auth_cred *, int);
+void                    rpcauth_init_cred(struct rpc_cred *, const struct auth_cred *, struct rpc_auth *, const struct rpc_credops *);
 struct rpc_cred *       rpcauth_lookupcred(struct rpc_auth *, int);
 struct rpc_cred *       rpcauth_bindcred(struct rpc_task *);
 void                    rpcauth_holdcred(struct rpc_task *);
@@ -138,8 +147,9 @@ int			rpcauth_unwrap_resp(struct rpc_task *task, kxdrproc_t decode, void *rqstp,
 int                     rpcauth_refreshcred(struct rpc_task *);
 void                    rpcauth_invalcred(struct rpc_task *);
 int                     rpcauth_uptodatecred(struct rpc_task *);
-int                     rpcauth_init_credcache(struct rpc_auth *, unsigned long);
-void                    rpcauth_free_credcache(struct rpc_auth *);
+int                     rpcauth_init_credcache(struct rpc_auth *);
+void                    rpcauth_destroy_credcache(struct rpc_auth *);
+void                    rpcauth_clear_credcache(struct rpc_cred_cache *);
 
 static inline
 struct rpc_cred *       get_rpccred(struct rpc_cred *cred)
diff --git a/include/linux/sunrpc/auth_gss.h b/include/linux/sunrpc/auth_gss.h
index 2db2fbf34947..67658e17a375 100644
--- a/include/linux/sunrpc/auth_gss.h
+++ b/include/linux/sunrpc/auth_gss.h
@@ -75,6 +75,7 @@ struct gss_cl_ctx {
         struct xdr_netobj       gc_wire_ctx;
         u32                     gc_win;
         unsigned long           gc_expiry;
+        struct rcu_head         gc_rcu;
 };
 
 struct gss_upcall_msg;
@@ -85,11 +86,6 @@ struct gss_cred {
         struct gss_upcall_msg   *gc_upcall;
 };
 
-#define gc_uid                  gc_base.cr_uid
-#define gc_count                gc_base.cr_count
-#define gc_flags                gc_base.cr_flags
-#define gc_expire               gc_base.cr_expire
-
 #endif /* __KERNEL__ */
 #endif /* _LINUX_SUNRPC_AUTH_GSS_H */
 
diff --git a/include/linux/sunrpc/clnt.h b/include/linux/sunrpc/clnt.h
index 66611423c8ee..c0d9d14983b3 100644
--- a/include/linux/sunrpc/clnt.h
+++ b/include/linux/sunrpc/clnt.h
@@ -24,8 +24,10 @@ struct rpc_inode;
  * The high-level client handle
  */
 struct rpc_clnt {
-        atomic_t                cl_count;       /* Number of clones */
-        atomic_t                cl_users;       /* number of references */
+        struct kref             cl_kref;        /* Number of references */
+        struct list_head        cl_clients;     /* Global list of clients */
+        struct list_head        cl_tasks;       /* List of tasks */
+        spinlock_t              cl_lock;        /* spinlock */
         struct rpc_xprt *       cl_xprt;        /* transport */
         struct rpc_procinfo *   cl_procinfo;    /* procedure info */
         u32                     cl_prog,        /* RPC program number */
@@ -41,9 +43,7 @@ struct rpc_clnt {
         unsigned int            cl_softrtry : 1,/* soft timeouts */
                                 cl_intr     : 1,/* interruptible */
                                 cl_discrtry : 1,/* disconnect before retry */
-                                cl_autobind : 1,/* use getport() */
-                                cl_oneshot  : 1,/* dispose after use */
-                                cl_dead     : 1;/* abandoned */
+                                cl_autobind : 1;/* use getport() */
 
         struct rpc_rtt *        cl_rtt;         /* RTO estimator data */
 
@@ -98,6 +98,7 @@ struct rpc_create_args {
         int                     protocol;
         struct sockaddr         *address;
         size_t                  addrsize;
+        struct sockaddr         *saddress;
         struct rpc_timeout      *timeout;
         char                    *servername;
         struct rpc_program      *program;
@@ -110,20 +111,20 @@ struct rpc_create_args {
 #define RPC_CLNT_CREATE_HARDRTRY        (1UL << 0)
 #define RPC_CLNT_CREATE_INTR            (1UL << 1)
 #define RPC_CLNT_CREATE_AUTOBIND        (1UL << 2)
-#define RPC_CLNT_CREATE_ONESHOT         (1UL << 3)
-#define RPC_CLNT_CREATE_NONPRIVPORT     (1UL << 4)
-#define RPC_CLNT_CREATE_NOPING          (1UL << 5)
-#define RPC_CLNT_CREATE_DISCRTRY        (1UL << 6)
+#define RPC_CLNT_CREATE_NONPRIVPORT     (1UL << 3)
+#define RPC_CLNT_CREATE_NOPING          (1UL << 4)
+#define RPC_CLNT_CREATE_DISCRTRY        (1UL << 5)
 
 struct rpc_clnt *rpc_create(struct rpc_create_args *args);
 struct rpc_clnt *rpc_bind_new_program(struct rpc_clnt *,
                                 struct rpc_program *, int);
 struct rpc_clnt *rpc_clone_client(struct rpc_clnt *);
-int             rpc_shutdown_client(struct rpc_clnt *);
-int             rpc_destroy_client(struct rpc_clnt *);
+void            rpc_shutdown_client(struct rpc_clnt *);
 void            rpc_release_client(struct rpc_clnt *);
+
 int             rpcb_register(u32, u32, int, unsigned short, int *);
-void            rpcb_getport(struct rpc_task *);
+int             rpcb_getport_sync(struct sockaddr_in *, __u32, __u32, int);
+void            rpcb_getport_async(struct rpc_task *);
 
 void            rpc_call_setup(struct rpc_task *, struct rpc_message *, int);
 
@@ -132,20 +133,16 @@ int		rpc_call_async(struct rpc_clnt *clnt, struct rpc_message *msg,
                                void *calldata);
 int             rpc_call_sync(struct rpc_clnt *clnt, struct rpc_message *msg,
                               int flags);
+struct rpc_task *rpc_call_null(struct rpc_clnt *clnt, struct rpc_cred *cred,
+                               int flags);
 void            rpc_restart_call(struct rpc_task *);
 void            rpc_clnt_sigmask(struct rpc_clnt *clnt, sigset_t *oldset);
 void            rpc_clnt_sigunmask(struct rpc_clnt *clnt, sigset_t *oldset);
 void            rpc_setbufsize(struct rpc_clnt *, unsigned int, unsigned int);
 size_t          rpc_max_payload(struct rpc_clnt *);
 void            rpc_force_rebind(struct rpc_clnt *);
-int             rpc_ping(struct rpc_clnt *clnt, int flags);
 size_t          rpc_peeraddr(struct rpc_clnt *, struct sockaddr *, size_t);
 char *          rpc_peeraddr2str(struct rpc_clnt *, enum rpc_display_format_t);
 
-/*
- * Helper function for NFSroot support
- */
-int             rpcb_getport_external(struct sockaddr_in *, __u32, __u32, int);
-
 #endif /* __KERNEL__ */
 #endif /* _LINUX_SUNRPC_CLNT_H */
diff --git a/include/linux/sunrpc/gss_api.h b/include/linux/sunrpc/gss_api.h
index 5eca9e442051..459c5fc11d51 100644
--- a/include/linux/sunrpc/gss_api.h
+++ b/include/linux/sunrpc/gss_api.h
@@ -58,6 +58,7 @@ u32 gss_unwrap(
 u32 gss_delete_sec_context(
                 struct gss_ctx          **ctx_id);
 
+u32 gss_svc_to_pseudoflavor(struct gss_api_mech *, u32 service);
 u32 gss_pseudoflavor_to_service(struct gss_api_mech *, u32 pseudoflavor);
 char *gss_service_to_auth_domain_name(struct gss_api_mech *, u32 service);
 
@@ -77,7 +78,7 @@ struct gss_api_mech {
         struct module           *gm_owner;
         struct xdr_netobj       gm_oid;
         char                    *gm_name;
-        struct gss_api_ops      *gm_ops;
+        const struct gss_api_ops *gm_ops;
         /* pseudoflavors supported by this mechanism: */
         int                     gm_pf_num;
         struct pf_desc *        gm_pfs;
diff --git a/include/linux/sunrpc/rpc_pipe_fs.h b/include/linux/sunrpc/rpc_pipe_fs.h
index ad293760f6eb..51b977a4ca20 100644
--- a/include/linux/sunrpc/rpc_pipe_fs.h
+++ b/include/linux/sunrpc/rpc_pipe_fs.h
@@ -23,9 +23,11 @@ struct rpc_inode {
         void *private;
         struct list_head pipe;
         struct list_head in_upcall;
+        struct list_head in_downcall;
         int pipelen;
         int nreaders;
         int nwriters;
+        int nkern_readwriters;
         wait_queue_head_t waitq;
 #define RPC_PIPE_WAIT_FOR_OPEN  1
         int flags;
diff --git a/include/linux/sunrpc/sched.h b/include/linux/sunrpc/sched.h
index 2047fb202a13..8ea077db0099 100644
--- a/include/linux/sunrpc/sched.h
+++ b/include/linux/sunrpc/sched.h
@@ -98,7 +98,6 @@ struct rpc_task {
         unsigned short          tk_pid;         /* debugging aid */
 #endif
 };
-#define tk_auth                 tk_client->cl_auth
 #define tk_xprt                 tk_client->cl_xprt
 
 /* support walking a list of tasks on a wait queue */
@@ -110,11 +109,6 @@ struct rpc_task {
         if (!list_empty(head) &&  \
             ((task=list_entry((head)->next, struct rpc_task, u.tk_wait.list)),1))
 
-/* .. and walking list of all tasks */
-#define alltask_for_each(task, pos, head) \
-        list_for_each(pos, head) \
-                if ((task=list_entry(pos, struct rpc_task, tk_task)),1)
-
 typedef void                    (*rpc_action)(struct rpc_task *);
 
 struct rpc_call_ops {
diff --git a/include/linux/sunrpc/svc.h b/include/linux/sunrpc/svc.h
index 129d50f2225c..8531a70da73d 100644
--- a/include/linux/sunrpc/svc.h
+++ b/include/linux/sunrpc/svc.h
@@ -212,6 +212,7 @@ struct svc_rqst {
         struct svc_pool *       rq_pool;        /* thread pool */
         struct svc_procedure *  rq_procinfo;    /* procedure info */
         struct auth_ops *       rq_authop;      /* authentication flavour */
+        u32                     rq_flavor;      /* pseudoflavor */
         struct svc_cred         rq_cred;        /* auth info */
         struct sk_buff *        rq_skbuff;      /* fast recv inet buffer */
         struct svc_deferred_req*rq_deferred;    /* deferred request we are replaying */
@@ -248,6 +249,7 @@ struct svc_rqst {
                                                  */
         /* Catering to nfsd */
         struct auth_domain *    rq_client;      /* RPC peer info */
+        struct auth_domain *    rq_gssclient;   /* "gss/"-style peer info */
         struct svc_cacherep *   rq_cacherep;    /* cache info */
         struct knfsd_fh *       rq_reffh;       /* Referrence filehandle, used to
                                                  * determine what device number
diff --git a/include/linux/sunrpc/svcauth.h b/include/linux/sunrpc/svcauth.h
index de92619b0826..22e1ef8e200e 100644
--- a/include/linux/sunrpc/svcauth.h
+++ b/include/linux/sunrpc/svcauth.h
@@ -127,6 +127,7 @@ extern struct auth_domain *auth_unix_lookup(struct in_addr addr);
 extern int auth_unix_forget_old(struct auth_domain *dom);
 extern void svcauth_unix_purge(void);
 extern void svcauth_unix_info_release(void *);
+extern int svcauth_unix_set_client(struct svc_rqst *rqstp);
 
 static inline unsigned long hash_str(char *name, int bits)
 {
diff --git a/include/linux/sunrpc/svcauth_gss.h b/include/linux/sunrpc/svcauth_gss.h
index 5a5db16ab660..417a1def56db 100644
--- a/include/linux/sunrpc/svcauth_gss.h
+++ b/include/linux/sunrpc/svcauth_gss.h
@@ -22,6 +22,7 @@
 int gss_svc_init(void);
 void gss_svc_shutdown(void);
 int svcauth_gss_register_pseudoflavor(u32 pseudoflavor, char * name);
+u32 svcauth_gss_flavor(struct auth_domain *dom);
 
 #endif /* __KERNEL__ */
 #endif /* _LINUX_SUNRPC_SVCAUTH_GSS_H */
diff --git a/include/linux/sunrpc/svcsock.h b/include/linux/sunrpc/svcsock.h
index e21dd93ac4b7..a53e0fa855d2 100644
--- a/include/linux/sunrpc/svcsock.h
+++ b/include/linux/sunrpc/svcsock.h
@@ -59,6 +59,7 @@ struct svc_sock {
         /* cache of various info for TCP sockets */
         void                    *sk_info_authunix;
 
+        struct sockaddr_storage sk_local;       /* local address */
         struct sockaddr_storage sk_remote;      /* remote peer's address */
         int                     sk_remotelen;   /* length of address */
 };
diff --git a/include/linux/sunrpc/xdr.h b/include/linux/sunrpc/xdr.h
index 9e340fa23c06..c6b53d181bfa 100644
--- a/include/linux/sunrpc/xdr.h
+++ b/include/linux/sunrpc/xdr.h
@@ -12,6 +12,7 @@
 #include <linux/uio.h>
 #include <asm/byteorder.h>
 #include <linux/scatterlist.h>
+#include <linux/smp_lock.h>
 
 /*
  * Buffer adjustment
@@ -36,6 +37,21 @@ struct xdr_netobj {
 typedef int     (*kxdrproc_t)(void *rqstp, __be32 *data, void *obj);
 
 /*
+ * We're still requiring the BKL in the xdr code until it's been
+ * more carefully audited, at which point this wrapper will become
+ * unnecessary.
+ */
+static inline int rpc_call_xdrproc(kxdrproc_t xdrproc, void *rqstp, __be32 *data, void *obj)
+{
+        int ret;
+
+        lock_kernel();
+        ret = xdrproc(rqstp, data, obj);
+        unlock_kernel();
+        return ret;
+}
+
+/*
  * Basic structure for transmission/reception of a client XDR message.
  * Features a header (for a linear buffer containing RPC headers
  * and the data payload for short messages), and then an array of
diff --git a/include/linux/sunrpc/xprt.h b/include/linux/sunrpc/xprt.h
index 34f7590506fa..d11cedd14f0f 100644
--- a/include/linux/sunrpc/xprt.h
+++ b/include/linux/sunrpc/xprt.h
@@ -17,6 +17,8 @@
 #include <linux/sunrpc/xdr.h>
 #include <linux/sunrpc/msg_prot.h>
 
+#ifdef __KERNEL__
+
 extern unsigned int xprt_udp_slot_table_entries;
 extern unsigned int xprt_tcp_slot_table_entries;
 
@@ -194,7 +196,13 @@ struct rpc_xprt {
         char *                  address_strings[RPC_DISPLAY_MAX];
 };
 
-#ifdef __KERNEL__
+struct rpc_xprtsock_create {
+        int                     proto;          /* IPPROTO_UDP or IPPROTO_TCP */
+        struct sockaddr *       srcaddr;        /* optional local address */
+        struct sockaddr *       dstaddr;        /* remote peer address */
+        size_t                  addrlen;
+        struct rpc_timeout *    timeout;        /* optional timeout parameters */
+};
 
 /*
  * Transport operations used by ULPs
@@ -204,7 +212,7 @@ void			xprt_set_timeout(struct rpc_timeout *to, unsigned int retr, unsigned long
 /*
  * Generic internal transport functions
  */
-struct rpc_xprt *       xprt_create_transport(int proto, struct sockaddr *addr, size_t size, struct rpc_timeout *toparms);
+struct rpc_xprt *       xprt_create_transport(struct rpc_xprtsock_create *args);
 void                    xprt_connect(struct rpc_task *task);
 void                    xprt_reserve(struct rpc_task *task);
 int                     xprt_reserve_xprt(struct rpc_task *task);
@@ -242,8 +250,8 @@ void			xprt_disconnect(struct rpc_xprt *xprt);
 /*
  * Socket transport setup operations
  */
-struct rpc_xprt *       xs_setup_udp(struct sockaddr *addr, size_t addrlen, struct rpc_timeout *to);
-struct rpc_xprt *       xs_setup_tcp(struct sockaddr *addr, size_t addrlen, struct rpc_timeout *to);
+struct rpc_xprt *       xs_setup_udp(struct rpc_xprtsock_create *args);
+struct rpc_xprt *       xs_setup_tcp(struct rpc_xprtsock_create *args);
 int                     init_socket_xprt(void);
 void                    cleanup_socket_xprt(void);
 
diff --git a/include/linux/suspend.h b/include/linux/suspend.h
index 9c7cb6430666..e8e6da394c92 100644
--- a/include/linux/suspend.h
+++ b/include/linux/suspend.h
@@ -43,14 +43,19 @@ static inline void pm_restore_console(void) {}
  * @prepare: prepare system for hibernation
  * @enter: shut down system after state has been saved to disk
  * @finish: finish/clean up after state has been reloaded
+ * @pre_restore: prepare system for the restoration from a hibernation image
+ * @restore_cleanup: clean up after a failing image restoration
  */
 struct hibernation_ops {
         int (*prepare)(void);
         int (*enter)(void);
         void (*finish)(void);
+        int (*pre_restore)(void);
+        void (*restore_cleanup)(void);
 };
 
-#if defined(CONFIG_PM) && defined(CONFIG_SOFTWARE_SUSPEND)
+#ifdef CONFIG_PM
+#ifdef CONFIG_SOFTWARE_SUSPEND
 /* kernel/power/snapshot.c */
 extern void __register_nosave_region(unsigned long b, unsigned long e, int km);
 static inline void register_nosave_region(unsigned long b, unsigned long e)
@@ -68,16 +73,14 @@ extern unsigned long get_safe_page(gfp_t gfp_mask);
 
 extern void hibernation_set_ops(struct hibernation_ops *ops);
 extern int hibernate(void);
-#else
-static inline void register_nosave_region(unsigned long b, unsigned long e) {}
-static inline void register_nosave_region_late(unsigned long b, unsigned long e) {}
+#else /* CONFIG_SOFTWARE_SUSPEND */
 static inline int swsusp_page_is_forbidden(struct page *p) { return 0; }
 static inline void swsusp_set_page_free(struct page *p) {}
 static inline void swsusp_unset_page_free(struct page *p) {}
 
 static inline void hibernation_set_ops(struct hibernation_ops *ops) {}
 static inline int hibernate(void) { return -ENOSYS; }
-#endif /* defined(CONFIG_PM) && defined(CONFIG_SOFTWARE_SUSPEND) */
+#endif /* CONFIG_SOFTWARE_SUSPEND */
 
 void save_processor_state(void);
 void restore_processor_state(void);
@@ -85,4 +88,43 @@ struct saved_context;
 void __save_processor_state(struct saved_context *ctxt);
 void __restore_processor_state(struct saved_context *ctxt);
 
+/* kernel/power/main.c */
+extern struct blocking_notifier_head pm_chain_head;
+
+static inline int register_pm_notifier(struct notifier_block *nb)
+{
+        return blocking_notifier_chain_register(&pm_chain_head, nb);
+}
+
+static inline int unregister_pm_notifier(struct notifier_block *nb)
+{
+        return blocking_notifier_chain_unregister(&pm_chain_head, nb);
+}
+
+#define pm_notifier(fn, pri) {                          \
+        static struct notifier_block fn##_nb =                  \
+                { .notifier_call = fn, .priority = pri };       \
+        register_pm_notifier(&fn##_nb);                 \
+}
+#else /* CONFIG_PM */
+
+static inline int register_pm_notifier(struct notifier_block *nb)
+{
+        return 0;
+}
+
+static inline int unregister_pm_notifier(struct notifier_block *nb)
+{
+        return 0;
+}
+
+#define pm_notifier(fn, pri)    do { (void)(fn); } while (0)
+#endif /* CONFIG_PM */
+
+#if !defined CONFIG_SOFTWARE_SUSPEND || !defined(CONFIG_PM)
+static inline void register_nosave_region(unsigned long b, unsigned long e)
+{
+}
+#endif
+
 #endif /* _LINUX_SWSUSP_H */
diff --git a/include/linux/swap.h b/include/linux/swap.h
index 006868881346..665f85f2a3af 100644
--- a/include/linux/swap.h
+++ b/include/linux/swap.h
@@ -188,7 +188,8 @@ extern int rotate_reclaimable_page(struct page *page);
 extern void swap_setup(void);
 
 /* linux/mm/vmscan.c */
-extern unsigned long try_to_free_pages(struct zone **, gfp_t);
+extern unsigned long try_to_free_pages(struct zone **zones, int order,
+                                        gfp_t gfp_mask);
 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);
diff --git a/include/linux/syscalls.h b/include/linux/syscalls.h
index 83d0ec11235e..61def7c8fbb3 100644
--- a/include/linux/syscalls.h
+++ b/include/linux/syscalls.h
@@ -549,7 +549,7 @@ asmlinkage long sys_inotify_rm_watch(int fd, u32 wd);
 asmlinkage long sys_spu_run(int fd, __u32 __user *unpc,
                                  __u32 __user *ustatus);
 asmlinkage long sys_spu_create(const char __user *name,
-                unsigned int flags, mode_t mode);
+                unsigned int flags, mode_t mode, int fd);
 
 asmlinkage long sys_mknodat(int dfd, const char __user * filename, int mode,
                             unsigned dev);
@@ -610,6 +610,7 @@ asmlinkage long sys_signalfd(int ufd, sigset_t __user *user_mask, size_t sizemas
 asmlinkage long sys_timerfd(int ufd, int clockid, int flags,
                             const struct itimerspec __user *utmr);
 asmlinkage long sys_eventfd(unsigned int count);
+asmlinkage long sys_fallocate(int fd, int mode, loff_t offset, loff_t len);
 
 int kernel_execve(const char *filename, char *const argv[], char *const envp[]);
 
diff --git a/include/linux/sysdev.h b/include/linux/sysdev.h
index e699ab279c2c..e285746588d6 100644
--- a/include/linux/sysdev.h
+++ b/include/linux/sysdev.h
@@ -101,8 +101,7 @@ struct sysdev_attribute {
 
 #define _SYSDEV_ATTR(_name,_mode,_show,_store)                  \
 {                                                               \
-        .attr = { .name = __stringify(_name), .mode = _mode,    \
-                 .owner = THIS_MODULE },                        \
+        .attr = { .name = __stringify(_name), .mode = _mode },  \
         .show   = _show,                                        \
         .store  = _store,                                       \
 }
diff --git a/include/linux/sysfs.h b/include/linux/sysfs.h
index 7d5d1ec95c2e..be8228e50a27 100644
--- a/include/linux/sysfs.h
+++ b/include/linux/sysfs.h
@@ -19,10 +19,15 @@ struct kobject;
 struct module;
 struct nameidata;
 struct dentry;
+struct sysfs_dirent;
 
+/* FIXME
+ * The *owner field is no longer used, but leave around
+ * until the tree gets cleaned up fully.
+ */
 struct attribute {
         const char              * name;
-        struct module           * owner;
+        struct module           * owner;
         mode_t                  mode;
 };
 
@@ -39,14 +44,14 @@ struct attribute_group {
  */
 
 #define __ATTR(_name,_mode,_show,_store) { \
-        .attr = {.name = __stringify(_name), .mode = _mode, .owner = THIS_MODULE },     \
+        .attr = {.name = __stringify(_name), .mode = _mode },   \
         .show   = _show,                                        \
         .store  = _store,                                       \
 }
 
 #define __ATTR_RO(_name) { \
-        .attr   = { .name = __stringify(_name), .mode = 0444, .owner = THIS_MODULE },   \
-        .show   = _name##_show, \
+        .attr   = { .name = __stringify(_name), .mode = 0444 }, \
+        .show   = _name##_show,                                 \
 }
 
 #define __ATTR_NULL { .attr = { .name = NULL } }
@@ -59,8 +64,10 @@ struct bin_attribute {
         struct attribute        attr;
         size_t                  size;
         void                    *private;
-        ssize_t (*read)(struct kobject *, char *, loff_t, size_t);
-        ssize_t (*write)(struct kobject *, char *, loff_t, size_t);
+        ssize_t (*read)(struct kobject *, struct bin_attribute *,
+                        char *, loff_t, size_t);
+        ssize_t (*write)(struct kobject *, struct bin_attribute *,
+                         char *, loff_t, size_t);
         int (*mmap)(struct kobject *, struct bin_attribute *attr,
                     struct vm_area_struct *vma);
 };
@@ -70,12 +77,16 @@ struct sysfs_ops {
         ssize_t (*store)(struct kobject *,struct attribute *,const char *, size_t);
 };
 
+#define SYSFS_TYPE_MASK         0x00ff
 #define SYSFS_ROOT              0x0001
 #define SYSFS_DIR               0x0002
 #define SYSFS_KOBJ_ATTR         0x0004
 #define SYSFS_KOBJ_BIN_ATTR     0x0008
 #define SYSFS_KOBJ_LINK         0x0020
-#define SYSFS_NOT_PINNED        (SYSFS_KOBJ_ATTR | SYSFS_KOBJ_BIN_ATTR | SYSFS_KOBJ_LINK)
+#define SYSFS_COPY_NAME         (SYSFS_DIR | SYSFS_KOBJ_LINK)
+
+#define SYSFS_FLAG_MASK         ~SYSFS_TYPE_MASK
+#define SYSFS_FLAG_REMOVED      0x0100
 
 #ifdef CONFIG_SYSFS
 
@@ -83,13 +94,14 @@ extern int sysfs_schedule_callback(struct kobject *kobj,
                 void (*func)(void *), void *data, struct module *owner);
 
 extern int __must_check
-sysfs_create_dir(struct kobject *, struct dentry *);
+sysfs_create_dir(struct kobject *kobj, struct sysfs_dirent *shadow_parent_sd);
 
 extern void
 sysfs_remove_dir(struct kobject *);
 
 extern int __must_check
-sysfs_rename_dir(struct kobject *, struct dentry *, const char *new_name);
+sysfs_rename_dir(struct kobject *kobj, struct sysfs_dirent *new_parent_sd,
+                 const char *new_name);
 
 extern int __must_check
 sysfs_move_dir(struct kobject *, struct kobject *);
@@ -129,8 +141,8 @@ void sysfs_notify(struct kobject * k, char *dir, char *attr);
 
 extern int sysfs_make_shadowed_dir(struct kobject *kobj,
         void * (*follow_link)(struct dentry *, struct nameidata *));
-extern struct dentry *sysfs_create_shadow_dir(struct kobject *kobj);
-extern void sysfs_remove_shadow_dir(struct dentry *dir);
+extern struct sysfs_dirent *sysfs_create_shadow_dir(struct kobject *kobj);
+extern void sysfs_remove_shadow_dir(struct sysfs_dirent *shadow_sd);
 
 extern int __must_check sysfs_init(void);
 
@@ -142,7 +154,8 @@ static inline int sysfs_schedule_callback(struct kobject *kobj,
         return -ENOSYS;
 }
 
-static inline int sysfs_create_dir(struct kobject * k, struct dentry *shadow)
+static inline int sysfs_create_dir(struct kobject *kobj,
+                                   struct sysfs_dirent *shadow_parent_sd)
 {
         return 0;
 }
@@ -152,9 +165,9 @@ static inline void sysfs_remove_dir(struct kobject * k)
         ;
 }
 
-static inline int sysfs_rename_dir(struct kobject * k,
-                                        struct dentry *new_parent,
-                                        const char *new_name)
+static inline int sysfs_rename_dir(struct kobject *kobj,
+                                   struct sysfs_dirent *new_parent_sd,
+                                   const char *new_name)
 {
         return 0;
 }
diff --git a/include/linux/taskstats.h b/include/linux/taskstats.h
index a46104a28f66..dce1ed204972 100644
--- a/include/linux/taskstats.h
+++ b/include/linux/taskstats.h
@@ -31,7 +31,7 @@
  */
 
 
-#define TASKSTATS_VERSION       4
+#define TASKSTATS_VERSION       5
 #define TS_COMM_LEN             32      /* should be >= TASK_COMM_LEN
                                          * in linux/sched.h */
 
@@ -149,6 +149,9 @@ struct taskstats {
         __u64   read_bytes;             /* bytes of read I/O */
         __u64   write_bytes;            /* bytes of write I/O */
         __u64   cancelled_write_bytes;  /* bytes of cancelled write I/O */
+
+        __u64  nvcsw;                   /* voluntary_ctxt_switches */
+        __u64  nivcsw;                  /* nonvoluntary_ctxt_switches */
 };
 
 
diff --git a/include/linux/time.h b/include/linux/time.h
index dda9be685ab6..e6aea5146e5d 100644
--- a/include/linux/time.h
+++ b/include/linux/time.h
@@ -4,6 +4,7 @@
 #include <linux/types.h>
 
 #ifdef __KERNEL__
+# include <linux/cache.h>
 # include <linux/seqlock.h>
 #endif
 
@@ -36,7 +37,8 @@ struct timezone {
 #define NSEC_PER_SEC    1000000000L
 #define FSEC_PER_SEC    1000000000000000L
 
-static inline int timespec_equal(struct timespec *a, struct timespec *b)
+static inline int timespec_equal(const struct timespec *a,
+                                 const struct timespec *b)
 {
         return (a->tv_sec == b->tv_sec) && (a->tv_nsec == b->tv_nsec);
 }
@@ -93,6 +95,8 @@ extern struct timespec wall_to_monotonic;
 extern seqlock_t xtime_lock __attribute__((weak));
 
 extern unsigned long read_persistent_clock(void);
+extern int update_persistent_clock(struct timespec now);
+extern int no_sync_cmos_clock __read_mostly;
 void timekeeping_init(void);
 
 static inline unsigned long get_seconds(void)
@@ -116,6 +120,8 @@ extern int do_setitimer(int which, struct itimerval *value,
 extern unsigned int alarm_setitimer(unsigned int seconds);
 extern int do_getitimer(int which, struct itimerval *value);
 extern void getnstimeofday(struct timespec *tv);
+extern void getboottime(struct timespec *ts);
+extern void monotonic_to_bootbased(struct timespec *ts);
 
 extern struct timespec timespec_trunc(struct timespec t, unsigned gran);
 extern int timekeeping_is_continuous(void);
diff --git a/include/linux/timer.h b/include/linux/timer.h
index c661710d3627..78cf899b4409 100644
--- a/include/linux/timer.h
+++ b/include/linux/timer.h
@@ -3,7 +3,6 @@
 
 #include <linux/list.h>
 #include <linux/ktime.h>
-#include <linux/spinlock.h>
 #include <linux/stddef.h>
 
 struct tvec_t_base_s;
@@ -91,16 +90,13 @@ extern unsigned long get_next_timer_interrupt(unsigned long now);
  */
 #ifdef CONFIG_TIMER_STATS
 
+#define TIMER_STATS_FLAG_DEFERRABLE     0x1
+
 extern void init_timer_stats(void);
 
 extern void timer_stats_update_stats(void *timer, pid_t pid, void *startf,
-                                     void *timerf, char * comm);
-
-static inline void timer_stats_account_timer(struct timer_list *timer)
-{
-        timer_stats_update_stats(timer, timer->start_pid, timer->start_site,
-                                 timer->function, timer->start_comm);
-}
+                                     void *timerf, char *comm,
+                                     unsigned int timer_flag);
 
 extern void __timer_stats_timer_set_start_info(struct timer_list *timer,
                                                void *addr);
@@ -119,10 +115,6 @@ static inline void init_timer_stats(void)
 {
 }
 
-static inline void timer_stats_account_timer(struct timer_list *timer)
-{
-}
-
 static inline void timer_stats_timer_set_start_info(struct timer_list *timer)
 {
 }
diff --git a/include/linux/timex.h b/include/linux/timex.h
index da929dbbea2a..37ac3ff90faf 100644
--- a/include/linux/timex.h
+++ b/include/linux/timex.h
@@ -224,66 +224,6 @@ static inline int ntp_synced(void)
         __x < 0 ? -(-__x >> __s) : __x >> __s;  \
 })
 
-
-#ifdef CONFIG_TIME_INTERPOLATION
-
-#define TIME_SOURCE_CPU 0
-#define TIME_SOURCE_MMIO64 1
-#define TIME_SOURCE_MMIO32 2
-#define TIME_SOURCE_FUNCTION 3
-
-/* For proper operations time_interpolator clocks must run slightly slower
- * than the standard clock since the interpolator may only correct by having
- * time jump forward during a tick. A slower clock is usually a side effect
- * of the integer divide of the nanoseconds in a second by the frequency.
- * The accuracy of the division can be increased by specifying a shift.
- * However, this may cause the clock not to be slow enough.
- * The interpolator will self-tune the clock by slowing down if no
- * resets occur or speeding up if the time jumps per analysis cycle
- * become too high.
- *
- * Setting jitter compensates for a fluctuating timesource by comparing
- * to the last value read from the timesource to insure that an earlier value
- * is not returned by a later call. The price to pay
- * for the compensation is that the timer routines are not as scalable anymore.
- */
-
-struct time_interpolator {
-        u16 source;                     /* time source flags */
-        u8 shift;                       /* increases accuracy of multiply by shifting. */
-                                /* Note that bits may be lost if shift is set too high */
-        u8 jitter;                      /* if set compensate for fluctuations */
-        u32 nsec_per_cyc;               /* set by register_time_interpolator() */
-        void *addr;                     /* address of counter or function */
-        cycles_t mask;                  /* mask the valid bits of the counter */
-        unsigned long offset;           /* nsec offset at last update of interpolator */
-        u64 last_counter;               /* counter value in units of the counter at last update */
-        cycles_t last_cycle;            /* Last timer value if TIME_SOURCE_JITTER is set */
-        u64 frequency;                  /* frequency in counts/second */
-        long drift;                     /* drift in parts-per-million (or -1) */
-        unsigned long skips;            /* skips forward */
-        unsigned long ns_skipped;       /* nanoseconds skipped */
-        struct time_interpolator *next;
-};
-
-extern void register_time_interpolator(struct time_interpolator *);
-extern void unregister_time_interpolator(struct time_interpolator *);
-extern void time_interpolator_reset(void);
-extern unsigned long time_interpolator_get_offset(void);
-extern void time_interpolator_update(long delta_nsec);
-
-#else /* !CONFIG_TIME_INTERPOLATION */
-
-static inline void time_interpolator_reset(void)
-{
-}
-
-static inline void time_interpolator_update(long delta_nsec)
-{
-}
-
-#endif /* !CONFIG_TIME_INTERPOLATION */
-
 #define TICK_LENGTH_SHIFT       32
 
 #ifdef CONFIG_NO_HZ
diff --git a/include/linux/topology.h b/include/linux/topology.h
index da6c39b2d051..d0890a7e5bab 100644
--- a/include/linux/topology.h
+++ b/include/linux/topology.h
@@ -50,10 +50,10 @@
         for_each_online_node(node)                                              \
                 if (nr_cpus_node(node))
 
-#ifndef node_distance
 /* Conform to ACPI 2.0 SLIT distance definitions */
 #define LOCAL_DISTANCE          10
 #define REMOTE_DISTANCE         20
+#ifndef node_distance
 #define node_distance(from,to)  ((from) == (to) ? LOCAL_DISTANCE : REMOTE_DISTANCE)
 #endif
 #ifndef RECLAIM_DISTANCE
diff --git a/include/linux/tty.h b/include/linux/tty.h
index bb4576085203..691a1748d9d2 100644
--- a/include/linux/tty.h
+++ b/include/linux/tty.h
@@ -178,6 +178,7 @@ struct tty_bufhead {
 #define L_IEXTEN(tty)   _L_FLAG((tty),IEXTEN)
 
 struct device;
+struct signal_struct;
 /*
  * Where all of the state associated with a tty is kept while the tty
  * is open.  Since the termios state should be kept even if the tty
@@ -310,6 +311,7 @@ extern void tty_hangup(struct tty_struct * tty);
 extern void tty_vhangup(struct tty_struct * tty);
 extern void tty_unhangup(struct file *filp);
 extern int tty_hung_up_p(struct file * filp);
+extern int is_tty(struct file *filp);
 extern void do_SAK(struct tty_struct *tty);
 extern void __do_SAK(struct tty_struct *tty);
 extern void disassociate_ctty(int priv);
@@ -338,9 +340,46 @@ extern struct tty_struct *get_current_tty(void);
 
 extern struct mutex tty_mutex;
 
+extern void tty_write_unlock(struct tty_struct *tty);
+extern int tty_write_lock(struct tty_struct *tty, int ndelay);
+#define tty_is_writelocked(tty)  (mutex_is_locked(&tty->atomic_write_lock))
+
+
+
 /* n_tty.c */
 extern struct tty_ldisc tty_ldisc_N_TTY;
 
+/* tty_audit.c */
+#ifdef CONFIG_AUDIT
+extern void tty_audit_add_data(struct tty_struct *tty, unsigned char *data,
+                               size_t size);
+extern void tty_audit_exit(void);
+extern void tty_audit_fork(struct signal_struct *sig);
+extern void tty_audit_push(struct tty_struct *tty);
+extern void tty_audit_push_task(struct task_struct *tsk, uid_t loginuid);
+extern void tty_audit_opening(void);
+#else
+static inline void tty_audit_add_data(struct tty_struct *tty,
+                                      unsigned char *data, size_t size)
+{
+}
+static inline void tty_audit_exit(void)
+{
+}
+static inline void tty_audit_fork(struct signal_struct *sig)
+{
+}
+static inline void tty_audit_push(struct tty_struct *tty)
+{
+}
+static inline void tty_audit_push_task(struct task_struct *tsk, uid_t loginuid)
+{
+}
+static inline void tty_audit_opening(void)
+{
+}
+#endif
+
 /* tty_ioctl.c */
 extern int n_tty_ioctl(struct tty_struct * tty, struct file * file,
                        unsigned int cmd, unsigned long arg);
diff --git a/include/linux/udp.h b/include/linux/udp.h
index 6de445c31a64..8ec703f462da 100644
--- a/include/linux/udp.h
+++ b/include/linux/udp.h
@@ -42,6 +42,7 @@ static inline struct udphdr *udp_hdr(const struct sk_buff *skb)
 /* UDP encapsulation types */
 #define UDP_ENCAP_ESPINUDP_NON_IKE      1 /* draft-ietf-ipsec-nat-t-ike-00/01 */
 #define UDP_ENCAP_ESPINUDP      2 /* draft-ietf-ipsec-udp-encaps-06 */
+#define UDP_ENCAP_L2TPINUDP     3 /* rfc2661 */
 
 #ifdef __KERNEL__
 #include <linux/types.h>
@@ -70,6 +71,11 @@ struct udp_sock {
 #define UDPLITE_SEND_CC  0x2            /* set via udplite setsockopt         */
 #define UDPLITE_RECV_CC  0x4            /* set via udplite setsocktopt        */
         __u8             pcflag;        /* marks socket as UDP-Lite if > 0    */
+        __u8             unused[3];
+        /*
+         * For encapsulation sockets.
+         */
+        int (*encap_rcv)(struct sock *sk, struct sk_buff *skb);
 };
 
 static inline struct udp_sock *udp_sk(const struct sock *sk)
diff --git a/include/linux/uio.h b/include/linux/uio.h
index 9af8bbcd8963..b7fe13883bdb 100644
--- a/include/linux/uio.h
+++ b/include/linux/uio.h
@@ -13,10 +13,6 @@
  *              2 of the License, or (at your option) any later version.
  */
 
-
-/* A word of warning: Our uio structure will clash with the C library one (which is now obsolete). Remove the C
-   library one from sys/uio.h if you have a very old library set */
-
 struct iovec
 {
         void __user *iov_base;  /* BSD uses caddr_t (1003.1g requires void *) */
@@ -38,11 +34,6 @@ struct kvec {
  
 #define UIO_FASTIOV     8
 #define UIO_MAXIOV      1024
-#if 0
-#define UIO_MAXIOV      16      /* Maximum iovec's in one operation 
-                                   16 matches BSD */
-                                /* Beg pardon: BSD has 1024 --ANK */
-#endif
 
 /*
  * Total number of bytes covered by an iovec.
diff --git a/include/linux/uio_driver.h b/include/linux/uio_driver.h
new file mode 100644
index 000000000000..44c28e94df50
--- /dev/null
+++ b/include/linux/uio_driver.h
@@ -0,0 +1,91 @@
+/*
+ * include/linux/uio_driver.h
+ *
+ * Copyright(C) 2005, Benedikt Spranger <b.spranger@linutronix.de>
+ * Copyright(C) 2005, Thomas Gleixner <tglx@linutronix.de>
+ * Copyright(C) 2006, Hans J. Koch <hjk@linutronix.de>
+ * Copyright(C) 2006, Greg Kroah-Hartman <greg@kroah.com>
+ *
+ * Userspace IO driver.
+ *
+ * Licensed under the GPLv2 only.
+ */
+
+#ifndef _UIO_DRIVER_H_
+#define _UIO_DRIVER_H_
+
+#include <linux/module.h>
+#include <linux/fs.h>
+#include <linux/interrupt.h>
+
+/**
+ * struct uio_mem - description of a UIO memory region
+ * @kobj:               kobject for this mapping
+ * @addr:               address of the device's memory
+ * @size:               size of IO
+ * @memtype:            type of memory addr points to
+ * @internal_addr:      ioremap-ped version of addr, for driver internal use
+ */
+struct uio_mem {
+        struct kobject          kobj;
+        unsigned long           addr;
+        unsigned long           size;
+        int                     memtype;
+        void __iomem            *internal_addr;
+};
+
+#define MAX_UIO_MAPS    5
+
+struct uio_device;
+
+/**
+ * struct uio_info - UIO device capabilities
+ * @uio_dev:            the UIO device this info belongs to
+ * @name:               device name
+ * @version:            device driver version
+ * @mem:                list of mappable memory regions, size==0 for end of list
+ * @irq:                interrupt number or UIO_IRQ_CUSTOM
+ * @irq_flags:          flags for request_irq()
+ * @priv:               optional private data
+ * @handler:            the device's irq handler
+ * @mmap:               mmap operation for this uio device
+ * @open:               open operation for this uio device
+ * @release:            release operation for this uio device
+ */
+struct uio_info {
+        struct uio_device       *uio_dev;
+        char                    *name;
+        char                    *version;
+        struct uio_mem          mem[MAX_UIO_MAPS];
+        long                    irq;
+        unsigned long           irq_flags;
+        void                    *priv;
+        irqreturn_t (*handler)(int irq, struct uio_info *dev_info);
+        int (*mmap)(struct uio_info *info, struct vm_area_struct *vma);
+        int (*open)(struct uio_info *info, struct inode *inode);
+        int (*release)(struct uio_info *info, struct inode *inode);
+};
+
+extern int __must_check
+        __uio_register_device(struct module *owner,
+                              struct device *parent,
+                              struct uio_info *info);
+static inline int __must_check
+        uio_register_device(struct device *parent, struct uio_info *info)
+{
+        return __uio_register_device(THIS_MODULE, parent, info);
+}
+extern void uio_unregister_device(struct uio_info *info);
+extern void uio_event_notify(struct uio_info *info);
+
+/* defines for uio_device->irq */
+#define UIO_IRQ_CUSTOM  -1
+#define UIO_IRQ_NONE    -2
+
+/* defines for uio_device->memtype */
+#define UIO_MEM_NONE    0
+#define UIO_MEM_PHYS    1
+#define UIO_MEM_LOGICAL 2
+#define UIO_MEM_VIRTUAL 3
+
+#endif /* _LINUX_UIO_DRIVER_H_ */
diff --git a/include/linux/usb.h b/include/linux/usb.h
index 56aa2ee21f1b..7a60946df3b6 100644
--- a/include/linux/usb.h
+++ b/include/linux/usb.h
@@ -146,6 +146,10 @@ struct usb_interface {
                                          * active alternate setting */
         unsigned num_altsetting;        /* number of alternate settings */
 
+        /* If there is an interface association descriptor then it will list
+         * the associated interfaces */
+        struct usb_interface_assoc_descriptor *intf_assoc;
+
         int minor;                      /* minor number this interface is
                                          * bound to */
         enum usb_interface_condition condition;         /* state of binding */
@@ -175,6 +179,7 @@ void usb_put_intf(struct usb_interface *intf);
 
 /* this maximum is arbitrary */
 #define USB_MAXINTERFACES       32
+#define USB_MAXIADS             USB_MAXINTERFACES/2
 
 /**
  * struct usb_interface_cache - long-term representation of a device interface
@@ -245,6 +250,11 @@ struct usb_host_config {
         struct usb_config_descriptor    desc;
 
         char *string;           /* iConfiguration string, if present */
+
+        /* List of any Interface Association Descriptors in this
+         * configuration. */
+        struct usb_interface_assoc_descriptor *intf_assoc[USB_MAXIADS];
+
         /* the interfaces associated with this configuration,
          * stored in no particular order */
         struct usb_interface *interface[USB_MAXINTERFACES];
@@ -403,6 +413,8 @@ struct usb_device {
 
         unsigned auto_pm:1;             /* autosuspend/resume in progress */
         unsigned do_remote_wakeup:1;    /* remote wakeup should be enabled */
+        unsigned reset_resume:1;        /* needs reset instead of resume */
+        unsigned persist_enabled:1;     /* USB_PERSIST enabled for this dev */
         unsigned autosuspend_disabled:1; /* autosuspend and autoresume */
         unsigned autoresume_disabled:1;  /*  disabled by the user */
 #endif
@@ -770,6 +782,28 @@ static inline int usb_endpoint_is_isoc_out(const struct usb_endpoint_descriptor
         .match_flags = USB_DEVICE_ID_MATCH_INT_INFO, .bInterfaceClass = (cl), \
         .bInterfaceSubClass = (sc), .bInterfaceProtocol = (pr)
 
+/**
+ * USB_DEVICE_AND_INTERFACE_INFO - macro used to describe a specific usb device
+ *              with a class of usb interfaces
+ * @vend: the 16 bit USB Vendor ID
+ * @prod: the 16 bit USB Product ID
+ * @cl: bInterfaceClass value
+ * @sc: bInterfaceSubClass value
+ * @pr: bInterfaceProtocol value
+ *
+ * This macro is used to create a struct usb_device_id that matches a
+ * specific device with a specific class of interfaces.
+ *
+ * This is especially useful when explicitly matching devices that have
+ * vendor specific bDeviceClass values, but standards-compliant interfaces.
+ */
+#define USB_DEVICE_AND_INTERFACE_INFO(vend,prod,cl,sc,pr) \
+        .match_flags = USB_DEVICE_ID_MATCH_INT_INFO \
+                | USB_DEVICE_ID_MATCH_DEVICE, \
+        .idVendor = (vend), .idProduct = (prod), \
+        .bInterfaceClass = (cl), \
+        .bInterfaceSubClass = (sc), .bInterfaceProtocol = (pr)
+
 /* ----------------------------------------------------------------------- */
 
 /* Stuff for dynamic usb ids */
@@ -816,10 +850,15 @@ struct usbdrv_wrap {
  *      do (or don't) show up otherwise in the filesystem.
  * @suspend: Called when the device is going to be suspended by the system.
  * @resume: Called when the device is being resumed by the system.
+ * @reset_resume: Called when the suspended device has been reset instead
+ *      of being resumed.
  * @pre_reset: Called by usb_reset_composite_device() when the device
  *      is about to be reset.
  * @post_reset: Called by usb_reset_composite_device() after the device
- *      has been reset.
+ *      has been reset, or in lieu of @resume following a reset-resume
+ *      (i.e., the device is reset instead of being resumed, as might
+ *      happen if power was lost).  The second argument tells which is
+ *      the reason.
  * @id_table: USB drivers use ID table to support hotplugging.
  *      Export this with MODULE_DEVICE_TABLE(usb,...).  This must be set
  *      or your driver's probe function will never get called.
@@ -859,9 +898,10 @@ struct usb_driver {
 
         int (*suspend) (struct usb_interface *intf, pm_message_t message);
         int (*resume) (struct usb_interface *intf);
+        int (*reset_resume)(struct usb_interface *intf);
 
-        void (*pre_reset) (struct usb_interface *intf);
-        void (*post_reset) (struct usb_interface *intf);
+        int (*pre_reset)(struct usb_interface *intf);
+        int (*post_reset)(struct usb_interface *intf);
 
         const struct usb_device_id *id_table;
 
@@ -964,6 +1004,7 @@ extern int usb_disabled(void);
 #define URB_ZERO_PACKET         0x0040  /* Finish bulk OUT with short packet */
 #define URB_NO_INTERRUPT        0x0080  /* HINT: no non-error interrupt
                                          * needed */
+#define URB_FREE_BUFFER         0x0100  /* Free transfer buffer with the URB */
 
 struct usb_iso_packet_descriptor {
         unsigned int offset;
@@ -974,11 +1015,26 @@ struct usb_iso_packet_descriptor {
 
 struct urb;
 
+struct usb_anchor {
+        struct list_head urb_list;
+        wait_queue_head_t wait;
+        spinlock_t lock;
+};
+
+static inline void init_usb_anchor(struct usb_anchor *anchor)
+{
+        INIT_LIST_HEAD(&anchor->urb_list);
+        init_waitqueue_head(&anchor->wait);
+        spin_lock_init(&anchor->lock);
+}
+
 typedef void (*usb_complete_t)(struct urb *);
 
 /**
  * struct urb - USB Request Block
  * @urb_list: For use by current owner of the URB.
+ * @anchor_list: membership in the list of an anchor
+ * @anchor: to anchor URBs to a common mooring
  * @pipe: Holds endpoint number, direction, type, and more.
  *      Create these values with the eight macros available;
  *      usb_{snd,rcv}TYPEpipe(dev,endpoint), where the TYPE is "ctrl"
@@ -1151,6 +1207,8 @@ struct urb
         /* public: documented fields in the urb that can be used by drivers */
         struct list_head urb_list;      /* list head for use by the urb's
                                          * current owner */
+        struct list_head anchor_list;   /* the URB may be anchored by the driver */
+        struct usb_anchor *anchor;
         struct usb_device *dev;         /* (in) pointer to associated device */
         unsigned int pipe;              /* (in) pipe information */
         int status;                     /* (return) non-ISO status */
@@ -1286,6 +1344,11 @@ extern struct urb *usb_get_urb(struct urb *urb);
 extern int usb_submit_urb(struct urb *urb, gfp_t mem_flags);
 extern int usb_unlink_urb(struct urb *urb);
 extern void usb_kill_urb(struct urb *urb);
+extern void usb_kill_anchored_urbs(struct usb_anchor *anchor);
+extern void usb_anchor_urb(struct urb *urb, struct usb_anchor *anchor);
+extern void usb_unanchor_urb(struct urb *urb);
+extern int usb_wait_anchor_empty_timeout(struct usb_anchor *anchor,
+                                         unsigned int timeout);
 
 void *usb_buffer_alloc (struct usb_device *dev, size_t size,
         gfp_t mem_flags, dma_addr_t *dma);
diff --git a/include/linux/usb/Kbuild b/include/linux/usb/Kbuild
index 43f160cfe003..6ce42bf9f743 100644
--- a/include/linux/usb/Kbuild
+++ b/include/linux/usb/Kbuild
@@ -1,5 +1,6 @@
 unifdef-y += audio.h
 unifdef-y += cdc.h
 unifdef-y += ch9.h
+unifdef-y += gadgetfs.h
 unifdef-y += midi.h
 
diff --git a/include/linux/usb_gadgetfs.h b/include/linux/usb/gadgetfs.h
index 8086d5a9b94e..e8654c338729 100644
--- a/include/linux/usb_gadgetfs.h
+++ b/include/linux/usb/gadgetfs.h
@@ -1,3 +1,5 @@
+#ifndef __LINUX_USB_GADGETFS_H
+#define __LINUX_USB_GADGETFS_H
 
 #include <asm/types.h>
 #include <asm/ioctl.h>
@@ -7,11 +9,12 @@
 /*
  * Filesystem based user-mode API to USB Gadget controller hardware
  *
- * Almost everything can be done with only read and write operations,
+ * Other than ep0 operations, most things are done by read() and write()
  * on endpoint files found in one directory.  They are configured by
  * writing descriptors, and then may be used for normal stream style
  * i/o requests.  When ep0 is configured, the device can enumerate;
- * when it's closed, the device disconnects from usb.
+ * when it's closed, the device disconnects from usb.  Operations on
+ * ep0 require ioctl() operations.
  *
  * Configuration and device descriptors get written to /dev/gadget/$CHIP,
  * which may then be used to read usb_gadgetfs_event structs.  The driver
@@ -21,9 +24,9 @@
  */
 
 /*
- * Events are delivered on the ep0 file descriptor, if the user mode driver
+ * Events are delivered on the ep0 file descriptor, when the user mode driver
  * reads from this file descriptor after writing the descriptors.  Don't
- * stop polling this descriptor, if you write that kind of driver.
+ * stop polling this descriptor.
  */
 
 enum usb_gadgetfs_event_type {
@@ -36,8 +39,10 @@ enum usb_gadgetfs_event_type {
         // and likely more !
 };
 
+/* NOTE:  this structure must stay the same size and layout on
+ * both 32-bit and 64-bit kernels.
+ */
 struct usb_gadgetfs_event {
-        enum usb_gadgetfs_event_type    type;
         union {
                 // NOP, DISCONNECT, SUSPEND: nothing
                 // ... some hardware can't report disconnection
@@ -46,19 +51,20 @@ struct usb_gadgetfs_event {
                 enum usb_device_speed   speed;
 
                 // SETUP: packet; DATA phase i/o precedes next event
-                // (setup.bmRequestType & USB_DIR_IN) flags direction 
+                // (setup.bmRequestType & USB_DIR_IN) flags direction
                 // ... includes SET_CONFIGURATION, SET_INTERFACE
                 struct usb_ctrlrequest  setup;
         } u;
+        enum usb_gadgetfs_event_type    type;
 };
 
 
 /* endpoint ioctls */
 
 /* IN transfers may be reported to the gadget driver as complete
- *      when the fifo is loaded, before the host reads the data;
+ *      when the fifo is loaded, before the host reads the data;
  * OUT transfers may be reported to the host's "client" driver as
- *      complete when they're sitting in the FIFO unread.
+ *      complete when they're sitting in the FIFO unread.
  * THIS returns how many bytes are "unclaimed" in the endpoint fifo
  * (needed for precise fault handling, when the hardware allows it)
  */
@@ -72,4 +78,4 @@ struct usb_gadgetfs_event {
  */
 #define GADGETFS_CLEAR_HALT     _IO('g',3)
 
-
+#endif /* __LINUX_USB_GADGETFS_H */
diff --git a/include/linux/usb/quirks.h b/include/linux/usb/quirks.h
index 6bac8faacbc6..8da374caf582 100644
--- a/include/linux/usb/quirks.h
+++ b/include/linux/usb/quirks.h
@@ -9,3 +9,6 @@
 
 /* string descriptors must not be fetched using a 255-byte read */
 #define USB_QUIRK_STRING_FETCH_255      0x00000002
+
+/* device can't resume correctly so reset it instead */
+#define USB_QUIRK_RESET_RESUME          0x00000004
diff --git a/include/linux/usb/serial.h b/include/linux/usb/serial.h
index 32acbae28d24..e8b8928232c8 100644
--- a/include/linux/usb/serial.h
+++ b/include/linux/usb/serial.h
@@ -221,6 +221,9 @@ struct usb_serial_driver {
         int (*port_probe) (struct usb_serial_port *port);
         int (*port_remove) (struct usb_serial_port *port);
 
+        int (*suspend) (struct usb_serial *serial, pm_message_t message);
+        int (*resume) (struct usb_serial *serial);
+
         /* serial function calls */
         int  (*open)            (struct usb_serial_port *port, struct file * filp);
         void (*close)           (struct usb_serial_port *port, struct file * filp);
@@ -249,6 +252,9 @@ extern void usb_serial_port_softint(struct usb_serial_port *port);
 extern int usb_serial_probe(struct usb_interface *iface, const struct usb_device_id *id);
 extern void usb_serial_disconnect(struct usb_interface *iface);
 
+extern int usb_serial_suspend(struct usb_interface *intf, pm_message_t message);
+extern int usb_serial_resume(struct usb_interface *intf);
+
 extern int ezusb_writememory (struct usb_serial *serial, int address, unsigned char *data, int length, __u8 bRequest);
 extern int ezusb_set_reset (struct usb_serial *serial, unsigned char reset_bit);
 
@@ -269,6 +275,7 @@ extern void usb_serial_put(struct usb_serial *serial);
 extern int usb_serial_generic_open (struct usb_serial_port *port, struct file *filp);
 extern int usb_serial_generic_write (struct usb_serial_port *port, const unsigned char *buf, int count);
 extern void usb_serial_generic_close (struct usb_serial_port *port, struct file *filp);
+extern int usb_serial_generic_resume (struct usb_serial *serial);
 extern int usb_serial_generic_write_room (struct usb_serial_port *port);
 extern int usb_serial_generic_chars_in_buffer (struct usb_serial_port *port);
 extern void usb_serial_generic_read_bulk_callback (struct urb *urb);
diff --git a/include/linux/usb_gadget.h b/include/linux/usb_gadget.h
index e17186dbcdca..4f59b2aa8a9e 100644
--- a/include/linux/usb_gadget.h
+++ b/include/linux/usb_gadget.h
@@ -110,13 +110,6 @@ struct usb_ep_ops {
                 gfp_t gfp_flags);
         void (*free_request) (struct usb_ep *ep, struct usb_request *req);
 
-        void *(*alloc_buffer) (struct usb_ep *ep, unsigned bytes,
-                dma_addr_t *dma, gfp_t gfp_flags);
-        void (*free_buffer) (struct usb_ep *ep, void *buf, dma_addr_t dma,
-                unsigned bytes);
-        // NOTE:  on 2.6, drivers may also use dma_map() and
-        // dma_sync_single_*() to directly manage dma overhead. 
-
         int (*queue) (struct usb_ep *ep, struct usb_request *req,
                 gfp_t gfp_flags);
         int (*dequeue) (struct usb_ep *ep, struct usb_request *req);
@@ -235,47 +228,6 @@ usb_ep_free_request (struct usb_ep *ep, struct usb_request *req)
 }
 
 /**
- * usb_ep_alloc_buffer - allocate an I/O buffer
- * @ep:the endpoint associated with the buffer
- * @len:length of the desired buffer
- * @dma:pointer to the buffer's DMA address; must be valid
- * @gfp_flags:GFP_* flags to use
- *
- * Returns a new buffer, or null if one could not be allocated.
- * The buffer is suitably aligned for dma, if that endpoint uses DMA,
- * and the caller won't have to care about dma-inconsistency
- * or any hidden "bounce buffer" mechanism.  No additional per-request
- * DMA mapping will be required for such buffers.
- * Free it later with usb_ep_free_buffer().
- *
- * You don't need to use this call to allocate I/O buffers unless you
- * want to make sure drivers don't incur costs for such "bounce buffer"
- * copies or per-request DMA mappings.
- */
-static inline void *
-usb_ep_alloc_buffer (struct usb_ep *ep, unsigned len, dma_addr_t *dma,
-        gfp_t gfp_flags)
-{
-        return ep->ops->alloc_buffer (ep, len, dma, gfp_flags);
-}
-
-/**
- * usb_ep_free_buffer - frees an i/o buffer
- * @ep:the endpoint associated with the buffer
- * @buf:CPU view address of the buffer
- * @dma:the buffer's DMA address
- * @len:length of the buffer
- *
- * reverses the effect of usb_ep_alloc_buffer().
- * caller guarantees the buffer will no longer be accessed
- */
-static inline void
-usb_ep_free_buffer (struct usb_ep *ep, void *buf, dma_addr_t dma, unsigned len)
-{
-        ep->ops->free_buffer (ep, buf, dma, len);
-}
-
-/**
  * usb_ep_queue - queues (submits) an I/O request to an endpoint.
  * @ep:the endpoint associated with the request
  * @req:the request being submitted
diff --git a/include/linux/user_namespace.h b/include/linux/user_namespace.h
new file mode 100644
index 000000000000..1101b0ce878f
--- /dev/null
+++ b/include/linux/user_namespace.h
@@ -0,0 +1,61 @@
+#ifndef _LINUX_USER_NAMESPACE_H
+#define _LINUX_USER_NAMESPACE_H
+
+#include <linux/kref.h>
+#include <linux/nsproxy.h>
+#include <linux/sched.h>
+#include <linux/err.h>
+
+#define UIDHASH_BITS    (CONFIG_BASE_SMALL ? 3 : 8)
+#define UIDHASH_SZ      (1 << UIDHASH_BITS)
+
+struct user_namespace {
+        struct kref             kref;
+        struct list_head        uidhash_table[UIDHASH_SZ];
+        struct user_struct      *root_user;
+};
+
+extern struct user_namespace init_user_ns;
+
+#ifdef CONFIG_USER_NS
+
+static inline struct user_namespace *get_user_ns(struct user_namespace *ns)
+{
+        if (ns)
+                kref_get(&ns->kref);
+        return ns;
+}
+
+extern struct user_namespace *copy_user_ns(int flags,
+                                           struct user_namespace *old_ns);
+extern void free_user_ns(struct kref *kref);
+
+static inline void put_user_ns(struct user_namespace *ns)
+{
+        if (ns)
+                kref_put(&ns->kref, free_user_ns);
+}
+
+#else
+
+static inline struct user_namespace *get_user_ns(struct user_namespace *ns)
+{
+        return &init_user_ns;
+}
+
+static inline struct user_namespace *copy_user_ns(int flags,
+                                                  struct user_namespace *old_ns)
+{
+        if (flags & CLONE_NEWUSER)
+                return ERR_PTR(-EINVAL);
+
+        return old_ns;
+}
+
+static inline void put_user_ns(struct user_namespace *ns)
+{
+}
+
+#endif
+
+#endif /* _LINUX_USER_H */
diff --git a/include/linux/utsname.h b/include/linux/utsname.h
index f8d3b326e93a..923db99175f2 100644
--- a/include/linux/utsname.h
+++ b/include/linux/utsname.h
@@ -48,26 +48,14 @@ static inline void get_uts_ns(struct uts_namespace *ns)
         kref_get(&ns->kref);
 }
 
-#ifdef CONFIG_UTS_NS
-extern struct uts_namespace *copy_utsname(int flags, struct uts_namespace *ns);
+extern struct uts_namespace *copy_utsname(unsigned long flags,
+                                        struct uts_namespace *ns);
 extern void free_uts_ns(struct kref *kref);
 
 static inline void put_uts_ns(struct uts_namespace *ns)
 {
         kref_put(&ns->kref, free_uts_ns);
 }
-#else
-static inline struct uts_namespace *copy_utsname(int flags,
-                                                struct uts_namespace *ns)
-{
-        return ns;
-}
-
-static inline void put_uts_ns(struct uts_namespace *ns)
-{
-}
-#endif
-
 static inline struct new_utsname *utsname(void)
 {
         return &current->nsproxy->uts_ns->name;
diff --git a/include/linux/videodev2.h b/include/linux/videodev2.h
index d16a2b57dc81..c66c8a3410b9 100644
--- a/include/linux/videodev2.h
+++ b/include/linux/videodev2.h
@@ -60,6 +60,7 @@
 #include <linux/compiler.h> /* need __user */
 #else
 #define __user
+#include <sys/time.h>
 #endif
 #include <linux/types.h>
 
diff --git a/include/linux/vmalloc.h b/include/linux/vmalloc.h
index 4b7ee83787c1..89338b468d0d 100644
--- a/include/linux/vmalloc.h
+++ b/include/linux/vmalloc.h
@@ -58,6 +58,13 @@ void vmalloc_sync_all(void);
 /*
  *      Lowlevel-APIs (not for driver use!)
  */
+
+static inline size_t get_vm_area_size(const struct vm_struct *area)
+{
+        /* return actual size without guard page */
+        return area->size - PAGE_SIZE;
+}
+
 extern struct vm_struct *get_vm_area(unsigned long size, unsigned long flags);
 extern struct vm_struct *__get_vm_area(unsigned long size, unsigned long flags,
                                         unsigned long start, unsigned long end);
@@ -65,9 +72,14 @@ extern struct vm_struct *get_vm_area_node(unsigned long size,
                                           unsigned long flags, int node,
                                           gfp_t gfp_mask);
 extern struct vm_struct *remove_vm_area(void *addr);
+
 extern int map_vm_area(struct vm_struct *area, pgprot_t prot,
                         struct page ***pages);
-extern void unmap_vm_area(struct vm_struct *area);
+extern void unmap_kernel_range(unsigned long addr, unsigned long size);
+
+/* Allocate/destroy a 'vmalloc' VM area. */
+extern struct vm_struct *alloc_vm_area(size_t size);
+extern void free_vm_area(struct vm_struct *area);
 
 /*
  *      Internals.  Dont't use..
diff --git a/include/linux/vmstat.h b/include/linux/vmstat.h
index d9325cf8a134..75370ec0923e 100644
--- a/include/linux/vmstat.h
+++ b/include/linux/vmstat.h
@@ -25,7 +25,7 @@
 #define HIGHMEM_ZONE(xx)
 #endif
 
-#define FOR_ALL_ZONES(xx) DMA_ZONE(xx) DMA32_ZONE(xx) xx##_NORMAL HIGHMEM_ZONE(xx)
+#define FOR_ALL_ZONES(xx) DMA_ZONE(xx) DMA32_ZONE(xx) xx##_NORMAL HIGHMEM_ZONE(xx) , xx##_MOVABLE
 
 enum vm_event_item { PGPGIN, PGPGOUT, PSWPIN, PSWPOUT,
                 FOR_ALL_ZONES(PGALLOC),
@@ -170,7 +170,8 @@ static inline unsigned long node_page_state(int node,
 #ifdef CONFIG_HIGHMEM
                 zone_page_state(&zones[ZONE_HIGHMEM], item) +
 #endif
-                zone_page_state(&zones[ZONE_NORMAL], item);
+                zone_page_state(&zones[ZONE_NORMAL], item) +
+                zone_page_state(&zones[ZONE_MOVABLE], item);
 }
 
 extern void zone_statistics(struct zonelist *, struct zone *);
diff --git a/include/linux/vt_kern.h b/include/linux/vt_kern.h
index d961635d0e61..699b7e9864fa 100644
--- a/include/linux/vt_kern.h
+++ b/include/linux/vt_kern.h
@@ -75,6 +75,8 @@ 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);
+extern int unbind_con_driver(const struct consw *csw, int first, int last,
+                             int deflt);
 
 /*
  * vc_screen.c shares this temporary buffer with the console write code so that
diff --git a/include/linux/workqueue.h b/include/linux/workqueue.h
index ce0719a2cfeb..ce6badc98f6d 100644
--- a/include/linux/workqueue.h
+++ b/include/linux/workqueue.h
@@ -148,7 +148,7 @@ extern int keventd_up(void);
 extern void init_workqueues(void);
 int execute_in_process_context(work_func_t fn, struct execute_work *);
 
-extern void cancel_work_sync(struct work_struct *work);
+extern int cancel_work_sync(struct work_struct *work);
 
 /*
  * Kill off a pending schedule_delayed_work().  Note that the work callback
@@ -166,14 +166,21 @@ static inline int cancel_delayed_work(struct delayed_work *work)
         return ret;
 }
 
-extern void cancel_rearming_delayed_work(struct delayed_work *work);
+extern int cancel_delayed_work_sync(struct delayed_work *work);
 
-/* Obsolete. use cancel_rearming_delayed_work() */
+/* Obsolete. use cancel_delayed_work_sync() */
 static inline
 void cancel_rearming_delayed_workqueue(struct workqueue_struct *wq,
                                         struct delayed_work *work)
 {
-        cancel_rearming_delayed_work(work);
+        cancel_delayed_work_sync(work);
+}
+
+/* Obsolete. use cancel_delayed_work_sync() */
+static inline
+void cancel_rearming_delayed_work(struct delayed_work *work)
+{
+        cancel_delayed_work_sync(work);
 }
 
 #endif