243 files changed, 7675 insertions, 3368 deletions

diff --git a/include/linux/Kbuild b/include/linux/Kbuild
index e9581fd9fb66..ca9b9b9bd331 100644
--- a/include/linux/Kbuild
+++ b/include/linux/Kbuild
@@ -67,6 +67,7 @@ header-y += falloc.h
 header-y += fd.h
 header-y += fdreg.h
 header-y += fib_rules.h
+header-y += fiemap.h
 header-y += firewire-cdev.h
 header-y += firewire-constants.h
 header-y += fuse.h
@@ -158,8 +159,6 @@ header-y += ultrasound.h
 header-y += un.h
 header-y += utime.h
 header-y += veth.h
-header-y += video_decoder.h
-header-y += video_encoder.h
 header-y += videotext.h
 header-y += x25.h
 
diff --git a/include/linux/acpi.h b/include/linux/acpi.h
index 78199151c00b..88be890ee3c7 100644
--- a/include/linux/acpi.h
+++ b/include/linux/acpi.h
@@ -97,6 +97,7 @@ void acpi_table_print_madt_entry (struct acpi_subtable_header *madt);
 /* the following four functions are architecture-dependent */
 void acpi_numa_slit_init (struct acpi_table_slit *slit);
 void acpi_numa_processor_affinity_init (struct acpi_srat_cpu_affinity *pa);
+void acpi_numa_x2apic_affinity_init(struct acpi_srat_x2apic_cpu_affinity *pa);
 void acpi_numa_memory_affinity_init (struct acpi_srat_mem_affinity *ma);
 void acpi_numa_arch_fixup(void);
 
@@ -110,6 +111,7 @@ int acpi_register_ioapic(acpi_handle handle, u64 phys_addr, u32 gsi_base);
 int acpi_unregister_ioapic(acpi_handle handle, u32 gsi_base);
 void acpi_irq_stats_init(void);
 extern u32 acpi_irq_handled;
+extern u32 acpi_irq_not_handled;
 
 extern struct acpi_mcfg_allocation *pci_mmcfg_config;
 extern int pci_mmcfg_config_num;
@@ -257,6 +259,40 @@ void __init acpi_no_s4_hw_signature(void);
 void __init acpi_old_suspend_ordering(void);
 void __init acpi_s4_no_nvs(void);
 #endif /* CONFIG_PM_SLEEP */
+
+#define OSC_QUERY_TYPE                  0
+#define OSC_SUPPORT_TYPE                1
+#define OSC_CONTROL_TYPE                2
+#define OSC_SUPPORT_MASKS               0x1f
+
+/* _OSC DW0 Definition */
+#define OSC_QUERY_ENABLE                1
+#define OSC_REQUEST_ERROR               2
+#define OSC_INVALID_UUID_ERROR          4
+#define OSC_INVALID_REVISION_ERROR      8
+#define OSC_CAPABILITIES_MASK_ERROR     16
+
+/* _OSC DW1 Definition (OS Support Fields) */
+#define OSC_EXT_PCI_CONFIG_SUPPORT              1
+#define OSC_ACTIVE_STATE_PWR_SUPPORT            2
+#define OSC_CLOCK_PWR_CAPABILITY_SUPPORT        4
+#define OSC_PCI_SEGMENT_GROUPS_SUPPORT          8
+#define OSC_MSI_SUPPORT                         16
+
+/* _OSC DW1 Definition (OS Control Fields) */
+#define OSC_PCI_EXPRESS_NATIVE_HP_CONTROL       1
+#define OSC_SHPC_NATIVE_HP_CONTROL              2
+#define OSC_PCI_EXPRESS_PME_CONTROL             4
+#define OSC_PCI_EXPRESS_AER_CONTROL             8
+#define OSC_PCI_EXPRESS_CAP_STRUCTURE_CONTROL   16
+
+#define OSC_CONTROL_MASKS       (OSC_PCI_EXPRESS_NATIVE_HP_CONTROL |    \
+                                OSC_SHPC_NATIVE_HP_CONTROL |            \
+                                OSC_PCI_EXPRESS_PME_CONTROL |           \
+                                OSC_PCI_EXPRESS_AER_CONTROL |           \
+                                OSC_PCI_EXPRESS_CAP_STRUCTURE_CONTROL)
+
+extern acpi_status acpi_pci_osc_control_set(acpi_handle handle, u32 flags);
 #else   /* CONFIG_ACPI */
 
 static inline int early_acpi_boot_init(void)
diff --git a/include/linux/async_tx.h b/include/linux/async_tx.h
index 45f6297821bd..5fc2ef8d97fa 100644
--- a/include/linux/async_tx.h
+++ b/include/linux/async_tx.h
@@ -21,6 +21,15 @@
 #include <linux/spinlock.h>
 #include <linux/interrupt.h>
 
+/* on architectures without dma-mapping capabilities we need to ensure
+ * that the asynchronous path compiles away
+ */
+#ifdef CONFIG_HAS_DMA
+#define __async_inline
+#else
+#define __async_inline __always_inline
+#endif
+
 /**
  * dma_chan_ref - object used to manage dma channels received from the
  *   dmaengine core.
diff --git a/include/linux/ata.h b/include/linux/ata.h
index 6617c9f8f2ca..cb79b7a208e1 100644
--- a/include/linux/ata.h
+++ b/include/linux/ata.h
@@ -29,6 +29,8 @@
 #ifndef __LINUX_ATA_H__
 #define __LINUX_ATA_H__
 
+#include <linux/kernel.h>
+#include <linux/string.h>
 #include <linux/types.h>
 #include <asm/byteorder.h>
 
@@ -91,6 +93,7 @@ enum {
         ATA_ID_CFA_POWER        = 160,
         ATA_ID_CFA_KEY_MGMT     = 162,
         ATA_ID_CFA_MODES        = 163,
+        ATA_ID_DATA_SET_MGMT    = 169,
         ATA_ID_ROT_SPEED        = 217,
         ATA_ID_PIO4             = (1 << 1),
 
@@ -248,6 +251,7 @@ enum {
         ATA_CMD_SMART           = 0xB0,
         ATA_CMD_MEDIA_LOCK      = 0xDE,
         ATA_CMD_MEDIA_UNLOCK    = 0xDF,
+        ATA_CMD_DSM             = 0x06,
         /* marked obsolete in the ATA/ATAPI-7 spec */
         ATA_CMD_RESTORE         = 0x10,
 
@@ -321,6 +325,9 @@ enum {
         ATA_SMART_READ_VALUES   = 0xD0,
         ATA_SMART_READ_THRESHOLDS = 0xD1,
 
+        /* feature values for Data Set Management */
+        ATA_DSM_TRIM            = 0x01,
+
         /* password used in LBA Mid / LBA High for executing SMART commands */
         ATA_SMART_LBAM_PASS     = 0x4F,
         ATA_SMART_LBAH_PASS     = 0xC2,
@@ -723,6 +730,14 @@ static inline int ata_id_has_unload(const u16 *id)
         return 0;
 }
 
+static inline int ata_id_has_trim(const u16 *id)
+{
+        if (ata_id_major_version(id) >= 7 &&
+            (id[ATA_ID_DATA_SET_MGMT] & 1))
+                return 1;
+        return 0;
+}
+
 static inline int ata_id_current_chs_valid(const u16 *id)
 {
         /* For ATA-1 devices, if the INITIALIZE DEVICE PARAMETERS command
@@ -863,6 +878,32 @@ static inline void ata_id_to_hd_driveid(u16 *id)
 #endif
 }
 
+/*
+ * Write up to 'max' LBA Range Entries to the buffer that will cover the
+ * extent from sector to sector + count.  This is used for TRIM and for
+ * ADD LBA(S) TO NV CACHE PINNED SET.
+ */
+static inline unsigned ata_set_lba_range_entries(void *_buffer, unsigned max,
+                                                u64 sector, unsigned long count)
+{
+        __le64 *buffer = _buffer;
+        unsigned i = 0;
+
+        while (i < max) {
+                u64 entry = sector |
+                        ((u64)(count > 0xffff ? 0xffff : count) << 48);
+                buffer[i++] = __cpu_to_le64(entry);
+                if (count <= 0xffff)
+                        break;
+                count -= 0xffff;
+                sector += 0xffff;
+        }
+
+        max = ALIGN(i * 8, 512);
+        memset(buffer + i, 0, max - i * 8);
+        return max;
+}
+
 static inline int is_multi_taskfile(struct ata_taskfile *tf)
 {
         return (tf->command == ATA_CMD_READ_MULTI) ||
diff --git a/include/linux/auto_dev-ioctl.h b/include/linux/auto_dev-ioctl.h
index 91a773993a5c..850f39b33e74 100644
--- a/include/linux/auto_dev-ioctl.h
+++ b/include/linux/auto_dev-ioctl.h
@@ -10,8 +10,13 @@
 #ifndef _LINUX_AUTO_DEV_IOCTL_H
 #define _LINUX_AUTO_DEV_IOCTL_H
 
+#include <linux/auto_fs.h>
+
+#ifdef __KERNEL__
 #include <linux/string.h>
-#include <linux/types.h>
+#else
+#include <string.h>
+#endif /* __KERNEL__ */
 
 #define AUTOFS_DEVICE_NAME              "autofs"
 
diff --git a/include/linux/auto_fs.h b/include/linux/auto_fs.h
index c21e5972a3e8..63265852b7d1 100644
--- a/include/linux/auto_fs.h
+++ b/include/linux/auto_fs.h
@@ -17,11 +17,13 @@
 #ifdef __KERNEL__
 #include <linux/fs.h>
 #include <linux/limits.h>
+#include <linux/types.h>
+#include <linux/ioctl.h>
+#else
 #include <asm/types.h>
+#include <sys/ioctl.h>
 #endif /* __KERNEL__ */
 
-#include <linux/ioctl.h>
-
 /* This file describes autofs v3 */
 #define AUTOFS_PROTO_VERSION    3
 
diff --git a/include/linux/backing-dev.h b/include/linux/backing-dev.h
index bee52abb8a4d..0ec2c594868e 100644
--- a/include/linux/backing-dev.h
+++ b/include/linux/backing-dev.h
@@ -24,8 +24,8 @@ struct dentry;
  */
 enum bdi_state {
         BDI_pdflush,            /* A pdflush thread is working this device */
-        BDI_write_congested,    /* The write queue is getting full */
-        BDI_read_congested,     /* The read queue is getting full */
+        BDI_async_congested,    /* The async (write) queue is getting full */
+        BDI_sync_congested,     /* The sync queue is getting full */
         BDI_unused,             /* Available bits start here */
 };
 
@@ -215,18 +215,18 @@ static inline int bdi_congested(struct backing_dev_info *bdi, int bdi_bits)
 
 static inline int bdi_read_congested(struct backing_dev_info *bdi)
 {
-        return bdi_congested(bdi, 1 << BDI_read_congested);
+        return bdi_congested(bdi, 1 << BDI_sync_congested);
 }
 
 static inline int bdi_write_congested(struct backing_dev_info *bdi)
 {
-        return bdi_congested(bdi, 1 << BDI_write_congested);
+        return bdi_congested(bdi, 1 << BDI_async_congested);
 }
 
 static inline int bdi_rw_congested(struct backing_dev_info *bdi)
 {
-        return bdi_congested(bdi, (1 << BDI_read_congested)|
-                                  (1 << BDI_write_congested));
+        return bdi_congested(bdi, (1 << BDI_sync_congested) |
+                                  (1 << BDI_async_congested));
 }
 
 void clear_bdi_congested(struct backing_dev_info *bdi, int rw);
diff --git a/include/linux/binfmts.h b/include/linux/binfmts.h
index 77b4a9e46004..61ee18c1bdb4 100644
--- a/include/linux/binfmts.h
+++ b/include/linux/binfmts.h
@@ -35,8 +35,7 @@ struct linux_binprm{
 #endif
         struct mm_struct *mm;
         unsigned long p; /* current top of mem */
-        unsigned int sh_bang:1,
-                misc_bang:1,
+        unsigned int
                 cred_prepared:1,/* true if creds already prepared (multiple
                                  * preps happen for interpreters) */
                 cap_effective:1;/* true if has elevated effective capabilities,
@@ -83,7 +82,19 @@ struct linux_binfmt {
         int hasvdso;
 };
 
-extern int register_binfmt(struct linux_binfmt *);
+extern int __register_binfmt(struct linux_binfmt *fmt, int insert);
+
+/* Registration of default binfmt handlers */
+static inline int register_binfmt(struct linux_binfmt *fmt)
+{
+        return __register_binfmt(fmt, 0);
+}
+/* Same as above, but adds a new binfmt at the top of the list */
+static inline int insert_binfmt(struct linux_binfmt *fmt)
+{
+        return __register_binfmt(fmt, 1);
+}
+
 extern void unregister_binfmt(struct linux_binfmt *);
 
 extern int prepare_binprm(struct linux_binprm *);
diff --git a/include/linux/bio.h b/include/linux/bio.h
index b05b1d4d17d2..7b214fd672a2 100644
--- a/include/linux/bio.h
+++ b/include/linux/bio.h
@@ -132,6 +132,7 @@ struct bio {
  * top 4 bits of bio flags indicate the pool this bio came from
  */
 #define BIO_POOL_BITS           (4)
+#define BIO_POOL_NONE           ((1UL << BIO_POOL_BITS) - 1)
 #define BIO_POOL_OFFSET         (BITS_PER_LONG - BIO_POOL_BITS)
 #define BIO_POOL_MASK           (1UL << BIO_POOL_OFFSET)
 #define BIO_POOL_IDX(bio)       ((bio)->bi_flags >> BIO_POOL_OFFSET)    
@@ -145,20 +146,21 @@ struct bio {
  * bit 2 -- barrier
  *      Insert a serialization point in the IO queue, forcing previously
  *      submitted IO to be completed before this one is issued.
- * bit 3 -- synchronous I/O hint: the block layer will unplug immediately
- *      Note that this does NOT indicate that the IO itself is sync, just
- *      that the block layer will not postpone issue of this IO by plugging.
- * bit 4 -- metadata request
+ * bit 3 -- synchronous I/O hint.
+ * bit 4 -- Unplug the device immediately after submitting this bio.
+ * bit 5 -- metadata request
  *      Used for tracing to differentiate metadata and data IO. May also
  *      get some preferential treatment in the IO scheduler
- * bit 5 -- discard sectors
+ * bit 6 -- discard sectors
  *      Informs the lower level device that this range of sectors is no longer
  *      used by the file system and may thus be freed by the device. Used
  *      for flash based storage.
- * bit 6 -- fail fast device errors
- * bit 7 -- fail fast transport errors
- * bit 8 -- fail fast driver errors
+ * bit 7 -- fail fast device errors
+ * bit 8 -- fail fast transport errors
+ * bit 9 -- fail fast driver errors
  *      Don't want driver retries for any fast fail whatever the reason.
+ * bit 10 -- Tell the IO scheduler not to wait for more requests after this
+        one has been submitted, even if it is a SYNC request.
  */
 #define BIO_RW          0       /* Must match RW in req flags (blkdev.h) */
 #define BIO_RW_AHEAD    1       /* Must match FAILFAST in req flags */
@@ -170,6 +172,7 @@ struct bio {
 #define BIO_RW_FAILFAST_DEV             7
 #define BIO_RW_FAILFAST_TRANSPORT       8
 #define BIO_RW_FAILFAST_DRIVER          9
+#define BIO_RW_NOIDLE   10
 
 #define bio_rw_flagged(bio, flag)       ((bio)->bi_rw & (1 << (flag)))
 
@@ -188,6 +191,7 @@ struct bio {
 #define bio_rw_ahead(bio)       bio_rw_flagged(bio, BIO_RW_AHEAD)
 #define bio_rw_meta(bio)        bio_rw_flagged(bio, BIO_RW_META)
 #define bio_discard(bio)        bio_rw_flagged(bio, BIO_RW_DISCARD)
+#define bio_noidle(bio)         bio_rw_flagged(bio, BIO_RW_NOIDLE)
 
 /*
  * upper 16 bits of bi_rw define the io priority of this bio
@@ -501,6 +505,115 @@ static inline int bio_has_data(struct bio *bio)
         return bio && bio->bi_io_vec != NULL;
 }
 
+/*
+ * BIO list managment for use by remapping drivers (e.g. DM or MD).
+ *
+ * A bio_list anchors a singly-linked list of bios chained through the bi_next
+ * member of the bio.  The bio_list also caches the last list member to allow
+ * fast access to the tail.
+ */
+struct bio_list {
+        struct bio *head;
+        struct bio *tail;
+};
+
+static inline int bio_list_empty(const struct bio_list *bl)
+{
+        return bl->head == NULL;
+}
+
+static inline void bio_list_init(struct bio_list *bl)
+{
+        bl->head = bl->tail = NULL;
+}
+
+#define bio_list_for_each(bio, bl) \
+        for (bio = (bl)->head; bio; bio = bio->bi_next)
+
+static inline unsigned bio_list_size(const struct bio_list *bl)
+{
+        unsigned sz = 0;
+        struct bio *bio;
+
+        bio_list_for_each(bio, bl)
+                sz++;
+
+        return sz;
+}
+
+static inline void bio_list_add(struct bio_list *bl, struct bio *bio)
+{
+        bio->bi_next = NULL;
+
+        if (bl->tail)
+                bl->tail->bi_next = bio;
+        else
+                bl->head = bio;
+
+        bl->tail = bio;
+}
+
+static inline void bio_list_add_head(struct bio_list *bl, struct bio *bio)
+{
+        bio->bi_next = bl->head;
+
+        bl->head = bio;
+
+        if (!bl->tail)
+                bl->tail = bio;
+}
+
+static inline void bio_list_merge(struct bio_list *bl, struct bio_list *bl2)
+{
+        if (!bl2->head)
+                return;
+
+        if (bl->tail)
+                bl->tail->bi_next = bl2->head;
+        else
+                bl->head = bl2->head;
+
+        bl->tail = bl2->tail;
+}
+
+static inline void bio_list_merge_head(struct bio_list *bl,
+                                       struct bio_list *bl2)
+{
+        if (!bl2->head)
+                return;
+
+        if (bl->head)
+                bl2->tail->bi_next = bl->head;
+        else
+                bl->tail = bl2->tail;
+
+        bl->head = bl2->head;
+}
+
+static inline struct bio *bio_list_pop(struct bio_list *bl)
+{
+        struct bio *bio = bl->head;
+
+        if (bio) {
+                bl->head = bl->head->bi_next;
+                if (!bl->head)
+                        bl->tail = NULL;
+
+                bio->bi_next = NULL;
+        }
+
+        return bio;
+}
+
+static inline struct bio *bio_list_get(struct bio_list *bl)
+{
+        struct bio *bio = bl->head;
+
+        bl->head = bl->tail = NULL;
+
+        return bio;
+}
+
 #if defined(CONFIG_BLK_DEV_INTEGRITY)
 
 #define bip_vec_idx(bip, idx)   (&(bip->bip_vec[(idx)]))
diff --git a/include/linux/bitops.h b/include/linux/bitops.h
index 61829139795a..c05a29cb9bb2 100644
--- a/include/linux/bitops.h
+++ b/include/linux/bitops.h
@@ -112,6 +112,25 @@ static inline unsigned fls_long(unsigned long l)
         return fls64(l);
 }
 
+/**
+ * __ffs64 - find first set bit in a 64 bit word
+ * @word: The 64 bit word
+ *
+ * On 64 bit arches this is a synomyn for __ffs
+ * The result is not defined if no bits are set, so check that @word
+ * is non-zero before calling this.
+ */
+static inline unsigned long __ffs64(u64 word)
+{
+#if BITS_PER_LONG == 32
+        if (((u32)word) == 0UL)
+                return __ffs((u32)(word >> 32)) + 32;
+#elif BITS_PER_LONG != 64
+#error BITS_PER_LONG not 32 or 64
+#endif
+        return __ffs((unsigned long)word);
+}
+
 #ifdef __KERNEL__
 #ifdef CONFIG_GENERIC_FIND_FIRST_BIT
 
diff --git a/include/linux/blkdev.h b/include/linux/blkdev.h
index 465d6babc847..b4f71f1a4af7 100644
--- a/include/linux/blkdev.h
+++ b/include/linux/blkdev.h
@@ -38,6 +38,10 @@ struct request;
 typedef void (rq_end_io_fn)(struct request *, int);
 
 struct request_list {
+        /*
+         * count[], starved[], and wait[] are indexed by
+         * BLK_RW_SYNC/BLK_RW_ASYNC
+         */
         int count[2];
         int starved[2];
         int elvpriv;
@@ -66,6 +70,11 @@ enum rq_cmd_type_bits {
         REQ_TYPE_ATA_PC,
 };
 
+enum {
+        BLK_RW_ASYNC    = 0,
+        BLK_RW_SYNC     = 1,
+};
+
 /*
  * For request of type REQ_TYPE_LINUX_BLOCK, rq->cmd[0] is the opcode being
  * sent down (similar to how REQ_TYPE_BLOCK_PC means that ->cmd[] holds a
@@ -103,12 +112,13 @@ enum rq_flag_bits {
         __REQ_QUIET,            /* don't worry about errors */
         __REQ_PREEMPT,          /* set for "ide_preempt" requests */
         __REQ_ORDERED_COLOR,    /* is before or after barrier */
-        __REQ_RW_SYNC,          /* request is sync (O_DIRECT) */
+        __REQ_RW_SYNC,          /* request is sync (sync write or read) */
         __REQ_ALLOCED,          /* request came from our alloc pool */
         __REQ_RW_META,          /* metadata io request */
         __REQ_COPY_USER,        /* contains copies of user pages */
         __REQ_INTEGRITY,        /* integrity metadata has been remapped */
-        __REQ_UNPLUG,           /* unplug queue on submission */
+        __REQ_NOIDLE,           /* Don't anticipate more IO after this one */
+        __REQ_IO_STAT,          /* account I/O stat */
         __REQ_NR_BITS,          /* stops here */
 };
 
@@ -135,7 +145,8 @@ enum rq_flag_bits {
 #define REQ_RW_META     (1 << __REQ_RW_META)
 #define REQ_COPY_USER   (1 << __REQ_COPY_USER)
 #define REQ_INTEGRITY   (1 << __REQ_INTEGRITY)
-#define REQ_UNPLUG      (1 << __REQ_UNPLUG)
+#define REQ_NOIDLE      (1 << __REQ_NOIDLE)
+#define REQ_IO_STAT     (1 << __REQ_IO_STAT)
 
 #define BLK_MAX_CDB     16
 
@@ -438,8 +449,8 @@ struct request_queue
 #define QUEUE_FLAG_CLUSTER      0       /* cluster several segments into 1 */
 #define QUEUE_FLAG_QUEUED       1       /* uses generic tag queueing */
 #define QUEUE_FLAG_STOPPED      2       /* queue is stopped */
-#define QUEUE_FLAG_READFULL     3       /* read queue has been filled */
-#define QUEUE_FLAG_WRITEFULL    4       /* write queue has been filled */
+#define QUEUE_FLAG_SYNCFULL     3       /* read queue has been filled */
+#define QUEUE_FLAG_ASYNCFULL    4       /* write queue has been filled */
 #define QUEUE_FLAG_DEAD         5       /* queue being torn down */
 #define QUEUE_FLAG_REENTER      6       /* Re-entrancy avoidance */
 #define QUEUE_FLAG_PLUGGED      7       /* queue is plugged */
@@ -589,6 +600,8 @@ enum {
                                  blk_failfast_transport(rq) ||  \
                                  blk_failfast_driver(rq))
 #define blk_rq_started(rq)      ((rq)->cmd_flags & REQ_STARTED)
+#define blk_rq_io_stat(rq)      ((rq)->cmd_flags & REQ_IO_STAT)
+#define blk_rq_quiet(rq)        ((rq)->cmd_flags & REQ_QUIET)
 
 #define blk_account_rq(rq)      (blk_rq_started(rq) && (blk_fs_request(rq) || blk_discard_rq(rq))) 
 
@@ -611,32 +624,42 @@ enum {
 #define rq_data_dir(rq)         ((rq)->cmd_flags & 1)
 
 /*
- * We regard a request as sync, if it's a READ or a SYNC write.
+ * We regard a request as sync, if either a read or a sync write
  */
-#define rq_is_sync(rq)          (rq_data_dir((rq)) == READ || (rq)->cmd_flags & REQ_RW_SYNC)
+static inline bool rw_is_sync(unsigned int rw_flags)
+{
+        return !(rw_flags & REQ_RW) || (rw_flags & REQ_RW_SYNC);
+}
+
+static inline bool rq_is_sync(struct request *rq)
+{
+        return rw_is_sync(rq->cmd_flags);
+}
+
 #define rq_is_meta(rq)          ((rq)->cmd_flags & REQ_RW_META)
+#define rq_noidle(rq)           ((rq)->cmd_flags & REQ_NOIDLE)
 
-static inline int blk_queue_full(struct request_queue *q, int rw)
+static inline int blk_queue_full(struct request_queue *q, int sync)
 {
-        if (rw == READ)
-                return test_bit(QUEUE_FLAG_READFULL, &q->queue_flags);
-        return test_bit(QUEUE_FLAG_WRITEFULL, &q->queue_flags);
+        if (sync)
+                return test_bit(QUEUE_FLAG_SYNCFULL, &q->queue_flags);
+        return test_bit(QUEUE_FLAG_ASYNCFULL, &q->queue_flags);
 }
 
-static inline void blk_set_queue_full(struct request_queue *q, int rw)
+static inline void blk_set_queue_full(struct request_queue *q, int sync)
 {
-        if (rw == READ)
-                queue_flag_set(QUEUE_FLAG_READFULL, q);
+        if (sync)
+                queue_flag_set(QUEUE_FLAG_SYNCFULL, q);
         else
-                queue_flag_set(QUEUE_FLAG_WRITEFULL, q);
+                queue_flag_set(QUEUE_FLAG_ASYNCFULL, q);
 }
 
-static inline void blk_clear_queue_full(struct request_queue *q, int rw)
+static inline void blk_clear_queue_full(struct request_queue *q, int sync)
 {
-        if (rw == READ)
-                queue_flag_clear(QUEUE_FLAG_READFULL, q);
+        if (sync)
+                queue_flag_clear(QUEUE_FLAG_SYNCFULL, q);
         else
-                queue_flag_clear(QUEUE_FLAG_WRITEFULL, q);
+                queue_flag_clear(QUEUE_FLAG_ASYNCFULL, q);
 }
 
 
diff --git a/include/linux/blktrace_api.h b/include/linux/blktrace_api.h
index 6e915878e88c..d960889e92ef 100644
--- a/include/linux/blktrace_api.h
+++ b/include/linux/blktrace_api.h
@@ -144,6 +144,9 @@ struct blk_user_trace_setup {
 
 #ifdef __KERNEL__
 #if defined(CONFIG_BLK_DEV_IO_TRACE)
+
+#include <linux/sysfs.h>
+
 struct blk_trace {
         int trace_state;
         struct rchan *rchan;
@@ -194,6 +197,8 @@ extern int blk_trace_setup(struct request_queue *q, char *name, dev_t dev,
 extern int blk_trace_startstop(struct request_queue *q, int start);
 extern int blk_trace_remove(struct request_queue *q);
 
+extern struct attribute_group blk_trace_attr_group;
+
 #else /* !CONFIG_BLK_DEV_IO_TRACE */
 #define blk_trace_ioctl(bdev, cmd, arg)         (-ENOTTY)
 #define blk_trace_shutdown(q)                   do { } while (0)
diff --git a/include/linux/bootmem.h b/include/linux/bootmem.h
index 455d83219fae..bc3ab7073695 100644
--- a/include/linux/bootmem.h
+++ b/include/linux/bootmem.h
@@ -146,10 +146,10 @@ extern void *alloc_large_system_hash(const char *tablename,
 
 #define HASH_EARLY      0x00000001      /* Allocating during early boot? */
 
-/* Only NUMA needs hash distribution.
- * IA64 and x86_64 have sufficient vmalloc space.
+/* Only NUMA needs hash distribution. 64bit NUMA architectures have
+ * sufficient vmalloc space.
  */
-#if defined(CONFIG_NUMA) && (defined(CONFIG_IA64) || defined(CONFIG_X86_64))
+#if defined(CONFIG_NUMA) && defined(CONFIG_64BIT)
 #define HASHDIST_DEFAULT 1
 #else
 #define HASHDIST_DEFAULT 0
diff --git a/include/linux/buffer_head.h b/include/linux/buffer_head.h
index f19fd9045ea0..16ed0284d780 100644
--- a/include/linux/buffer_head.h
+++ b/include/linux/buffer_head.h
@@ -155,6 +155,7 @@ void create_empty_buffers(struct page *, unsigned long,
                         unsigned long b_state);
 void end_buffer_read_sync(struct buffer_head *bh, int uptodate);
 void end_buffer_write_sync(struct buffer_head *bh, int uptodate);
+void end_buffer_async_write(struct buffer_head *bh, int uptodate);
 
 /* Things to do with buffers at mapping->private_list */
 void mark_buffer_dirty_inode(struct buffer_head *bh, struct inode *inode);
@@ -197,6 +198,8 @@ extern int buffer_heads_over_limit;
 void block_invalidatepage(struct page *page, unsigned long offset);
 int block_write_full_page(struct page *page, get_block_t *get_block,
                                 struct writeback_control *wbc);
+int block_write_full_page_endio(struct page *page, get_block_t *get_block,
+                        struct writeback_control *wbc, bh_end_io_t *handler);
 int block_read_full_page(struct page*, get_block_t*);
 int block_is_partially_uptodate(struct page *page, read_descriptor_t *desc,
                                 unsigned long from);
@@ -216,7 +219,7 @@ int cont_write_begin(struct file *, struct address_space *, loff_t,
                         get_block_t *, loff_t *);
 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,
+int block_page_mkwrite(struct vm_area_struct *vma, struct vm_fault *vmf,
                                 get_block_t get_block);
 void block_sync_page(struct page *);
 sector_t generic_block_bmap(struct address_space *, sector_t, get_block_t *);
@@ -332,22 +335,10 @@ extern int __set_page_dirty_buffers(struct page *page);
 
 static inline void buffer_init(void) {}
 static inline int try_to_free_buffers(struct page *page) { return 1; }
-static inline int sync_blockdev(struct block_device *bdev) { return 0; }
 static inline int inode_has_buffers(struct inode *inode) { return 0; }
 static inline void invalidate_inode_buffers(struct inode *inode) {}
 static inline int remove_inode_buffers(struct inode *inode) { return 1; }
 static inline int sync_mapping_buffers(struct address_space *mapping) { return 0; }
-static inline void invalidate_bdev(struct block_device *bdev) {}
-
-static inline struct super_block *freeze_bdev(struct block_device *sb)
-{
-        return NULL;
-}
-
-static inline int thaw_bdev(struct block_device *bdev, struct super_block *sb)
-{
-        return 0;
-}
 
 #endif /* CONFIG_BLOCK */
 #endif /* _LINUX_BUFFER_HEAD_H */
diff --git a/include/linux/capability.h b/include/linux/capability.h
index 4864a43b2b45..c3021105edc0 100644
--- a/include/linux/capability.h
+++ b/include/linux/capability.h
@@ -377,7 +377,21 @@ struct cpu_vfs_cap_data {
 #define CAP_FOR_EACH_U32(__capi)  \
         for (__capi = 0; __capi < _KERNEL_CAPABILITY_U32S; ++__capi)
 
+/*
+ * CAP_FS_MASK and CAP_NFSD_MASKS:
+ *
+ * The fs mask is all the privileges that fsuid==0 historically meant.
+ * At one time in the past, that included CAP_MKNOD and CAP_LINUX_IMMUTABLE.
+ *
+ * It has never meant setting security.* and trusted.* xattrs.
+ *
+ * We could also define fsmask as follows:
+ *   1. CAP_FS_MASK is the privilege to bypass all fs-related DAC permissions
+ *   2. The security.* and trusted.* xattrs are fs-related MAC permissions
+ */
+
 # define CAP_FS_MASK_B0     (CAP_TO_MASK(CAP_CHOWN)             \
+                            | CAP_TO_MASK(CAP_MKNOD)            \
                             | CAP_TO_MASK(CAP_DAC_OVERRIDE)     \
                             | CAP_TO_MASK(CAP_DAC_READ_SEARCH)  \
                             | CAP_TO_MASK(CAP_FOWNER)           \
@@ -392,11 +406,12 @@ struct cpu_vfs_cap_data {
 # define CAP_EMPTY_SET    ((kernel_cap_t){{ 0, 0 }})
 # define CAP_FULL_SET     ((kernel_cap_t){{ ~0, ~0 }})
 # define CAP_INIT_EFF_SET ((kernel_cap_t){{ ~CAP_TO_MASK(CAP_SETPCAP), ~0 }})
-# define CAP_FS_SET       ((kernel_cap_t){{ CAP_FS_MASK_B0, CAP_FS_MASK_B1 } })
+# define CAP_FS_SET       ((kernel_cap_t){{ CAP_FS_MASK_B0 \
+                                    | CAP_TO_MASK(CAP_LINUX_IMMUTABLE), \
+                                    CAP_FS_MASK_B1 } })
 # define CAP_NFSD_SET     ((kernel_cap_t){{ CAP_FS_MASK_B0 \
-                                            | CAP_TO_MASK(CAP_SYS_RESOURCE) \
-                                            | CAP_TO_MASK(CAP_MKNOD), \
-                                            CAP_FS_MASK_B1 } })
+                                    | CAP_TO_MASK(CAP_SYS_RESOURCE), \
+                                    CAP_FS_MASK_B1 } })
 
 #endif /* _KERNEL_CAPABILITY_U32S != 2 */
 
diff --git a/include/linux/cgroup.h b/include/linux/cgroup.h
index 499900d0cee7..665fa70e4094 100644
--- a/include/linux/cgroup.h
+++ b/include/linux/cgroup.h
@@ -15,6 +15,7 @@
 #include <linux/cgroupstats.h>
 #include <linux/prio_heap.h>
 #include <linux/rwsem.h>
+#include <linux/idr.h>
 
 #ifdef CONFIG_CGROUPS
 
@@ -22,6 +23,7 @@ struct cgroupfs_root;
 struct cgroup_subsys;
 struct inode;
 struct cgroup;
+struct css_id;
 
 extern int cgroup_init_early(void);
 extern int cgroup_init(void);
@@ -47,18 +49,24 @@ enum cgroup_subsys_id {
 
 /* Per-subsystem/per-cgroup state maintained by the system. */
 struct cgroup_subsys_state {
-        /* The cgroup that this subsystem is attached to. Useful
+        /*
+         * The cgroup that this subsystem is attached to. Useful
          * for subsystems that want to know about the cgroup
-         * hierarchy structure */
+         * hierarchy structure
+         */
         struct cgroup *cgroup;
 
-        /* State maintained by the cgroup system to allow subsystems
+        /*
+         * State maintained by the cgroup system to allow subsystems
          * to be "busy". Should be accessed via css_get(),
-         * css_tryget() and and css_put(). */
+         * css_tryget() and and css_put().
+         */
 
         atomic_t refcnt;
 
         unsigned long flags;
+        /* ID for this css, if possible */
+        struct css_id *id;
 };
 
 /* bits in struct cgroup_subsys_state flags field */
@@ -120,19 +128,26 @@ static inline void css_put(struct cgroup_subsys_state *css)
 enum {
         /* Control Group is dead */
         CGRP_REMOVED,
-        /* Control Group has previously had a child cgroup or a task,
-         * but no longer (only if CGRP_NOTIFY_ON_RELEASE is set) */
+        /*
+         * Control Group has previously had a child cgroup or a task,
+         * but no longer (only if CGRP_NOTIFY_ON_RELEASE is set)
+         */
         CGRP_RELEASABLE,
         /* Control Group requires release notifications to userspace */
         CGRP_NOTIFY_ON_RELEASE,
+        /*
+         * A thread in rmdir() is wating for this cgroup.
+         */
+        CGRP_WAIT_ON_RMDIR,
 };
 
 struct cgroup {
         unsigned long flags;            /* "unsigned long" so bitops work */
 
-        /* count users of this cgroup. >0 means busy, but doesn't
-         * necessarily indicate the number of tasks in the
-         * cgroup */
+        /*
+         * count users of this cgroup. >0 means busy, but doesn't
+         * necessarily indicate the number of tasks in the cgroup
+         */
         atomic_t count;
 
         /*
@@ -142,7 +157,7 @@ struct cgroup {
         struct list_head sibling;       /* my parent's children */
         struct list_head children;      /* my children */
 
-        struct cgroup *parent;  /* my parent */
+        struct cgroup *parent;          /* my parent */
         struct dentry *dentry;          /* cgroup fs entry, RCU protected */
 
         /* Private pointers for each registered subsystem */
@@ -177,11 +192,12 @@ struct cgroup {
         struct rcu_head rcu_head;
 };
 
-/* A css_set is a structure holding pointers to a set of
+/*
+ * A css_set is a structure holding pointers to a set of
  * cgroup_subsys_state objects. This saves space in the task struct
  * object and speeds up fork()/exit(), since a single inc/dec and a
- * list_add()/del() can bump the reference count on the entire
- * cgroup set for a task.
+ * list_add()/del() can bump the reference count on the entire cgroup
+ * set for a task.
  */
 
 struct css_set {
@@ -226,13 +242,8 @@ struct cgroup_map_cb {
         void *state;
 };
 
-/* struct cftype:
- *
- * The files in the cgroup filesystem mostly have a very simple read/write
- * handling, some common function will take care of it. Nevertheless some cases
- * (read tasks) are special and therefore I define this structure for every
- * kind of file.
- *
+/*
+ * struct cftype: handler definitions for cgroup control files
  *
  * When reading/writing to a file:
  *      - the cgroup to use is file->f_dentry->d_parent->d_fsdata
@@ -241,10 +252,17 @@ struct cgroup_map_cb {
 
 #define MAX_CFTYPE_NAME 64
 struct cftype {
-        /* By convention, the name should begin with the name of the
-         * subsystem, followed by a period */
+        /*
+         * By convention, the name should begin with the name of the
+         * subsystem, followed by a period
+         */
         char name[MAX_CFTYPE_NAME];
         int private;
+        /*
+         * If not 0, file mode is set to this value, otherwise it will
+         * be figured out automatically
+         */
+        mode_t mode;
 
         /*
          * If non-zero, defines the maximum length of string that can
@@ -319,15 +337,20 @@ struct cgroup_scanner {
         void (*process_task)(struct task_struct *p,
                         struct cgroup_scanner *scan);
         struct ptr_heap *heap;
+        void *data;
 };
 
-/* Add a new file to the given cgroup directory. Should only be
- * called by subsystems from within a populate() method */
+/*
+ * Add a new file to the given cgroup directory. Should only be
+ * called by subsystems from within a populate() method
+ */
 int cgroup_add_file(struct cgroup *cgrp, struct cgroup_subsys *subsys,
                        const struct cftype *cft);
 
-/* Add a set of new files to the given cgroup directory. Should
- * only be called by subsystems from within a populate() method */
+/*
+ * Add a set of new files to the given cgroup directory. Should
+ * only be called by subsystems from within a populate() method
+ */
 int cgroup_add_files(struct cgroup *cgrp,
                         struct cgroup_subsys *subsys,
                         const struct cftype cft[],
@@ -339,15 +362,18 @@ int cgroup_path(const struct cgroup *cgrp, char *buf, int buflen);
 
 int cgroup_task_count(const struct cgroup *cgrp);
 
-/* Return true if the cgroup is a descendant of the current cgroup */
-int cgroup_is_descendant(const struct cgroup *cgrp);
+/* Return true if cgrp is a descendant of the task's cgroup */
+int cgroup_is_descendant(const struct cgroup *cgrp, struct task_struct *task);
 
-/* Control Group subsystem type. See Documentation/cgroups.txt for details */
+/*
+ * Control Group subsystem type.
+ * See Documentation/cgroups/cgroups.txt for details
+ */
 
 struct cgroup_subsys {
         struct cgroup_subsys_state *(*create)(struct cgroup_subsys *ss,
                                                   struct cgroup *cgrp);
-        void (*pre_destroy)(struct cgroup_subsys *ss, struct cgroup *cgrp);
+        int (*pre_destroy)(struct cgroup_subsys *ss, struct cgroup *cgrp);
         void (*destroy)(struct cgroup_subsys *ss, struct cgroup *cgrp);
         int (*can_attach)(struct cgroup_subsys *ss,
                           struct cgroup *cgrp, struct task_struct *tsk);
@@ -364,6 +390,11 @@ struct cgroup_subsys {
         int active;
         int disabled;
         int early_init;
+        /*
+         * True if this subsys uses ID. ID is not available before cgroup_init()
+         * (not available in early_init time.)
+         */
+        bool use_id;
 #define MAX_CGROUP_TYPE_NAMELEN 32
         const char *name;
 
@@ -386,6 +417,9 @@ struct cgroup_subsys {
          */
         struct cgroupfs_root *root;
         struct list_head sibling;
+        /* used when use_id == true */
+        struct idr idr;
+        spinlock_t id_lock;
 };
 
 #define SUBSYS(_x) extern struct cgroup_subsys _x ## _subsys;
@@ -419,7 +453,8 @@ struct cgroup_iter {
         struct list_head *task;
 };
 
-/* To iterate across the tasks in a cgroup:
+/*
+ * To iterate across the tasks in a cgroup:
  *
  * 1) call cgroup_iter_start to intialize an iterator
  *
@@ -428,9 +463,10 @@ struct cgroup_iter {
  *
  * 3) call cgroup_iter_end() to destroy the iterator.
  *
- * Or, call cgroup_scan_tasks() to iterate through every task in a cpuset.
- *    - cgroup_scan_tasks() holds the css_set_lock when calling the test_task()
- *      callback, but not while calling the process_task() callback.
+ * Or, call cgroup_scan_tasks() to iterate through every task in a
+ * cgroup - cgroup_scan_tasks() holds the css_set_lock when calling
+ * the test_task() callback, but not while calling the process_task()
+ * callback.
  */
 void cgroup_iter_start(struct cgroup *cgrp, struct cgroup_iter *it);
 struct task_struct *cgroup_iter_next(struct cgroup *cgrp,
@@ -439,6 +475,44 @@ void cgroup_iter_end(struct cgroup *cgrp, struct cgroup_iter *it);
 int cgroup_scan_tasks(struct cgroup_scanner *scan);
 int cgroup_attach_task(struct cgroup *, struct task_struct *);
 
+/*
+ * CSS ID is ID for cgroup_subsys_state structs under subsys. This only works
+ * if cgroup_subsys.use_id == true. It can be used for looking up and scanning.
+ * CSS ID is assigned at cgroup allocation (create) automatically
+ * and removed when subsys calls free_css_id() function. This is because
+ * the lifetime of cgroup_subsys_state is subsys's matter.
+ *
+ * Looking up and scanning function should be called under rcu_read_lock().
+ * Taking cgroup_mutex()/hierarchy_mutex() is not necessary for following calls.
+ * But the css returned by this routine can be "not populated yet" or "being
+ * destroyed". The caller should check css and cgroup's status.
+ */
+
+/*
+ * Typically Called at ->destroy(), or somewhere the subsys frees
+ * cgroup_subsys_state.
+ */
+void free_css_id(struct cgroup_subsys *ss, struct cgroup_subsys_state *css);
+
+/* Find a cgroup_subsys_state which has given ID */
+
+struct cgroup_subsys_state *css_lookup(struct cgroup_subsys *ss, int id);
+
+/*
+ * Get a cgroup whose id is greater than or equal to id under tree of root.
+ * Returning a cgroup_subsys_state or NULL.
+ */
+struct cgroup_subsys_state *css_get_next(struct cgroup_subsys *ss, int id,
+                struct cgroup_subsys_state *root, int *foundid);
+
+/* Returns true if root is ancestor of cg */
+bool css_is_ancestor(struct cgroup_subsys_state *cg,
+                     const struct cgroup_subsys_state *root);
+
+/* Get id and depth of css */
+unsigned short css_id(struct cgroup_subsys_state *css);
+unsigned short css_depth(struct cgroup_subsys_state *css);
+
 #else /* !CONFIG_CGROUPS */
 
 static inline int cgroup_init_early(void) { return 0; }
diff --git a/include/linux/clocksource.h b/include/linux/clocksource.h
index 573819ef4cc0..5a40d14daa9f 100644
--- a/include/linux/clocksource.h
+++ b/include/linux/clocksource.h
@@ -143,7 +143,9 @@ extern u64 timecounter_cyc2time(struct timecounter *tc,
  *                      400-499: Perfect
  *                              The ideal clocksource. A must-use where
  *                              available.
- * @read:               returns a cycle value
+ * @read:               returns a cycle value, passes clocksource as argument
+ * @enable:             optional function to enable the clocksource
+ * @disable:            optional function to disable the clocksource
  * @mask:               bitmask for two's complement
  *                      subtraction of non 64 bit counters
  * @mult:               cycle to nanosecond multiplier (adjusted by NTP)
@@ -162,7 +164,9 @@ struct clocksource {
         char *name;
         struct list_head list;
         int rating;
-        cycle_t (*read)(void);
+        cycle_t (*read)(struct clocksource *cs);
+        int (*enable)(struct clocksource *cs);
+        void (*disable)(struct clocksource *cs);
         cycle_t mask;
         u32 mult;
         u32 mult_orig;
@@ -271,7 +275,34 @@ static inline u32 clocksource_hz2mult(u32 hz, u32 shift_constant)
  */
 static inline cycle_t clocksource_read(struct clocksource *cs)
 {
-        return cs->read();
+        return cs->read(cs);
+}
+
+/**
+ * clocksource_enable: - enable clocksource
+ * @cs:         pointer to clocksource
+ *
+ * Enables the specified clocksource. The clocksource callback
+ * function should start up the hardware and setup mult and field
+ * members of struct clocksource to reflect hardware capabilities.
+ */
+static inline int clocksource_enable(struct clocksource *cs)
+{
+        return cs->enable ? cs->enable(cs) : 0;
+}
+
+/**
+ * clocksource_disable: - disable clocksource
+ * @cs:         pointer to clocksource
+ *
+ * Disables the specified clocksource. The clocksource callback
+ * function should power down the now unused hardware block to
+ * save power.
+ */
+static inline void clocksource_disable(struct clocksource *cs)
+{
+        if (cs->disable)
+                cs->disable(cs);
 }
 
 /**
diff --git a/include/linux/compat.h b/include/linux/compat.h
index b880864672de..f2ded21f9a3c 100644
--- a/include/linux/compat.h
+++ b/include/linux/compat.h
@@ -191,6 +191,12 @@ asmlinkage ssize_t compat_sys_readv(unsigned long fd,
                 const struct compat_iovec __user *vec, unsigned long vlen);
 asmlinkage ssize_t compat_sys_writev(unsigned long fd,
                 const struct compat_iovec __user *vec, unsigned long vlen);
+asmlinkage ssize_t compat_sys_preadv(unsigned long fd,
+                const struct compat_iovec __user *vec,
+                unsigned long vlen, u32 pos_low, u32 pos_high);
+asmlinkage ssize_t compat_sys_pwritev(unsigned long fd,
+                const struct compat_iovec __user *vec,
+                unsigned long vlen, u32 pos_low, u32 pos_high);
 
 int compat_do_execve(char * filename, compat_uptr_t __user *argv,
                 compat_uptr_t __user *envp, struct pt_regs * regs);
diff --git a/include/linux/compiler.h b/include/linux/compiler.h
index d95da1020f1c..37bcb50a4d7c 100644
--- a/include/linux/compiler.h
+++ b/include/linux/compiler.h
@@ -68,6 +68,7 @@ struct ftrace_branch_data {
                         unsigned long miss;
                         unsigned long hit;
                 };
+                unsigned long miss_hit[2];
         };
 };
 
@@ -75,7 +76,8 @@ struct ftrace_branch_data {
  * Note: DISABLE_BRANCH_PROFILING can be used by special lowlevel code
  * to disable branch tracing on a per file basis.
  */
-#if defined(CONFIG_TRACE_BRANCH_PROFILING) && !defined(DISABLE_BRANCH_PROFILING)
+#if defined(CONFIG_TRACE_BRANCH_PROFILING) \
+    && !defined(DISABLE_BRANCH_PROFILING) && !defined(__CHECKER__)
 void ftrace_likely_update(struct ftrace_branch_data *f, int val, int expect);
 
 #define likely_notrace(x)       __builtin_expect(!!(x), 1)
@@ -113,7 +115,9 @@ void ftrace_likely_update(struct ftrace_branch_data *f, int val, int expect);
  * "Define 'is'", Bill Clinton
  * "Define 'if'", Steven Rostedt
  */
-#define if(cond) if (__builtin_constant_p((cond)) ? !!(cond) :          \
+#define if(cond, ...) __trace_if( (cond , ## __VA_ARGS__) )
+#define __trace_if(cond) \
+        if (__builtin_constant_p((cond)) ? !!(cond) :                   \
         ({                                                              \
                 int ______r;                                            \
                 static struct ftrace_branch_data                        \
@@ -125,10 +129,7 @@ void ftrace_likely_update(struct ftrace_branch_data *f, int val, int expect);
                                 .line = __LINE__,                       \
                         };                                              \
                 ______r = !!(cond);                                     \
-                if (______r)                                            \
-                        ______f.hit++;                                  \
-                else                                                    \
-                        ______f.miss++;                                 \
+                ______f.miss_hit[______r]++;                                    \
                 ______r;                                                \
         }))
 #endif /* CONFIG_PROFILE_ALL_BRANCHES */
diff --git a/include/linux/connector.h b/include/linux/connector.h
index fc65d219d88c..b9966e64604e 100644
--- a/include/linux/connector.h
+++ b/include/linux/connector.h
@@ -39,8 +39,10 @@
 #define CN_IDX_V86D                     0x4
 #define CN_VAL_V86D_UVESAFB             0x1
 #define CN_IDX_BB                       0x5     /* BlackBoard, from the TSP GPL sampling framework */
+#define CN_DST_IDX                      0x6
+#define CN_DST_VAL                      0x1
 
-#define CN_NETLINK_USERS                6
+#define CN_NETLINK_USERS                7
 
 /*
  * Maximum connector's message size.
diff --git a/include/linux/cpu.h b/include/linux/cpu.h
index c2747ac2ae43..2643d848df90 100644
--- a/include/linux/cpu.h
+++ b/include/linux/cpu.h
@@ -23,7 +23,6 @@
 #include <linux/node.h>
 #include <linux/compiler.h>
 #include <linux/cpumask.h>
-#include <linux/mutex.h>
 
 struct cpu {
         int node_id;            /* The node which contains the CPU */
@@ -103,16 +102,6 @@ extern struct sysdev_class cpu_sysdev_class;
 #ifdef CONFIG_HOTPLUG_CPU
 /* Stop CPUs going up and down. */
 
-static inline void cpuhotplug_mutex_lock(struct mutex *cpu_hp_mutex)
-{
-        mutex_lock(cpu_hp_mutex);
-}
-
-static inline void cpuhotplug_mutex_unlock(struct mutex *cpu_hp_mutex)
-{
-        mutex_unlock(cpu_hp_mutex);
-}
-
 extern void get_online_cpus(void);
 extern void put_online_cpus(void);
 #define hotcpu_notifier(fn, pri) {                              \
@@ -126,11 +115,6 @@ int cpu_down(unsigned int cpu);
 
 #else           /* CONFIG_HOTPLUG_CPU */
 
-static inline void cpuhotplug_mutex_lock(struct mutex *cpu_hp_mutex)
-{ }
-static inline void cpuhotplug_mutex_unlock(struct mutex *cpu_hp_mutex)
-{ }
-
 #define get_online_cpus()       do { } while (0)
 #define put_online_cpus()       do { } while (0)
 #define hotcpu_notifier(fn, pri)        do { (void)(fn); } while (0)
diff --git a/include/linux/cpuset.h b/include/linux/cpuset.h
index 90c6074a36ca..05ea1dd7d681 100644
--- a/include/linux/cpuset.h
+++ b/include/linux/cpuset.h
@@ -12,6 +12,7 @@
 #include <linux/cpumask.h>
 #include <linux/nodemask.h>
 #include <linux/cgroup.h>
+#include <linux/mm.h>
 
 #ifdef CONFIG_CPUSETS
 
@@ -29,19 +30,29 @@ void cpuset_init_current_mems_allowed(void);
 void cpuset_update_task_memory_state(void);
 int cpuset_nodemask_valid_mems_allowed(nodemask_t *nodemask);
 
-extern int __cpuset_zone_allowed_softwall(struct zone *z, gfp_t gfp_mask);
-extern int __cpuset_zone_allowed_hardwall(struct zone *z, gfp_t gfp_mask);
+extern int __cpuset_node_allowed_softwall(int node, gfp_t gfp_mask);
+extern int __cpuset_node_allowed_hardwall(int node, gfp_t gfp_mask);
 
-static int inline cpuset_zone_allowed_softwall(struct zone *z, gfp_t gfp_mask)
+static inline int cpuset_node_allowed_softwall(int node, gfp_t gfp_mask)
 {
         return number_of_cpusets <= 1 ||
-                __cpuset_zone_allowed_softwall(z, gfp_mask);
+                __cpuset_node_allowed_softwall(node, gfp_mask);
 }
 
-static int inline cpuset_zone_allowed_hardwall(struct zone *z, gfp_t gfp_mask)
+static inline int cpuset_node_allowed_hardwall(int node, gfp_t gfp_mask)
 {
         return number_of_cpusets <= 1 ||
-                __cpuset_zone_allowed_hardwall(z, gfp_mask);
+                __cpuset_node_allowed_hardwall(node, gfp_mask);
+}
+
+static inline int cpuset_zone_allowed_softwall(struct zone *z, gfp_t gfp_mask)
+{
+        return cpuset_node_allowed_softwall(zone_to_nid(z), gfp_mask);
+}
+
+static inline int cpuset_zone_allowed_hardwall(struct zone *z, gfp_t gfp_mask)
+{
+        return cpuset_node_allowed_hardwall(zone_to_nid(z), gfp_mask);
 }
 
 extern int cpuset_mems_allowed_intersects(const struct task_struct *tsk1,
@@ -90,12 +101,12 @@ static inline void cpuset_init_smp(void) {}
 static inline void cpuset_cpus_allowed(struct task_struct *p,
                                        struct cpumask *mask)
 {
-        *mask = cpu_possible_map;
+        cpumask_copy(mask, cpu_possible_mask);
 }
 static inline void cpuset_cpus_allowed_locked(struct task_struct *p,
                                               struct cpumask *mask)
 {
-        *mask = cpu_possible_map;
+        cpumask_copy(mask, cpu_possible_mask);
 }
 
 static inline nodemask_t cpuset_mems_allowed(struct task_struct *p)
@@ -112,6 +123,16 @@ static inline int cpuset_nodemask_valid_mems_allowed(nodemask_t *nodemask)
         return 1;
 }
 
+static inline int cpuset_node_allowed_softwall(int node, gfp_t gfp_mask)
+{
+        return 1;
+}
+
+static inline int cpuset_node_allowed_hardwall(int node, gfp_t gfp_mask)
+{
+        return 1;
+}
+
 static inline int cpuset_zone_allowed_softwall(struct zone *z, gfp_t gfp_mask)
 {
         return 1;
diff --git a/include/linux/debug_locks.h b/include/linux/debug_locks.h
index 096476f1fb35..29b3ce3f2a1d 100644
--- a/include/linux/debug_locks.h
+++ b/include/linux/debug_locks.h
@@ -2,12 +2,20 @@
 #define __LINUX_DEBUG_LOCKING_H
 
 #include <linux/kernel.h>
+#include <asm/atomic.h>
+#include <asm/system.h>
 
 struct task_struct;
 
 extern int debug_locks;
 extern int debug_locks_silent;
 
+
+static inline int __debug_locks_off(void)
+{
+        return xchg(&debug_locks, 0);
+}
+
 /*
  * Generic 'turn off all lock debugging' function:
  */
diff --git a/include/linux/debugfs.h b/include/linux/debugfs.h
index af0e01d4c663..eb5c2ba2f81a 100644
--- a/include/linux/debugfs.h
+++ b/include/linux/debugfs.h
@@ -71,6 +71,9 @@ struct dentry *debugfs_create_bool(const char *name, mode_t mode,
 struct dentry *debugfs_create_blob(const char *name, mode_t mode,
                                   struct dentry *parent,
                                   struct debugfs_blob_wrapper *blob);
+
+bool debugfs_initialized(void);
+
 #else
 
 #include <linux/err.h>
@@ -183,6 +186,11 @@ static inline struct dentry *debugfs_create_blob(const char *name, mode_t mode,
         return ERR_PTR(-ENODEV);
 }
 
+static inline bool debugfs_initialized(void)
+{
+        return false;
+}
+
 #endif
 
 #endif
diff --git a/include/linux/device-mapper.h b/include/linux/device-mapper.h
index 8209e08969f9..ded2d7c42668 100644
--- a/include/linux/device-mapper.h
+++ b/include/linux/device-mapper.h
@@ -116,7 +116,6 @@ void dm_put_device(struct dm_target *ti, struct dm_dev *d);
 /*
  * Target features
  */
-#define DM_TARGET_SUPPORTS_BARRIERS 0x00000001
 
 struct target_type {
         uint64_t features;
@@ -139,6 +138,9 @@ struct target_type {
         dm_ioctl_fn ioctl;
         dm_merge_fn merge;
         dm_busy_fn busy;
+
+        /* For internal device-mapper use. */
+        struct list_head list;
 };
 
 struct io_restrictions {
diff --git a/include/linux/device.h b/include/linux/device.h
index 2918c0e8fdfd..6a69caaac18a 100644
--- a/include/linux/device.h
+++ b/include/linux/device.h
@@ -551,6 +551,7 @@ extern int (*platform_notify_remove)(struct device *dev);
 extern struct device *get_device(struct device *dev);
 extern void put_device(struct device *dev);
 
+extern void wait_for_device_probe(void);
 
 /* drivers/base/power/shutdown.c */
 extern void device_shutdown(void);
diff --git a/include/linux/dm-dirty-log.h b/include/linux/dm-dirty-log.h
index 600c5fb2daad..5e8b11d88f6f 100644
--- a/include/linux/dm-dirty-log.h
+++ b/include/linux/dm-dirty-log.h
@@ -28,6 +28,9 @@ struct dm_dirty_log_type {
         const char *name;
         struct module *module;
 
+        /* For internal device-mapper use */
+        struct list_head list;
+
         int (*ctr)(struct dm_dirty_log *log, struct dm_target *ti,
                    unsigned argc, char **argv);
         void (*dtr)(struct dm_dirty_log *log);
@@ -113,6 +116,16 @@ struct dm_dirty_log_type {
          */
         int (*status)(struct dm_dirty_log *log, status_type_t status_type,
                       char *result, unsigned maxlen);
+
+        /*
+         * is_remote_recovering is necessary for cluster mirroring. It provides
+         * a way to detect recovery on another node, so we aren't writing
+         * concurrently.  This function is likely to block (when a cluster log
+         * is used).
+         *
+         * Returns: 0, 1
+         */
+        int (*is_remote_recovering)(struct dm_dirty_log *log, region_t region);
 };
 
 int dm_dirty_log_type_register(struct dm_dirty_log_type *type);
diff --git a/include/linux/dma-debug.h b/include/linux/dma-debug.h
new file mode 100644
index 000000000000..28d53cb7b5a2
--- /dev/null
+++ b/include/linux/dma-debug.h
@@ -0,0 +1,174 @@
+/*
+ * Copyright (C) 2008 Advanced Micro Devices, Inc.
+ *
+ * Author: Joerg Roedel <joerg.roedel@amd.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.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307 USA
+ */
+
+#ifndef __DMA_DEBUG_H
+#define __DMA_DEBUG_H
+
+#include <linux/types.h>
+
+struct device;
+struct scatterlist;
+struct bus_type;
+
+#ifdef CONFIG_DMA_API_DEBUG
+
+extern void dma_debug_add_bus(struct bus_type *bus);
+
+extern void dma_debug_init(u32 num_entries);
+
+extern void debug_dma_map_page(struct device *dev, struct page *page,
+                               size_t offset, size_t size,
+                               int direction, dma_addr_t dma_addr,
+                               bool map_single);
+
+extern void debug_dma_unmap_page(struct device *dev, dma_addr_t addr,
+                                 size_t size, int direction, bool map_single);
+
+extern void debug_dma_map_sg(struct device *dev, struct scatterlist *sg,
+                             int nents, int mapped_ents, int direction);
+
+extern void debug_dma_unmap_sg(struct device *dev, struct scatterlist *sglist,
+                               int nelems, int dir);
+
+extern void debug_dma_alloc_coherent(struct device *dev, size_t size,
+                                     dma_addr_t dma_addr, void *virt);
+
+extern void debug_dma_free_coherent(struct device *dev, size_t size,
+                                    void *virt, dma_addr_t addr);
+
+extern void debug_dma_sync_single_for_cpu(struct device *dev,
+                                          dma_addr_t dma_handle, size_t size,
+                                          int direction);
+
+extern void debug_dma_sync_single_for_device(struct device *dev,
+                                             dma_addr_t dma_handle,
+                                             size_t size, int direction);
+
+extern void debug_dma_sync_single_range_for_cpu(struct device *dev,
+                                                dma_addr_t dma_handle,
+                                                unsigned long offset,
+                                                size_t size,
+                                                int direction);
+
+extern void debug_dma_sync_single_range_for_device(struct device *dev,
+                                                   dma_addr_t dma_handle,
+                                                   unsigned long offset,
+                                                   size_t size, int direction);
+
+extern void debug_dma_sync_sg_for_cpu(struct device *dev,
+                                      struct scatterlist *sg,
+                                      int nelems, int direction);
+
+extern void debug_dma_sync_sg_for_device(struct device *dev,
+                                         struct scatterlist *sg,
+                                         int nelems, int direction);
+
+extern void debug_dma_dump_mappings(struct device *dev);
+
+#else /* CONFIG_DMA_API_DEBUG */
+
+static inline void dma_debug_add_bus(struct bus_type *bus)
+{
+}
+
+static inline void dma_debug_init(u32 num_entries)
+{
+}
+
+static inline void debug_dma_map_page(struct device *dev, struct page *page,
+                                      size_t offset, size_t size,
+                                      int direction, dma_addr_t dma_addr,
+                                      bool map_single)
+{
+}
+
+static inline void debug_dma_unmap_page(struct device *dev, dma_addr_t addr,
+                                        size_t size, int direction,
+                                        bool map_single)
+{
+}
+
+static inline void debug_dma_map_sg(struct device *dev, struct scatterlist *sg,
+                                    int nents, int mapped_ents, int direction)
+{
+}
+
+static inline void debug_dma_unmap_sg(struct device *dev,
+                                      struct scatterlist *sglist,
+                                      int nelems, int dir)
+{
+}
+
+static inline void debug_dma_alloc_coherent(struct device *dev, size_t size,
+                                            dma_addr_t dma_addr, void *virt)
+{
+}
+
+static inline void debug_dma_free_coherent(struct device *dev, size_t size,
+                                           void *virt, dma_addr_t addr)
+{
+}
+
+static inline void debug_dma_sync_single_for_cpu(struct device *dev,
+                                                 dma_addr_t dma_handle,
+                                                 size_t size, int direction)
+{
+}
+
+static inline void debug_dma_sync_single_for_device(struct device *dev,
+                                                    dma_addr_t dma_handle,
+                                                    size_t size, int direction)
+{
+}
+
+static inline void debug_dma_sync_single_range_for_cpu(struct device *dev,
+                                                       dma_addr_t dma_handle,
+                                                       unsigned long offset,
+                                                       size_t size,
+                                                       int direction)
+{
+}
+
+static inline void debug_dma_sync_single_range_for_device(struct device *dev,
+                                                          dma_addr_t dma_handle,
+                                                          unsigned long offset,
+                                                          size_t size,
+                                                          int direction)
+{
+}
+
+static inline void debug_dma_sync_sg_for_cpu(struct device *dev,
+                                             struct scatterlist *sg,
+                                             int nelems, int direction)
+{
+}
+
+static inline void debug_dma_sync_sg_for_device(struct device *dev,
+                                                struct scatterlist *sg,
+                                                int nelems, int direction)
+{
+}
+
+static inline void debug_dma_dump_mappings(struct device *dev)
+{
+}
+
+#endif /* CONFIG_DMA_API_DEBUG */
+
+#endif /* __DMA_DEBUG_H */
diff --git a/include/linux/dma-mapping.h b/include/linux/dma-mapping.h
index ba9114ec5d3a..8083b6a36a38 100644
--- a/include/linux/dma-mapping.h
+++ b/include/linux/dma-mapping.h
@@ -3,6 +3,8 @@
 
 #include <linux/device.h>
 #include <linux/err.h>
+#include <linux/dma-attrs.h>
+#include <linux/scatterlist.h>
 
 /* These definitions mirror those in pci.h, so they can be used
  * interchangeably with their PCI_ counterparts */
@@ -13,6 +15,52 @@ enum dma_data_direction {
         DMA_NONE = 3,
 };
 
+struct dma_map_ops {
+        void* (*alloc_coherent)(struct device *dev, size_t size,
+                                dma_addr_t *dma_handle, gfp_t gfp);
+        void (*free_coherent)(struct device *dev, size_t size,
+                              void *vaddr, dma_addr_t dma_handle);
+        dma_addr_t (*map_page)(struct device *dev, struct page *page,
+                               unsigned long offset, size_t size,
+                               enum dma_data_direction dir,
+                               struct dma_attrs *attrs);
+        void (*unmap_page)(struct device *dev, dma_addr_t dma_handle,
+                           size_t size, enum dma_data_direction dir,
+                           struct dma_attrs *attrs);
+        int (*map_sg)(struct device *dev, struct scatterlist *sg,
+                      int nents, enum dma_data_direction dir,
+                      struct dma_attrs *attrs);
+        void (*unmap_sg)(struct device *dev,
+                         struct scatterlist *sg, int nents,
+                         enum dma_data_direction dir,
+                         struct dma_attrs *attrs);
+        void (*sync_single_for_cpu)(struct device *dev,
+                                    dma_addr_t dma_handle, size_t size,
+                                    enum dma_data_direction dir);
+        void (*sync_single_for_device)(struct device *dev,
+                                       dma_addr_t dma_handle, size_t size,
+                                       enum dma_data_direction dir);
+        void (*sync_single_range_for_cpu)(struct device *dev,
+                                          dma_addr_t dma_handle,
+                                          unsigned long offset,
+                                          size_t size,
+                                          enum dma_data_direction dir);
+        void (*sync_single_range_for_device)(struct device *dev,
+                                             dma_addr_t dma_handle,
+                                             unsigned long offset,
+                                             size_t size,
+                                             enum dma_data_direction dir);
+        void (*sync_sg_for_cpu)(struct device *dev,
+                                struct scatterlist *sg, int nents,
+                                enum dma_data_direction dir);
+        void (*sync_sg_for_device)(struct device *dev,
+                                   struct scatterlist *sg, int nents,
+                                   enum dma_data_direction dir);
+        int (*mapping_error)(struct device *dev, dma_addr_t dma_addr);
+        int (*dma_supported)(struct device *dev, u64 mask);
+        int is_phys;
+};
+
 #define DMA_BIT_MASK(n) (((n) == 64) ? ~0ULL : ((1ULL<<(n))-1))
 
 /*
@@ -67,7 +115,7 @@ static inline u64 dma_get_mask(struct device *dev)
 {
         if (dev && dev->dma_mask && *dev->dma_mask)
                 return *dev->dma_mask;
-        return DMA_32BIT_MASK;
+        return DMA_BIT_MASK(32);
 }
 
 extern u64 dma_get_required_mask(struct device *dev);
diff --git a/include/linux/dma_remapping.h b/include/linux/dma_remapping.h
index af1dab41674b..1a455f1f86d7 100644
--- a/include/linux/dma_remapping.h
+++ b/include/linux/dma_remapping.h
@@ -11,6 +11,7 @@
 
 #define DMA_PTE_READ (1)
 #define DMA_PTE_WRITE (2)
+#define DMA_PTE_SNP (1 << 11)
 
 struct intel_iommu;
 struct dmar_domain;
diff --git a/include/linux/dmaengine.h b/include/linux/dmaengine.h
index 1956c8d46d32..2e2aa3df170c 100644
--- a/include/linux/dmaengine.h
+++ b/include/linux/dmaengine.h
@@ -23,9 +23,6 @@
 
 #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>
 
 /**
@@ -205,6 +202,7 @@ struct dma_async_tx_descriptor {
 /**
  * struct dma_device - info on the entity supplying DMA services
  * @chancnt: how many DMA channels are supported
+ * @privatecnt: how many DMA channels are requested by dma_request_channel
  * @channels: the list of struct dma_chan
  * @global_node: list_head for global dma_device_list
  * @cap_mask: one or more dma_capability flags
@@ -227,6 +225,7 @@ struct dma_async_tx_descriptor {
 struct dma_device {
 
         unsigned int chancnt;
+        unsigned int privatecnt;
         struct list_head channels;
         struct list_head global_node;
         dma_cap_mask_t  cap_mask;
@@ -291,6 +290,24 @@ static inline void net_dmaengine_put(void)
 }
 #endif
 
+#ifdef CONFIG_ASYNC_TX_DMA
+#define async_dmaengine_get()   dmaengine_get()
+#define async_dmaengine_put()   dmaengine_put()
+#define async_dma_find_channel(type) dma_find_channel(type)
+#else
+static inline void async_dmaengine_get(void)
+{
+}
+static inline void async_dmaengine_put(void)
+{
+}
+static inline struct dma_chan *
+async_dma_find_channel(enum dma_transaction_type type)
+{
+        return NULL;
+}
+#endif
+
 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,
@@ -337,6 +354,13 @@ __dma_cap_set(enum dma_transaction_type tx_type, dma_cap_mask_t *dstp)
         set_bit(tx_type, dstp->bits);
 }
 
+#define dma_cap_clear(tx, mask) __dma_cap_clear((tx), &(mask))
+static inline void
+__dma_cap_clear(enum dma_transaction_type tx_type, dma_cap_mask_t *dstp)
+{
+        clear_bit(tx_type, dstp->bits);
+}
+
 #define dma_cap_zero(mask) __dma_cap_zero(&(mask))
 static inline void __dma_cap_zero(dma_cap_mask_t *dstp)
 {
diff --git a/include/linux/dmar.h b/include/linux/dmar.h
index f28440784cf0..e397dc342cda 100644
--- a/include/linux/dmar.h
+++ b/include/linux/dmar.h
@@ -24,16 +24,17 @@
 #include <linux/acpi.h>
 #include <linux/types.h>
 #include <linux/msi.h>
+#include <linux/irqreturn.h>
 
-#if defined(CONFIG_DMAR) || defined(CONFIG_INTR_REMAP)
 struct intel_iommu;
-
+#if defined(CONFIG_DMAR) || defined(CONFIG_INTR_REMAP)
 struct dmar_drhd_unit {
         struct list_head list;          /* list of drhd units   */
         struct  acpi_dmar_header *hdr;  /* ACPI header          */
         u64     reg_base_addr;          /* register base address*/
         struct  pci_dev **devices;      /* target device array  */
         int     devices_cnt;            /* target device count  */
+        u16     segment;                /* PCI domain           */
         u8      ignored:1;              /* ignore drhd          */
         u8      include_all:1;
         struct intel_iommu *iommu;
@@ -44,12 +45,20 @@ extern struct list_head dmar_drhd_units;
 #define for_each_drhd_unit(drhd) \
         list_for_each_entry(drhd, &dmar_drhd_units, list)
 
+#define for_each_active_iommu(i, drhd)                                  \
+        list_for_each_entry(drhd, &dmar_drhd_units, list)               \
+                if (i=drhd->iommu, drhd->ignored) {} else
+
+#define for_each_iommu(i, drhd)                                         \
+        list_for_each_entry(drhd, &dmar_drhd_units, list)               \
+                if (i=drhd->iommu, 0) {} else 
+
 extern int dmar_table_init(void);
 extern int dmar_dev_scope_init(void);
 
 /* Intel IOMMU detection */
 extern void detect_intel_iommu(void);
-
+extern int enable_drhd_fault_handling(void);
 
 extern int parse_ioapics_under_ir(void);
 extern int alloc_iommu(struct dmar_drhd_unit *);
@@ -63,12 +72,12 @@ static inline int dmar_table_init(void)
 {
         return -ENODEV;
 }
+static inline int enable_drhd_fault_handling(void)
+{
+        return -1;
+}
 #endif /* !CONFIG_DMAR && !CONFIG_INTR_REMAP */
 
-#ifdef CONFIG_INTR_REMAP
-extern int intr_remapping_enabled;
-extern int enable_intr_remapping(int);
-
 struct irte {
         union {
                 struct {
@@ -97,6 +106,12 @@ struct irte {
                 __u64 high;
         };
 };
+#ifdef CONFIG_INTR_REMAP
+extern int intr_remapping_enabled;
+extern int enable_intr_remapping(int);
+extern void disable_intr_remapping(void);
+extern int reenable_intr_remapping(int);
+
 extern int get_irte(int irq, struct irte *entry);
 extern int modify_irte(int irq, struct irte *irte_modified);
 extern int alloc_irte(struct intel_iommu *iommu, int irq, u16 count);
@@ -111,14 +126,40 @@ extern int irq_remapped(int irq);
 extern struct intel_iommu *map_dev_to_ir(struct pci_dev *dev);
 extern struct intel_iommu *map_ioapic_to_ir(int apic);
 #else
+static inline int alloc_irte(struct intel_iommu *iommu, int irq, u16 count)
+{
+        return -1;
+}
+static inline int modify_irte(int irq, struct irte *irte_modified)
+{
+        return -1;
+}
+static inline int free_irte(int irq)
+{
+        return -1;
+}
+static inline int map_irq_to_irte_handle(int irq, u16 *sub_handle)
+{
+        return -1;
+}
+static inline int set_irte_irq(int irq, struct intel_iommu *iommu, u16 index,
+                               u16 sub_handle)
+{
+        return -1;
+}
+static inline struct intel_iommu *map_dev_to_ir(struct pci_dev *dev)
+{
+        return NULL;
+}
+static inline struct intel_iommu *map_ioapic_to_ir(int apic)
+{
+        return NULL;
+}
 #define irq_remapped(irq)               (0)
 #define enable_intr_remapping(mode)     (-1)
 #define intr_remapping_enabled          (0)
 #endif
 
-#ifdef CONFIG_DMAR
-extern const char *dmar_get_fault_reason(u8 fault_reason);
-
 /* Can't use the common MSI interrupt functions
  * since DMAR is not a pci device
  */
@@ -127,8 +168,10 @@ extern void dmar_msi_mask(unsigned int irq);
 extern void dmar_msi_read(int irq, struct msi_msg *msg);
 extern void dmar_msi_write(int irq, struct msi_msg *msg);
 extern int dmar_set_interrupt(struct intel_iommu *iommu);
+extern irqreturn_t dmar_fault(int irq, void *dev_id);
 extern int arch_setup_dmar_msi(unsigned int irq);
 
+#ifdef CONFIG_DMAR
 extern int iommu_detected, no_iommu;
 extern struct list_head dmar_rmrr_units;
 struct dmar_rmrr_unit {
diff --git a/include/linux/dmi.h b/include/linux/dmi.h
index d741b9ceb0e0..bb5489c82c99 100644
--- a/include/linux/dmi.h
+++ b/include/linux/dmi.h
@@ -47,7 +47,8 @@ extern int dmi_get_year(int field);
 extern int dmi_name_in_vendors(const char *str);
 extern int dmi_name_in_serial(const char *str);
 extern int dmi_available;
-extern int dmi_walk(void (*decode)(const struct dmi_header *));
+extern int dmi_walk(void (*decode)(const struct dmi_header *, void *),
+        void *private_data);
 extern bool dmi_match(enum dmi_field f, const char *str);
 
 #else
@@ -61,8 +62,8 @@ static inline int dmi_get_year(int year) { return 0; }
 static inline int dmi_name_in_vendors(const char *s) { return 0; }
 static inline int dmi_name_in_serial(const char *s) { return 0; }
 #define dmi_available 0
-static inline int dmi_walk(void (*decode)(const struct dmi_header *))
-        { return -1; }
+static inline int dmi_walk(void (*decode)(const struct dmi_header *, void *),
+        void *private_data) { return -1; }
 static inline bool dmi_match(enum dmi_field f, const char *str)
         { return false; }
 static inline const struct dmi_system_id *
diff --git a/include/linux/ds1wm.h b/include/linux/ds1wm.h
deleted file mode 100644
index d3c65e48a2e7..000000000000
--- a/include/linux/ds1wm.h
+++ /dev/null
@@ -1,12 +0,0 @@
-/* platform data for the DS1WM driver */
-
-struct ds1wm_platform_data {
-        int bus_shift;      /* number of shifts needed to calculate the
-                             * offset between DS1WM registers;
-                             * e.g. on h5xxx and h2200 this is 2
-                             * (registers aligned to 4-byte boundaries),
-                             * while on hx4700 this is 1 */
-        int active_high;
-        void (*enable)(struct platform_device *pdev);
-        void (*disable)(struct platform_device *pdev);
-};
diff --git a/include/linux/dst.h b/include/linux/dst.h
new file mode 100644
index 000000000000..e26fed84b1aa
--- /dev/null
+++ b/include/linux/dst.h
@@ -0,0 +1,587 @@
+/*
+ * 2007+ Copyright (c) Evgeniy Polyakov <johnpol@2ka.mipt.ru>
+ * All rights reserved.
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License 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.
+ */
+
+#ifndef __DST_H
+#define __DST_H
+
+#include <linux/types.h>
+#include <linux/connector.h>
+
+#define DST_NAMELEN             32
+#define DST_NAME                "dst"
+
+enum {
+        /* Remove node with given id from storage */
+        DST_DEL_NODE    = 0,
+        /* Add remote node with given id to the storage */
+        DST_ADD_REMOTE,
+        /* Add local node with given id to the storage to be exported and used by remote peers */
+        DST_ADD_EXPORT,
+        /* Crypto initialization command (hash/cipher used to protect the connection) */
+        DST_CRYPTO,
+        /* Security attributes for given connection (permissions for example) */
+        DST_SECURITY,
+        /* Register given node in the block layer subsystem */
+        DST_START,
+        DST_CMD_MAX
+};
+
+struct dst_ctl
+{
+        /* Storage name */
+        char                    name[DST_NAMELEN];
+        /* Command flags */
+        __u32                   flags;
+        /* Command itself (see above) */
+        __u32                   cmd;
+        /* Maximum number of pages per single request in this device */
+        __u32                   max_pages;
+        /* Stale/error transaction scanning timeout in milliseconds */
+        __u32                   trans_scan_timeout;
+        /* Maximum number of retry sends before completing transaction as broken */
+        __u32                   trans_max_retries;
+        /* Storage size */
+        __u64                   size;
+};
+
+/* Reply command carries completion status */
+struct dst_ctl_ack
+{
+        struct cn_msg           msg;
+        int                     error;
+        int                     unused[3];
+};
+
+/*
+ * Unfortunaltely socket address structure is not exported to userspace
+ * and is redefined there.
+ */
+#define SADDR_MAX_DATA  128
+
+struct saddr {
+        /* address family, AF_xxx       */
+        unsigned short          sa_family;
+        /* 14 bytes of protocol address */
+        char                    sa_data[SADDR_MAX_DATA];
+        /* Number of bytes used in sa_data */
+        unsigned short          sa_data_len;
+};
+
+/* Address structure */
+struct dst_network_ctl
+{
+        /* Socket type: datagram, stream...*/
+        unsigned int            type;
+        /* Let me guess, is it a Jupiter diameter? */
+        unsigned int            proto;
+        /* Peer's address */
+        struct saddr            addr;
+};
+
+struct dst_crypto_ctl
+{
+        /* Cipher and hash names */
+        char                    cipher_algo[DST_NAMELEN];
+        char                    hash_algo[DST_NAMELEN];
+
+        /* Key sizes. Can be zero for digest for example */
+        unsigned int            cipher_keysize, hash_keysize;
+        /* Alignment. Calculated by the DST itself. */
+        unsigned int            crypto_attached_size;
+        /* Number of threads to perform crypto operations */
+        int                     thread_num;
+};
+
+/* Export security attributes have this bits checked in when client connects */
+#define DST_PERM_READ           (1<<0)
+#define DST_PERM_WRITE          (1<<1)
+
+/*
+ * Right now it is simple model, where each remote address
+ * is assigned to set of permissions it is allowed to perform.
+ * In real world block device does not know anything but
+ * reading and writing, so it should be more than enough.
+ */
+struct dst_secure_user
+{
+        unsigned int            permissions;
+        struct saddr            addr;
+};
+
+/*
+ * Export control command: device to export and network address to accept
+ * clients to work with given device
+ */
+struct dst_export_ctl
+{
+        char                    device[DST_NAMELEN];
+        struct dst_network_ctl  ctl;
+};
+
+enum {
+        DST_CFG = 1,            /* Request remote configuration */
+        DST_IO,                 /* IO command */
+        DST_IO_RESPONSE,        /* IO response */
+        DST_PING,               /* Keepalive message */
+        DST_NCMD_MAX,
+};
+
+struct dst_cmd
+{
+        /* Network command itself, see above */
+        __u32                   cmd;
+        /*
+         * Size of the attached data
+         * (in most cases, for READ command it means how many bytes were requested)
+         */
+        __u32                   size;
+        /* Crypto size: number of attached bytes with digest/hmac */
+        __u32                   csize;
+        /* Here we can carry secret data */
+        __u32                   reserved;
+        /* Read/write bits, see how they are encoded in bio structure */
+        __u64                   rw;
+        /* BIO flags */
+        __u64                   flags;
+        /* Unique command id (like transaction ID) */
+        __u64                   id;
+        /* Sector to start IO from */
+        __u64                   sector;
+        /* Hash data is placed after this header */
+        __u8                    hash[0];
+};
+
+/*
+ * Convert command to/from network byte order.
+ * We do not use hton*() functions, since there is
+ * no 64-bit implementation.
+ */
+static inline void dst_convert_cmd(struct dst_cmd *c)
+{
+        c->cmd = __cpu_to_be32(c->cmd);
+        c->csize = __cpu_to_be32(c->csize);
+        c->size = __cpu_to_be32(c->size);
+        c->sector = __cpu_to_be64(c->sector);
+        c->id = __cpu_to_be64(c->id);
+        c->flags = __cpu_to_be64(c->flags);
+        c->rw = __cpu_to_be64(c->rw);
+}
+
+/* Transaction id */
+typedef __u64 dst_gen_t;
+
+#ifdef __KERNEL__
+
+#include <linux/blkdev.h>
+#include <linux/bio.h>
+#include <linux/device.h>
+#include <linux/mempool.h>
+#include <linux/net.h>
+#include <linux/poll.h>
+#include <linux/rbtree.h>
+
+#ifdef CONFIG_DST_DEBUG
+#define dprintk(f, a...) printk(KERN_NOTICE f, ##a)
+#else
+static inline void __attribute__ ((format (printf, 1, 2)))
+        dprintk(const char *fmt, ...) {}
+#endif
+
+struct dst_node;
+
+struct dst_trans
+{
+        /* DST node we are working with */
+        struct dst_node         *n;
+
+        /* Entry inside transaction tree */
+        struct rb_node          trans_entry;
+
+        /* Merlin kills this transaction when this memory cell equals zero */
+        atomic_t                refcnt;
+
+        /* How this transaction should be processed by crypto engine */
+        short                   enc;
+        /* How many times this transaction was resent */
+        short                   retries;
+        /* Completion status */
+        int                     error;
+
+        /* When did we send it to the remote peer */
+        long                    send_time;
+
+        /* My name is...
+         * Well, computers does not speak, they have unique id instead */
+        dst_gen_t               gen;
+
+        /* Block IO we are working with */
+        struct bio              *bio;
+
+        /* Network command for above block IO request */
+        struct dst_cmd          cmd;
+};
+
+struct dst_crypto_engine
+{
+        /* What should we do with all block requests */
+        struct crypto_hash      *hash;
+        struct crypto_ablkcipher        *cipher;
+
+        /* Pool of pages used to encrypt data into before sending */
+        int                     page_num;
+        struct page             **pages;
+
+        /* What to do with current request */
+        int                     enc;
+        /* Who we are and where do we go */
+        struct scatterlist      *src, *dst;
+
+        /* Maximum timeout waiting for encryption to be completed */
+        long                    timeout;
+        /* IV is a 64-bit sequential counter */
+        u64                     iv;
+
+        /* Secret data */
+        void                    *private;
+
+        /* Cached temporary data lives here */
+        int                     size;
+        void                    *data;
+};
+
+struct dst_state
+{
+        /* The main state protection */
+        struct mutex            state_lock;
+
+        /* Polling machinery for sockets */
+        wait_queue_t            wait;
+        wait_queue_head_t       *whead;
+        /* Most of events are being waited here */
+        wait_queue_head_t       thread_wait;
+
+        /* Who owns this? */
+        struct dst_node         *node;
+
+        /* Network address for this state */
+        struct dst_network_ctl  ctl;
+
+        /* Permissions to work with: read-only or rw connection */
+        u32                     permissions;
+
+        /* Called when we need to clean private data */
+        void                    (* cleanup)(struct dst_state *st);
+
+        /* Used by the server: BIO completion queues BIOs here */
+        struct list_head        request_list;
+        spinlock_t              request_lock;
+
+        /* Guess what? No, it is not number of planets */
+        atomic_t                refcnt;
+
+        /* This flags is set when connection should be dropped */
+        int                     need_exit;
+
+        /*
+         * Socket to work with. Second pointer is used for
+         * lockless check if socket was changed before performing
+         * next action (like working with cached polling result)
+         */
+        struct socket           *socket, *read_socket;
+
+        /* Cached preallocated data */
+        void                    *data;
+        unsigned int            size;
+
+        /* Currently processed command */
+        struct dst_cmd          cmd;
+};
+
+struct dst_info
+{
+        /* Device size */
+        u64                     size;
+
+        /* Local device name for export devices */
+        char                    local[DST_NAMELEN];
+
+        /* Network setup */
+        struct dst_network_ctl  net;
+
+        /* Sysfs bits use this */
+        struct device           device;
+};
+
+struct dst_node
+{
+        struct list_head        node_entry;
+
+        /* Hi, my name is stored here */
+        char                    name[DST_NAMELEN];
+        /* My cache name is stored here */
+        char                    cache_name[DST_NAMELEN];
+
+        /* Block device attached to given node.
+         * Only valid for exporting nodes */
+        struct block_device     *bdev;
+        /* Network state machine for given peer */
+        struct dst_state        *state;
+
+        /* Block IO machinery */
+        struct request_queue    *queue;
+        struct gendisk          *disk;
+
+        /* Number of threads in processing pool */
+        int                     thread_num;
+        /* Maximum number of pages in single IO */
+        int                     max_pages;
+
+        /* I'm that big in bytes */
+        loff_t                  size;
+
+        /* Exported to userspace node information */
+        struct dst_info         *info;
+
+        /*
+         * Security attribute list.
+         * Used only by exporting node currently.
+         */
+        struct list_head        security_list;
+        struct mutex            security_lock;
+
+        /*
+         * When this unerflows below zero, university collapses.
+         * But this will not happen, since node will be freed,
+         * when reference counter reaches zero.
+         */
+        atomic_t                refcnt;
+
+        /* How precisely should I be started? */
+        int                     (*start)(struct dst_node *);
+
+        /* Crypto capabilities */
+        struct dst_crypto_ctl   crypto;
+        u8                      *hash_key;
+        u8                      *cipher_key;
+
+        /* Pool of processing thread */
+        struct thread_pool      *pool;
+
+        /* Transaction IDs live here */
+        atomic_long_t           gen;
+
+        /*
+         * How frequently and how many times transaction
+         * tree should be scanned to drop stale objects.
+         */
+        long                    trans_scan_timeout;
+        int                     trans_max_retries;
+
+        /* Small gnomes live here */
+        struct rb_root          trans_root;
+        struct mutex            trans_lock;
+
+        /*
+         * Transaction cache/memory pool.
+         * It is big enough to contain not only transaction
+         * itself, but additional crypto data (digest/hmac).
+         */
+        struct kmem_cache       *trans_cache;
+        mempool_t               *trans_pool;
+
+        /* This entity scans transaction tree */
+        struct delayed_work     trans_work;
+
+        wait_queue_head_t       wait;
+};
+
+/* Kernel representation of the security attribute */
+struct dst_secure
+{
+        struct list_head        sec_entry;
+        struct dst_secure_user  sec;
+};
+
+int dst_process_bio(struct dst_node *n, struct bio *bio);
+
+int dst_node_init_connected(struct dst_node *n, struct dst_network_ctl *r);
+int dst_node_init_listened(struct dst_node *n, struct dst_export_ctl *le);
+
+static inline struct dst_state *dst_state_get(struct dst_state *st)
+{
+        BUG_ON(atomic_read(&st->refcnt) == 0);
+        atomic_inc(&st->refcnt);
+        return st;
+}
+
+void dst_state_put(struct dst_state *st);
+
+struct dst_state *dst_state_alloc(struct dst_node *n);
+int dst_state_socket_create(struct dst_state *st);
+void dst_state_socket_release(struct dst_state *st);
+
+void dst_state_exit_connected(struct dst_state *st);
+
+int dst_state_schedule_receiver(struct dst_state *st);
+
+void dst_dump_addr(struct socket *sk, struct sockaddr *sa, char *str);
+
+static inline void dst_state_lock(struct dst_state *st)
+{
+        mutex_lock(&st->state_lock);
+}
+
+static inline void dst_state_unlock(struct dst_state *st)
+{
+        mutex_unlock(&st->state_lock);
+}
+
+void dst_poll_exit(struct dst_state *st);
+int dst_poll_init(struct dst_state *st);
+
+static inline unsigned int dst_state_poll(struct dst_state *st)
+{
+        unsigned int revents = POLLHUP | POLLERR;
+
+        dst_state_lock(st);
+        if (st->socket)
+                revents = st->socket->ops->poll(NULL, st->socket, NULL);
+        dst_state_unlock(st);
+
+        return revents;
+}
+
+static inline int dst_thread_setup(void *private, void *data)
+{
+        return 0;
+}
+
+void dst_node_put(struct dst_node *n);
+
+static inline struct dst_node *dst_node_get(struct dst_node *n)
+{
+        atomic_inc(&n->refcnt);
+        return n;
+}
+
+int dst_data_recv(struct dst_state *st, void *data, unsigned int size);
+int dst_recv_cdata(struct dst_state *st, void *cdata);
+int dst_data_send_header(struct socket *sock,
+                void *data, unsigned int size, int more);
+
+int dst_send_bio(struct dst_state *st, struct dst_cmd *cmd, struct bio *bio);
+
+int dst_process_io(struct dst_state *st);
+int dst_export_crypto(struct dst_node *n, struct bio *bio);
+int dst_export_send_bio(struct bio *bio);
+int dst_start_export(struct dst_node *n);
+
+int __init dst_export_init(void);
+void dst_export_exit(void);
+
+/* Private structure for export block IO requests */
+struct dst_export_priv
+{
+        struct list_head                request_entry;
+        struct dst_state                *state;
+        struct bio                      *bio;
+        struct dst_cmd                  cmd;
+};
+
+static inline void dst_trans_get(struct dst_trans *t)
+{
+        atomic_inc(&t->refcnt);
+}
+
+struct dst_trans *dst_trans_search(struct dst_node *node, dst_gen_t gen);
+int dst_trans_remove(struct dst_trans *t);
+int dst_trans_remove_nolock(struct dst_trans *t);
+void dst_trans_put(struct dst_trans *t);
+
+/*
+ * Convert bio into network command.
+ */
+static inline void dst_bio_to_cmd(struct bio *bio, struct dst_cmd *cmd,
+                u32 command, u64 id)
+{
+        cmd->cmd = command;
+        cmd->flags = (bio->bi_flags << BIO_POOL_BITS) >> BIO_POOL_BITS;
+        cmd->rw = bio->bi_rw;
+        cmd->size = bio->bi_size;
+        cmd->csize = 0;
+        cmd->id = id;
+        cmd->sector = bio->bi_sector;
+};
+
+int dst_trans_send(struct dst_trans *t);
+int dst_trans_crypto(struct dst_trans *t);
+
+int dst_node_crypto_init(struct dst_node *n, struct dst_crypto_ctl *ctl);
+void dst_node_crypto_exit(struct dst_node *n);
+
+static inline int dst_need_crypto(struct dst_node *n)
+{
+        struct dst_crypto_ctl *c = &n->crypto;
+        /*
+         * Logical OR is appropriate here, but boolean one produces
+         * more optimal code, so it is used instead.
+         */
+        return (c->hash_algo[0] | c->cipher_algo[0]);
+}
+
+int dst_node_trans_init(struct dst_node *n, unsigned int size);
+void dst_node_trans_exit(struct dst_node *n);
+
+/*
+ * Pool of threads.
+ * Ready list contains threads currently free to be used,
+ * active one contains threads with some work scheduled for them.
+ * Caller can wait in given queue when thread is ready.
+ */
+struct thread_pool
+{
+        int                     thread_num;
+        struct mutex            thread_lock;
+        struct list_head        ready_list, active_list;
+
+        wait_queue_head_t       wait;
+};
+
+void thread_pool_del_worker(struct thread_pool *p);
+void thread_pool_del_worker_id(struct thread_pool *p, unsigned int id);
+int thread_pool_add_worker(struct thread_pool *p,
+                char *name,
+                unsigned int id,
+                void *(* init)(void *data),
+                void (* cleanup)(void *data),
+                void *data);
+
+void thread_pool_destroy(struct thread_pool *p);
+struct thread_pool *thread_pool_create(int num, char *name,
+                void *(* init)(void *data),
+                void (* cleanup)(void *data),
+                void *data);
+
+int thread_pool_schedule(struct thread_pool *p,
+                int (* setup)(void *stored_private, void *setup_data),
+                int (* action)(void *stored_private, void *setup_data),
+                void *setup_data, long timeout);
+int thread_pool_schedule_private(struct thread_pool *p,
+                int (* setup)(void *private, void *data),
+                int (* action)(void *private, void *data),
+                void *data, long timeout, void *id);
+
+#endif /* __KERNEL__ */
+#endif /* __DST_H */
diff --git a/include/linux/dw_dmac.h b/include/linux/dw_dmac.h
index d797dde247f7..c8aad713a046 100644
--- a/include/linux/dw_dmac.h
+++ b/include/linux/dw_dmac.h
@@ -74,4 +74,23 @@ struct dw_dma_slave {
 #define DWC_CFGL_HS_DST_POL     (1 << 18)       /* dst handshake active low */
 #define DWC_CFGL_HS_SRC_POL     (1 << 19)       /* src handshake active low */
 
+/* DMA API extensions */
+struct dw_cyclic_desc {
+        struct dw_desc  **desc;
+        unsigned long   periods;
+        void            (*period_callback)(void *param);
+        void            *period_callback_param;
+};
+
+struct dw_cyclic_desc *dw_dma_cyclic_prep(struct dma_chan *chan,
+                dma_addr_t buf_addr, size_t buf_len, size_t period_len,
+                enum dma_data_direction direction);
+void dw_dma_cyclic_free(struct dma_chan *chan);
+int dw_dma_cyclic_start(struct dma_chan *chan);
+void dw_dma_cyclic_stop(struct dma_chan *chan);
+
+dma_addr_t dw_dma_get_src_addr(struct dma_chan *chan);
+
+dma_addr_t dw_dma_get_dst_addr(struct dma_chan *chan);
+
 #endif /* DW_DMAC_H */
diff --git a/include/linux/dynamic_debug.h b/include/linux/dynamic_debug.h
index baabf33be244..a0d9422a1569 100644
--- a/include/linux/dynamic_debug.h
+++ b/include/linux/dynamic_debug.h
@@ -70,7 +70,7 @@ extern int ddebug_remove_module(char *mod_name);
                 DEBUG_HASH2, __LINE__, _DPRINTK_FLAGS_DEFAULT };        \
         if (__dynamic_dbg_enabled(descriptor))                          \
                         dev_printk(KERN_DEBUG, dev,                     \
-                                        KBUILD_MODNAME ": " pr_fmt(fmt),\
+                                        KBUILD_MODNAME ": " fmt,        \
                                         ##__VA_ARGS__);                 \
         } while (0)
 
diff --git a/include/linux/elevator.h b/include/linux/elevator.h
index 7a204256b155..c59b769f62b0 100644
--- a/include/linux/elevator.h
+++ b/include/linux/elevator.h
@@ -116,6 +116,7 @@ extern void elv_abort_queue(struct request_queue *);
 extern void elv_completed_request(struct request_queue *, struct request *);
 extern int elv_set_request(struct request_queue *, struct request *, gfp_t);
 extern void elv_put_request(struct request_queue *, struct request *);
+extern void elv_drain_elevator(struct request_queue *);
 
 /*
  * io scheduler registration
diff --git a/include/linux/eventfd.h b/include/linux/eventfd.h
index a667637b54e3..f45a8ae5f828 100644
--- a/include/linux/eventfd.h
+++ b/include/linux/eventfd.h
@@ -13,10 +13,20 @@
 /* For O_CLOEXEC and O_NONBLOCK */
 #include <linux/fcntl.h>
 
-/* Flags for eventfd2.  */
+/*
+ * CAREFUL: Check include/asm-generic/fcntl.h when defining
+ * new flags, since they might collide with O_* ones. We want
+ * to re-use O_* flags that couldn't possibly have a meaning
+ * from eventfd, in order to leave a free define-space for
+ * shared O_* flags.
+ */
+#define EFD_SEMAPHORE (1 << 0)
 #define EFD_CLOEXEC O_CLOEXEC
 #define EFD_NONBLOCK O_NONBLOCK
 
+#define EFD_SHARED_FCNTL_FLAGS (O_CLOEXEC | O_NONBLOCK)
+#define EFD_FLAGS_SET (EFD_SHARED_FCNTL_FLAGS | EFD_SEMAPHORE)
+
 struct file *eventfd_fget(int fd);
 int eventfd_signal(struct file *file, int n);
 
diff --git a/include/linux/ext3_fs.h b/include/linux/ext3_fs.h
index dd495b8c3091..634a5e5aba3e 100644
--- a/include/linux/ext3_fs.h
+++ b/include/linux/ext3_fs.h
@@ -208,6 +208,7 @@ static inline __u32 ext3_mask_flags(umode_t mode, __u32 flags)
 #define EXT3_STATE_JDATA                0x00000001 /* journaled data exists */
 #define EXT3_STATE_NEW                  0x00000002 /* inode is newly created */
 #define EXT3_STATE_XATTR                0x00000004 /* has in-inode xattrs */
+#define EXT3_STATE_FLUSH_ON_CLOSE       0x00000008
 
 /* Used to pass group descriptor data when online resize is done */
 struct ext3_new_group_input {
@@ -893,9 +894,8 @@ extern int ext3_fiemap(struct inode *inode, struct fiemap_extent_info *fieinfo,
                        u64 start, u64 len);
 
 /* ioctl.c */
-extern int ext3_ioctl (struct inode *, struct file *, unsigned int,
-                       unsigned long);
-extern long ext3_compat_ioctl (struct file *, unsigned int, unsigned long);
+extern long ext3_ioctl(struct file *, unsigned int, unsigned long);
+extern long ext3_compat_ioctl(struct file *, unsigned int, unsigned long);
 
 /* namei.c */
 extern int ext3_orphan_add(handle_t *, struct inode *);
diff --git a/include/linux/fb.h b/include/linux/fb.h
index 31527e17076b..330c4b1bfcaa 100644
--- a/include/linux/fb.h
+++ b/include/linux/fb.h
@@ -123,6 +123,7 @@ struct dentry;
 #define FB_ACCEL_TRIDENT_3DIMAGE 51     /* Trident 3DImage              */
 #define FB_ACCEL_TRIDENT_BLADE3D 52     /* Trident Blade3D              */
 #define FB_ACCEL_TRIDENT_BLADEXP 53     /* Trident BladeXP              */
+#define FB_ACCEL_CIRRUS_ALPINE   53     /* Cirrus Logic 543x/544x/5480  */
 #define FB_ACCEL_NEOMAGIC_NM2070 90     /* NeoMagic NM2070              */
 #define FB_ACCEL_NEOMAGIC_NM2090 91     /* NeoMagic NM2090              */
 #define FB_ACCEL_NEOMAGIC_NM2093 92     /* NeoMagic NM2093              */
@@ -172,8 +173,12 @@ struct fb_fix_screeninfo {
 /* Interpretation of offset for color fields: All offsets are from the right,
  * inside a "pixel" value, which is exactly 'bits_per_pixel' wide (means: you
  * can use the offset as right argument to <<). A pixel afterwards is a bit
- * stream and is written to video memory as that unmodified. This implies
- * big-endian byte order if bits_per_pixel is greater than 8.
+ * stream and is written to video memory as that unmodified.
+ *
+ * For pseudocolor: offset and length should be the same for all color
+ * components. Offset specifies the position of the least significant bit
+ * of the pallette index in a pixel value. Length indicates the number
+ * of available palette entries (i.e. # of entries = 1 << length).
  */
 struct fb_bitfield {
         __u32 offset;                   /* beginning of bitfield        */
@@ -960,15 +965,7 @@ extern struct fb_info *registered_fb[FB_MAX];
 extern int num_registered_fb;
 extern struct class *fb_class;
 
-static inline int lock_fb_info(struct fb_info *info)
-{
-        mutex_lock(&info->lock);
-        if (!info->fbops) {
-                mutex_unlock(&info->lock);
-                return 0;
-        }
-        return 1;
-}
+extern int lock_fb_info(struct fb_info *info);
 
 static inline void unlock_fb_info(struct fb_info *info)
 {
diff --git a/include/linux/fdtable.h b/include/linux/fdtable.h
index 09d6c5bbdddd..a2ec74bc4812 100644
--- a/include/linux/fdtable.h
+++ b/include/linux/fdtable.h
@@ -5,12 +5,14 @@
 #ifndef __LINUX_FDTABLE_H
 #define __LINUX_FDTABLE_H
 
-#include <asm/atomic.h>
 #include <linux/posix_types.h>
 #include <linux/compiler.h>
 #include <linux/spinlock.h>
 #include <linux/rcupdate.h>
 #include <linux/types.h>
+#include <linux/init.h>
+
+#include <asm/atomic.h>
 
 /*
  * The default fd array needs to be at least BITS_PER_LONG,
diff --git a/include/linux/fiemap.h b/include/linux/fiemap.h
index 671decbd2aeb..934e22d65801 100644
--- a/include/linux/fiemap.h
+++ b/include/linux/fiemap.h
@@ -11,6 +11,8 @@
 #ifndef _LINUX_FIEMAP_H
 #define _LINUX_FIEMAP_H
 
+#include <linux/types.h>
+
 struct fiemap_extent {
         __u64 fe_logical;  /* logical offset in bytes for the start of
                             * the extent from the beginning of the file */
diff --git a/include/linux/fs.h b/include/linux/fs.h
index 42436ae42f70..5bed436f4353 100644
--- a/include/linux/fs.h
+++ b/include/linux/fs.h
@@ -87,6 +87,60 @@ struct inodes_stat_t {
  */
 #define FMODE_NOCMTIME          ((__force fmode_t)2048)
 
+/*
+ * The below are the various read and write types that we support. Some of
+ * them include behavioral modifiers that send information down to the
+ * block layer and IO scheduler. Terminology:
+ *
+ *      The block layer uses device plugging to defer IO a little bit, in
+ *      the hope that we will see more IO very shortly. This increases
+ *      coalescing of adjacent IO and thus reduces the number of IOs we
+ *      have to send to the device. It also allows for better queuing,
+ *      if the IO isn't mergeable. If the caller is going to be waiting
+ *      for the IO, then he must ensure that the device is unplugged so
+ *      that the IO is dispatched to the driver.
+ *
+ *      All IO is handled async in Linux. This is fine for background
+ *      writes, but for reads or writes that someone waits for completion
+ *      on, we want to notify the block layer and IO scheduler so that they
+ *      know about it. That allows them to make better scheduling
+ *      decisions. So when the below references 'sync' and 'async', it
+ *      is referencing this priority hint.
+ *
+ * With that in mind, the available types are:
+ *
+ * READ                 A normal read operation. Device will be plugged.
+ * READ_SYNC            A synchronous read. Device is not plugged, caller can
+ *                      immediately wait on this read without caring about
+ *                      unplugging.
+ * READA                Used for read-ahead operations. Lower priority, and the
+ *                       block layer could (in theory) choose to ignore this
+ *                      request if it runs into resource problems.
+ * WRITE                A normal async write. Device will be plugged.
+ * SWRITE               Like WRITE, but a special case for ll_rw_block() that
+ *                      tells it to lock the buffer first. Normally a buffer
+ *                      must be locked before doing IO.
+ * WRITE_SYNC_PLUG      Synchronous write. Identical to WRITE, but passes down
+ *                      the hint that someone will be waiting on this IO
+ *                      shortly. The device must still be unplugged explicitly,
+ *                      WRITE_SYNC_PLUG does not do this as we could be
+ *                      submitting more writes before we actually wait on any
+ *                      of them.
+ * WRITE_SYNC           Like WRITE_SYNC_PLUG, but also unplugs the device
+ *                      immediately after submission. The write equivalent
+ *                      of READ_SYNC.
+ * WRITE_ODIRECT        Special case write for O_DIRECT only.
+ * SWRITE_SYNC
+ * SWRITE_SYNC_PLUG     Like WRITE_SYNC/WRITE_SYNC_PLUG, but locks the buffer.
+ *                      See SWRITE.
+ * WRITE_BARRIER        Like WRITE, but tells the block layer that all
+ *                      previously submitted writes must be safely on storage
+ *                      before this one is started. Also guarantees that when
+ *                      this write is complete, it itself is also safely on
+ *                      storage. Prevents reordering of writes on both sides
+ *                      of this IO.
+ *
+ */
 #define RW_MASK         1
 #define RWA_MASK        2
 #define READ 0
@@ -95,9 +149,18 @@ struct inodes_stat_t {
 #define SWRITE 3        /* for ll_rw_block() - wait for buffer lock */
 #define READ_SYNC       (READ | (1 << BIO_RW_SYNCIO) | (1 << BIO_RW_UNPLUG))
 #define READ_META       (READ | (1 << BIO_RW_META))
-#define WRITE_SYNC      (WRITE | (1 << BIO_RW_SYNCIO) | (1 << BIO_RW_UNPLUG))
-#define SWRITE_SYNC     (SWRITE | (1 << BIO_RW_SYNCIO) | (1 << BIO_RW_UNPLUG))
+#define WRITE_SYNC_PLUG (WRITE | (1 << BIO_RW_SYNCIO) | (1 << BIO_RW_NOIDLE))
+#define WRITE_SYNC      (WRITE_SYNC_PLUG | (1 << BIO_RW_UNPLUG))
+#define WRITE_ODIRECT   (WRITE | (1 << BIO_RW_SYNCIO) | (1 << BIO_RW_UNPLUG))
+#define SWRITE_SYNC_PLUG        \
+                        (SWRITE | (1 << BIO_RW_SYNCIO) | (1 << BIO_RW_NOIDLE))
+#define SWRITE_SYNC     (SWRITE_SYNC_PLUG | (1 << BIO_RW_UNPLUG))
 #define WRITE_BARRIER   (WRITE | (1 << BIO_RW_BARRIER))
+
+/*
+ * These aren't really reads or writes, they pass down information about
+ * parts of device that are now unused by the file system.
+ */
 #define DISCARD_NOBARRIER (1 << BIO_RW_DISCARD)
 #define DISCARD_BARRIER ((1 << BIO_RW_DISCARD) | (1 << BIO_RW_BARRIER))
 
@@ -734,9 +797,6 @@ enum inode_i_mutex_lock_class
         I_MUTEX_QUOTA
 };
 
-extern void inode_double_lock(struct inode *inode1, struct inode *inode2);
-extern void inode_double_unlock(struct inode *inode1, struct inode *inode2);
-
 /*
  * NOTE: in a 32bit arch with a preemptable kernel and
  * an UP compile the i_size_read/write must be atomic
@@ -849,7 +909,7 @@ struct file {
 #define f_dentry        f_path.dentry
 #define f_vfsmnt        f_path.mnt
         const struct file_operations    *f_op;
-        spinlock_t              f_lock;  /* f_ep_links, f_flags */
+        spinlock_t              f_lock;  /* f_ep_links, f_flags, no IRQ */
         atomic_long_t           f_count;
         unsigned int            f_flags;
         fmode_t                 f_mode;
@@ -1695,6 +1755,9 @@ struct file_system_type {
         struct lock_class_key i_alloc_sem_key;
 };
 
+extern int get_sb_ns(struct file_system_type *fs_type, int flags, void *data,
+        int (*fill_super)(struct super_block *, void *, int),
+        struct vfsmount *mnt);
 extern int get_sb_bdev(struct file_system_type *fs_type,
         int flags, const char *dev_name, void *data,
         int (*fill_super)(struct super_block *, void *, int),
@@ -1741,6 +1804,8 @@ extern void drop_collected_mounts(struct vfsmount *);
 
 extern int vfs_statfs(struct dentry *, struct kstatfs *);
 
+extern int current_umask(void);
+
 /* /sys/fs */
 extern struct kobject *fs_kobj;
 
@@ -1878,12 +1943,25 @@ extern struct block_device *open_by_devnum(dev_t, fmode_t);
 extern void invalidate_bdev(struct block_device *);
 extern int sync_blockdev(struct block_device *bdev);
 extern struct super_block *freeze_bdev(struct block_device *);
+extern void emergency_thaw_all(void);
 extern int thaw_bdev(struct block_device *bdev, struct super_block *sb);
 extern int fsync_bdev(struct block_device *);
 extern int fsync_super(struct super_block *);
 extern int fsync_no_super(struct block_device *);
 #else
 static inline void bd_forget(struct inode *inode) {}
+static inline int sync_blockdev(struct block_device *bdev) { return 0; }
+static inline void invalidate_bdev(struct block_device *bdev) {}
+
+static inline struct super_block *freeze_bdev(struct block_device *sb)
+{
+        return NULL;
+}
+
+static inline int thaw_bdev(struct block_device *bdev, struct super_block *sb)
+{
+        return 0;
+}
 #endif
 extern const struct file_operations def_blk_fops;
 extern const struct file_operations def_chr_fops;
@@ -2128,8 +2206,6 @@ extern ssize_t generic_file_splice_read(struct file *, loff_t *,
                 struct pipe_inode_info *, size_t, unsigned int);
 extern ssize_t generic_file_splice_write(struct pipe_inode_info *,
                 struct file *, loff_t *, size_t, unsigned int);
-extern ssize_t generic_file_splice_write_nolock(struct pipe_inode_info *,
-                struct file *, loff_t *, size_t, unsigned int);
 extern ssize_t generic_splice_sendpage(struct pipe_inode_info *pipe,
                 struct file *out, loff_t *, size_t len, unsigned int flags);
 extern long do_splice_direct(struct file *in, loff_t *ppos, struct file *out,
@@ -2223,9 +2299,8 @@ extern int vfs_readdir(struct file *, filldir_t, void *);
 
 extern int vfs_stat(char __user *, struct kstat *);
 extern int vfs_lstat(char __user *, struct kstat *);
-extern int vfs_stat_fd(int dfd, char __user *, struct kstat *);
-extern int vfs_lstat_fd(int dfd, char __user *, struct kstat *);
 extern int vfs_fstat(unsigned int, struct kstat *);
+extern int vfs_fstatat(int , char __user *, struct kstat *, int);
 
 extern int do_vfs_ioctl(struct file *filp, unsigned int fd, unsigned int cmd,
                     unsigned long arg);
@@ -2322,19 +2397,7 @@ ssize_t simple_transaction_read(struct file *file, char __user *buf,
                                 size_t size, loff_t *pos);
 int simple_transaction_release(struct inode *inode, struct file *file);
 
-static inline void simple_transaction_set(struct file *file, size_t n)
-{
-        struct simple_transaction_argresp *ar = file->private_data;
-
-        BUG_ON(n > SIMPLE_TRANSACTION_LIMIT);
-
-        /*
-         * The barrier ensures that ar->size will really remain zero until
-         * ar->data is ready for reading.
-         */
-        smp_mb();
-        ar->size = n;
-}
+void simple_transaction_set(struct file *file, size_t n);
 
 /*
  * simple attribute files
@@ -2381,32 +2444,11 @@ ssize_t simple_attr_read(struct file *file, char __user *buf,
 ssize_t simple_attr_write(struct file *file, const char __user *buf,
                           size_t len, loff_t *ppos);
 
-
-#ifdef CONFIG_SECURITY
-static inline char *alloc_secdata(void)
-{
-        return (char *)get_zeroed_page(GFP_KERNEL);
-}
-
-static inline void free_secdata(void *secdata)
-{
-        free_page((unsigned long)secdata);
-}
-#else
-static inline char *alloc_secdata(void)
-{
-        return (char *)1;
-}
-
-static inline void free_secdata(void *secdata)
-{ }
-#endif  /* CONFIG_SECURITY */
-
 struct ctl_table;
 int proc_nr_files(struct ctl_table *table, int write, struct file *filp,
                   void __user *buffer, size_t *lenp, loff_t *ppos);
 
-int get_filesystem_list(char * buf);
+int __init get_filesystem_list(char *buf);
 
 #endif /* __KERNEL__ */
 #endif /* _LINUX_FS_H */
diff --git a/include/linux/fs_struct.h b/include/linux/fs_struct.h
index 18b467dbe278..78a05bfcd8eb 100644
--- a/include/linux/fs_struct.h
+++ b/include/linux/fs_struct.h
@@ -4,12 +4,10 @@
 #include <linux/path.h>
 
 struct fs_struct {
-        atomic_t count; /* This usage count is used by check_unsafe_exec() for
-                         * security checking purposes - therefore it may not be
-                         * incremented, except by clone(CLONE_FS).
-                         */
+        int users;
         rwlock_t lock;
         int umask;
+        int in_exec;
         struct path root, pwd;
 };
 
@@ -19,6 +17,8 @@ extern void exit_fs(struct task_struct *);
 extern void set_fs_root(struct fs_struct *, struct path *);
 extern void set_fs_pwd(struct fs_struct *, struct path *);
 extern struct fs_struct *copy_fs_struct(struct fs_struct *);
-extern void put_fs_struct(struct fs_struct *);
+extern void free_fs_struct(struct fs_struct *);
+extern void daemonize_fs_struct(void);
+extern int unshare_fs_struct(void);
 
 #endif /* _LINUX_FS_STRUCT_H */
diff --git a/include/linux/fscache-cache.h b/include/linux/fscache-cache.h
new file mode 100644
index 000000000000..84d3532dd3ea
--- /dev/null
+++ b/include/linux/fscache-cache.h
@@ -0,0 +1,505 @@
+/* General filesystem caching backing cache interface
+ *
+ * Copyright (C) 2004-2007 Red Hat, Inc. All Rights Reserved.
+ * Written by David Howells (dhowells@redhat.com)
+ *
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU General Public License
+ * as published by the Free Software Foundation; either version
+ * 2 of the License, or (at your option) any later version.
+ *
+ * NOTE!!! See:
+ *
+ *      Documentation/filesystems/caching/backend-api.txt
+ *
+ * for a description of the cache backend interface declared here.
+ */
+
+#ifndef _LINUX_FSCACHE_CACHE_H
+#define _LINUX_FSCACHE_CACHE_H
+
+#include <linux/fscache.h>
+#include <linux/sched.h>
+#include <linux/slow-work.h>
+
+#define NR_MAXCACHES BITS_PER_LONG
+
+struct fscache_cache;
+struct fscache_cache_ops;
+struct fscache_object;
+struct fscache_operation;
+
+/*
+ * cache tag definition
+ */
+struct fscache_cache_tag {
+        struct list_head        link;
+        struct fscache_cache    *cache;         /* cache referred to by this tag */
+        unsigned long           flags;
+#define FSCACHE_TAG_RESERVED    0               /* T if tag is reserved for a cache */
+        atomic_t                usage;
+        char                    name[0];        /* tag name */
+};
+
+/*
+ * cache definition
+ */
+struct fscache_cache {
+        const struct fscache_cache_ops *ops;
+        struct fscache_cache_tag *tag;          /* tag representing this cache */
+        struct kobject          *kobj;          /* system representation of this cache */
+        struct list_head        link;           /* link in list of caches */
+        size_t                  max_index_size; /* maximum size of index data */
+        char                    identifier[36]; /* cache label */
+
+        /* node management */
+        struct work_struct      op_gc;          /* operation garbage collector */
+        struct list_head        object_list;    /* list of data/index objects */
+        struct list_head        op_gc_list;     /* list of ops to be deleted */
+        spinlock_t              object_list_lock;
+        spinlock_t              op_gc_list_lock;
+        atomic_t                object_count;   /* no. of live objects in this cache */
+        struct fscache_object   *fsdef;         /* object for the fsdef index */
+        unsigned long           flags;
+#define FSCACHE_IOERROR         0       /* cache stopped on I/O error */
+#define FSCACHE_CACHE_WITHDRAWN 1       /* cache has been withdrawn */
+};
+
+extern wait_queue_head_t fscache_cache_cleared_wq;
+
+/*
+ * operation to be applied to a cache object
+ * - retrieval initiation operations are done in the context of the process
+ *   that issued them, and not in an async thread pool
+ */
+typedef void (*fscache_operation_release_t)(struct fscache_operation *op);
+typedef void (*fscache_operation_processor_t)(struct fscache_operation *op);
+
+struct fscache_operation {
+        union {
+                struct work_struct fast_work;   /* record for fast ops */
+                struct slow_work slow_work;     /* record for (very) slow ops */
+        };
+        struct list_head        pend_link;      /* link in object->pending_ops */
+        struct fscache_object   *object;        /* object to be operated upon */
+
+        unsigned long           flags;
+#define FSCACHE_OP_TYPE         0x000f  /* operation type */
+#define FSCACHE_OP_FAST         0x0001  /* - fast op, processor may not sleep for disk */
+#define FSCACHE_OP_SLOW         0x0002  /* - (very) slow op, processor may sleep for disk */
+#define FSCACHE_OP_MYTHREAD     0x0003  /* - processing is done be issuing thread, not pool */
+#define FSCACHE_OP_WAITING      4       /* cleared when op is woken */
+#define FSCACHE_OP_EXCLUSIVE    5       /* exclusive op, other ops must wait */
+#define FSCACHE_OP_DEAD         6       /* op is now dead */
+
+        atomic_t                usage;
+        unsigned                debug_id;       /* debugging ID */
+
+        /* operation processor callback
+         * - can be NULL if FSCACHE_OP_WAITING is going to be used to perform
+         *   the op in a non-pool thread */
+        fscache_operation_processor_t processor;
+
+        /* operation releaser */
+        fscache_operation_release_t release;
+};
+
+extern atomic_t fscache_op_debug_id;
+extern const struct slow_work_ops fscache_op_slow_work_ops;
+
+extern void fscache_enqueue_operation(struct fscache_operation *);
+extern void fscache_put_operation(struct fscache_operation *);
+
+/**
+ * fscache_operation_init - Do basic initialisation of an operation
+ * @op: The operation to initialise
+ * @release: The release function to assign
+ *
+ * Do basic initialisation of an operation.  The caller must still set flags,
+ * object, either fast_work or slow_work if necessary, and processor if needed.
+ */
+static inline void fscache_operation_init(struct fscache_operation *op,
+                                          fscache_operation_release_t release)
+{
+        atomic_set(&op->usage, 1);
+        op->debug_id = atomic_inc_return(&fscache_op_debug_id);
+        op->release = release;
+        INIT_LIST_HEAD(&op->pend_link);
+}
+
+/**
+ * fscache_operation_init_slow - Do additional initialisation of a slow op
+ * @op: The operation to initialise
+ * @processor: The processor function to assign
+ *
+ * Do additional initialisation of an operation as required for slow work.
+ */
+static inline
+void fscache_operation_init_slow(struct fscache_operation *op,
+                                 fscache_operation_processor_t processor)
+{
+        op->processor = processor;
+        slow_work_init(&op->slow_work, &fscache_op_slow_work_ops);
+}
+
+/*
+ * data read operation
+ */
+struct fscache_retrieval {
+        struct fscache_operation op;
+        struct address_space    *mapping;       /* netfs pages */
+        fscache_rw_complete_t   end_io_func;    /* function to call on I/O completion */
+        void                    *context;       /* netfs read context (pinned) */
+        struct list_head        to_do;          /* list of things to be done by the backend */
+        unsigned long           start_time;     /* time at which retrieval started */
+};
+
+typedef int (*fscache_page_retrieval_func_t)(struct fscache_retrieval *op,
+                                             struct page *page,
+                                             gfp_t gfp);
+
+typedef int (*fscache_pages_retrieval_func_t)(struct fscache_retrieval *op,
+                                              struct list_head *pages,
+                                              unsigned *nr_pages,
+                                              gfp_t gfp);
+
+/**
+ * fscache_get_retrieval - Get an extra reference on a retrieval operation
+ * @op: The retrieval operation to get a reference on
+ *
+ * Get an extra reference on a retrieval operation.
+ */
+static inline
+struct fscache_retrieval *fscache_get_retrieval(struct fscache_retrieval *op)
+{
+        atomic_inc(&op->op.usage);
+        return op;
+}
+
+/**
+ * fscache_enqueue_retrieval - Enqueue a retrieval operation for processing
+ * @op: The retrieval operation affected
+ *
+ * Enqueue a retrieval operation for processing by the FS-Cache thread pool.
+ */
+static inline void fscache_enqueue_retrieval(struct fscache_retrieval *op)
+{
+        fscache_enqueue_operation(&op->op);
+}
+
+/**
+ * fscache_put_retrieval - Drop a reference to a retrieval operation
+ * @op: The retrieval operation affected
+ *
+ * Drop a reference to a retrieval operation.
+ */
+static inline void fscache_put_retrieval(struct fscache_retrieval *op)
+{
+        fscache_put_operation(&op->op);
+}
+
+/*
+ * cached page storage work item
+ * - used to do three things:
+ *   - batch writes to the cache
+ *   - do cache writes asynchronously
+ *   - defer writes until cache object lookup completion
+ */
+struct fscache_storage {
+        struct fscache_operation op;
+        pgoff_t                 store_limit;    /* don't write more than this */
+};
+
+/*
+ * cache operations
+ */
+struct fscache_cache_ops {
+        /* name of cache provider */
+        const char *name;
+
+        /* allocate an object record for a cookie */
+        struct fscache_object *(*alloc_object)(struct fscache_cache *cache,
+                                               struct fscache_cookie *cookie);
+
+        /* look up the object for a cookie */
+        void (*lookup_object)(struct fscache_object *object);
+
+        /* finished looking up */
+        void (*lookup_complete)(struct fscache_object *object);
+
+        /* increment the usage count on this object (may fail if unmounting) */
+        struct fscache_object *(*grab_object)(struct fscache_object *object);
+
+        /* pin an object in the cache */
+        int (*pin_object)(struct fscache_object *object);
+
+        /* unpin an object in the cache */
+        void (*unpin_object)(struct fscache_object *object);
+
+        /* store the updated auxilliary data on an object */
+        void (*update_object)(struct fscache_object *object);
+
+        /* discard the resources pinned by an object and effect retirement if
+         * necessary */
+        void (*drop_object)(struct fscache_object *object);
+
+        /* dispose of a reference to an object */
+        void (*put_object)(struct fscache_object *object);
+
+        /* sync a cache */
+        void (*sync_cache)(struct fscache_cache *cache);
+
+        /* notification that the attributes of a non-index object (such as
+         * i_size) have changed */
+        int (*attr_changed)(struct fscache_object *object);
+
+        /* reserve space for an object's data and associated metadata */
+        int (*reserve_space)(struct fscache_object *object, loff_t i_size);
+
+        /* request a backing block for a page be read or allocated in the
+         * cache */
+        fscache_page_retrieval_func_t read_or_alloc_page;
+
+        /* request backing blocks for a list of pages be read or allocated in
+         * the cache */
+        fscache_pages_retrieval_func_t read_or_alloc_pages;
+
+        /* request a backing block for a page be allocated in the cache so that
+         * it can be written directly */
+        fscache_page_retrieval_func_t allocate_page;
+
+        /* request backing blocks for pages be allocated in the cache so that
+         * they can be written directly */
+        fscache_pages_retrieval_func_t allocate_pages;
+
+        /* write a page to its backing block in the cache */
+        int (*write_page)(struct fscache_storage *op, struct page *page);
+
+        /* detach backing block from a page (optional)
+         * - must release the cookie lock before returning
+         * - may sleep
+         */
+        void (*uncache_page)(struct fscache_object *object,
+                             struct page *page);
+
+        /* dissociate a cache from all the pages it was backing */
+        void (*dissociate_pages)(struct fscache_cache *cache);
+};
+
+/*
+ * data file or index object cookie
+ * - a file will only appear in one cache
+ * - a request to cache a file may or may not be honoured, subject to
+ *   constraints such as disk space
+ * - indices are created on disk just-in-time
+ */
+struct fscache_cookie {
+        atomic_t                        usage;          /* number of users of this cookie */
+        atomic_t                        n_children;     /* number of children of this cookie */
+        spinlock_t                      lock;
+        struct hlist_head               backing_objects; /* object(s) backing this file/index */
+        const struct fscache_cookie_def *def;           /* definition */
+        struct fscache_cookie           *parent;        /* parent of this entry */
+        void                            *netfs_data;    /* back pointer to netfs */
+        struct radix_tree_root          stores;         /* pages to be stored on this cookie */
+#define FSCACHE_COOKIE_PENDING_TAG      0               /* pages tag: pending write to cache */
+
+        unsigned long                   flags;
+#define FSCACHE_COOKIE_LOOKING_UP       0       /* T if non-index cookie being looked up still */
+#define FSCACHE_COOKIE_CREATING         1       /* T if non-index object being created still */
+#define FSCACHE_COOKIE_NO_DATA_YET      2       /* T if new object with no cached data yet */
+#define FSCACHE_COOKIE_PENDING_FILL     3       /* T if pending initial fill on object */
+#define FSCACHE_COOKIE_FILLING          4       /* T if filling object incrementally */
+#define FSCACHE_COOKIE_UNAVAILABLE      5       /* T if cookie is unavailable (error, etc) */
+};
+
+extern struct fscache_cookie fscache_fsdef_index;
+
+/*
+ * on-disk cache file or index handle
+ */
+struct fscache_object {
+        enum fscache_object_state {
+                FSCACHE_OBJECT_INIT,            /* object in initial unbound state */
+                FSCACHE_OBJECT_LOOKING_UP,      /* looking up object */
+                FSCACHE_OBJECT_CREATING,        /* creating object */
+
+                /* active states */
+                FSCACHE_OBJECT_AVAILABLE,       /* cleaning up object after creation */
+                FSCACHE_OBJECT_ACTIVE,          /* object is usable */
+                FSCACHE_OBJECT_UPDATING,        /* object is updating */
+
+                /* terminal states */
+                FSCACHE_OBJECT_DYING,           /* object waiting for accessors to finish */
+                FSCACHE_OBJECT_LC_DYING,        /* object cleaning up after lookup/create */
+                FSCACHE_OBJECT_ABORT_INIT,      /* abort the init state */
+                FSCACHE_OBJECT_RELEASING,       /* releasing object */
+                FSCACHE_OBJECT_RECYCLING,       /* retiring object */
+                FSCACHE_OBJECT_WITHDRAWING,     /* withdrawing object */
+                FSCACHE_OBJECT_DEAD,            /* object is now dead */
+        } state;
+
+        int                     debug_id;       /* debugging ID */
+        int                     n_children;     /* number of child objects */
+        int                     n_ops;          /* number of ops outstanding on object */
+        int                     n_obj_ops;      /* number of object ops outstanding on object */
+        int                     n_in_progress;  /* number of ops in progress */
+        int                     n_exclusive;    /* number of exclusive ops queued */
+        spinlock_t              lock;           /* state and operations lock */
+
+        unsigned long           lookup_jif;     /* time at which lookup started */
+        unsigned long           event_mask;     /* events this object is interested in */
+        unsigned long           events;         /* events to be processed by this object
+                                                 * (order is important - using fls) */
+#define FSCACHE_OBJECT_EV_REQUEUE       0       /* T if object should be requeued */
+#define FSCACHE_OBJECT_EV_UPDATE        1       /* T if object should be updated */
+#define FSCACHE_OBJECT_EV_CLEARED       2       /* T if accessors all gone */
+#define FSCACHE_OBJECT_EV_ERROR         3       /* T if fatal error occurred during processing */
+#define FSCACHE_OBJECT_EV_RELEASE       4       /* T if netfs requested object release */
+#define FSCACHE_OBJECT_EV_RETIRE        5       /* T if netfs requested object retirement */
+#define FSCACHE_OBJECT_EV_WITHDRAW      6       /* T if cache requested object withdrawal */
+
+        unsigned long           flags;
+#define FSCACHE_OBJECT_LOCK             0       /* T if object is busy being processed */
+#define FSCACHE_OBJECT_PENDING_WRITE    1       /* T if object has pending write */
+#define FSCACHE_OBJECT_WAITING          2       /* T if object is waiting on its parent */
+
+        struct list_head        cache_link;     /* link in cache->object_list */
+        struct hlist_node       cookie_link;    /* link in cookie->backing_objects */
+        struct fscache_cache    *cache;         /* cache that supplied this object */
+        struct fscache_cookie   *cookie;        /* netfs's file/index object */
+        struct fscache_object   *parent;        /* parent object */
+        struct slow_work        work;           /* attention scheduling record */
+        struct list_head        dependents;     /* FIFO of dependent objects */
+        struct list_head        dep_link;       /* link in parent's dependents list */
+        struct list_head        pending_ops;    /* unstarted operations on this object */
+        pgoff_t                 store_limit;    /* current storage limit */
+};
+
+extern const char *fscache_object_states[];
+
+#define fscache_object_is_active(obj)                         \
+        (!test_bit(FSCACHE_IOERROR, &(obj)->cache->flags) &&  \
+         (obj)->state >= FSCACHE_OBJECT_AVAILABLE &&          \
+         (obj)->state < FSCACHE_OBJECT_DYING)
+
+extern const struct slow_work_ops fscache_object_slow_work_ops;
+
+/**
+ * fscache_object_init - Initialise a cache object description
+ * @object: Object description
+ *
+ * Initialise a cache object description to its basic values.
+ *
+ * See Documentation/filesystems/caching/backend-api.txt for a complete
+ * description.
+ */
+static inline
+void fscache_object_init(struct fscache_object *object,
+                         struct fscache_cookie *cookie,
+                         struct fscache_cache *cache)
+{
+        atomic_inc(&cache->object_count);
+
+        object->state = FSCACHE_OBJECT_INIT;
+        spin_lock_init(&object->lock);
+        INIT_LIST_HEAD(&object->cache_link);
+        INIT_HLIST_NODE(&object->cookie_link);
+        vslow_work_init(&object->work, &fscache_object_slow_work_ops);
+        INIT_LIST_HEAD(&object->dependents);
+        INIT_LIST_HEAD(&object->dep_link);
+        INIT_LIST_HEAD(&object->pending_ops);
+        object->n_children = 0;
+        object->n_ops = object->n_in_progress = object->n_exclusive = 0;
+        object->events = object->event_mask = 0;
+        object->flags = 0;
+        object->store_limit = 0;
+        object->cache = cache;
+        object->cookie = cookie;
+        object->parent = NULL;
+}
+
+extern void fscache_object_lookup_negative(struct fscache_object *object);
+extern void fscache_obtained_object(struct fscache_object *object);
+
+/**
+ * fscache_object_destroyed - Note destruction of an object in a cache
+ * @cache: The cache from which the object came
+ *
+ * Note the destruction and deallocation of an object record in a cache.
+ */
+static inline void fscache_object_destroyed(struct fscache_cache *cache)
+{
+        if (atomic_dec_and_test(&cache->object_count))
+                wake_up_all(&fscache_cache_cleared_wq);
+}
+
+/**
+ * fscache_object_lookup_error - Note an object encountered an error
+ * @object: The object on which the error was encountered
+ *
+ * Note that an object encountered a fatal error (usually an I/O error) and
+ * that it should be withdrawn as soon as possible.
+ */
+static inline void fscache_object_lookup_error(struct fscache_object *object)
+{
+        set_bit(FSCACHE_OBJECT_EV_ERROR, &object->events);
+}
+
+/**
+ * fscache_set_store_limit - Set the maximum size to be stored in an object
+ * @object: The object to set the maximum on
+ * @i_size: The limit to set in bytes
+ *
+ * Set the maximum size an object is permitted to reach, implying the highest
+ * byte that may be written.  Intended to be called by the attr_changed() op.
+ *
+ * See Documentation/filesystems/caching/backend-api.txt for a complete
+ * description.
+ */
+static inline
+void fscache_set_store_limit(struct fscache_object *object, loff_t i_size)
+{
+        object->store_limit = i_size >> PAGE_SHIFT;
+        if (i_size & ~PAGE_MASK)
+                object->store_limit++;
+}
+
+/**
+ * fscache_end_io - End a retrieval operation on a page
+ * @op: The FS-Cache operation covering the retrieval
+ * @page: The page that was to be fetched
+ * @error: The error code (0 if successful)
+ *
+ * Note the end of an operation to retrieve a page, as covered by a particular
+ * operation record.
+ */
+static inline void fscache_end_io(struct fscache_retrieval *op,
+                                  struct page *page, int error)
+{
+        op->end_io_func(page, op->context, error);
+}
+
+/*
+ * out-of-line cache backend functions
+ */
+extern void fscache_init_cache(struct fscache_cache *cache,
+                               const struct fscache_cache_ops *ops,
+                               const char *idfmt,
+                               ...) __attribute__ ((format (printf, 3, 4)));
+
+extern int fscache_add_cache(struct fscache_cache *cache,
+                             struct fscache_object *fsdef,
+                             const char *tagname);
+extern void fscache_withdraw_cache(struct fscache_cache *cache);
+
+extern void fscache_io_error(struct fscache_cache *cache);
+
+extern void fscache_mark_pages_cached(struct fscache_retrieval *op,
+                                      struct pagevec *pagevec);
+
+extern enum fscache_checkaux fscache_check_aux(struct fscache_object *object,
+                                               const void *data,
+                                               uint16_t datalen);
+
+#endif /* _LINUX_FSCACHE_CACHE_H */
diff --git a/include/linux/fscache.h b/include/linux/fscache.h
new file mode 100644
index 000000000000..6d8ee466e0a0
--- /dev/null
+++ b/include/linux/fscache.h
@@ -0,0 +1,618 @@
+/* General filesystem caching interface
+ *
+ * Copyright (C) 2004-2007 Red Hat, Inc. All Rights Reserved.
+ * Written by David Howells (dhowells@redhat.com)
+ *
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU General Public License
+ * as published by the Free Software Foundation; either version
+ * 2 of the License, or (at your option) any later version.
+ *
+ * NOTE!!! See:
+ *
+ *      Documentation/filesystems/caching/netfs-api.txt
+ *
+ * for a description of the network filesystem interface declared here.
+ */
+
+#ifndef _LINUX_FSCACHE_H
+#define _LINUX_FSCACHE_H
+
+#include <linux/fs.h>
+#include <linux/list.h>
+#include <linux/pagemap.h>
+#include <linux/pagevec.h>
+
+#if defined(CONFIG_FSCACHE) || defined(CONFIG_FSCACHE_MODULE)
+#define fscache_available() (1)
+#define fscache_cookie_valid(cookie) (cookie)
+#else
+#define fscache_available() (0)
+#define fscache_cookie_valid(cookie) (0)
+#endif
+
+
+/*
+ * overload PG_private_2 to give us PG_fscache - this is used to indicate that
+ * a page is currently backed by a local disk cache
+ */
+#define PageFsCache(page)               PagePrivate2((page))
+#define SetPageFsCache(page)            SetPagePrivate2((page))
+#define ClearPageFsCache(page)          ClearPagePrivate2((page))
+#define TestSetPageFsCache(page)        TestSetPagePrivate2((page))
+#define TestClearPageFsCache(page)      TestClearPagePrivate2((page))
+
+/* pattern used to fill dead space in an index entry */
+#define FSCACHE_INDEX_DEADFILL_PATTERN 0x79
+
+struct pagevec;
+struct fscache_cache_tag;
+struct fscache_cookie;
+struct fscache_netfs;
+
+typedef void (*fscache_rw_complete_t)(struct page *page,
+                                      void *context,
+                                      int error);
+
+/* result of index entry consultation */
+enum fscache_checkaux {
+        FSCACHE_CHECKAUX_OKAY,          /* entry okay as is */
+        FSCACHE_CHECKAUX_NEEDS_UPDATE,  /* entry requires update */
+        FSCACHE_CHECKAUX_OBSOLETE,      /* entry requires deletion */
+};
+
+/*
+ * fscache cookie definition
+ */
+struct fscache_cookie_def {
+        /* name of cookie type */
+        char name[16];
+
+        /* cookie type */
+        uint8_t type;
+#define FSCACHE_COOKIE_TYPE_INDEX       0
+#define FSCACHE_COOKIE_TYPE_DATAFILE    1
+
+        /* select the cache into which to insert an entry in this index
+         * - optional
+         * - should return a cache identifier or NULL to cause the cache to be
+         *   inherited from the parent if possible or the first cache picked
+         *   for a non-index file if not
+         */
+        struct fscache_cache_tag *(*select_cache)(
+                const void *parent_netfs_data,
+                const void *cookie_netfs_data);
+
+        /* get an index key
+         * - should store the key data in the buffer
+         * - should return the amount of amount stored
+         * - not permitted to return an error
+         * - the netfs data from the cookie being used as the source is
+         *   presented
+         */
+        uint16_t (*get_key)(const void *cookie_netfs_data,
+                            void *buffer,
+                            uint16_t bufmax);
+
+        /* get certain file attributes from the netfs data
+         * - this function can be absent for an index
+         * - not permitted to return an error
+         * - the netfs data from the cookie being used as the source is
+         *   presented
+         */
+        void (*get_attr)(const void *cookie_netfs_data, uint64_t *size);
+
+        /* get the auxilliary data from netfs data
+         * - this function can be absent if the index carries no state data
+         * - should store the auxilliary data in the buffer
+         * - should return the amount of amount stored
+         * - not permitted to return an error
+         * - the netfs data from the cookie being used as the source is
+         *   presented
+         */
+        uint16_t (*get_aux)(const void *cookie_netfs_data,
+                            void *buffer,
+                            uint16_t bufmax);
+
+        /* consult the netfs about the state of an object
+         * - this function can be absent if the index carries no state data
+         * - the netfs data from the cookie being used as the target is
+         *   presented, as is the auxilliary data
+         */
+        enum fscache_checkaux (*check_aux)(void *cookie_netfs_data,
+                                           const void *data,
+                                           uint16_t datalen);
+
+        /* get an extra reference on a read context
+         * - this function can be absent if the completion function doesn't
+         *   require a context
+         */
+        void (*get_context)(void *cookie_netfs_data, void *context);
+
+        /* release an extra reference on a read context
+         * - this function can be absent if the completion function doesn't
+         *   require a context
+         */
+        void (*put_context)(void *cookie_netfs_data, void *context);
+
+        /* indicate pages that now have cache metadata retained
+         * - this function should mark the specified pages as now being cached
+         * - the pages will have been marked with PG_fscache before this is
+         *   called, so this is optional
+         */
+        void (*mark_pages_cached)(void *cookie_netfs_data,
+                                  struct address_space *mapping,
+                                  struct pagevec *cached_pvec);
+
+        /* indicate the cookie is no longer cached
+         * - this function is called when the backing store currently caching
+         *   a cookie is removed
+         * - the netfs should use this to clean up any markers indicating
+         *   cached pages
+         * - this is mandatory for any object that may have data
+         */
+        void (*now_uncached)(void *cookie_netfs_data);
+};
+
+/*
+ * fscache cached network filesystem type
+ * - name, version and ops must be filled in before registration
+ * - all other fields will be set during registration
+ */
+struct fscache_netfs {
+        uint32_t                        version;        /* indexing version */
+        const char                      *name;          /* filesystem name */
+        struct fscache_cookie           *primary_index;
+        struct list_head                link;           /* internal link */
+};
+
+/*
+ * slow-path functions for when there is actually caching available, and the
+ * netfs does actually have a valid token
+ * - these are not to be called directly
+ * - these are undefined symbols when FS-Cache is not configured and the
+ *   optimiser takes care of not using them
+ */
+extern int __fscache_register_netfs(struct fscache_netfs *);
+extern void __fscache_unregister_netfs(struct fscache_netfs *);
+extern struct fscache_cache_tag *__fscache_lookup_cache_tag(const char *);
+extern void __fscache_release_cache_tag(struct fscache_cache_tag *);
+
+extern struct fscache_cookie *__fscache_acquire_cookie(
+        struct fscache_cookie *,
+        const struct fscache_cookie_def *,
+        void *);
+extern void __fscache_relinquish_cookie(struct fscache_cookie *, int);
+extern void __fscache_update_cookie(struct fscache_cookie *);
+extern int __fscache_attr_changed(struct fscache_cookie *);
+extern int __fscache_read_or_alloc_page(struct fscache_cookie *,
+                                        struct page *,
+                                        fscache_rw_complete_t,
+                                        void *,
+                                        gfp_t);
+extern int __fscache_read_or_alloc_pages(struct fscache_cookie *,
+                                         struct address_space *,
+                                         struct list_head *,
+                                         unsigned *,
+                                         fscache_rw_complete_t,
+                                         void *,
+                                         gfp_t);
+extern int __fscache_alloc_page(struct fscache_cookie *, struct page *, gfp_t);
+extern int __fscache_write_page(struct fscache_cookie *, struct page *, gfp_t);
+extern void __fscache_uncache_page(struct fscache_cookie *, struct page *);
+extern bool __fscache_check_page_write(struct fscache_cookie *, struct page *);
+extern void __fscache_wait_on_page_write(struct fscache_cookie *, struct page *);
+
+/**
+ * fscache_register_netfs - Register a filesystem as desiring caching services
+ * @netfs: The description of the filesystem
+ *
+ * Register a filesystem as desiring caching services if they're available.
+ *
+ * See Documentation/filesystems/caching/netfs-api.txt for a complete
+ * description.
+ */
+static inline
+int fscache_register_netfs(struct fscache_netfs *netfs)
+{
+        if (fscache_available())
+                return __fscache_register_netfs(netfs);
+        else
+                return 0;
+}
+
+/**
+ * fscache_unregister_netfs - Indicate that a filesystem no longer desires
+ * caching services
+ * @netfs: The description of the filesystem
+ *
+ * Indicate that a filesystem no longer desires caching services for the
+ * moment.
+ *
+ * See Documentation/filesystems/caching/netfs-api.txt for a complete
+ * description.
+ */
+static inline
+void fscache_unregister_netfs(struct fscache_netfs *netfs)
+{
+        if (fscache_available())
+                __fscache_unregister_netfs(netfs);
+}
+
+/**
+ * fscache_lookup_cache_tag - Look up a cache tag
+ * @name: The name of the tag to search for
+ *
+ * Acquire a specific cache referral tag that can be used to select a specific
+ * cache in which to cache an index.
+ *
+ * See Documentation/filesystems/caching/netfs-api.txt for a complete
+ * description.
+ */
+static inline
+struct fscache_cache_tag *fscache_lookup_cache_tag(const char *name)
+{
+        if (fscache_available())
+                return __fscache_lookup_cache_tag(name);
+        else
+                return NULL;
+}
+
+/**
+ * fscache_release_cache_tag - Release a cache tag
+ * @tag: The tag to release
+ *
+ * Release a reference to a cache referral tag previously looked up.
+ *
+ * See Documentation/filesystems/caching/netfs-api.txt for a complete
+ * description.
+ */
+static inline
+void fscache_release_cache_tag(struct fscache_cache_tag *tag)
+{
+        if (fscache_available())
+                __fscache_release_cache_tag(tag);
+}
+
+/**
+ * fscache_acquire_cookie - Acquire a cookie to represent a cache object
+ * @parent: The cookie that's to be the parent of this one
+ * @def: A description of the cache object, including callback operations
+ * @netfs_data: An arbitrary piece of data to be kept in the cookie to
+ * represent the cache object to the netfs
+ *
+ * This function is used to inform FS-Cache about part of an index hierarchy
+ * that can be used to locate files.  This is done by requesting a cookie for
+ * each index in the path to the file.
+ *
+ * See Documentation/filesystems/caching/netfs-api.txt for a complete
+ * description.
+ */
+static inline
+struct fscache_cookie *fscache_acquire_cookie(
+        struct fscache_cookie *parent,
+        const struct fscache_cookie_def *def,
+        void *netfs_data)
+{
+        if (fscache_cookie_valid(parent))
+                return __fscache_acquire_cookie(parent, def, netfs_data);
+        else
+                return NULL;
+}
+
+/**
+ * fscache_relinquish_cookie - Return the cookie to the cache, maybe discarding
+ * it
+ * @cookie: The cookie being returned
+ * @retire: True if the cache object the cookie represents is to be discarded
+ *
+ * This function returns a cookie to the cache, forcibly discarding the
+ * associated cache object if retire is set to true.
+ *
+ * See Documentation/filesystems/caching/netfs-api.txt for a complete
+ * description.
+ */
+static inline
+void fscache_relinquish_cookie(struct fscache_cookie *cookie, int retire)
+{
+        if (fscache_cookie_valid(cookie))
+                __fscache_relinquish_cookie(cookie, retire);
+}
+
+/**
+ * fscache_update_cookie - Request that a cache object be updated
+ * @cookie: The cookie representing the cache object
+ *
+ * Request an update of the index data for the cache object associated with the
+ * cookie.
+ *
+ * See Documentation/filesystems/caching/netfs-api.txt for a complete
+ * description.
+ */
+static inline
+void fscache_update_cookie(struct fscache_cookie *cookie)
+{
+        if (fscache_cookie_valid(cookie))
+                __fscache_update_cookie(cookie);
+}
+
+/**
+ * fscache_pin_cookie - Pin a data-storage cache object in its cache
+ * @cookie: The cookie representing the cache object
+ *
+ * Permit data-storage cache objects to be pinned in the cache.
+ *
+ * See Documentation/filesystems/caching/netfs-api.txt for a complete
+ * description.
+ */
+static inline
+int fscache_pin_cookie(struct fscache_cookie *cookie)
+{
+        return -ENOBUFS;
+}
+
+/**
+ * fscache_pin_cookie - Unpin a data-storage cache object in its cache
+ * @cookie: The cookie representing the cache object
+ *
+ * Permit data-storage cache objects to be unpinned from the cache.
+ *
+ * See Documentation/filesystems/caching/netfs-api.txt for a complete
+ * description.
+ */
+static inline
+void fscache_unpin_cookie(struct fscache_cookie *cookie)
+{
+}
+
+/**
+ * fscache_attr_changed - Notify cache that an object's attributes changed
+ * @cookie: The cookie representing the cache object
+ *
+ * Send a notification to the cache indicating that an object's attributes have
+ * changed.  This includes the data size.  These attributes will be obtained
+ * through the get_attr() cookie definition op.
+ *
+ * See Documentation/filesystems/caching/netfs-api.txt for a complete
+ * description.
+ */
+static inline
+int fscache_attr_changed(struct fscache_cookie *cookie)
+{
+        if (fscache_cookie_valid(cookie))
+                return __fscache_attr_changed(cookie);
+        else
+                return -ENOBUFS;
+}
+
+/**
+ * fscache_reserve_space - Reserve data space for a cached object
+ * @cookie: The cookie representing the cache object
+ * @i_size: The amount of space to be reserved
+ *
+ * Reserve an amount of space in the cache for the cache object attached to a
+ * cookie so that a write to that object within the space can always be
+ * honoured.
+ *
+ * See Documentation/filesystems/caching/netfs-api.txt for a complete
+ * description.
+ */
+static inline
+int fscache_reserve_space(struct fscache_cookie *cookie, loff_t size)
+{
+        return -ENOBUFS;
+}
+
+/**
+ * fscache_read_or_alloc_page - Read a page from the cache or allocate a block
+ * in which to store it
+ * @cookie: The cookie representing the cache object
+ * @page: The netfs page to fill if possible
+ * @end_io_func: The callback to invoke when and if the page is filled
+ * @context: An arbitrary piece of data to pass on to end_io_func()
+ * @gfp: The conditions under which memory allocation should be made
+ *
+ * Read a page from the cache, or if that's not possible make a potential
+ * one-block reservation in the cache into which the page may be stored once
+ * fetched from the server.
+ *
+ * If the page is not backed by the cache object, or if it there's some reason
+ * it can't be, -ENOBUFS will be returned and nothing more will be done for
+ * that page.
+ *
+ * Else, if that page is backed by the cache, a read will be initiated directly
+ * to the netfs's page and 0 will be returned by this function.  The
+ * end_io_func() callback will be invoked when the operation terminates on a
+ * completion or failure.  Note that the callback may be invoked before the
+ * return.
+ *
+ * Else, if the page is unbacked, -ENODATA is returned and a block may have
+ * been allocated in the cache.
+ *
+ * See Documentation/filesystems/caching/netfs-api.txt for a complete
+ * description.
+ */
+static inline
+int fscache_read_or_alloc_page(struct fscache_cookie *cookie,
+                               struct page *page,
+                               fscache_rw_complete_t end_io_func,
+                               void *context,
+                               gfp_t gfp)
+{
+        if (fscache_cookie_valid(cookie))
+                return __fscache_read_or_alloc_page(cookie, page, end_io_func,
+                                                    context, gfp);
+        else
+                return -ENOBUFS;
+}
+
+/**
+ * fscache_read_or_alloc_pages - Read pages from the cache and/or allocate
+ * blocks in which to store them
+ * @cookie: The cookie representing the cache object
+ * @mapping: The netfs inode mapping to which the pages will be attached
+ * @pages: A list of potential netfs pages to be filled
+ * @end_io_func: The callback to invoke when and if each page is filled
+ * @context: An arbitrary piece of data to pass on to end_io_func()
+ * @gfp: The conditions under which memory allocation should be made
+ *
+ * Read a set of pages from the cache, or if that's not possible, attempt to
+ * make a potential one-block reservation for each page in the cache into which
+ * that page may be stored once fetched from the server.
+ *
+ * If some pages are not backed by the cache object, or if it there's some
+ * reason they can't be, -ENOBUFS will be returned and nothing more will be
+ * done for that pages.
+ *
+ * Else, if some of the pages are backed by the cache, a read will be initiated
+ * directly to the netfs's page and 0 will be returned by this function.  The
+ * end_io_func() callback will be invoked when the operation terminates on a
+ * completion or failure.  Note that the callback may be invoked before the
+ * return.
+ *
+ * Else, if a page is unbacked, -ENODATA is returned and a block may have
+ * been allocated in the cache.
+ *
+ * Because the function may want to return all of -ENOBUFS, -ENODATA and 0 in
+ * regard to different pages, the return values are prioritised in that order.
+ * Any pages submitted for reading are removed from the pages list.
+ *
+ * See Documentation/filesystems/caching/netfs-api.txt for a complete
+ * description.
+ */
+static inline
+int fscache_read_or_alloc_pages(struct fscache_cookie *cookie,
+                                struct address_space *mapping,
+                                struct list_head *pages,
+                                unsigned *nr_pages,
+                                fscache_rw_complete_t end_io_func,
+                                void *context,
+                                gfp_t gfp)
+{
+        if (fscache_cookie_valid(cookie))
+                return __fscache_read_or_alloc_pages(cookie, mapping, pages,
+                                                     nr_pages, end_io_func,
+                                                     context, gfp);
+        else
+                return -ENOBUFS;
+}
+
+/**
+ * fscache_alloc_page - Allocate a block in which to store a page
+ * @cookie: The cookie representing the cache object
+ * @page: The netfs page to allocate a page for
+ * @gfp: The conditions under which memory allocation should be made
+ *
+ * Request Allocation a block in the cache in which to store a netfs page
+ * without retrieving any contents from the cache.
+ *
+ * If the page is not backed by a file then -ENOBUFS will be returned and
+ * nothing more will be done, and no reservation will be made.
+ *
+ * Else, a block will be allocated if one wasn't already, and 0 will be
+ * returned
+ *
+ * See Documentation/filesystems/caching/netfs-api.txt for a complete
+ * description.
+ */
+static inline
+int fscache_alloc_page(struct fscache_cookie *cookie,
+                       struct page *page,
+                       gfp_t gfp)
+{
+        if (fscache_cookie_valid(cookie))
+                return __fscache_alloc_page(cookie, page, gfp);
+        else
+                return -ENOBUFS;
+}
+
+/**
+ * fscache_write_page - Request storage of a page in the cache
+ * @cookie: The cookie representing the cache object
+ * @page: The netfs page to store
+ * @gfp: The conditions under which memory allocation should be made
+ *
+ * Request the contents of the netfs page be written into the cache.  This
+ * request may be ignored if no cache block is currently allocated, in which
+ * case it will return -ENOBUFS.
+ *
+ * If a cache block was already allocated, a write will be initiated and 0 will
+ * be returned.  The PG_fscache_write page bit is set immediately and will then
+ * be cleared at the completion of the write to indicate the success or failure
+ * of the operation.  Note that the completion may happen before the return.
+ *
+ * See Documentation/filesystems/caching/netfs-api.txt for a complete
+ * description.
+ */
+static inline
+int fscache_write_page(struct fscache_cookie *cookie,
+                       struct page *page,
+                       gfp_t gfp)
+{
+        if (fscache_cookie_valid(cookie))
+                return __fscache_write_page(cookie, page, gfp);
+        else
+                return -ENOBUFS;
+}
+
+/**
+ * fscache_uncache_page - Indicate that caching is no longer required on a page
+ * @cookie: The cookie representing the cache object
+ * @page: The netfs page that was being cached.
+ *
+ * Tell the cache that we no longer want a page to be cached and that it should
+ * remove any knowledge of the netfs page it may have.
+ *
+ * Note that this cannot cancel any outstanding I/O operations between this
+ * page and the cache.
+ *
+ * See Documentation/filesystems/caching/netfs-api.txt for a complete
+ * description.
+ */
+static inline
+void fscache_uncache_page(struct fscache_cookie *cookie,
+                          struct page *page)
+{
+        if (fscache_cookie_valid(cookie))
+                __fscache_uncache_page(cookie, page);
+}
+
+/**
+ * fscache_check_page_write - Ask if a page is being writing to the cache
+ * @cookie: The cookie representing the cache object
+ * @page: The netfs page that is being cached.
+ *
+ * Ask the cache if a page is being written to the cache.
+ *
+ * See Documentation/filesystems/caching/netfs-api.txt for a complete
+ * description.
+ */
+static inline
+bool fscache_check_page_write(struct fscache_cookie *cookie,
+                              struct page *page)
+{
+        if (fscache_cookie_valid(cookie))
+                return __fscache_check_page_write(cookie, page);
+        return false;
+}
+
+/**
+ * fscache_wait_on_page_write - Wait for a page to complete writing to the cache
+ * @cookie: The cookie representing the cache object
+ * @page: The netfs page that is being cached.
+ *
+ * Ask the cache to wake us up when a page is no longer being written to the
+ * cache.
+ *
+ * See Documentation/filesystems/caching/netfs-api.txt for a complete
+ * description.
+ */
+static inline
+void fscache_wait_on_page_write(struct fscache_cookie *cookie,
+                                struct page *page)
+{
+        if (fscache_cookie_valid(cookie))
+                __fscache_wait_on_page_write(cookie, page);
+}
+
+#endif /* _LINUX_FSCACHE_H */
diff --git a/include/linux/fsl_devices.h b/include/linux/fsl_devices.h
index d9051d717d27..244677cc082b 100644
--- a/include/linux/fsl_devices.h
+++ b/include/linux/fsl_devices.h
@@ -18,7 +18,6 @@
 #define _FSL_DEVICE_H_
 
 #include <linux/types.h>
-#include <linux/phy.h>
 
 /*
  * Some conventions on how we handle peripherals on Freescale chips
@@ -44,31 +43,6 @@
  *
  */
 
-struct gianfar_platform_data {
-        /* device specific information */
-        u32     device_flags;
-        char    bus_id[BUS_ID_SIZE];
-        phy_interface_t interface;
-};
-
-struct gianfar_mdio_data {
-        /* board specific information */
-        int     irq[32];
-};
-
-/* Flags in gianfar_platform_data */
-#define FSL_GIANFAR_BRD_HAS_PHY_INTR    0x00000001 /* set or use a timer */
-#define FSL_GIANFAR_BRD_IS_REDUCED      0x00000002 /* Set if RGMII, RMII */
-
-struct fsl_i2c_platform_data {
-        /* device specific information */
-        u32     device_flags;
-};
-
-/* Flags related to I2C device features */
-#define FSL_I2C_DEV_SEPARATE_DFSRR      0x00000001
-#define FSL_I2C_DEV_CLOCK_5200          0x00000002
-
 enum fsl_usb2_operating_modes {
         FSL_USB2_MPH_HOST,
         FSL_USB2_DR_HOST,
@@ -95,15 +69,20 @@ struct fsl_usb2_platform_data {
 #define FSL_USB2_PORT0_ENABLED  0x00000001
 #define FSL_USB2_PORT1_ENABLED  0x00000002
 
+struct spi_device;
+
 struct fsl_spi_platform_data {
         u32     initial_spmode; /* initial SPMODE value */
-        u16     bus_num;
+        s16     bus_num;
         bool    qe_mode;
         /* board specific information */
         u16     max_chipselect;
+        void    (*cs_control)(struct spi_device *spi, bool on);
+        u32     sysclk;
+
+        /* Legacy hooks, used by mpc52xx_psc_spi driver. */
         void    (*activate_cs)(u8 cs, u8 polarity);
         void    (*deactivate_cs)(u8 cs, u8 polarity);
-        u32     sysclk;
 };
 
 struct mpc8xx_pcmcia_ops {
diff --git a/include/linux/ftrace.h b/include/linux/ftrace.h
index 677432b9cb7e..8a0c2f221e6b 100644
--- a/include/linux/ftrace.h
+++ b/include/linux/ftrace.h
@@ -1,15 +1,18 @@
 #ifndef _LINUX_FTRACE_H
 #define _LINUX_FTRACE_H
 
-#include <linux/linkage.h>
-#include <linux/fs.h>
-#include <linux/ktime.h>
-#include <linux/init.h>
-#include <linux/types.h>
-#include <linux/module.h>
+#include <linux/trace_clock.h>
 #include <linux/kallsyms.h>
+#include <linux/linkage.h>
 #include <linux/bitops.h>
+#include <linux/module.h>
+#include <linux/ktime.h>
 #include <linux/sched.h>
+#include <linux/types.h>
+#include <linux/init.h>
+#include <linux/fs.h>
+
+#include <asm/ftrace.h>
 
 #ifdef CONFIG_FUNCTION_TRACER
 
@@ -95,9 +98,41 @@ stack_trace_sysctl(struct ctl_table *table, int write,
                    loff_t *ppos);
 #endif
 
+struct ftrace_func_command {
+        struct list_head        list;
+        char                    *name;
+        int                     (*func)(char *func, char *cmd,
+                                        char *params, int enable);
+};
+
 #ifdef CONFIG_DYNAMIC_FTRACE
-/* asm/ftrace.h must be defined for archs supporting dynamic ftrace */
-#include <asm/ftrace.h>
+
+int ftrace_arch_code_modify_prepare(void);
+int ftrace_arch_code_modify_post_process(void);
+
+struct seq_file;
+
+struct ftrace_probe_ops {
+        void                    (*func)(unsigned long ip,
+                                        unsigned long parent_ip,
+                                        void **data);
+        int                     (*callback)(unsigned long ip, void **data);
+        void                    (*free)(void **data);
+        int                     (*print)(struct seq_file *m,
+                                         unsigned long ip,
+                                         struct ftrace_probe_ops *ops,
+                                         void *data);
+};
+
+extern int
+register_ftrace_function_probe(char *glob, struct ftrace_probe_ops *ops,
+                              void *data);
+extern void
+unregister_ftrace_function_probe(char *glob, struct ftrace_probe_ops *ops,
+                                void *data);
+extern void
+unregister_ftrace_function_probe_func(char *glob, struct ftrace_probe_ops *ops);
+extern void unregister_ftrace_function_probe_all(char *glob);
 
 enum {
         FTRACE_FL_FREE          = (1 << 0),
@@ -110,15 +145,23 @@ enum {
 };
 
 struct dyn_ftrace {
-        struct list_head        list;
-        unsigned long           ip; /* address of mcount call-site */
-        unsigned long           flags;
-        struct dyn_arch_ftrace  arch;
+        union {
+                unsigned long           ip; /* address of mcount call-site */
+                struct dyn_ftrace       *freelist;
+        };
+        union {
+                unsigned long           flags;
+                struct dyn_ftrace       *newlist;
+        };
+        struct dyn_arch_ftrace          arch;
 };
 
 int ftrace_force_update(void);
 void ftrace_set_filter(unsigned char *buf, int len, int reset);
 
+int register_ftrace_command(struct ftrace_func_command *cmd);
+int unregister_ftrace_command(struct ftrace_func_command *cmd);
+
 /* defined in arch */
 extern int ftrace_ip_converted(unsigned long ip);
 extern int ftrace_dyn_arch_init(void *data);
@@ -126,6 +169,10 @@ extern int ftrace_update_ftrace_func(ftrace_func_t func);
 extern void ftrace_caller(void);
 extern void ftrace_call(void);
 extern void mcount_call(void);
+
+#ifndef FTRACE_ADDR
+#define FTRACE_ADDR ((unsigned long)ftrace_caller)
+#endif
 #ifdef CONFIG_FUNCTION_GRAPH_TRACER
 extern void ftrace_graph_caller(void);
 extern int ftrace_enable_ftrace_graph_caller(void);
@@ -136,7 +183,7 @@ static inline int ftrace_disable_ftrace_graph_caller(void) { return 0; }
 #endif
 
 /**
- * ftrace_make_nop - convert code into top
+ * ftrace_make_nop - convert code into nop
  * @mod: module structure if called by module load initialization
  * @rec: the mcount call site record
  * @addr: the address that the call site should be calling
@@ -181,7 +228,6 @@ extern int ftrace_make_nop(struct module *mod,
  */
 extern int ftrace_make_call(struct dyn_ftrace *rec, unsigned long addr);
 
-
 /* May be defined in arch */
 extern int ftrace_arch_read_dyn_info(char *buf, int size);
 
@@ -198,6 +244,14 @@ extern void ftrace_enable_daemon(void);
 # define ftrace_disable_daemon()                do { } while (0)
 # define ftrace_enable_daemon()                 do { } while (0)
 static inline void ftrace_release(void *start, unsigned long size) { }
+static inline int register_ftrace_command(struct ftrace_func_command *cmd)
+{
+        return -EINVAL;
+}
+static inline int unregister_ftrace_command(char *cmd_name)
+{
+        return -EINVAL;
+}
 #endif /* CONFIG_DYNAMIC_FTRACE */
 
 /* totally disable ftrace - can not re-enable after this */
@@ -233,24 +287,25 @@ static inline void __ftrace_enabled_restore(int enabled)
 #endif
 }
 
-#ifdef CONFIG_FRAME_POINTER
-/* TODO: need to fix this for ARM */
-# define CALLER_ADDR0 ((unsigned long)__builtin_return_address(0))
-# define CALLER_ADDR1 ((unsigned long)__builtin_return_address(1))
-# define CALLER_ADDR2 ((unsigned long)__builtin_return_address(2))
-# define CALLER_ADDR3 ((unsigned long)__builtin_return_address(3))
-# define CALLER_ADDR4 ((unsigned long)__builtin_return_address(4))
-# define CALLER_ADDR5 ((unsigned long)__builtin_return_address(5))
-# define CALLER_ADDR6 ((unsigned long)__builtin_return_address(6))
-#else
-# define CALLER_ADDR0 ((unsigned long)__builtin_return_address(0))
-# define CALLER_ADDR1 0UL
-# define CALLER_ADDR2 0UL
-# define CALLER_ADDR3 0UL
-# define CALLER_ADDR4 0UL
-# define CALLER_ADDR5 0UL
-# define CALLER_ADDR6 0UL
-#endif
+#ifndef HAVE_ARCH_CALLER_ADDR
+# ifdef CONFIG_FRAME_POINTER
+#  define CALLER_ADDR0 ((unsigned long)__builtin_return_address(0))
+#  define CALLER_ADDR1 ((unsigned long)__builtin_return_address(1))
+#  define CALLER_ADDR2 ((unsigned long)__builtin_return_address(2))
+#  define CALLER_ADDR3 ((unsigned long)__builtin_return_address(3))
+#  define CALLER_ADDR4 ((unsigned long)__builtin_return_address(4))
+#  define CALLER_ADDR5 ((unsigned long)__builtin_return_address(5))
+#  define CALLER_ADDR6 ((unsigned long)__builtin_return_address(6))
+# else
+#  define CALLER_ADDR0 ((unsigned long)__builtin_return_address(0))
+#  define CALLER_ADDR1 0UL
+#  define CALLER_ADDR2 0UL
+#  define CALLER_ADDR3 0UL
+#  define CALLER_ADDR4 0UL
+#  define CALLER_ADDR5 0UL
+#  define CALLER_ADDR6 0UL
+# endif
+#endif /* ifndef HAVE_ARCH_CALLER_ADDR */
 
 #ifdef CONFIG_IRQSOFF_TRACER
   extern void time_hardirqs_on(unsigned long a0, unsigned long a1);
@@ -268,54 +323,6 @@ static inline void __ftrace_enabled_restore(int enabled)
 # define trace_preempt_off(a0, a1)              do { } while (0)
 #endif
 
-#ifdef CONFIG_TRACING
-extern int ftrace_dump_on_oops;
-
-extern void tracing_start(void);
-extern void tracing_stop(void);
-extern void ftrace_off_permanent(void);
-
-extern void
-ftrace_special(unsigned long arg1, unsigned long arg2, unsigned long arg3);
-
-/**
- * ftrace_printk - printf formatting in the ftrace buffer
- * @fmt: the printf format for printing
- *
- * Note: __ftrace_printk is an internal function for ftrace_printk and
- *       the @ip is passed in via the ftrace_printk macro.
- *
- * This function allows a kernel developer to debug fast path sections
- * that printk is not appropriate for. By scattering in various
- * printk like tracing in the code, a developer can quickly see
- * where problems are occurring.
- *
- * This is intended as a debugging tool for the developer only.
- * Please refrain from leaving ftrace_printks scattered around in
- * your code.
- */
-# define ftrace_printk(fmt...) __ftrace_printk(_THIS_IP_, fmt)
-extern int
-__ftrace_printk(unsigned long ip, const char *fmt, ...)
-        __attribute__ ((format (printf, 2, 3)));
-extern void ftrace_dump(void);
-#else
-static inline void
-ftrace_special(unsigned long arg1, unsigned long arg2, unsigned long arg3) { }
-static inline int
-ftrace_printk(const char *fmt, ...) __attribute__ ((format (printf, 1, 2)));
-
-static inline void tracing_start(void) { }
-static inline void tracing_stop(void) { }
-static inline void ftrace_off_permanent(void) { }
-static inline int
-ftrace_printk(const char *fmt, ...)
-{
-        return 0;
-}
-static inline void ftrace_dump(void) { }
-#endif
-
 #ifdef CONFIG_FTRACE_MCOUNT_RECORD
 extern void ftrace_init(void);
 extern void ftrace_init_module(struct module *mod,
@@ -327,36 +334,6 @@ ftrace_init_module(struct module *mod,
                    unsigned long *start, unsigned long *end) { }
 #endif
 
-enum {
-        POWER_NONE = 0,
-        POWER_CSTATE = 1,
-        POWER_PSTATE = 2,
-};
-
-struct power_trace {
-#ifdef CONFIG_POWER_TRACER
-        ktime_t                 stamp;
-        ktime_t                 end;
-        int                     type;
-        int                     state;
-#endif
-};
-
-#ifdef CONFIG_POWER_TRACER
-extern void trace_power_start(struct power_trace *it, unsigned int type,
-                                        unsigned int state);
-extern void trace_power_mark(struct power_trace *it, unsigned int type,
-                                        unsigned int state);
-extern void trace_power_end(struct power_trace *it);
-#else
-static inline void trace_power_start(struct power_trace *it, unsigned int type,
-                                        unsigned int state) { }
-static inline void trace_power_mark(struct power_trace *it, unsigned int type,
-                                        unsigned int state) { }
-static inline void trace_power_end(struct power_trace *it) { }
-#endif
-
-
 /*
  * Structure that defines an entry function trace.
  */
@@ -379,6 +356,32 @@ struct ftrace_graph_ret {
 
 #ifdef CONFIG_FUNCTION_GRAPH_TRACER
 
+/* for init task */
+#define INIT_FTRACE_GRAPH               .ret_stack = NULL,
+
+/*
+ * Stack of return addresses for functions
+ * of a thread.
+ * Used in struct thread_info
+ */
+struct ftrace_ret_stack {
+        unsigned long ret;
+        unsigned long func;
+        unsigned long long calltime;
+};
+
+/*
+ * Primary handler of a function return.
+ * It relays on ftrace_return_to_handler.
+ * Defined in entry_32/64.S
+ */
+extern void return_to_handler(void);
+
+extern int
+ftrace_push_return_trace(unsigned long ret, unsigned long func, int *depth);
+extern void
+ftrace_pop_return_trace(struct ftrace_graph_ret *trace, unsigned long *ret);
+
 /*
  * Sometimes we don't want to trace a function with the function
  * graph tracer but we want them to keep traced by the usual function
@@ -430,10 +433,11 @@ static inline void unpause_graph_tracing(void)
 {
         atomic_dec(&current->tracing_graph_pause);
 }
-#else
+#else /* !CONFIG_FUNCTION_GRAPH_TRACER */
 
 #define __notrace_funcgraph
 #define __irq_entry
+#define INIT_FTRACE_GRAPH
 
 static inline void ftrace_graph_init_task(struct task_struct *t) { }
 static inline void ftrace_graph_exit_task(struct task_struct *t) { }
@@ -445,7 +449,7 @@ static inline int task_curr_ret_stack(struct task_struct *tsk)
 
 static inline void pause_graph_tracing(void) { }
 static inline void unpause_graph_tracing(void) { }
-#endif
+#endif /* CONFIG_FUNCTION_GRAPH_TRACER */
 
 #ifdef CONFIG_TRACING
 #include <linux/sched.h>
@@ -490,6 +494,21 @@ static inline int test_tsk_trace_graph(struct task_struct *tsk)
         return tsk->trace & TSK_TRACE_FL_GRAPH;
 }
 
+extern int ftrace_dump_on_oops;
+
 #endif /* CONFIG_TRACING */
 
+
+#ifdef CONFIG_HW_BRANCH_TRACER
+
+void trace_hw_branch(u64 from, u64 to);
+void trace_hw_branch_oops(void);
+
+#else /* CONFIG_HW_BRANCH_TRACER */
+
+static inline void trace_hw_branch(u64 from, u64 to) {}
+static inline void trace_hw_branch_oops(void) {}
+
+#endif /* CONFIG_HW_BRANCH_TRACER */
+
 #endif /* _LINUX_FTRACE_H */
diff --git a/include/linux/ftrace_irq.h b/include/linux/ftrace_irq.h
index 366a054d0b05..dca7bf8cffe2 100644
--- a/include/linux/ftrace_irq.h
+++ b/include/linux/ftrace_irq.h
@@ -2,7 +2,7 @@
 #define _LINUX_FTRACE_IRQ_H
 
 
-#if defined(CONFIG_DYNAMIC_FTRACE) || defined(CONFIG_FUNCTION_GRAPH_TRACER)
+#ifdef CONFIG_FTRACE_NMI_ENTER
 extern void ftrace_nmi_enter(void);
 extern void ftrace_nmi_exit(void);
 #else
diff --git a/include/linux/genhd.h b/include/linux/genhd.h
index 634c53028fb8..a1a28caed23d 100644
--- a/include/linux/genhd.h
+++ b/include/linux/genhd.h
@@ -214,6 +214,7 @@ static inline void disk_put_part(struct hd_struct *part)
 #define DISK_PITER_REVERSE      (1 << 0) /* iterate in the reverse direction */
 #define DISK_PITER_INCL_EMPTY   (1 << 1) /* include 0-sized parts */
 #define DISK_PITER_INCL_PART0   (1 << 2) /* include partition 0 */
+#define DISK_PITER_INCL_EMPTY_PART0 (1 << 3) /* include empty partition 0 */
 
 struct disk_part_iter {
         struct gendisk          *disk;
diff --git a/include/linux/gfp.h b/include/linux/gfp.h
index dd20cd78faa8..0bbc15f54536 100644
--- a/include/linux/gfp.h
+++ b/include/linux/gfp.h
@@ -4,6 +4,7 @@
 #include <linux/mmzone.h>
 #include <linux/stddef.h>
 #include <linux/linkage.h>
+#include <linux/topology.h>
 
 struct vm_area_struct;
 
diff --git a/include/linux/hardirq.h b/include/linux/hardirq.h
index f83288347dda..45257475623c 100644
--- a/include/linux/hardirq.h
+++ b/include/linux/hardirq.h
@@ -15,55 +15,61 @@
  * - bits 0-7 are the preemption count (max preemption depth: 256)
  * - bits 8-15 are the softirq count (max # of softirqs: 256)
  *
- * The hardirq count can be overridden per architecture, the default is:
+ * The hardirq count can in theory reach the same as NR_IRQS.
+ * In reality, the number of nested IRQS is limited to the stack
+ * size as well. For archs with over 1000 IRQS it is not practical
+ * to expect that they will all nest. We give a max of 10 bits for
+ * hardirq nesting. An arch may choose to give less than 10 bits.
+ * m68k expects it to be 8.
  *
- * - bits 16-27 are the hardirq count (max # of hardirqs: 4096)
- * - ( bit 28 is the PREEMPT_ACTIVE flag. )
+ * - bits 16-25 are the hardirq count (max # of nested hardirqs: 1024)
+ * - bit 26 is the NMI_MASK
+ * - bit 28 is the PREEMPT_ACTIVE flag
  *
  * PREEMPT_MASK: 0x000000ff
  * SOFTIRQ_MASK: 0x0000ff00
- * HARDIRQ_MASK: 0x0fff0000
+ * HARDIRQ_MASK: 0x03ff0000
+ *     NMI_MASK: 0x04000000
  */
 #define PREEMPT_BITS    8
 #define SOFTIRQ_BITS    8
+#define NMI_BITS        1
 
-#ifndef HARDIRQ_BITS
-#define HARDIRQ_BITS    12
+#define MAX_HARDIRQ_BITS 10
 
-#ifndef MAX_HARDIRQS_PER_CPU
-#define MAX_HARDIRQS_PER_CPU NR_IRQS
+#ifndef HARDIRQ_BITS
+# define HARDIRQ_BITS   MAX_HARDIRQ_BITS
 #endif
 
-/*
- * The hardirq mask has to be large enough to have space for potentially
- * all IRQ sources in the system nesting on a single CPU.
- */
-#if (1 << HARDIRQ_BITS) < MAX_HARDIRQS_PER_CPU
-# error HARDIRQ_BITS is too low!
-#endif
+#if HARDIRQ_BITS > MAX_HARDIRQ_BITS
+#error HARDIRQ_BITS too high!
 #endif
 
 #define PREEMPT_SHIFT   0
 #define SOFTIRQ_SHIFT   (PREEMPT_SHIFT + PREEMPT_BITS)
 #define HARDIRQ_SHIFT   (SOFTIRQ_SHIFT + SOFTIRQ_BITS)
+#define NMI_SHIFT       (HARDIRQ_SHIFT + HARDIRQ_BITS)
 
 #define __IRQ_MASK(x)   ((1UL << (x))-1)
 
 #define PREEMPT_MASK    (__IRQ_MASK(PREEMPT_BITS) << PREEMPT_SHIFT)
 #define SOFTIRQ_MASK    (__IRQ_MASK(SOFTIRQ_BITS) << SOFTIRQ_SHIFT)
 #define HARDIRQ_MASK    (__IRQ_MASK(HARDIRQ_BITS) << HARDIRQ_SHIFT)
+#define NMI_MASK        (__IRQ_MASK(NMI_BITS)     << NMI_SHIFT)
 
 #define PREEMPT_OFFSET  (1UL << PREEMPT_SHIFT)
 #define SOFTIRQ_OFFSET  (1UL << SOFTIRQ_SHIFT)
 #define HARDIRQ_OFFSET  (1UL << HARDIRQ_SHIFT)
+#define NMI_OFFSET      (1UL << NMI_SHIFT)
 
-#if PREEMPT_ACTIVE < (1 << (HARDIRQ_SHIFT + HARDIRQ_BITS))
+#if PREEMPT_ACTIVE < (1 << (NMI_SHIFT + NMI_BITS))
 #error PREEMPT_ACTIVE is too low!
 #endif
 
 #define hardirq_count() (preempt_count() & HARDIRQ_MASK)
 #define softirq_count() (preempt_count() & SOFTIRQ_MASK)
-#define irq_count()     (preempt_count() & (HARDIRQ_MASK | SOFTIRQ_MASK))
+#define irq_count()     (preempt_count() & (HARDIRQ_MASK | SOFTIRQ_MASK \
+                                 | NMI_MASK))
 
 /*
  * Are we doing bottom half or hardware interrupt processing?
@@ -73,6 +79,11 @@
 #define in_softirq()            (softirq_count())
 #define in_interrupt()          (irq_count())
 
+/*
+ * Are we in NMI context?
+ */
+#define in_nmi()        (preempt_count() & NMI_MASK)
+
 #if defined(CONFIG_PREEMPT)
 # define PREEMPT_INATOMIC_BASE kernel_locked()
 # define PREEMPT_CHECK_OFFSET 1
@@ -105,7 +116,7 @@
 # define IRQ_EXIT_OFFSET HARDIRQ_OFFSET
 #endif
 
-#ifdef CONFIG_SMP
+#if defined(CONFIG_SMP) || defined(CONFIG_GENERIC_HARDIRQS)
 extern void synchronize_irq(unsigned int irq);
 #else
 # define synchronize_irq(irq)   barrier()
@@ -164,20 +175,24 @@ extern void irq_enter(void);
  */
 extern void irq_exit(void);
 
-#define nmi_enter()                             \
-        do {                                    \
-                ftrace_nmi_enter();             \
-                lockdep_off();                  \
-                rcu_nmi_enter();                \
-                __irq_enter();                  \
+#define nmi_enter()                                             \
+        do {                                                    \
+                ftrace_nmi_enter();                             \
+                BUG_ON(in_nmi());                               \
+                add_preempt_count(NMI_OFFSET + HARDIRQ_OFFSET); \
+                lockdep_off();                                  \
+                rcu_nmi_enter();                                \
+                trace_hardirq_enter();                          \
         } while (0)
 
-#define nmi_exit()                              \
-        do {                                    \
-                __irq_exit();                   \
-                rcu_nmi_exit();                 \
-                lockdep_on();                   \
-                ftrace_nmi_exit();              \
+#define nmi_exit()                                              \
+        do {                                                    \
+                trace_hardirq_exit();                           \
+                rcu_nmi_exit();                                 \
+                lockdep_on();                                   \
+                BUG_ON(!in_nmi());                              \
+                sub_preempt_count(NMI_OFFSET + HARDIRQ_OFFSET); \
+                ftrace_nmi_exit();                              \
         } while (0)
 
 #endif /* LINUX_HARDIRQ_H */
diff --git a/include/linux/hdreg.h b/include/linux/hdreg.h
index ed21bd3dbd25..29ee2873f4a8 100644
--- a/include/linux/hdreg.h
+++ b/include/linux/hdreg.h
@@ -1,68 +1,6 @@
 #ifndef _LINUX_HDREG_H
 #define _LINUX_HDREG_H
 
-#ifdef __KERNEL__
-#include <linux/ata.h>
-
-/*
- * This file contains some defines for the AT-hd-controller.
- * Various sources.
- */
-
-/* ide.c has its own port definitions in "ide.h" */
-
-#define HD_IRQ          14
-
-/* Hd controller regs. Ref: IBM AT Bios-listing */
-#define HD_DATA         0x1f0           /* _CTL when writing */
-#define HD_ERROR        0x1f1           /* see err-bits */
-#define HD_NSECTOR      0x1f2           /* nr of sectors to read/write */
-#define HD_SECTOR       0x1f3           /* starting sector */
-#define HD_LCYL         0x1f4           /* starting cylinder */
-#define HD_HCYL         0x1f5           /* high byte of starting cyl */
-#define HD_CURRENT      0x1f6           /* 101dhhhh , d=drive, hhhh=head */
-#define HD_STATUS       0x1f7           /* see status-bits */
-#define HD_FEATURE      HD_ERROR        /* same io address, read=error, write=feature */
-#define HD_PRECOMP      HD_FEATURE      /* obsolete use of this port - predates IDE */
-#define HD_COMMAND      HD_STATUS       /* same io address, read=status, write=cmd */
-
-#define HD_CMD          0x3f6           /* used for resets */
-#define HD_ALTSTATUS    0x3f6           /* same as HD_STATUS but doesn't clear irq */
-
-/* remainder is shared between hd.c, ide.c, ide-cd.c, and the hdparm utility */
-
-/* Bits of HD_STATUS */
-#define ERR_STAT                0x01
-#define INDEX_STAT              0x02
-#define ECC_STAT                0x04    /* Corrected error */
-#define DRQ_STAT                0x08
-#define SEEK_STAT               0x10
-#define SRV_STAT                0x10
-#define WRERR_STAT              0x20
-#define READY_STAT              0x40
-#define BUSY_STAT               0x80
-
-/* Bits for HD_ERROR */
-#define MARK_ERR                0x01    /* Bad address mark */
-#define ILI_ERR                 0x01    /* Illegal Length Indication (ATAPI) */
-#define TRK0_ERR                0x02    /* couldn't find track 0 */
-#define EOM_ERR                 0x02    /* End Of Media (ATAPI) */
-#define ABRT_ERR                0x04    /* Command aborted */
-#define MCR_ERR                 0x08    /* media change request */
-#define ID_ERR                  0x10    /* ID field not found */
-#define MC_ERR                  0x20    /* media changed */
-#define ECC_ERR                 0x40    /* Uncorrectable ECC error */
-#define BBD_ERR                 0x80    /* pre-EIDE meaning:  block marked bad */
-#define ICRC_ERR                0x80    /* new meaning:  CRC error during transfer */
-#define LFS_ERR                 0xf0    /* Last Failed Sense (ATAPI) */
-
-/* Bits of HD_NSECTOR */
-#define CD                      0x01
-#define IO                      0x02
-#define REL                     0x04
-#define TAG_MASK                0xf8
-#endif /* __KERNEL__ */
-
 #include <linux/types.h>
 
 /*
@@ -191,6 +129,7 @@ typedef struct hd_drive_hob_hdr {
 #define TASKFILE_INVALID                0x7fff
 #endif
 
+#ifndef __KERNEL__
 /* ATA/ATAPI Commands pre T13 Spec */
 #define WIN_NOP                         0x00
 /*
@@ -379,6 +318,7 @@ typedef struct hd_drive_hob_hdr {
 #define SECURITY_ERASE_UNIT             0xBD
 #define SECURITY_FREEZE_LOCK            0xBE
 #define SECURITY_DISABLE_PASSWORD       0xBF
+#endif /* __KERNEL__ */
 
 struct hd_geometry {
       unsigned char heads;
@@ -448,6 +388,7 @@ enum {
 
 #define __NEW_HD_DRIVE_ID
 
+#ifndef __KERNEL__
 /*
  * Structure returned by HDIO_GET_IDENTITY, as per ANSI NCITS ATA6 rev.1b spec.
  *
@@ -699,6 +640,7 @@ struct hd_driveid {
                                          *  7:0 Signature
                                          */
 };
+#endif /* __KERNEL__ */
 
 /*
  * IDE "nice" flags. These are used on a per drive basis to determine
diff --git a/include/linux/hid.h b/include/linux/hid.h
index fa8ee9cef7be..a72876e43589 100644
--- a/include/linux/hid.h
+++ b/include/linux/hid.h
@@ -270,6 +270,7 @@ struct hid_item {
 
 #define HID_QUIRK_INVERT                        0x00000001
 #define HID_QUIRK_NOTOUCH                       0x00000002
+#define HID_QUIRK_IGNORE                        0x00000004
 #define HID_QUIRK_NOGET                         0x00000008
 #define HID_QUIRK_BADPAD                        0x00000020
 #define HID_QUIRK_MULTI_INPUT                   0x00000040
@@ -603,12 +604,17 @@ struct hid_ll_driver {
         int (*open)(struct hid_device *hdev);
         void (*close)(struct hid_device *hdev);
 
+        int (*power)(struct hid_device *hdev, int level);
+
         int (*hidinput_input_event) (struct input_dev *idev, unsigned int type,
                         unsigned int code, int value);
 
         int (*parse)(struct hid_device *hdev);
 };
 
+#define PM_HINT_FULLON  1<<5
+#define PM_HINT_NORMAL  1<<1
+
 /* Applications from HID Usage Tables 4/8/99 Version 1.1 */
 /* We ignore a few input applications that are not widely used */
 #define IS_INPUT_APPLICATION(a) (((a >= 0x00010000) && (a <= 0x00010008)) || (a == 0x00010080) || (a == 0x000c0001) || (a == 0x000d0002))
@@ -641,6 +647,7 @@ int hidinput_find_field(struct hid_device *hid, unsigned int type, unsigned int
 void hid_output_report(struct hid_report *report, __u8 *data);
 struct hid_device *hid_allocate_device(void);
 int hid_parse_report(struct hid_device *hid, __u8 *start, unsigned size);
+int hid_check_keys_pressed(struct hid_device *hid);
 int hid_connect(struct hid_device *hid, unsigned int connect_mask);
 
 /**
@@ -791,21 +798,5 @@ dbg_hid(const char *fmt, ...)
                 __FILE__ , ## arg)
 #endif /* HID_FF */
 
-#ifdef __KERNEL__
-#ifdef CONFIG_HID_COMPAT
-#define HID_COMPAT_LOAD_DRIVER(name)    \
-/* prototype to avoid sparse warning */ \
-extern void hid_compat_##name(void);    \
-void hid_compat_##name(void) { }        \
-EXPORT_SYMBOL(hid_compat_##name)
-#else
-#define HID_COMPAT_LOAD_DRIVER(name)
-#endif /* HID_COMPAT */
-#define HID_COMPAT_CALL_DRIVER(name)    do {    \
-        extern void hid_compat_##name(void);    \
-        hid_compat_##name();                    \
-} while (0)
-#endif /* __KERNEL__ */
-
 #endif
 
diff --git a/include/linux/highmem.h b/include/linux/highmem.h
index 13875ce9112a..1fcb7126a01f 100644
--- a/include/linux/highmem.h
+++ b/include/linux/highmem.h
@@ -19,8 +19,21 @@ static inline void flush_kernel_dcache_page(struct page *page)
 }
 #endif
 
-#ifdef CONFIG_HIGHMEM
+#include <asm/kmap_types.h>
+
+#if defined(CONFIG_DEBUG_HIGHMEM) && defined(CONFIG_TRACE_IRQFLAGS_SUPPORT)
+
+void debug_kmap_atomic(enum km_type type);
 
+#else
+
+static inline void debug_kmap_atomic(enum km_type type)
+{
+}
+
+#endif
+
+#ifdef CONFIG_HIGHMEM
 #include <asm/highmem.h>
 
 /* declarations for linux/mm/highmem.c */
@@ -44,8 +57,6 @@ static inline void *kmap(struct page *page)
 
 #define kunmap(page) do { (void) (page); } while (0)
 
-#include <asm/kmap_types.h>
-
 static inline void *kmap_atomic(struct page *page, enum km_type idx)
 {
         pagefault_disable();
diff --git a/include/linux/hrtimer.h b/include/linux/hrtimer.h
index bd37078c2d7d..0d2f7c8a33d6 100644
--- a/include/linux/hrtimer.h
+++ b/include/linux/hrtimer.h
@@ -336,6 +336,11 @@ extern int hrtimer_start(struct hrtimer *timer, ktime_t tim,
                          const enum hrtimer_mode mode);
 extern int hrtimer_start_range_ns(struct hrtimer *timer, ktime_t tim,
                         unsigned long range_ns, const enum hrtimer_mode mode);
+extern int
+__hrtimer_start_range_ns(struct hrtimer *timer, ktime_t tim,
+                         unsigned long delta_ns,
+                         const enum hrtimer_mode mode, int wakeup);
+
 extern int hrtimer_cancel(struct hrtimer *timer);
 extern int hrtimer_try_to_cancel(struct hrtimer *timer);
 
diff --git a/include/linux/i2c-algo-sgi.h b/include/linux/i2c-algo-sgi.h
deleted file mode 100644
index 3b7715024e69..000000000000
--- a/include/linux/i2c-algo-sgi.h
+++ /dev/null
@@ -1,26 +0,0 @@
-/*
- * This file is subject to the terms and conditions of the GNU General Public
- * License version 2 as published by the Free Software Foundation.
- *
- * Copyright (C) 2003 Ladislav Michl <ladis@linux-mips.org>
- */
-
-#ifndef I2C_ALGO_SGI_H
-#define I2C_ALGO_SGI_H 1
-
-#include <linux/i2c.h>
-
-struct i2c_algo_sgi_data {
-        void *data;     /* private data for lowlevel routines */
-        unsigned (*getctrl)(void *data);
-        void (*setctrl)(void *data, unsigned val);
-        unsigned (*rdata)(void *data);
-        void (*wdata)(void *data, unsigned val);
-
-        int xfer_timeout;
-        int ack_timeout;
-};
-
-int i2c_sgi_add_bus(struct i2c_adapter *);
-
-#endif /* I2C_ALGO_SGI_H */
diff --git a/include/linux/i2c-id.h b/include/linux/i2c-id.h
index 1ffc23bc5d1e..c9087de5c6c6 100644
--- a/include/linux/i2c-id.h
+++ b/include/linux/i2c-id.h
@@ -33,46 +33,10 @@
 
 #define I2C_DRIVERID_MSP3400     1
 #define I2C_DRIVERID_TUNER       2
-#define I2C_DRIVERID_TEA6420     5      /* audio matrix switch          */
-#define I2C_DRIVERID_TEA6415C    6      /* video matrix switch          */
-#define I2C_DRIVERID_TDA9840     7      /* stereo sound processor       */
-#define I2C_DRIVERID_SAA7111A    8      /* video input processor        */
-#define I2C_DRIVERID_SAA7185B   13      /* video encoder                */
-#define I2C_DRIVERID_SAA7110    22      /* video decoder                */
-#define I2C_DRIVERID_SAA5249    24      /* SAA5249 and compatibles      */
 #define I2C_DRIVERID_TDA7432    27      /* Stereo sound processor       */
 #define I2C_DRIVERID_TVAUDIO    29      /* Generic TV sound driver      */
-#define I2C_DRIVERID_TDA9875    32      /* TV sound decoder chip        */
-#define I2C_DRIVERID_BT819      40     /* video decoder                 */
-#define I2C_DRIVERID_BT856      41     /* video encoder                 */
-#define I2C_DRIVERID_VPX3220    42     /* video decoder+vbi/vtxt        */
-#define I2C_DRIVERID_ADV7175    48     /* ADV 7175/7176 video encoder   */
-#define I2C_DRIVERID_SAA7114    49      /* video decoder                */
-#define I2C_DRIVERID_ADV7170    54      /* video encoder                */
-#define I2C_DRIVERID_SAA7191    57      /* video decoder                */
-#define I2C_DRIVERID_INDYCAM    58      /* SGI IndyCam                  */
-#define I2C_DRIVERID_OVCAMCHIP  61      /* OmniVision CMOS image sens.  */
-#define I2C_DRIVERID_SAA6752HS  67      /* MPEG2 encoder                */
-#define I2C_DRIVERID_TVEEPROM   68      /* TV EEPROM                    */
-#define I2C_DRIVERID_WM8775     69      /* wm8775 audio processor       */
-#define I2C_DRIVERID_CS53L32A   70      /* cs53l32a audio processor     */
-#define I2C_DRIVERID_CX25840    71      /* cx2584x video encoder        */
-#define I2C_DRIVERID_SAA7127    72      /* saa7127 video encoder        */
 #define I2C_DRIVERID_SAA711X    73      /* saa711x video encoders       */
 #define I2C_DRIVERID_INFRARED   75      /* I2C InfraRed on Video boards */
-#define I2C_DRIVERID_TVP5150    76      /* TVP5150 video decoder        */
-#define I2C_DRIVERID_WM8739     77      /* wm8739 audio processor       */
-#define I2C_DRIVERID_UPD64083   78      /* upd64083 video processor     */
-#define I2C_DRIVERID_UPD64031A  79      /* upd64031a video processor    */
-#define I2C_DRIVERID_SAA717X    80      /* saa717x video encoder        */
-#define I2C_DRIVERID_BT866      85      /* Conexant bt866 video encoder */
-#define I2C_DRIVERID_KS0127     86      /* Samsung ks0127 video decoder */
-#define I2C_DRIVERID_TLV320AIC23B 87    /* TI TLV320AIC23B audio codec  */
-#define I2C_DRIVERID_VP27SMPX   93      /* Panasonic VP27s tuner internal MPX */
-#define I2C_DRIVERID_M52790     95      /* Mitsubishi M52790SP/FP AV switch */
-#define I2C_DRIVERID_CS5345     96      /* cs5345 audio processor       */
-
-#define I2C_DRIVERID_OV7670 1048        /* Omnivision 7670 camera */
 
 /*
  * ---- Adapter types ----------------------------------------------------
@@ -87,6 +51,8 @@
 #define I2C_HW_B_CX2341X        0x010020 /* Conexant CX2341X MPEG encoder cards */
 #define I2C_HW_B_CX23885        0x010022 /* conexant 23885 based tv cards (bus1) */
 #define I2C_HW_B_AU0828         0x010023 /* auvitek au0828 usb bridge */
+#define I2C_HW_B_CX231XX        0x010024 /* Conexant CX231XX USB based cards */
+#define I2C_HW_B_HDPVR          0x010025 /* Hauppauge HD PVR */
 
 /* --- SGI adapters                                                     */
 #define I2C_HW_SGI_VINO         0x160000
diff --git a/include/linux/i2c.h b/include/linux/i2c.h
index c86c3b07604c..ad2580596033 100644
--- a/include/linux/i2c.h
+++ b/include/linux/i2c.h
@@ -274,7 +274,7 @@ struct i2c_board_info {
  * are provided using conventional syntax.
  */
 #define I2C_BOARD_INFO(dev_type, dev_addr) \
-        .type = (dev_type), .addr = (dev_addr)
+        .type = dev_type, .addr = (dev_addr)
 
 
 /* Add-on boards should register/unregister their devices; e.g. a board
@@ -353,8 +353,8 @@ struct i2c_adapter {
         void *algo_data;
 
         /* --- administration stuff. */
-        int (*client_register)(struct i2c_client *);
-        int (*client_unregister)(struct i2c_client *);
+        int (*client_register)(struct i2c_client *) __deprecated;
+        int (*client_unregister)(struct i2c_client *) __deprecated;
 
         /* data fields that are valid for all devices   */
         u8 level;                       /* nesting level for lockdep */
diff --git a/include/linux/i2c/at24.h b/include/linux/i2c/at24.h
index f6edd522a929..8ace93024d60 100644
--- a/include/linux/i2c/at24.h
+++ b/include/linux/i2c/at24.h
@@ -2,6 +2,7 @@
 #define _LINUX_AT24_H
 
 #include <linux/types.h>
+#include <linux/memory.h>
 
 /*
  * As seen through Linux I2C, differences between the most common types of I2C
@@ -23,6 +24,9 @@ struct at24_platform_data {
 #define AT24_FLAG_READONLY      0x40    /* sysfs-entry will be read-only */
 #define AT24_FLAG_IRUGO         0x20    /* sysfs-entry will be world-readable */
 #define AT24_FLAG_TAKE8ADDR     0x10    /* take always 8 addresses (24c00) */
+
+        void            (*setup)(struct memory_accessor *, void *context);
+        void            *context;
 };
 
 #endif /* _LINUX_AT24_H */
diff --git a/include/linux/i2c/s6000.h b/include/linux/i2c/s6000.h
new file mode 100644
index 000000000000..d9b34bfdae76
--- /dev/null
+++ b/include/linux/i2c/s6000.h
@@ -0,0 +1,10 @@
+#ifndef __LINUX_I2C_S6000_H
+#define __LINUX_I2C_S6000_H
+
+struct s6_i2c_platform_data {
+        const char *clock; /* the clock to use */
+        int bus_num; /* the bus number to register */
+};
+
+#endif
+
diff --git a/include/linux/i2c/twl4030.h b/include/linux/i2c/twl4030.h
index 8137f660a5cc..0dc80ef24975 100644
--- a/include/linux/i2c/twl4030.h
+++ b/include/linux/i2c/twl4030.h
@@ -218,6 +218,53 @@ int twl4030_i2c_read(u8 mod_no, u8 *value, u8 reg, unsigned num_bytes);
 
 /*----------------------------------------------------------------------*/
 
+/* Power bus message definitions */
+
+#define DEV_GRP_NULL            0x0
+#define DEV_GRP_P1              0x1
+#define DEV_GRP_P2              0x2
+#define DEV_GRP_P3              0x4
+
+#define RES_GRP_RES             0x0
+#define RES_GRP_PP              0x1
+#define RES_GRP_RC              0x2
+#define RES_GRP_PP_RC           0x3
+#define RES_GRP_PR              0x4
+#define RES_GRP_PP_PR           0x5
+#define RES_GRP_RC_PR           0x6
+#define RES_GRP_ALL             0x7
+
+#define RES_TYPE2_R0            0x0
+
+#define RES_TYPE_ALL            0x7
+
+#define RES_STATE_WRST          0xF
+#define RES_STATE_ACTIVE        0xE
+#define RES_STATE_SLEEP         0x8
+#define RES_STATE_OFF           0x0
+
+/*
+ * Power Bus Message Format ... these can be sent individually by Linux,
+ * but are usually part of downloaded scripts that are run when various
+ * power events are triggered.
+ *
+ *  Broadcast Message (16 Bits):
+ *    DEV_GRP[15:13] MT[12]  RES_GRP[11:9]  RES_TYPE2[8:7] RES_TYPE[6:4]
+ *    RES_STATE[3:0]
+ *
+ *  Singular Message (16 Bits):
+ *    DEV_GRP[15:13] MT[12]  RES_ID[11:4]  RES_STATE[3:0]
+ */
+
+#define MSG_BROADCAST(devgrp, grp, type, type2, state) \
+        ( (devgrp) << 13 | 1 << 12 | (grp) << 9 | (type2) << 7 \
+        | (type) << 4 | (state))
+
+#define MSG_SINGULAR(devgrp, id, state) \
+        ((devgrp) << 13 | 0 << 12 | (id) << 4 | (state))
+
+/*----------------------------------------------------------------------*/
+
 struct twl4030_bci_platform_data {
         int *battery_tmp_tbl;
         unsigned int tblsize;
diff --git a/include/linux/ide.h b/include/linux/ide.h
index 854eba8b2ba3..ff65fffb078f 100644
--- a/include/linux/ide.h
+++ b/include/linux/ide.h
@@ -40,6 +40,13 @@
 #define ERROR_RESET     3       /* Reset controller every 4th retry */
 #define ERROR_RECAL     1       /* Recalibrate every 2nd retry */
 
+/* Error codes returned in rq->errors to the higher part of the driver. */
+enum {
+        IDE_DRV_ERROR_GENERAL   = 101,
+        IDE_DRV_ERROR_FILEMARK  = 102,
+        IDE_DRV_ERROR_EOD       = 103,
+};
+
 /*
  * Definitions for accessing IDE controller registers
  */
@@ -193,26 +200,8 @@ static inline void ide_std_init_ports(hw_regs_t *hw,
         hw->io_ports.ctl_addr = ctl_addr;
 }
 
-#if defined(CONFIG_ARM) || defined(CONFIG_M68K) || defined(CONFIG_MIPS) || \
-    defined(CONFIG_PARISC) || defined(CONFIG_PPC) || defined(CONFIG_SPARC)
-#include <asm/ide.h>
-#else
-#include <asm-generic/ide_iops.h>
-#endif
-
 #define MAX_HWIFS       10
 
-/* Currently only m68k, apus and m8xx need it */
-#ifndef IDE_ARCH_ACK_INTR
-# define ide_ack_intr(hwif) (1)
-#endif
-
-/* Currently only Atari needs it */
-#ifndef IDE_ARCH_LOCK
-# define ide_release_lock()                     do {} while (0)
-# define ide_get_lock(hdlr, data)               do {} while (0)
-#endif /* IDE_ARCH_LOCK */
-
 /*
  * Now for the data we need to maintain per-drive:  ide_drive_t
  */
@@ -251,108 +240,92 @@ typedef enum {
 } ide_startstop_t;
 
 enum {
+        IDE_VALID_ERROR                 = (1 << 1),
+        IDE_VALID_FEATURE               = IDE_VALID_ERROR,
+        IDE_VALID_NSECT                 = (1 << 2),
+        IDE_VALID_LBAL                  = (1 << 3),
+        IDE_VALID_LBAM                  = (1 << 4),
+        IDE_VALID_LBAH                  = (1 << 5),
+        IDE_VALID_DEVICE                = (1 << 6),
+        IDE_VALID_LBA                   = IDE_VALID_LBAL |
+                                          IDE_VALID_LBAM |
+                                          IDE_VALID_LBAH,
+        IDE_VALID_OUT_TF                = IDE_VALID_FEATURE |
+                                          IDE_VALID_NSECT |
+                                          IDE_VALID_LBA,
+        IDE_VALID_IN_TF                 = IDE_VALID_NSECT |
+                                          IDE_VALID_LBA,
+        IDE_VALID_OUT_HOB               = IDE_VALID_OUT_TF,
+        IDE_VALID_IN_HOB                = IDE_VALID_ERROR |
+                                          IDE_VALID_NSECT |
+                                          IDE_VALID_LBA,
+};
+
+enum {
         IDE_TFLAG_LBA48                 = (1 << 0),
-        IDE_TFLAG_FLAGGED               = (1 << 2),
-        IDE_TFLAG_OUT_DATA              = (1 << 3),
-        IDE_TFLAG_OUT_HOB_FEATURE       = (1 << 4),
-        IDE_TFLAG_OUT_HOB_NSECT         = (1 << 5),
-        IDE_TFLAG_OUT_HOB_LBAL          = (1 << 6),
-        IDE_TFLAG_OUT_HOB_LBAM          = (1 << 7),
-        IDE_TFLAG_OUT_HOB_LBAH          = (1 << 8),
-        IDE_TFLAG_OUT_HOB               = IDE_TFLAG_OUT_HOB_FEATURE |
-                                          IDE_TFLAG_OUT_HOB_NSECT |
-                                          IDE_TFLAG_OUT_HOB_LBAL |
-                                          IDE_TFLAG_OUT_HOB_LBAM |
-                                          IDE_TFLAG_OUT_HOB_LBAH,
-        IDE_TFLAG_OUT_FEATURE           = (1 << 9),
-        IDE_TFLAG_OUT_NSECT             = (1 << 10),
-        IDE_TFLAG_OUT_LBAL              = (1 << 11),
-        IDE_TFLAG_OUT_LBAM              = (1 << 12),
-        IDE_TFLAG_OUT_LBAH              = (1 << 13),
-        IDE_TFLAG_OUT_TF                = IDE_TFLAG_OUT_FEATURE |
-                                          IDE_TFLAG_OUT_NSECT |
-                                          IDE_TFLAG_OUT_LBAL |
-                                          IDE_TFLAG_OUT_LBAM |
-                                          IDE_TFLAG_OUT_LBAH,
-        IDE_TFLAG_OUT_DEVICE            = (1 << 14),
-        IDE_TFLAG_WRITE                 = (1 << 15),
-        IDE_TFLAG_FLAGGED_SET_IN_FLAGS  = (1 << 16),
-        IDE_TFLAG_IN_DATA               = (1 << 17),
-        IDE_TFLAG_CUSTOM_HANDLER        = (1 << 18),
-        IDE_TFLAG_DMA_PIO_FALLBACK      = (1 << 19),
-        IDE_TFLAG_IN_HOB_FEATURE        = (1 << 20),
-        IDE_TFLAG_IN_HOB_NSECT          = (1 << 21),
-        IDE_TFLAG_IN_HOB_LBAL           = (1 << 22),
-        IDE_TFLAG_IN_HOB_LBAM           = (1 << 23),
-        IDE_TFLAG_IN_HOB_LBAH           = (1 << 24),
-        IDE_TFLAG_IN_HOB_LBA            = IDE_TFLAG_IN_HOB_LBAL |
-                                          IDE_TFLAG_IN_HOB_LBAM |
-                                          IDE_TFLAG_IN_HOB_LBAH,
-        IDE_TFLAG_IN_HOB                = IDE_TFLAG_IN_HOB_FEATURE |
-                                          IDE_TFLAG_IN_HOB_NSECT |
-                                          IDE_TFLAG_IN_HOB_LBA,
-        IDE_TFLAG_IN_FEATURE            = (1 << 1),
-        IDE_TFLAG_IN_NSECT              = (1 << 25),
-        IDE_TFLAG_IN_LBAL               = (1 << 26),
-        IDE_TFLAG_IN_LBAM               = (1 << 27),
-        IDE_TFLAG_IN_LBAH               = (1 << 28),
-        IDE_TFLAG_IN_LBA                = IDE_TFLAG_IN_LBAL |
-                                          IDE_TFLAG_IN_LBAM |
-                                          IDE_TFLAG_IN_LBAH,
-        IDE_TFLAG_IN_TF                 = IDE_TFLAG_IN_NSECT |
-                                          IDE_TFLAG_IN_LBA,
-        IDE_TFLAG_IN_DEVICE             = (1 << 29),
-        IDE_TFLAG_HOB                   = IDE_TFLAG_OUT_HOB |
-                                          IDE_TFLAG_IN_HOB,
-        IDE_TFLAG_TF                    = IDE_TFLAG_OUT_TF |
-                                          IDE_TFLAG_IN_TF,
-        IDE_TFLAG_DEVICE                = IDE_TFLAG_OUT_DEVICE |
-                                          IDE_TFLAG_IN_DEVICE,
+        IDE_TFLAG_WRITE                 = (1 << 1),
+        IDE_TFLAG_CUSTOM_HANDLER        = (1 << 2),
+        IDE_TFLAG_DMA_PIO_FALLBACK      = (1 << 3),
         /* force 16-bit I/O operations */
-        IDE_TFLAG_IO_16BIT              = (1 << 30),
-        /* ide_task_t was allocated using kmalloc() */
-        IDE_TFLAG_DYN                   = (1 << 31),
+        IDE_TFLAG_IO_16BIT              = (1 << 4),
+        /* struct ide_cmd was allocated using kmalloc() */
+        IDE_TFLAG_DYN                   = (1 << 5),
+        IDE_TFLAG_FS                    = (1 << 6),
+        IDE_TFLAG_MULTI_PIO             = (1 << 7),
 };
 
-struct ide_taskfile {
-        u8      hob_data;       /*  0: high data byte (for TASKFILE IOCTL) */
+enum {
+        IDE_FTFLAG_FLAGGED              = (1 << 0),
+        IDE_FTFLAG_SET_IN_FLAGS         = (1 << 1),
+        IDE_FTFLAG_OUT_DATA             = (1 << 2),
+        IDE_FTFLAG_IN_DATA              = (1 << 3),
+};
 
-        u8      hob_feature;    /*  1-5: additional data to support LBA48 */
-        u8      hob_nsect;
-        u8      hob_lbal;
-        u8      hob_lbam;
-        u8      hob_lbah;
+struct ide_taskfile {
+        u8      data;           /* 0: data byte (for TASKFILE ioctl) */
+        union {                 /* 1: */
+                u8 error;       /*  read: error */
+                u8 feature;     /* write: feature */
+        };
+        u8      nsect;          /* 2: number of sectors */
+        u8      lbal;           /* 3: LBA low */
+        u8      lbam;           /* 4: LBA mid */
+        u8      lbah;           /* 5: LBA high */
+        u8      device;         /* 6: device select */
+        union {                 /* 7: */
+                u8 status;      /*  read: status */
+                u8 command;     /* write: command */
+        };
+};
 
-        u8      data;           /*  6: low data byte (for TASKFILE IOCTL) */
+struct ide_cmd {
+        struct ide_taskfile     tf;
+        struct ide_taskfile     hob;
+        struct {
+                struct {
+                        u8              tf;
+                        u8              hob;
+                } out, in;
+        } valid;
 
-        union {                 /*  7: */
-                u8 error;       /*   read:  error */
-                u8 feature;     /*  write: feature */
-        };
+        u8                      tf_flags;
+        u8                      ftf_flags;      /* for TASKFILE ioctl */
+        int                     protocol;
 
-        u8      nsect;          /*  8: number of sectors */
-        u8      lbal;           /*  9: LBA low */
-        u8      lbam;           /* 10: LBA mid */
-        u8      lbah;           /* 11: LBA high */
+        int                     sg_nents;         /* number of sg entries */
+        int                     orig_sg_nents;
+        int                     sg_dma_direction; /* DMA transfer direction */
 
-        u8      device;         /* 12: device select */
+        unsigned int            nbytes;
+        unsigned int            nleft;
+        unsigned int            last_xfer_len;
 
-        union {                 /* 13: */
-                u8 status;      /*  read: status  */
-                u8 command;     /* write: command */
-        };
-};
+        struct scatterlist      *cursg;
+        unsigned int            cursg_ofs;
 
-typedef struct ide_task_s {
-        union {
-                struct ide_taskfile     tf;
-                u8                      tf_array[14];
-        };
-        u32                     tf_flags;
-        int                     data_phase;
         struct request          *rq;            /* copy of request */
         void                    *special;       /* valid_t generally */
-} ide_task_t;
+};
 
 /* ATAPI packet command flags */
 enum {
@@ -364,15 +337,13 @@ enum {
         PC_FLAG_DMA_IN_PROGRESS         = (1 << 4),
         PC_FLAG_DMA_ERROR               = (1 << 5),
         PC_FLAG_WRITING                 = (1 << 6),
-        /* command timed out */
-        PC_FLAG_TIMEDOUT                = (1 << 7),
 };
 
 /*
  * With each packet command, we allocate a buffer of IDE_PC_BUFFER_SIZE bytes.
  * This is used for several packet commands (not for READ/WRITE commands).
  */
-#define IDE_PC_BUFFER_SIZE      256
+#define IDE_PC_BUFFER_SIZE      64
 #define ATAPI_WAIT_PC           (60 * HZ)
 
 struct ide_atapi_pc {
@@ -410,9 +381,6 @@ struct ide_atapi_pc {
         struct idetape_bh *bh;
         char *b_data;
 
-        struct scatterlist *sg;
-        unsigned int sg_cnt;
-
         unsigned long timeout;
 };
 
@@ -436,7 +404,6 @@ struct ide_disk_ops {
                                         int);
         ide_startstop_t (*do_request)(struct ide_drive_s *, struct request *,
                                       sector_t);
-        int             (*end_request)(struct ide_drive_s *, int, int);
         int             (*ioctl)(struct ide_drive_s *, struct block_device *,
                                  fmode_t, unsigned int, unsigned long);
 };
@@ -454,11 +421,6 @@ enum {
         IDE_AFLAG_TOCADDR_AS_BCD        = (1 << 3),
         /* TOC track numbers are in BCD. */
         IDE_AFLAG_TOCTRACKS_AS_BCD      = (1 << 4),
-        /*
-         * Drive does not provide data in multiples of SECTOR_SIZE
-         * when more than one interrupt is needed.
-         */
-        IDE_AFLAG_LIMIT_NFRAMES         = (1 << 5),
         /* Saved TOC information is current. */
         IDE_AFLAG_TOC_VALID             = (1 << 6),
         /* We think that the drive door is locked. */
@@ -512,8 +474,6 @@ enum {
         IDE_DFLAG_NICE1                 = (1 << 5),
         /* device is physically present */
         IDE_DFLAG_PRESENT               = (1 << 6),
-        /* device ejected hint */
-        IDE_DFLAG_DEAD                  = (1 << 7),
         /* id read from device (synthetic if not set) */
         IDE_DFLAG_ID_READ               = (1 << 8),
         IDE_DFLAG_NOPROBE               = (1 << 9),
@@ -605,7 +565,7 @@ struct ide_drive_s {
 
         unsigned int    bios_cyl;       /* BIOS/fdisk/LILO number of cyls */
         unsigned int    cyl;            /* "real" number of cyls */
-        unsigned int    drive_data;     /* used by set_pio_mode/selectproc */
+        unsigned int    drive_data;     /* used by set_pio_mode/dev_select() */
         unsigned int    failures;       /* current failure count */
         unsigned int    max_failures;   /* maximum allowed failure count */
         u64             probed_capacity;/* initial reported media capacity (ide-cd only currently) */
@@ -627,8 +587,11 @@ struct ide_drive_s {
         /* current packet command */
         struct ide_atapi_pc *pc;
 
+        /* last failed packet command */
+        struct ide_atapi_pc *failed_pc;
+
         /* callback for packet commands */
-        void (*pc_callback)(struct ide_drive_s *, int);
+        int  (*pc_callback)(struct ide_drive_s *, int);
 
         void (*pc_update_buffers)(struct ide_drive_s *, struct ide_atapi_pc *);
         int  (*pc_io_buffers)(struct ide_drive_s *, struct ide_atapi_pc *,
@@ -658,16 +621,16 @@ struct ide_tp_ops {
         void    (*exec_command)(struct hwif_s *, u8);
         u8      (*read_status)(struct hwif_s *);
         u8      (*read_altstatus)(struct hwif_s *);
+        void    (*write_devctl)(struct hwif_s *, u8);
 
-        void    (*set_irq)(struct hwif_s *, int);
+        void    (*dev_select)(ide_drive_t *);
+        void    (*tf_load)(ide_drive_t *, struct ide_taskfile *, u8);
+        void    (*tf_read)(ide_drive_t *, struct ide_taskfile *, u8);
 
-        void    (*tf_load)(ide_drive_t *, struct ide_task_s *);
-        void    (*tf_read)(ide_drive_t *, struct ide_task_s *);
-
-        void    (*input_data)(ide_drive_t *, struct request *, void *,
-                              unsigned int);
-        void    (*output_data)(ide_drive_t *, struct request *, void *,
-                               unsigned int);
+        void    (*input_data)(ide_drive_t *, struct ide_cmd *,
+                              void *, unsigned int);
+        void    (*output_data)(ide_drive_t *, struct ide_cmd *,
+                               void *, unsigned int);
 };
 
 extern const struct ide_tp_ops default_tp_ops;
@@ -678,7 +641,6 @@ extern const struct ide_tp_ops default_tp_ops;
  * @init_dev:           host specific initialization of a device
  * @set_pio_mode:       routine to program host for PIO mode
  * @set_dma_mode:       routine to program host for DMA mode
- * @selectproc:         tweaks hardware to select drive
  * @reset_poll:         chipset polling based on hba specifics
  * @pre_reset:          chipset specific changes to default for device-hba resets
  * @resetproc:          routine to reset controller after a disk reset
@@ -695,7 +657,6 @@ struct ide_port_ops {
         void    (*init_dev)(ide_drive_t *);
         void    (*set_pio_mode)(ide_drive_t *, const u8);
         void    (*set_dma_mode)(ide_drive_t *, const u8);
-        void    (*selectproc)(ide_drive_t *);
         int     (*reset_poll)(ide_drive_t *);
         void    (*pre_reset)(ide_drive_t *);
         void    (*resetproc)(ide_drive_t *);
@@ -711,13 +672,15 @@ struct ide_port_ops {
 
 struct ide_dma_ops {
         void    (*dma_host_set)(struct ide_drive_s *, int);
-        int     (*dma_setup)(struct ide_drive_s *);
-        void    (*dma_exec_cmd)(struct ide_drive_s *, u8);
+        int     (*dma_setup)(struct ide_drive_s *, struct ide_cmd *);
         void    (*dma_start)(struct ide_drive_s *);
         int     (*dma_end)(struct ide_drive_s *);
         int     (*dma_test_irq)(struct ide_drive_s *);
         void    (*dma_lost_irq)(struct ide_drive_s *);
-        void    (*dma_timeout)(struct ide_drive_s *);
+        /* below ones are optional */
+        int     (*dma_check)(struct ide_drive_s *, struct ide_cmd *);
+        int     (*dma_timer_expiry)(struct ide_drive_s *);
+        void    (*dma_clear)(struct ide_drive_s *);
         /*
          * The following method is optional and only required to be
          * implemented for the SFF-8038i compatible controllers.
@@ -780,19 +743,8 @@ typedef struct hwif_s {
         /* Scatter-gather list used to build the above */
         struct scatterlist *sg_table;
         int sg_max_nents;               /* Maximum number of entries in it */
-        int sg_nents;                   /* Current number of entries in it */
-        int orig_sg_nents;
-        int sg_dma_direction;           /* dma transfer direction */
-
-        /* data phase of the active command (currently only valid for PIO/DMA) */
-        int             data_phase;
-
-        struct ide_task_s task;         /* current command */
 
-        unsigned int nsect;
-        unsigned int nleft;
-        struct scatterlist *cursg;
-        unsigned int cursg_ofs;
+        struct ide_cmd cmd;             /* current command */
 
         int             rqsize;         /* max sectors per request */
         int             irq;            /* our irq number */
@@ -850,9 +802,18 @@ struct ide_host {
         ide_hwif_t      *ports[MAX_HOST_PORTS + 1];
         unsigned int    n_ports;
         struct device   *dev[2];
+
         int             (*init_chipset)(struct pci_dev *);
+
+        void            (*get_lock)(irq_handler_t, void *);
+        void            (*release_lock)(void);
+
         irq_handler_t   irq_handler;
+
         unsigned long   host_flags;
+
+        int             irq_flags;
+
         void            *host_priv;
         ide_hwif_t      *cur_port;      /* for hosts requiring serialization */
 
@@ -869,7 +830,7 @@ typedef ide_startstop_t (ide_handler_t)(ide_drive_t *);
 typedef int (ide_expiry_t)(ide_drive_t *);
 
 /* used by ide-cd, ide-floppy, etc. */
-typedef void (xfer_func_t)(ide_drive_t *, struct request *rq, void *, unsigned);
+typedef void (xfer_func_t)(ide_drive_t *, struct ide_cmd *, void *, unsigned);
 
 extern struct mutex ide_setting_mtx;
 
@@ -1045,10 +1006,11 @@ enum {
 };
 
 /* DRV_NAME has to be defined in the driver before using the macro below */
-#define __ide_debug_log(lvl, fmt, args...)                      \
-{                                                               \
-        if (unlikely(drive->debug_mask & lvl))                  \
-                printk(KERN_INFO DRV_NAME ": " fmt, ## args);   \
+#define __ide_debug_log(lvl, fmt, args...)                              \
+{                                                                       \
+        if (unlikely(drive->debug_mask & lvl))                          \
+                printk(KERN_INFO DRV_NAME ": %s: " fmt "\n",            \
+                                          __func__, ## args);           \
 }
 
 /*
@@ -1087,7 +1049,7 @@ int generic_ide_resume(struct device *);
 
 void ide_complete_power_step(ide_drive_t *, struct request *);
 ide_startstop_t ide_start_power_step(ide_drive_t *, struct request *);
-void ide_complete_pm_request(ide_drive_t *, struct request *);
+void ide_complete_pm_rq(ide_drive_t *, struct request *);
 void ide_check_pm_state(ide_drive_t *, struct request *);
 
 /*
@@ -1099,7 +1061,6 @@ void ide_check_pm_state(ide_drive_t *, struct request *);
 struct ide_driver {
         const char                      *version;
         ide_startstop_t (*do_request)(ide_drive_t *, struct request *, sector_t);
-        int             (*end_request)(ide_drive_t *, int, int);
         struct device_driver    gen_driver;
         int             (*probe)(ide_drive_t *);
         void            (*remove)(ide_drive_t *);
@@ -1130,19 +1091,15 @@ int generic_ide_ioctl(ide_drive_t *, struct block_device *, unsigned, unsigned l
 extern int ide_vlb_clk;
 extern int ide_pci_clk;
 
-int ide_end_request(ide_drive_t *, int, int);
-int ide_end_dequeued_request(ide_drive_t *, struct request *, int, int);
+unsigned int ide_rq_bytes(struct request *);
+int ide_end_rq(ide_drive_t *, struct request *, int, unsigned int);
 void ide_kill_rq(ide_drive_t *, struct request *);
 
-void __ide_set_handler(ide_drive_t *, ide_handler_t *, unsigned int,
-                       ide_expiry_t *);
-void ide_set_handler(ide_drive_t *, ide_handler_t *, unsigned int,
-                     ide_expiry_t *);
+void __ide_set_handler(ide_drive_t *, ide_handler_t *, unsigned int);
+void ide_set_handler(ide_drive_t *, ide_handler_t *, unsigned int);
 
-void ide_execute_command(ide_drive_t *, u8, ide_handler_t *, unsigned int,
-                         ide_expiry_t *);
-
-void ide_execute_pkt_cmd(ide_drive_t *);
+void ide_execute_command(ide_drive_t *, struct ide_cmd *, ide_handler_t *,
+                         unsigned int);
 
 void ide_pad_transfer(ide_drive_t *, int, int);
 
@@ -1164,25 +1121,24 @@ extern ide_startstop_t ide_do_reset (ide_drive_t *);
 extern int ide_devset_execute(ide_drive_t *drive,
                               const struct ide_devset *setting, int arg);
 
-extern void ide_end_drive_cmd(ide_drive_t *, u8, u8);
+void ide_complete_cmd(ide_drive_t *, struct ide_cmd *, u8, u8);
+int ide_complete_rq(ide_drive_t *, int, unsigned int);
 
-void ide_tf_dump(const char *, struct ide_taskfile *);
+void ide_tf_readback(ide_drive_t *drive, struct ide_cmd *cmd);
+void ide_tf_dump(const char *, struct ide_cmd *);
 
 void ide_exec_command(ide_hwif_t *, u8);
 u8 ide_read_status(ide_hwif_t *);
 u8 ide_read_altstatus(ide_hwif_t *);
+void ide_write_devctl(ide_hwif_t *, u8);
 
-void ide_set_irq(ide_hwif_t *, int);
-
-void ide_tf_load(ide_drive_t *, ide_task_t *);
-void ide_tf_read(ide_drive_t *, ide_task_t *);
-
-void ide_input_data(ide_drive_t *, struct request *, void *, unsigned int);
-void ide_output_data(ide_drive_t *, struct request *, void *, unsigned int);
+void ide_dev_select(ide_drive_t *);
+void ide_tf_load(ide_drive_t *, struct ide_taskfile *, u8);
+void ide_tf_read(ide_drive_t *, struct ide_taskfile *, u8);
 
-int ide_io_buffers(ide_drive_t *, struct ide_atapi_pc *, unsigned int, int);
+void ide_input_data(ide_drive_t *, struct ide_cmd *, void *, unsigned int);
+void ide_output_data(ide_drive_t *, struct ide_cmd *, void *, unsigned int);
 
-extern void SELECT_DRIVE(ide_drive_t *);
 void SELECT_MASK(ide_drive_t *, int);
 
 u8 ide_read_error(ide_drive_t *);
@@ -1224,16 +1180,18 @@ int ide_cd_expiry(ide_drive_t *);
 
 int ide_cd_get_xferlen(struct request *);
 
-ide_startstop_t ide_issue_pc(ide_drive_t *);
+ide_startstop_t ide_issue_pc(ide_drive_t *, struct ide_cmd *);
 
-ide_startstop_t do_rw_taskfile(ide_drive_t *, ide_task_t *);
+ide_startstop_t do_rw_taskfile(ide_drive_t *, struct ide_cmd *);
 
-void task_end_request(ide_drive_t *, struct request *, u8);
+void ide_pio_bytes(ide_drive_t *, struct ide_cmd *, unsigned int, unsigned int);
 
-int ide_raw_taskfile(ide_drive_t *, ide_task_t *, u8 *, u16);
-int ide_no_data_taskfile(ide_drive_t *, ide_task_t *);
+void ide_finish_cmd(ide_drive_t *, struct ide_cmd *, u8);
 
-int ide_taskfile_ioctl(ide_drive_t *, unsigned int, unsigned long);
+int ide_raw_taskfile(ide_drive_t *, struct ide_cmd *, u8 *, u16);
+int ide_no_data_taskfile(ide_drive_t *, struct ide_cmd *);
+
+int ide_taskfile_ioctl(ide_drive_t *, unsigned long);
 
 int ide_dev_read_id(ide_drive_t *, u8, u16 *);
 
@@ -1335,6 +1293,10 @@ enum {
         IDE_HFLAG_ERROR_STOPS_FIFO      = (1 << 19),
         /* serialize ports */
         IDE_HFLAG_SERIALIZE             = (1 << 20),
+        /* host is DTC2278 */
+        IDE_HFLAG_DTC2278               = (1 << 21),
+        /* 4 devices on a single set of I/O ports */
+        IDE_HFLAG_4DRIVES               = (1 << 22),
         /* host is TRM290 */
         IDE_HFLAG_TRM290                = (1 << 23),
         /* use 32-bit I/O ops */
@@ -1362,7 +1324,12 @@ enum {
 
 struct ide_port_info {
         char                    *name;
+
         int                     (*init_chipset)(struct pci_dev *);
+
+        void                    (*get_lock)(irq_handler_t, void *);
+        void                    (*release_lock)(void);
+
         void                    (*init_iops)(ide_hwif_t *);
         void                    (*init_hwif)(ide_hwif_t *);
         int                     (*init_dma)(ide_hwif_t *,
@@ -1379,6 +1346,9 @@ struct ide_port_info {
         u16                     max_sectors;    /* if < than the default one */
 
         u32                     host_flags;
+
+        int                     irq_flags;
+
         u8                      pio_mask;
         u8                      swdma_mask;
         u8                      mwdma_mask;
@@ -1398,8 +1368,8 @@ int ide_pci_resume(struct pci_dev *);
 #define ide_pci_resume NULL
 #endif
 
-void ide_map_sg(ide_drive_t *, struct request *);
-void ide_init_sg_cmd(ide_drive_t *, struct request *);
+void ide_map_sg(ide_drive_t *, struct ide_cmd *);
+void ide_init_sg_cmd(struct ide_cmd *, unsigned int);
 
 #define BAD_DMA_DRIVE           0
 #define GOOD_DMA_DRIVE          1
@@ -1433,18 +1403,18 @@ ide_startstop_t ide_dma_intr(ide_drive_t *);
 int ide_allocate_dma_engine(ide_hwif_t *);
 void ide_release_dma_engine(ide_hwif_t *);
 
-int ide_build_sglist(ide_drive_t *, struct request *);
-void ide_destroy_dmatable(ide_drive_t *);
+int ide_dma_prepare(ide_drive_t *, struct ide_cmd *);
+void ide_dma_unmap_sg(ide_drive_t *, struct ide_cmd *);
 
 #ifdef CONFIG_BLK_DEV_IDEDMA_SFF
 int config_drive_for_dma(ide_drive_t *);
-extern int ide_build_dmatable(ide_drive_t *, struct request *);
+int ide_build_dmatable(ide_drive_t *, struct ide_cmd *);
 void ide_dma_host_set(ide_drive_t *, int);
-extern int ide_dma_setup(ide_drive_t *);
-void ide_dma_exec_cmd(ide_drive_t *, u8);
+int ide_dma_setup(ide_drive_t *, struct ide_cmd *);
 extern void ide_dma_start(ide_drive_t *);
 int ide_dma_end(ide_drive_t *);
 int ide_dma_test_irq(ide_drive_t *);
+int ide_dma_sff_timer_expiry(ide_drive_t *);
 u8 ide_dma_sff_read_status(ide_hwif_t *);
 extern const struct ide_dma_ops sff_dma_ops;
 #else
@@ -1452,7 +1422,6 @@ static inline int config_drive_for_dma(ide_drive_t *drive) { return 0; }
 #endif /* CONFIG_BLK_DEV_IDEDMA_SFF */
 
 void ide_dma_lost_irq(ide_drive_t *);
-void ide_dma_timeout(ide_drive_t *);
 ide_startstop_t ide_dma_timeout_retry(ide_drive_t *, int);
 
 #else
@@ -1465,8 +1434,13 @@ static inline void ide_dma_on(ide_drive_t *drive) { ; }
 static inline void ide_dma_verbose(ide_drive_t *drive) { ; }
 static inline int ide_set_dma(ide_drive_t *drive) { return 1; }
 static inline void ide_check_dma_crc(ide_drive_t *drive) { ; }
+static inline ide_startstop_t ide_dma_intr(ide_drive_t *drive) { return ide_stopped; }
 static inline ide_startstop_t ide_dma_timeout_retry(ide_drive_t *drive, int error) { return ide_stopped; }
 static inline void ide_release_dma_engine(ide_hwif_t *hwif) { ; }
+static inline int ide_dma_prepare(ide_drive_t *drive,
+                                  struct ide_cmd *cmd) { return 1; }
+static inline void ide_dma_unmap_sg(ide_drive_t *drive,
+                                    struct ide_cmd *cmd) { ; }
 #endif /* CONFIG_BLK_DEV_IDEDMA */
 
 #ifdef CONFIG_BLK_DEV_IDEACPI
@@ -1518,7 +1492,7 @@ static inline void ide_set_hwifdata (ide_hwif_t * hwif, void *data)
 
 extern void ide_toggle_bounce(ide_drive_t *drive, int on);
 
-u64 ide_get_lba_addr(struct ide_taskfile *, int);
+u64 ide_get_lba_addr(struct ide_cmd *, int);
 u8 ide_dump_status(ide_drive_t *, const char *, u8);
 
 struct ide_timing {
diff --git a/include/linux/idr.h b/include/linux/idr.h
index dd846df8cd32..e968db71e33a 100644
--- a/include/linux/idr.h
+++ b/include/linux/idr.h
@@ -106,6 +106,7 @@ 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_get_next(struct idr *idp, int *nextid);
 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);
diff --git a/include/linux/init.h b/include/linux/init.h
index 68cb0265d009..0e06c176f185 100644
--- a/include/linux/init.h
+++ b/include/linux/init.h
@@ -2,6 +2,8 @@
 #define _LINUX_INIT_H
 
 #include <linux/compiler.h>
+#include <linux/section-names.h>
+#include <linux/stringify.h>
 
 /* These macros are used to mark some functions or 
  * initialized data (doesn't apply to uninitialized data)
@@ -60,14 +62,6 @@
 #define __refdata        __section(.ref.data)
 #define __refconst       __section(.ref.rodata)
 
-/* backward compatibility note
- *  A few places hardcode the old section names:
- *  .text.init.refok
- *  .data.init.refok
- *  .exit.text.refok
- *  They should be converted to use the defines from this file
- */
-
 /* compatibility defines */
 #define __init_refok     __ref
 #define __initdata_refok __refdata
@@ -107,7 +101,7 @@
 #define __memexitconst   __section(.memexit.rodata)
 
 /* For assembly routines */
-#define __HEAD          .section        ".head.text","ax"
+#define __HEAD          .section        __stringify(HEAD_TEXT_SECTION),"ax"
 #define __INIT          .section        ".init.text","ax"
 #define __FINIT         .previous
 
@@ -247,6 +241,7 @@ struct obs_kernel_param {
 
 /* Relies on boot_command_line being set */
 void __init parse_early_param(void);
+void __init parse_early_options(char *cmdline);
 #endif /* __ASSEMBLY__ */
 
 /**
diff --git a/include/linux/init_task.h b/include/linux/init_task.h
index af1de95e711e..d87247d2641f 100644
--- a/include/linux/init_task.h
+++ b/include/linux/init_task.h
@@ -5,6 +5,7 @@
 #include <linux/irqflags.h>
 #include <linux/utsname.h>
 #include <linux/lockdep.h>
+#include <linux/ftrace.h>
 #include <linux/ipc.h>
 #include <linux/pid_namespace.h>
 #include <linux/user_namespace.h>
@@ -14,19 +15,6 @@
 extern struct files_struct init_files;
 extern struct fs_struct init_fs;
 
-#define INIT_KIOCTX(name, which_mm) \
-{                                                       \
-        .users          = ATOMIC_INIT(1),               \
-        .dead           = 0,                            \
-        .mm             = &which_mm,                    \
-        .user_id        = 0,                            \
-        .next           = NULL,                         \
-        .wait           = __WAIT_QUEUE_HEAD_INITIALIZER(name.wait), \
-        .ctx_lock       = __SPIN_LOCK_UNLOCKED(name.ctx_lock), \
-        .reqs_active    = 0U,                           \
-        .max_reqs       = ~0U,                          \
-}
-
 #define INIT_MM(name) \
 {                                                               \
         .mm_rb          = RB_ROOT,                              \
@@ -185,6 +173,7 @@ extern struct cred init_cred;
         INIT_IDS                                                        \
         INIT_TRACE_IRQFLAGS                                             \
         INIT_LOCKDEP                                                    \
+        INIT_FTRACE_GRAPH                                               \
 }
 
 
diff --git a/include/linux/input.h b/include/linux/input.h
index 6b28048fc568..0e6ff5de3588 100644
--- a/include/linux/input.h
+++ b/include/linux/input.h
@@ -106,6 +106,7 @@ struct input_absinfo {
 
 #define SYN_REPORT              0
 #define SYN_CONFIG              1
+#define SYN_MT_REPORT           2
 
 /*
  * Keys and buttons
@@ -445,6 +446,7 @@ struct input_absinfo {
 #define BTN_STYLUS2             0x14c
 #define BTN_TOOL_DOUBLETAP      0x14d
 #define BTN_TOOL_TRIPLETAP      0x14e
+#define BTN_TOOL_QUADTAP        0x14f   /* Four fingers on trackpad */
 
 #define BTN_WHEEL               0x150
 #define BTN_GEAR_DOWN           0x150
@@ -644,6 +646,17 @@ struct input_absinfo {
 #define ABS_TOOL_WIDTH          0x1c
 #define ABS_VOLUME              0x20
 #define ABS_MISC                0x28
+
+#define ABS_MT_TOUCH_MAJOR      0x30    /* Major axis of touching ellipse */
+#define ABS_MT_TOUCH_MINOR      0x31    /* Minor axis (omit if circular) */
+#define ABS_MT_WIDTH_MAJOR      0x32    /* Major axis of approaching ellipse */
+#define ABS_MT_WIDTH_MINOR      0x33    /* Minor axis (omit if circular) */
+#define ABS_MT_ORIENTATION      0x34    /* Ellipse orientation */
+#define ABS_MT_POSITION_X       0x35    /* Center X ellipse position */
+#define ABS_MT_POSITION_Y       0x36    /* Center Y ellipse position */
+#define ABS_MT_TOOL_TYPE        0x37    /* Type of touching device */
+#define ABS_MT_BLOB_ID          0x38    /* Group a set of packets as a blob */
+
 #define ABS_MAX                 0x3f
 #define ABS_CNT                 (ABS_MAX+1)
 
@@ -743,6 +756,12 @@ struct input_absinfo {
 #define BUS_ATARI               0x1B
 
 /*
+ * MT_TOOL types
+ */
+#define MT_TOOL_FINGER          0
+#define MT_TOOL_PEN             1
+
+/*
  * Values describing the status of a force-feedback effect
  */
 #define FF_STATUS_STOPPED       0x00
@@ -1311,6 +1330,11 @@ static inline void input_sync(struct input_dev *dev)
         input_event(dev, EV_SYN, SYN_REPORT, 0);
 }
 
+static inline void input_mt_sync(struct input_dev *dev)
+{
+        input_event(dev, EV_SYN, SYN_MT_REPORT, 0);
+}
+
 void input_set_capability(struct input_dev *dev, unsigned int type, unsigned int code);
 
 static inline void input_set_abs_params(struct input_dev *dev, int axis, int min, int max, int fuzz, int flat)
diff --git a/include/linux/intel-iommu.h b/include/linux/intel-iommu.h
index d2e3cbfba14f..aa8c53171233 100644
--- a/include/linux/intel-iommu.h
+++ b/include/linux/intel-iommu.h
@@ -123,7 +123,7 @@ static inline void dmar_writeq(void __iomem *addr, u64 val)
 #define ecap_eim_support(e)     ((e >> 4) & 0x1)
 #define ecap_ir_support(e)      ((e >> 3) & 0x1)
 #define ecap_max_handle_mask(e) ((e >> 20) & 0xf)
-
+#define ecap_sc_support(e)      ((e >> 7) & 0x1) /* Snooping Control */
 
 /* IOTLB_REG */
 #define DMA_TLB_FLUSH_GRANU_OFFSET  60
@@ -164,6 +164,7 @@ static inline void dmar_writeq(void __iomem *addr, u64 val)
 #define DMA_GCMD_QIE (((u32)1) << 26)
 #define DMA_GCMD_SIRTP (((u32)1) << 24)
 #define DMA_GCMD_IRE (((u32) 1) << 25)
+#define DMA_GCMD_CFI (((u32) 1) << 23)
 
 /* GSTS_REG */
 #define DMA_GSTS_TES (((u32)1) << 31)
@@ -174,6 +175,7 @@ static inline void dmar_writeq(void __iomem *addr, u64 val)
 #define DMA_GSTS_QIES (((u32)1) << 26)
 #define DMA_GSTS_IRTPS (((u32)1) << 24)
 #define DMA_GSTS_IRES (((u32)1) << 25)
+#define DMA_GSTS_CFIS (((u32)1) << 23)
 
 /* CCMD_REG */
 #define DMA_CCMD_ICC (((u64)1) << 63)
@@ -284,6 +286,14 @@ struct iommu_flush {
                 unsigned int size_order, u64 type, int non_present_entry_flush);
 };
 
+enum {
+        SR_DMAR_FECTL_REG,
+        SR_DMAR_FEDATA_REG,
+        SR_DMAR_FEADDR_REG,
+        SR_DMAR_FEUADDR_REG,
+        MAX_SR_DMAR_REGS
+};
+
 struct intel_iommu {
         void __iomem    *reg; /* Pointer to hardware regs, virtual addr */
         u64             cap;
@@ -292,6 +302,8 @@ struct intel_iommu {
         spinlock_t      register_lock; /* protect register handling */
         int             seq_id; /* sequence id of the iommu */
         int             agaw; /* agaw of this iommu */
+        unsigned int    irq;
+        unsigned char   name[13];    /* Device Name */
 
 #ifdef CONFIG_DMAR
         unsigned long   *domain_ids; /* bitmap of domains */
@@ -299,11 +311,11 @@ struct intel_iommu {
         spinlock_t      lock; /* protect context, domain ids */
         struct root_entry *root_entry; /* virtual address */
 
-        unsigned int irq;
-        unsigned char name[7];    /* Device Name */
         struct iommu_flush flush;
 #endif
         struct q_inval  *qi;            /* Queued invalidation info */
+        u32 *iommu_state; /* Store iommu states between suspend and resume.*/
+
 #ifdef CONFIG_INTR_REMAP
         struct ir_table *ir_table;      /* Interrupt remapping info */
 #endif
@@ -321,6 +333,8 @@ extern struct dmar_drhd_unit * dmar_find_matched_drhd_unit(struct pci_dev *dev);
 extern int alloc_iommu(struct dmar_drhd_unit *drhd);
 extern void free_iommu(struct intel_iommu *iommu);
 extern int dmar_enable_qi(struct intel_iommu *iommu);
+extern void dmar_disable_qi(struct intel_iommu *iommu);
+extern int dmar_reenable_qi(struct intel_iommu *iommu);
 extern void qi_global_iec(struct intel_iommu *iommu);
 
 extern int qi_flush_context(struct intel_iommu *iommu, u16 did, u16 sid,
@@ -331,11 +345,4 @@ extern int qi_flush_iotlb(struct intel_iommu *iommu, u16 did, u64 addr,
 
 extern int qi_submit_sync(struct qi_desc *desc, struct intel_iommu *iommu);
 
-extern void *intel_alloc_coherent(struct device *, size_t, dma_addr_t *, gfp_t);
-extern void intel_free_coherent(struct device *, size_t, void *, dma_addr_t);
-extern dma_addr_t intel_map_single(struct device *, phys_addr_t, size_t, int);
-extern void intel_unmap_single(struct device *, dma_addr_t, size_t, int);
-extern int intel_map_sg(struct device *, struct scatterlist *, int, int);
-extern void intel_unmap_sg(struct device *, struct scatterlist *, int, int);
-
 #endif
diff --git a/include/linux/interrupt.h b/include/linux/interrupt.h
index 0c9cb63e6895..91bb76f44f14 100644
--- a/include/linux/interrupt.h
+++ b/include/linux/interrupt.h
@@ -59,6 +59,18 @@
 #define IRQF_NOBALANCING        0x00000800
 #define IRQF_IRQPOLL            0x00001000
 
+/*
+ * Bits used by threaded handlers:
+ * IRQTF_RUNTHREAD - signals that the interrupt handler thread should run
+ * IRQTF_DIED      - handler thread died
+ * IRQTF_WARNED    - warning "IRQ_WAKE_THREAD w/o thread_fn" has been printed
+ */
+enum {
+        IRQTF_RUNTHREAD,
+        IRQTF_DIED,
+        IRQTF_WARNED,
+};
+
 typedef irqreturn_t (*irq_handler_t)(int, void *);
 
 /**
@@ -71,6 +83,9 @@ typedef irqreturn_t (*irq_handler_t)(int, void *);
  * @next:       pointer to the next irqaction for shared interrupts
  * @irq:        interrupt number
  * @dir:        pointer to the proc/irq/NN/name entry
+ * @thread_fn:  interupt handler function for threaded interrupts
+ * @thread:     thread pointer for threaded interrupts
+ * @thread_flags:       flags related to @thread
  */
 struct irqaction {
         irq_handler_t handler;
@@ -81,18 +96,68 @@ struct irqaction {
         struct irqaction *next;
         int irq;
         struct proc_dir_entry *dir;
+        irq_handler_t thread_fn;
+        struct task_struct *thread;
+        unsigned long thread_flags;
 };
 
 extern irqreturn_t no_action(int cpl, void *dev_id);
-extern int __must_check request_irq(unsigned int, irq_handler_t handler,
-                       unsigned long, const char *, void *);
+
+#ifdef CONFIG_GENERIC_HARDIRQS
+extern int __must_check
+request_threaded_irq(unsigned int irq, irq_handler_t handler,
+                     irq_handler_t thread_fn,
+                     unsigned long flags, const char *name, void *dev);
+
+static inline int __must_check
+request_irq(unsigned int irq, irq_handler_t handler, unsigned long flags,
+            const char *name, void *dev)
+{
+        return request_threaded_irq(irq, handler, NULL, flags, name, dev);
+}
+
+extern void exit_irq_thread(void);
+#else
+
+extern int __must_check
+request_irq(unsigned int irq, irq_handler_t handler, unsigned long flags,
+            const char *name, void *dev);
+
+/*
+ * Special function to avoid ifdeffery in kernel/irq/devres.c which
+ * gets magically built by GENERIC_HARDIRQS=n architectures (sparc,
+ * m68k). I really love these $@%#!* obvious Makefile references:
+ * ../../../kernel/irq/devres.o
+ */
+static inline int __must_check
+request_threaded_irq(unsigned int irq, irq_handler_t handler,
+                     irq_handler_t thread_fn,
+                     unsigned long flags, const char *name, void *dev)
+{
+        return request_irq(irq, handler, flags, name, dev);
+}
+
+static inline void exit_irq_thread(void) { }
+#endif
+
 extern void free_irq(unsigned int, void *);
 
 struct device;
 
-extern int __must_check devm_request_irq(struct device *dev, unsigned int irq,
-                            irq_handler_t handler, unsigned long irqflags,
-                            const char *devname, void *dev_id);
+extern int __must_check
+devm_request_threaded_irq(struct device *dev, unsigned int irq,
+                          irq_handler_t handler, irq_handler_t thread_fn,
+                          unsigned long irqflags, const char *devname,
+                          void *dev_id);
+
+static inline int __must_check
+devm_request_irq(struct device *dev, unsigned int irq, irq_handler_t handler,
+                 unsigned long irqflags, const char *devname, void *dev_id)
+{
+        return devm_request_threaded_irq(dev, irq, handler, NULL, irqflags,
+                                         devname, dev_id);
+}
+
 extern void devm_free_irq(struct device *dev, unsigned int irq, void *dev_id);
 
 /*
@@ -117,6 +182,15 @@ extern void disable_irq_nosync(unsigned int irq);
 extern void disable_irq(unsigned int irq);
 extern void enable_irq(unsigned int irq);
 
+/* The following three functions are for the core kernel use only. */
+extern void suspend_device_irqs(void);
+extern void resume_device_irqs(void);
+#ifdef CONFIG_PM_SLEEP
+extern int check_wakeup_irqs(void);
+#else
+static inline int check_wakeup_irqs(void) { return 0; }
+#endif
+
 #if defined(CONFIG_SMP) && defined(CONFIG_GENERIC_HARDIRQS)
 
 extern cpumask_var_t irq_default_affinity;
@@ -269,6 +343,11 @@ enum
         NR_SOFTIRQS
 };
 
+/* map softirq index to softirq name. update 'softirq_to_name' in
+ * kernel/softirq.c when adding a new softirq.
+ */
+extern char *softirq_to_name[NR_SOFTIRQS];
+
 /* softirq mask and active fields moved to irq_cpustat_t in
  * asm/hardirq.h to get better cache usage.  KAO
  */
@@ -285,6 +364,7 @@ extern void softirq_init(void);
 #define __raise_softirq_irqoff(nr) do { or_softirq_pending(1UL << (nr)); } while (0)
 extern void raise_softirq_irqoff(unsigned int nr);
 extern void raise_softirq(unsigned int nr);
+extern void wakeup_softirqd(void);
 
 /* This is the worklist that queues up per-cpu softirq work.
  *
diff --git a/include/linux/iommu.h b/include/linux/iommu.h
index 8a7bfb1b6ca0..3af4ffd591b9 100644
--- a/include/linux/iommu.h
+++ b/include/linux/iommu.h
@@ -21,6 +21,7 @@
 
 #define IOMMU_READ      (1)
 #define IOMMU_WRITE     (2)
+#define IOMMU_CACHE     (4) /* DMA cache coherency */
 
 struct device;
 
@@ -28,6 +29,8 @@ struct iommu_domain {
         void *priv;
 };
 
+#define IOMMU_CAP_CACHE_COHERENCY       0x1
+
 struct iommu_ops {
         int (*domain_init)(struct iommu_domain *domain);
         void (*domain_destroy)(struct iommu_domain *domain);
@@ -39,6 +42,8 @@ struct iommu_ops {
                       size_t size);
         phys_addr_t (*iova_to_phys)(struct iommu_domain *domain,
                                     unsigned long iova);
+        int (*domain_has_cap)(struct iommu_domain *domain,
+                              unsigned long cap);
 };
 
 #ifdef CONFIG_IOMMU_API
@@ -57,6 +62,8 @@ extern void iommu_unmap_range(struct iommu_domain *domain, unsigned long iova,
                               size_t size);
 extern phys_addr_t iommu_iova_to_phys(struct iommu_domain *domain,
                                       unsigned long iova);
+extern int iommu_domain_has_cap(struct iommu_domain *domain,
+                                unsigned long cap);
 
 #else /* CONFIG_IOMMU_API */
 
@@ -107,6 +114,12 @@ static inline phys_addr_t iommu_iova_to_phys(struct iommu_domain *domain,
         return 0;
 }
 
+static inline int domain_has_cap(struct iommu_domain *domain,
+                                 unsigned long cap)
+{
+        return 0;
+}
+
 #endif /* CONFIG_IOMMU_API */
 
 #endif /* __LINUX_IOMMU_H */
diff --git a/include/linux/ipc_namespace.h b/include/linux/ipc_namespace.h
index ea330f9e7100..3bf40e246a80 100644
--- a/include/linux/ipc_namespace.h
+++ b/include/linux/ipc_namespace.h
@@ -25,7 +25,7 @@ struct ipc_ids {
 };
 
 struct ipc_namespace {
-        struct kref     kref;
+        atomic_t        count;
         struct ipc_ids  ids[3];
 
         int             sem_ctls[4];
@@ -44,25 +44,57 @@ struct ipc_namespace {
         int             shm_tot;
 
         struct notifier_block ipcns_nb;
+
+        /* The kern_mount of the mqueuefs sb.  We take a ref on it */
+        struct vfsmount *mq_mnt;
+
+        /* # queues in this ns, protected by mq_lock */
+        unsigned int    mq_queues_count;
+
+        /* next fields are set through sysctl */
+        unsigned int    mq_queues_max;   /* initialized to DFLT_QUEUESMAX */
+        unsigned int    mq_msg_max;      /* initialized to DFLT_MSGMAX */
+        unsigned int    mq_msgsize_max;  /* initialized to DFLT_MSGSIZEMAX */
+
 };
 
 extern struct ipc_namespace init_ipc_ns;
 extern atomic_t nr_ipc_ns;
 
-#ifdef CONFIG_SYSVIPC
+extern spinlock_t mq_lock;
+#if defined(CONFIG_POSIX_MQUEUE) || defined(CONFIG_SYSVIPC)
 #define INIT_IPC_NS(ns)         .ns             = &init_ipc_ns,
+#else
+#define INIT_IPC_NS(ns)
+#endif
 
+#ifdef CONFIG_SYSVIPC
 extern int register_ipcns_notifier(struct ipc_namespace *);
 extern int cond_register_ipcns_notifier(struct ipc_namespace *);
 extern void unregister_ipcns_notifier(struct ipc_namespace *);
 extern int ipcns_notify(unsigned long);
-
 #else /* CONFIG_SYSVIPC */
-#define INIT_IPC_NS(ns)
+static inline int register_ipcns_notifier(struct ipc_namespace *ns)
+{ return 0; }
+static inline int cond_register_ipcns_notifier(struct ipc_namespace *ns)
+{ return 0; }
+static inline void unregister_ipcns_notifier(struct ipc_namespace *ns) { }
+static inline int ipcns_notify(unsigned long l) { return 0; }
 #endif /* CONFIG_SYSVIPC */
 
-#if defined(CONFIG_SYSVIPC) && defined(CONFIG_IPC_NS)
-extern void free_ipc_ns(struct kref *kref);
+#ifdef CONFIG_POSIX_MQUEUE
+extern int mq_init_ns(struct ipc_namespace *ns);
+/* default values */
+#define DFLT_QUEUESMAX 256     /* max number of message queues */
+#define DFLT_MSGMAX    10      /* max number of messages in each queue */
+#define HARD_MSGMAX    (131072/sizeof(void *))
+#define DFLT_MSGSIZEMAX 8192   /* max message size */
+#else
+static inline int mq_init_ns(struct ipc_namespace *ns) { return 0; }
+#endif
+
+#if defined(CONFIG_IPC_NS)
+extern void free_ipc_ns(struct ipc_namespace *ns);
 extern struct ipc_namespace *copy_ipcs(unsigned long flags,
                                        struct ipc_namespace *ns);
 extern void free_ipcs(struct ipc_namespace *ns, struct ipc_ids *ids,
@@ -72,14 +104,11 @@ extern void free_ipcs(struct ipc_namespace *ns, struct ipc_ids *ids,
 static inline struct ipc_namespace *get_ipc_ns(struct ipc_namespace *ns)
 {
         if (ns)
-                kref_get(&ns->kref);
+                atomic_inc(&ns->count);
         return ns;
 }
 
-static inline void put_ipc_ns(struct ipc_namespace *ns)
-{
-        kref_put(&ns->kref, free_ipc_ns);
-}
+extern void put_ipc_ns(struct ipc_namespace *ns);
 #else
 static inline struct ipc_namespace *copy_ipcs(unsigned long flags,
                 struct ipc_namespace *ns)
@@ -99,4 +128,18 @@ static inline void put_ipc_ns(struct ipc_namespace *ns)
 {
 }
 #endif
+
+#ifdef CONFIG_POSIX_MQUEUE_SYSCTL
+
+struct ctl_table_header;
+extern struct ctl_table_header *mq_register_sysctl_table(void);
+
+#else /* CONFIG_POSIX_MQUEUE_SYSCTL */
+
+static inline struct ctl_table_header *mq_register_sysctl_table(void)
+{
+        return NULL;
+}
+
+#endif /* CONFIG_POSIX_MQUEUE_SYSCTL */
 #endif
diff --git a/include/linux/ipmi.h b/include/linux/ipmi.h
index 7ebdb4fb4e54..65aae34759de 100644
--- a/include/linux/ipmi.h
+++ b/include/linux/ipmi.h
@@ -198,6 +198,8 @@ struct kernel_ipmi_msg {
                                               response.  When you send a
                                               response message, this will
                                               be returned. */
+#define IPMI_OEM_RECV_TYPE              5 /* The response for OEM Channels */
+
 /* Note that async events and received commands do not have a completion
    code as the first byte of the incoming data, unlike a response. */
 
diff --git a/include/linux/ipmi_msgdefs.h b/include/linux/ipmi_msgdefs.h
index b56a158d587a..df97e6e31e87 100644
--- a/include/linux/ipmi_msgdefs.h
+++ b/include/linux/ipmi_msgdefs.h
@@ -58,6 +58,12 @@
 #define IPMI_READ_EVENT_MSG_BUFFER_CMD  0x35
 #define IPMI_GET_CHANNEL_INFO_CMD       0x42
 
+/* Bit for BMC global enables. */
+#define IPMI_BMC_RCV_MSG_INTR     0x01
+#define IPMI_BMC_EVT_MSG_INTR     0x02
+#define IPMI_BMC_EVT_MSG_BUFF     0x04
+#define IPMI_BMC_SYS_LOG          0x08
+
 #define IPMI_NETFN_STORAGE_REQUEST              0x0a
 #define IPMI_NETFN_STORAGE_RESPONSE             0x0b
 #define IPMI_ADD_SEL_ENTRY_CMD          0x44
@@ -109,5 +115,7 @@
 #define IPMI_CHANNEL_MEDIUM_USB1        10
 #define IPMI_CHANNEL_MEDIUM_USB2        11
 #define IPMI_CHANNEL_MEDIUM_SYSINTF     12
+#define IPMI_CHANNEL_MEDIUM_OEM_MIN     0x60
+#define IPMI_CHANNEL_MEDIUM_OEM_MAX     0x7f
 
 #endif /* __LINUX_IPMI_MSGDEFS_H */
diff --git a/include/linux/ipmi_smi.h b/include/linux/ipmi_smi.h
index 62b73668b602..f7c9c75a2775 100644
--- a/include/linux/ipmi_smi.h
+++ b/include/linux/ipmi_smi.h
@@ -230,6 +230,6 @@ static inline void ipmi_free_smi_msg(struct ipmi_smi_msg *msg)
    automatically be dstroyed when the interface is destroyed. */
 int ipmi_smi_add_proc_entry(ipmi_smi_t smi, char *name,
                             read_proc_t *read_proc,
-                            void *data, struct module *owner);
+                            void *data);
 
 #endif /* __LINUX_IPMI_SMI_H */
diff --git a/include/linux/irq.h b/include/linux/irq.h
index 873e4ac11b81..b7cbeed972e4 100644
--- a/include/linux/irq.h
+++ b/include/linux/irq.h
@@ -17,9 +17,12 @@
 #include <linux/cache.h>
 #include <linux/spinlock.h>
 #include <linux/cpumask.h>
+#include <linux/gfp.h>
 #include <linux/irqreturn.h>
 #include <linux/irqnr.h>
 #include <linux/errno.h>
+#include <linux/topology.h>
+#include <linux/wait.h>
 
 #include <asm/irq.h>
 #include <asm/ptrace.h>
@@ -65,6 +68,7 @@ typedef	void (*irq_flow_handler_t)(unsigned int irq,
 #define IRQ_SPURIOUS_DISABLED   0x00800000      /* IRQ was disabled by the spurious trap */
 #define IRQ_MOVE_PCNTXT         0x01000000      /* IRQ migration from process context */
 #define IRQ_AFFINITY_SET        0x02000000      /* IRQ affinity was set from userspace*/
+#define IRQ_SUSPENDED           0x04000000      /* IRQ has gone through suspend sequence */
 
 #ifdef CONFIG_IRQ_PER_CPU
 # define CHECK_IRQ_PER_CPU(var) ((var) & IRQ_PER_CPU)
@@ -155,6 +159,8 @@ struct irq_2_iommu;
  * @affinity:           IRQ affinity on SMP
  * @cpu:                cpu index useful for balancing
  * @pending_mask:       pending rebalanced interrupts
+ * @threads_active:     number of irqaction threads currently running
+ * @wait_for_threads:   wait queue for sync_irq to wait for threaded handlers
  * @dir:                /proc/irq/ procfs entry
  * @name:               flow handler name for /proc/interrupts output
  */
@@ -186,6 +192,8 @@ struct irq_desc {
         cpumask_var_t           pending_mask;
 #endif
 #endif
+        atomic_t                threads_active;
+        wait_queue_head_t       wait_for_threads;
 #ifdef CONFIG_PROC_FS
         struct proc_dir_entry   *dir;
 #endif
@@ -479,6 +487,16 @@ static inline void init_copy_desc_masks(struct irq_desc *old_desc,
 #endif
 }
 
+static inline void free_desc_masks(struct irq_desc *old_desc,
+                                   struct irq_desc *new_desc)
+{
+        free_cpumask_var(old_desc->affinity);
+
+#ifdef CONFIG_GENERIC_PENDING_IRQ
+        free_cpumask_var(old_desc->pending_mask);
+#endif
+}
+
 #else /* !CONFIG_SMP */
 
 static inline bool init_alloc_desc_masks(struct irq_desc *desc, int cpu,
@@ -492,6 +510,10 @@ static inline void init_copy_desc_masks(struct irq_desc *old_desc,
 {
 }
 
+static inline void free_desc_masks(struct irq_desc *old_desc,
+                                   struct irq_desc *new_desc)
+{
+}
 #endif  /* CONFIG_SMP */
 
 #endif /* _LINUX_IRQ_H */
diff --git a/include/linux/irqflags.h b/include/linux/irqflags.h
index 74bde13224c9..b02a3f1d46a0 100644
--- a/include/linux/irqflags.h
+++ b/include/linux/irqflags.h
@@ -24,8 +24,8 @@
 # define trace_softirqs_enabled(p)      ((p)->softirqs_enabled)
 # define trace_hardirq_enter()  do { current->hardirq_context++; } while (0)
 # define trace_hardirq_exit()   do { current->hardirq_context--; } while (0)
-# define trace_softirq_enter()  do { current->softirq_context++; } while (0)
-# define trace_softirq_exit()   do { current->softirq_context--; } while (0)
+# define lockdep_softirq_enter()        do { current->softirq_context++; } while (0)
+# define lockdep_softirq_exit() do { current->softirq_context--; } while (0)
 # define INIT_TRACE_IRQFLAGS    .softirqs_enabled = 1,
 #else
 # define trace_hardirqs_on()            do { } while (0)
@@ -38,8 +38,8 @@
 # define trace_softirqs_enabled(p)      0
 # define trace_hardirq_enter()          do { } while (0)
 # define trace_hardirq_exit()           do { } while (0)
-# define trace_softirq_enter()          do { } while (0)
-# define trace_softirq_exit()           do { } while (0)
+# define lockdep_softirq_enter()        do { } while (0)
+# define lockdep_softirq_exit()         do { } while (0)
 # define INIT_TRACE_IRQFLAGS
 #endif
 
diff --git a/include/linux/irqreturn.h b/include/linux/irqreturn.h
index c5584ca5b8c9..819acaaac3f5 100644
--- a/include/linux/irqreturn.h
+++ b/include/linux/irqreturn.h
@@ -5,10 +5,12 @@
  * enum irqreturn
  * @IRQ_NONE            interrupt was not from this device
  * @IRQ_HANDLED         interrupt was handled by this device
+ * @IRQ_WAKE_THREAD     handler requests to wake the handler thread
  */
 enum irqreturn {
         IRQ_NONE,
         IRQ_HANDLED,
+        IRQ_WAKE_THREAD,
 };
 
 typedef enum irqreturn irqreturn_t;
diff --git a/include/linux/ivtv.h b/include/linux/ivtv.h
index f2720280b9ec..062d20f74322 100644
--- a/include/linux/ivtv.h
+++ b/include/linux/ivtv.h
@@ -60,10 +60,10 @@ struct ivtv_dma_frame {
 
 #define IVTV_IOC_DMA_FRAME  _IOW ('V', BASE_VIDIOC_PRIVATE+0, struct ivtv_dma_frame)
 
-/* These are the VBI types as they appear in the embedded VBI private packets. */
-#define IVTV_SLICED_TYPE_TELETEXT_B     (1)
-#define IVTV_SLICED_TYPE_CAPTION_525    (4)
-#define IVTV_SLICED_TYPE_WSS_625        (5)
-#define IVTV_SLICED_TYPE_VPS            (7)
+/* Deprecated defines: applications should use the defines from videodev2.h */
+#define IVTV_SLICED_TYPE_TELETEXT_B     V4L2_MPEG_VBI_IVTV_TELETEXT_B
+#define IVTV_SLICED_TYPE_CAPTION_525    V4L2_MPEG_VBI_IVTV_CAPTION_525
+#define IVTV_SLICED_TYPE_WSS_625        V4L2_MPEG_VBI_IVTV_WSS_625
+#define IVTV_SLICED_TYPE_VPS            V4L2_MPEG_VBI_IVTV_VPS
 
 #endif /* _LINUX_IVTV_H */
diff --git a/include/linux/jbd.h b/include/linux/jbd.h
index 64246dce5663..c2049a04fa0b 100644
--- a/include/linux/jbd.h
+++ b/include/linux/jbd.h
@@ -35,7 +35,7 @@
 #define journal_oom_retry 1
 
 /*
- * Define JBD_PARANIOD_IOFAIL to cause a kernel BUG() if ext3 finds
+ * Define JBD_PARANOID_IOFAIL to cause a kernel BUG() if ext3 finds
  * certain classes of error which can occur due to failed IOs.  Under
  * normal use we want ext3 to continue after such errors, because
  * hardware _can_ fail, but for debugging purposes when running tests on
@@ -552,6 +552,11 @@ struct transaction_s
          */
         int t_handle_count;
 
+        /*
+         * This transaction is being forced and some process is
+         * waiting for it to finish.
+         */
+        int t_synchronous_commit:1;
 };
 
 /**
@@ -973,7 +978,8 @@ extern void	   journal_destroy_revoke(journal_t *);
 extern int         journal_revoke (handle_t *,
                                 unsigned long, struct buffer_head *);
 extern int         journal_cancel_revoke(handle_t *, struct journal_head *);
-extern void        journal_write_revoke_records(journal_t *, transaction_t *);
+extern void        journal_write_revoke_records(journal_t *,
+                                                transaction_t *, int);
 
 /* Recovery revoke support */
 extern int      journal_set_revoke(journal_t *, unsigned long, tid_t);
diff --git a/include/linux/jbd2.h b/include/linux/jbd2.h
index 4d248b3f1323..cc02393bfce8 100644
--- a/include/linux/jbd2.h
+++ b/include/linux/jbd2.h
@@ -649,6 +649,12 @@ struct transaction_s
         int t_handle_count;
 
         /*
+         * This transaction is being forced and some process is
+         * waiting for it to finish.
+         */
+        int t_synchronous_commit:1;
+
+        /*
          * For use by the filesystem to store fs-specific data
          * structures associated with the transaction
          */
@@ -1187,7 +1193,8 @@ extern int	   jbd2_journal_init_revoke_caches(void);
 extern void        jbd2_journal_destroy_revoke(journal_t *);
 extern int         jbd2_journal_revoke (handle_t *, unsigned long long, struct buffer_head *);
 extern int         jbd2_journal_cancel_revoke(handle_t *, struct journal_head *);
-extern void        jbd2_journal_write_revoke_records(journal_t *, transaction_t *);
+extern void        jbd2_journal_write_revoke_records(journal_t *,
+                                                     transaction_t *, int);
 
 /* Recovery revoke support */
 extern int      jbd2_journal_set_revoke(journal_t *, unsigned long long, tid_t);
diff --git a/include/linux/kallsyms.h b/include/linux/kallsyms.h
index f3fe34391d8e..792274269f2b 100644
--- a/include/linux/kallsyms.h
+++ b/include/linux/kallsyms.h
@@ -13,10 +13,17 @@
 #define KSYM_SYMBOL_LEN (sizeof("%s+%#lx/%#lx [%s]") + (KSYM_NAME_LEN - 1) + \
                          2*(BITS_PER_LONG*3/10) + (MODULE_NAME_LEN - 1) + 1)
 
+struct module;
+
 #ifdef CONFIG_KALLSYMS
 /* Lookup the address for a symbol. Returns 0 if not found. */
 unsigned long kallsyms_lookup_name(const char *name);
 
+/* Call a function on each kallsyms symbol in the core kernel */
+int kallsyms_on_each_symbol(int (*fn)(void *, const char *, struct module *,
+                                      unsigned long),
+                            void *data);
+
 extern int kallsyms_lookup_size_offset(unsigned long addr,
                                   unsigned long *symbolsize,
                                   unsigned long *offset);
@@ -43,6 +50,14 @@ static inline unsigned long kallsyms_lookup_name(const char *name)
         return 0;
 }
 
+static inline int kallsyms_on_each_symbol(int (*fn)(void *, const char *,
+                                                    struct module *,
+                                                    unsigned long),
+                                          void *data)
+{
+        return 0;
+}
+
 static inline int kallsyms_lookup_size_offset(unsigned long addr,
                                               unsigned long *symbolsize,
                                               unsigned long *offset)
diff --git a/include/linux/kernel.h b/include/linux/kernel.h
index 914918abfdd1..883cd44ff765 100644
--- a/include/linux/kernel.h
+++ b/include/linux/kernel.h
@@ -242,6 +242,20 @@ extern struct ratelimit_state printk_ratelimit_state;
 extern int printk_ratelimit(void);
 extern bool printk_timed_ratelimit(unsigned long *caller_jiffies,
                                    unsigned int interval_msec);
+
+/*
+ * Print a one-time message (analogous to WARN_ONCE() et al):
+ */
+#define printk_once(x...) ({                    \
+        static int __print_once = 1;            \
+                                                \
+        if (__print_once) {                     \
+                __print_once = 0;               \
+                printk(x);                      \
+        }                                       \
+})
+
+void log_buf_kexec_setup(void);
 #else
 static inline int vprintk(const char *s, va_list args)
         __attribute__ ((format (printf, 1, 0)));
@@ -253,6 +267,13 @@ static inline int printk_ratelimit(void) { return 0; }
 static inline bool printk_timed_ratelimit(unsigned long *caller_jiffies, \
                                           unsigned int interval_msec)   \
                 { return false; }
+
+/* No effect, but we still get type checking even in the !PRINTK case: */
+#define printk_once(x...) printk(x)
+
+static inline void log_buf_kexec_setup(void)
+{
+}
 #endif
 
 extern int printk_needs_cpu(int cpu);
@@ -353,6 +374,17 @@ static inline char *pack_hex_byte(char *buf, u8 byte)
         printk(KERN_NOTICE pr_fmt(fmt), ##__VA_ARGS__)
 #define pr_info(fmt, ...) \
         printk(KERN_INFO pr_fmt(fmt), ##__VA_ARGS__)
+#define pr_cont(fmt, ...) \
+        printk(KERN_CONT fmt, ##__VA_ARGS__)
+
+/* pr_devel() should produce zero code unless DEBUG is defined */
+#ifdef DEBUG
+#define pr_devel(fmt, ...) \
+        printk(KERN_DEBUG pr_fmt(fmt), ##__VA_ARGS__)
+#else
+#define pr_devel(fmt, ...) \
+        ({ if (0) printk(KERN_DEBUG pr_fmt(fmt), ##__VA_ARGS__); 0; })
+#endif
 
 /* If you are writing a driver, please use dev_dbg instead */
 #if defined(DEBUG)
@@ -369,6 +401,139 @@ static inline char *pack_hex_byte(char *buf, u8 byte)
 #endif
 
 /*
+ * General tracing related utility functions - trace_printk(),
+ * tracing_on/tracing_off and tracing_start()/tracing_stop
+ *
+ * Use tracing_on/tracing_off when you want to quickly turn on or off
+ * tracing. It simply enables or disables the recording of the trace events.
+ * This also corresponds to the user space debugfs/tracing/tracing_on
+ * file, which gives a means for the kernel and userspace to interact.
+ * Place a tracing_off() in the kernel where you want tracing to end.
+ * From user space, examine the trace, and then echo 1 > tracing_on
+ * to continue tracing.
+ *
+ * tracing_stop/tracing_start has slightly more overhead. It is used
+ * by things like suspend to ram where disabling the recording of the
+ * trace is not enough, but tracing must actually stop because things
+ * like calling smp_processor_id() may crash the system.
+ *
+ * Most likely, you want to use tracing_on/tracing_off.
+ */
+#ifdef CONFIG_RING_BUFFER
+void tracing_on(void);
+void tracing_off(void);
+/* trace_off_permanent stops recording with no way to bring it back */
+void tracing_off_permanent(void);
+int tracing_is_on(void);
+#else
+static inline void tracing_on(void) { }
+static inline void tracing_off(void) { }
+static inline void tracing_off_permanent(void) { }
+static inline int tracing_is_on(void) { return 0; }
+#endif
+#ifdef CONFIG_TRACING
+extern void tracing_start(void);
+extern void tracing_stop(void);
+extern void ftrace_off_permanent(void);
+
+extern void
+ftrace_special(unsigned long arg1, unsigned long arg2, unsigned long arg3);
+
+static inline void __attribute__ ((format (printf, 1, 2)))
+____trace_printk_check_format(const char *fmt, ...)
+{
+}
+#define __trace_printk_check_format(fmt, args...)                       \
+do {                                                                    \
+        if (0)                                                          \
+                ____trace_printk_check_format(fmt, ##args);             \
+} while (0)
+
+/**
+ * trace_printk - printf formatting in the ftrace buffer
+ * @fmt: the printf format for printing
+ *
+ * Note: __trace_printk is an internal function for trace_printk and
+ *       the @ip is passed in via the trace_printk macro.
+ *
+ * This function allows a kernel developer to debug fast path sections
+ * that printk is not appropriate for. By scattering in various
+ * printk like tracing in the code, a developer can quickly see
+ * where problems are occurring.
+ *
+ * This is intended as a debugging tool for the developer only.
+ * Please refrain from leaving trace_printks scattered around in
+ * your code.
+ */
+
+#define trace_printk(fmt, args...)                                      \
+do {                                                                    \
+        __trace_printk_check_format(fmt, ##args);                       \
+        if (__builtin_constant_p(fmt)) {                                \
+                static const char *trace_printk_fmt                     \
+                  __attribute__((section("__trace_printk_fmt"))) =      \
+                        __builtin_constant_p(fmt) ? fmt : NULL;         \
+                                                                        \
+                __trace_bprintk(_THIS_IP_, trace_printk_fmt, ##args);   \
+        } else                                                          \
+                __trace_printk(_THIS_IP_, fmt, ##args);         \
+} while (0)
+
+extern int
+__trace_bprintk(unsigned long ip, const char *fmt, ...)
+        __attribute__ ((format (printf, 2, 3)));
+
+extern int
+__trace_printk(unsigned long ip, const char *fmt, ...)
+        __attribute__ ((format (printf, 2, 3)));
+
+/*
+ * The double __builtin_constant_p is because gcc will give us an error
+ * if we try to allocate the static variable to fmt if it is not a
+ * constant. Even with the outer if statement.
+ */
+#define ftrace_vprintk(fmt, vargs)                                      \
+do {                                                                    \
+        if (__builtin_constant_p(fmt)) {                                \
+                static const char *trace_printk_fmt                     \
+                  __attribute__((section("__trace_printk_fmt"))) =      \
+                        __builtin_constant_p(fmt) ? fmt : NULL;         \
+                                                                        \
+                __ftrace_vbprintk(_THIS_IP_, trace_printk_fmt, vargs);  \
+        } else                                                          \
+                __ftrace_vprintk(_THIS_IP_, fmt, vargs);                \
+} while (0)
+
+extern int
+__ftrace_vbprintk(unsigned long ip, const char *fmt, va_list ap);
+
+extern int
+__ftrace_vprintk(unsigned long ip, const char *fmt, va_list ap);
+
+extern void ftrace_dump(void);
+#else
+static inline void
+ftrace_special(unsigned long arg1, unsigned long arg2, unsigned long arg3) { }
+static inline int
+trace_printk(const char *fmt, ...) __attribute__ ((format (printf, 1, 2)));
+
+static inline void tracing_start(void) { }
+static inline void tracing_stop(void) { }
+static inline void ftrace_off_permanent(void) { }
+static inline int
+trace_printk(const char *fmt, ...)
+{
+        return 0;
+}
+static inline int
+ftrace_vprintk(const char *fmt, va_list ap)
+{
+        return 0;
+}
+static inline void ftrace_dump(void) { }
+#endif /* CONFIG_TRACING */
+
+/*
  *      Display an IP address in readable format.
  */
 
@@ -379,18 +544,6 @@ static inline char *pack_hex_byte(char *buf, u8 byte)
         ((unsigned char *)&addr)[3]
 #define NIPQUAD_FMT "%u.%u.%u.%u"
 
-#if defined(__LITTLE_ENDIAN)
-#define HIPQUAD(addr) \
-        ((unsigned char *)&addr)[3], \
-        ((unsigned char *)&addr)[2], \
-        ((unsigned char *)&addr)[1], \
-        ((unsigned char *)&addr)[0]
-#elif defined(__BIG_ENDIAN)
-#define HIPQUAD NIPQUAD
-#else
-#error "Please fix asm/byteorder.h"
-#endif /* __LITTLE_ENDIAN */
-
 /*
  * min()/max()/clamp() macros that also do
  * strict type-checking.. See the
diff --git a/include/linux/key.h b/include/linux/key.h
index 21d32a142c00..e544f466d69a 100644
--- a/include/linux/key.h
+++ b/include/linux/key.h
@@ -20,6 +20,7 @@
 #include <linux/rbtree.h>
 #include <linux/rcupdate.h>
 #include <linux/sysctl.h>
+#include <linux/rwsem.h>
 #include <asm/atomic.h>
 
 #ifdef __KERNEL__
diff --git a/include/linux/kmod.h b/include/linux/kmod.h
index 92213a9194e1..384ca8bbf1ac 100644
--- a/include/linux/kmod.h
+++ b/include/linux/kmod.h
@@ -29,10 +29,15 @@
 #ifdef CONFIG_MODULES
 /* modprobe exit status on success, -ve on error.  Return value
  * usually useless though. */
-extern int request_module(const char * name, ...) __attribute__ ((format (printf, 1, 2)));
-#define try_then_request_module(x, mod...) ((x) ?: (request_module(mod), (x)))
+extern int __request_module(bool wait, const char *name, ...) \
+        __attribute__((format(printf, 2, 3)));
+#define request_module(mod...) __request_module(true, mod)
+#define request_module_nowait(mod...) __request_module(false, mod)
+#define try_then_request_module(x, mod...) \
+        ((x) ?: (__request_module(true, mod), (x)))
 #else
-static inline int request_module(const char * name, ...) { return -ENOSYS; }
+static inline int request_module(const char *name, ...) { return -ENOSYS; }
+static inline int request_module_nowait(const char *name, ...) { return -ENOSYS; }
 #define try_then_request_module(x, mod...) (x)
 #endif
 
diff --git a/include/linux/kprobes.h b/include/linux/kprobes.h
index 2ec6cc14a114..bcd9c07848be 100644
--- a/include/linux/kprobes.h
+++ b/include/linux/kprobes.h
@@ -94,12 +94,16 @@ struct kprobe {
         /* Called after addr is executed, unless... */
         kprobe_post_handler_t post_handler;
 
-        /* ... called if executing addr causes a fault (eg. page fault).
-         * Return 1 if it handled fault, otherwise kernel will see it. */
+        /*
+         * ... called if executing addr causes a fault (eg. page fault).
+         * Return 1 if it handled fault, otherwise kernel will see it.
+         */
         kprobe_fault_handler_t fault_handler;
 
-        /* ... called if breakpoint trap occurs in probe handler.
-         * Return 1 if it handled break, otherwise kernel will see it. */
+        /*
+         * ... called if breakpoint trap occurs in probe handler.
+         * Return 1 if it handled break, otherwise kernel will see it.
+         */
         kprobe_break_handler_t break_handler;
 
         /* Saved opcode (which has been replaced with breakpoint) */
@@ -108,18 +112,28 @@ struct kprobe {
         /* copy of the original instruction */
         struct arch_specific_insn ainsn;
 
-        /* Indicates various status flags.  Protected by kprobe_mutex. */
+        /*
+         * Indicates various status flags.
+         * Protected by kprobe_mutex after this kprobe is registered.
+         */
         u32 flags;
 };
 
 /* Kprobe status flags */
 #define KPROBE_FLAG_GONE        1 /* breakpoint has already gone */
+#define KPROBE_FLAG_DISABLED    2 /* probe is temporarily disabled */
 
+/* Has this kprobe gone ? */
 static inline int kprobe_gone(struct kprobe *p)
 {
         return p->flags & KPROBE_FLAG_GONE;
 }
 
+/* Is this kprobe disabled ? */
+static inline int kprobe_disabled(struct kprobe *p)
+{
+        return p->flags & (KPROBE_FLAG_DISABLED | KPROBE_FLAG_GONE);
+}
 /*
  * Special probe type that uses setjmp-longjmp type tricks to resume
  * execution at a specified entry with a matching prototype corresponding
@@ -279,6 +293,9 @@ void unregister_kretprobes(struct kretprobe **rps, int num);
 void kprobe_flush_task(struct task_struct *tk);
 void recycle_rp_inst(struct kretprobe_instance *ri, struct hlist_head *head);
 
+int disable_kprobe(struct kprobe *kp);
+int enable_kprobe(struct kprobe *kp);
+
 #else /* !CONFIG_KPROBES: */
 
 static inline int kprobes_built_in(void)
@@ -345,5 +362,30 @@ static inline void unregister_kretprobes(struct kretprobe **rps, int num)
 static inline void kprobe_flush_task(struct task_struct *tk)
 {
 }
+static inline int disable_kprobe(struct kprobe *kp)
+{
+        return -ENOSYS;
+}
+static inline int enable_kprobe(struct kprobe *kp)
+{
+        return -ENOSYS;
+}
 #endif /* CONFIG_KPROBES */
+static inline int disable_kretprobe(struct kretprobe *rp)
+{
+        return disable_kprobe(&rp->kp);
+}
+static inline int enable_kretprobe(struct kretprobe *rp)
+{
+        return enable_kprobe(&rp->kp);
+}
+static inline int disable_jprobe(struct jprobe *jp)
+{
+        return disable_kprobe(&jp->kp);
+}
+static inline int enable_jprobe(struct jprobe *jp)
+{
+        return enable_kprobe(&jp->kp);
+}
+
 #endif /* _LINUX_KPROBES_H */
diff --git a/include/linux/kvm.h b/include/linux/kvm.h
index 311a073afe8a..8cc137911b34 100644
--- a/include/linux/kvm.h
+++ b/include/linux/kvm.h
@@ -409,6 +409,8 @@ struct kvm_trace_rec {
 #ifdef __KVM_HAVE_DEVICE_ASSIGNMENT
 #define KVM_CAP_DEVICE_DEASSIGNMENT 27
 #endif
+/* Another bug in KVM_SET_USER_MEMORY_REGION fixed: */
+#define KVM_CAP_JOIN_MEMORY_REGIONS_WORKS 30
 
 #ifdef KVM_CAP_IRQ_ROUTING
 
diff --git a/include/linux/leds-bd2802.h b/include/linux/leds-bd2802.h
new file mode 100644
index 000000000000..42f854a1a199
--- /dev/null
+++ b/include/linux/leds-bd2802.h
@@ -0,0 +1,26 @@
+/*
+ * leds-bd2802.h - RGB LED Driver
+ *
+ * Copyright (C) 2009 Samsung Electronics
+ * Kim Kyuwon <q1.kim@samsung.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.
+ *
+ * Datasheet: http://www.rohm.com/products/databook/driver/pdf/bd2802gu-e.pdf
+ *
+ */
+#ifndef _LEDS_BD2802_H_
+#define _LEDS_BD2802_H_
+
+struct bd2802_led_platform_data{
+        int     reset_gpio;
+        u8      rgb_time;
+};
+
+#define RGB_TIME(slopedown, slopeup, waveform) \
+        ((slopedown) << 6 | (slopeup) << 4 | (waveform))
+
+#endif /* _LEDS_BD2802_H_ */
+
diff --git a/include/linux/leds.h b/include/linux/leds.h
index 24489da701e3..376fe07732ea 100644
--- a/include/linux/leds.h
+++ b/include/linux/leds.h
@@ -30,6 +30,7 @@ enum led_brightness {
 struct led_classdev {
         const char              *name;
         int                      brightness;
+        int                      max_brightness;
         int                      flags;
 
         /* Lower 16 bits reflect status */
@@ -140,7 +141,8 @@ struct gpio_led {
         const char *name;
         const char *default_trigger;
         unsigned        gpio;
-        u8              active_low;
+        u8              active_low : 1;
+        u8              retain_state_suspended : 1;
 };
 
 struct gpio_led_platform_data {
diff --git a/include/linux/leds_pwm.h b/include/linux/leds_pwm.h
new file mode 100644
index 000000000000..33a071167489
--- /dev/null
+++ b/include/linux/leds_pwm.h
@@ -0,0 +1,21 @@
+/*
+ * PWM LED driver data - see drivers/leds/leds-pwm.c
+ */
+#ifndef __LINUX_LEDS_PWM_H
+#define __LINUX_LEDS_PWM_H
+
+struct led_pwm {
+        const char      *name;
+        const char      *default_trigger;
+        unsigned        pwm_id;
+        u8              active_low;
+        unsigned        max_brightness;
+        unsigned        pwm_period_ns;
+};
+
+struct led_pwm_platform_data {
+        int                     num_leds;
+        struct led_pwm  *leds;
+};
+
+#endif
diff --git a/include/linux/libata.h b/include/linux/libata.h
index 76262d83656b..3d501db36a26 100644
--- a/include/linux/libata.h
+++ b/include/linux/libata.h
@@ -209,6 +209,7 @@ enum {
 
         /* bits 24:31 of ap->flags are reserved for LLD specific flags */
 
+
         /* struct ata_port pflags */
         ATA_PFLAG_EH_PENDING    = (1 << 0), /* EH pending */
         ATA_PFLAG_EH_IN_PROGRESS = (1 << 1), /* EH in progress */
@@ -225,6 +226,9 @@ enum {
         ATA_PFLAG_PM_PENDING    = (1 << 18), /* PM operation pending */
         ATA_PFLAG_INIT_GTM_VALID = (1 << 19), /* initial gtm data valid */
 
+        ATA_PFLAG_PIO32         = (1 << 20),  /* 32bit PIO */
+        ATA_PFLAG_PIO32CHANGE   = (1 << 21),  /* 32bit PIO can be turned on/off */
+
         /* struct ata_queued_cmd flags */
         ATA_QCFLAG_ACTIVE       = (1 << 0), /* cmd not yet ack'd to scsi lyer */
         ATA_QCFLAG_DMAMAP       = (1 << 1), /* SG table is DMA mapped */
@@ -379,7 +383,7 @@ enum {
         ATA_HORKAGE_BRIDGE_OK   = (1 << 10),    /* no bridge limits */
         ATA_HORKAGE_ATAPI_MOD16_DMA = (1 << 11), /* use ATAPI DMA for commands
                                                     not multiple of 16 bytes */
-        ATA_HORKAGE_FIRMWARE_WARN = (1 << 12),  /* firwmare update warning */
+        ATA_HORKAGE_FIRMWARE_WARN = (1 << 12),  /* firmware update warning */
         ATA_HORKAGE_1_5_GBPS    = (1 << 13),    /* force 1.5 Gbps */
 
          /* DMA mask for user DMA control: User visible values; DO NOT
@@ -689,7 +693,10 @@ struct ata_port {
         struct Scsi_Host        *scsi_host; /* our co-allocated scsi host */
         struct ata_port_operations *ops;
         spinlock_t              *lock;
+        /* Flags owned by the EH context. Only EH should touch these once the
+           port is active */
         unsigned long           flags;  /* ATA_FLAG_xxx */
+        /* Flags that change dynamically, protected by ap->lock */
         unsigned int            pflags; /* ATA_PFLAG_xxx */
         unsigned int            print_id; /* user visible unique port ID */
         unsigned int            port_no; /* 0 based port no. inside the host */
@@ -1595,6 +1602,7 @@ extern void ata_sff_drain_fifo(struct ata_queued_cmd *qc);
 extern void ata_sff_error_handler(struct ata_port *ap);
 extern void ata_sff_post_internal_cmd(struct ata_queued_cmd *qc);
 extern int ata_sff_port_start(struct ata_port *ap);
+extern int ata_sff_port_start32(struct ata_port *ap);
 extern void ata_sff_std_ports(struct ata_ioports *ioaddr);
 extern unsigned long ata_bmdma_mode_filter(struct ata_device *dev,
                                            unsigned long xfer_mask);
diff --git a/include/linux/lockd/xdr.h b/include/linux/lockd/xdr.h
index 7dc5b6cb44cd..d39ed1cc5fbf 100644
--- a/include/linux/lockd/xdr.h
+++ b/include/linux/lockd/xdr.h
@@ -25,13 +25,13 @@ struct svc_rqst;
 #define NLM_MAXCOOKIELEN        32
 #define NLM_MAXSTRLEN           1024
 
-#define nlm_granted             __constant_htonl(NLM_LCK_GRANTED)
-#define nlm_lck_denied          __constant_htonl(NLM_LCK_DENIED)
-#define nlm_lck_denied_nolocks  __constant_htonl(NLM_LCK_DENIED_NOLOCKS)
-#define nlm_lck_blocked         __constant_htonl(NLM_LCK_BLOCKED)
-#define nlm_lck_denied_grace_period     __constant_htonl(NLM_LCK_DENIED_GRACE_PERIOD)
+#define nlm_granted             cpu_to_be32(NLM_LCK_GRANTED)
+#define nlm_lck_denied          cpu_to_be32(NLM_LCK_DENIED)
+#define nlm_lck_denied_nolocks  cpu_to_be32(NLM_LCK_DENIED_NOLOCKS)
+#define nlm_lck_blocked         cpu_to_be32(NLM_LCK_BLOCKED)
+#define nlm_lck_denied_grace_period     cpu_to_be32(NLM_LCK_DENIED_GRACE_PERIOD)
 
-#define nlm_drop_reply          __constant_htonl(30000)
+#define nlm_drop_reply          cpu_to_be32(30000)
 
 /* Lock info passed via NLM */
 struct nlm_lock {
diff --git a/include/linux/lockd/xdr4.h b/include/linux/lockd/xdr4.h
index 12bfe09de2b1..7353821341ed 100644
--- a/include/linux/lockd/xdr4.h
+++ b/include/linux/lockd/xdr4.h
@@ -15,11 +15,11 @@
 #include <linux/lockd/xdr.h>
 
 /* error codes new to NLMv4 */
-#define nlm4_deadlock           __constant_htonl(NLM_DEADLCK)
-#define nlm4_rofs               __constant_htonl(NLM_ROFS)
-#define nlm4_stale_fh           __constant_htonl(NLM_STALE_FH)
-#define nlm4_fbig               __constant_htonl(NLM_FBIG)
-#define nlm4_failed             __constant_htonl(NLM_FAILED)
+#define nlm4_deadlock           cpu_to_be32(NLM_DEADLCK)
+#define nlm4_rofs               cpu_to_be32(NLM_ROFS)
+#define nlm4_stale_fh           cpu_to_be32(NLM_STALE_FH)
+#define nlm4_fbig               cpu_to_be32(NLM_FBIG)
+#define nlm4_failed             cpu_to_be32(NLM_FAILED)
 
 
 
diff --git a/include/linux/lockdep.h b/include/linux/lockdep.h
index 23bf02fb124f..da5a5a1f4cd2 100644
--- a/include/linux/lockdep.h
+++ b/include/linux/lockdep.h
@@ -20,43 +20,10 @@ struct lockdep_map;
 #include <linux/stacktrace.h>
 
 /*
- * Lock-class usage-state bits:
+ * We'd rather not expose kernel/lockdep_states.h this wide, but we do need
+ * the total number of states... :-(
  */
-enum lock_usage_bit
-{
-        LOCK_USED = 0,
-        LOCK_USED_IN_HARDIRQ,
-        LOCK_USED_IN_SOFTIRQ,
-        LOCK_ENABLED_SOFTIRQS,
-        LOCK_ENABLED_HARDIRQS,
-        LOCK_USED_IN_HARDIRQ_READ,
-        LOCK_USED_IN_SOFTIRQ_READ,
-        LOCK_ENABLED_SOFTIRQS_READ,
-        LOCK_ENABLED_HARDIRQS_READ,
-        LOCK_USAGE_STATES
-};
-
-/*
- * Usage-state bitmasks:
- */
-#define LOCKF_USED                      (1 << LOCK_USED)
-#define LOCKF_USED_IN_HARDIRQ           (1 << LOCK_USED_IN_HARDIRQ)
-#define LOCKF_USED_IN_SOFTIRQ           (1 << LOCK_USED_IN_SOFTIRQ)
-#define LOCKF_ENABLED_HARDIRQS          (1 << LOCK_ENABLED_HARDIRQS)
-#define LOCKF_ENABLED_SOFTIRQS          (1 << LOCK_ENABLED_SOFTIRQS)
-
-#define LOCKF_ENABLED_IRQS (LOCKF_ENABLED_HARDIRQS | LOCKF_ENABLED_SOFTIRQS)
-#define LOCKF_USED_IN_IRQ (LOCKF_USED_IN_HARDIRQ | LOCKF_USED_IN_SOFTIRQ)
-
-#define LOCKF_USED_IN_HARDIRQ_READ      (1 << LOCK_USED_IN_HARDIRQ_READ)
-#define LOCKF_USED_IN_SOFTIRQ_READ      (1 << LOCK_USED_IN_SOFTIRQ_READ)
-#define LOCKF_ENABLED_HARDIRQS_READ     (1 << LOCK_ENABLED_HARDIRQS_READ)
-#define LOCKF_ENABLED_SOFTIRQS_READ     (1 << LOCK_ENABLED_SOFTIRQS_READ)
-
-#define LOCKF_ENABLED_IRQS_READ \
-                (LOCKF_ENABLED_HARDIRQS_READ | LOCKF_ENABLED_SOFTIRQS_READ)
-#define LOCKF_USED_IN_IRQ_READ \
-                (LOCKF_USED_IN_HARDIRQ_READ | LOCKF_USED_IN_SOFTIRQ_READ)
+#define XXX_LOCK_USAGE_STATES           (1+3*4)
 
 #define MAX_LOCKDEP_SUBCLASSES          8UL
 
@@ -97,7 +64,7 @@ struct lock_class {
          * IRQ/softirq usage tracking bits:
          */
         unsigned long                   usage_mask;
-        struct stack_trace              usage_traces[LOCK_USAGE_STATES];
+        struct stack_trace              usage_traces[XXX_LOCK_USAGE_STATES];
 
         /*
          * These fields represent a directed graph of lock dependencies,
@@ -324,7 +291,11 @@ static inline void lock_set_subclass(struct lockdep_map *lock,
         lock_set_class(lock, lock->name, lock->key, subclass, ip);
 }
 
-# define INIT_LOCKDEP                           .lockdep_recursion = 0,
+extern void lockdep_set_current_reclaim_state(gfp_t gfp_mask);
+extern void lockdep_clear_current_reclaim_state(void);
+extern void lockdep_trace_alloc(gfp_t mask);
+
+# define INIT_LOCKDEP                           .lockdep_recursion = 0, .lockdep_reclaim_gfp = 0,
 
 #define lockdep_depth(tsk)      (debug_locks ? (tsk)->lockdep_depth : 0)
 
@@ -342,6 +313,9 @@ static inline void lockdep_on(void)
 # define lock_release(l, n, i)                  do { } while (0)
 # define lock_set_class(l, n, k, s, i)          do { } while (0)
 # define lock_set_subclass(l, s, i)             do { } while (0)
+# define lockdep_set_current_reclaim_state(g)   do { } while (0)
+# define lockdep_clear_current_reclaim_state()  do { } while (0)
+# define lockdep_trace_alloc(g)                 do { } while (0)
 # define lockdep_init()                         do { } while (0)
 # define lockdep_info()                         do { } while (0)
 # define lockdep_init_map(lock, name, key, sub) \
@@ -390,6 +364,23 @@ do {								\
 
 #endif /* CONFIG_LOCK_STAT */
 
+#ifdef CONFIG_LOCKDEP
+
+/*
+ * On lockdep we dont want the hand-coded irq-enable of
+ * _raw_*_lock_flags() code, because lockdep assumes
+ * that interrupts are not re-enabled during lock-acquire:
+ */
+#define LOCK_CONTENDED_FLAGS(_lock, try, lock, lockfl, flags) \
+        LOCK_CONTENDED((_lock), (try), (lock))
+
+#else /* CONFIG_LOCKDEP */
+
+#define LOCK_CONTENDED_FLAGS(_lock, try, lock, lockfl, flags) \
+        lockfl((_lock), (flags))
+
+#endif /* CONFIG_LOCKDEP */
+
 #ifdef CONFIG_GENERIC_HARDIRQS
 extern void early_init_irq_lock_class(void);
 #else
diff --git a/include/linux/loop.h b/include/linux/loop.h
index 6ffd6db5bb0d..40725447f5e0 100644
--- a/include/linux/loop.h
+++ b/include/linux/loop.h
@@ -160,5 +160,6 @@ int loop_unregister_transfer(int number);
 #define LOOP_SET_STATUS64       0x4C04
 #define LOOP_GET_STATUS64       0x4C05
 #define LOOP_CHANGE_FD          0x4C06
+#define LOOP_SET_CAPACITY       0x4C07
 
 #endif
diff --git a/include/linux/memcontrol.h b/include/linux/memcontrol.h
index 326f45c86530..25b9ca93d232 100644
--- a/include/linux/memcontrol.h
+++ b/include/linux/memcontrol.h
@@ -56,7 +56,7 @@ extern void mem_cgroup_move_lists(struct page *page,
                                   enum lru_list from, enum lru_list to);
 extern void mem_cgroup_uncharge_page(struct page *page);
 extern void mem_cgroup_uncharge_cache_page(struct page *page);
-extern int mem_cgroup_shrink_usage(struct page *page,
+extern int mem_cgroup_shmem_charge_fallback(struct page *page,
                         struct mm_struct *mm, gfp_t gfp_mask);
 
 extern unsigned long mem_cgroup_isolate_pages(unsigned long nr_to_scan,
@@ -75,7 +75,7 @@ int mm_match_cgroup(const struct mm_struct *mm, const struct mem_cgroup *cgroup)
 {
         struct mem_cgroup *mem;
         rcu_read_lock();
-        mem = mem_cgroup_from_task((mm)->owner);
+        mem = mem_cgroup_from_task(rcu_dereference((mm)->owner));
         rcu_read_unlock();
         return cgroup == mem;
 }
@@ -88,9 +88,6 @@ extern void mem_cgroup_end_migration(struct mem_cgroup *mem,
 /*
  * For memory reclaim.
  */
-extern int mem_cgroup_calc_mapped_ratio(struct mem_cgroup *mem);
-extern long mem_cgroup_reclaim_imbalance(struct mem_cgroup *mem);
-
 extern int mem_cgroup_get_reclaim_priority(struct mem_cgroup *mem);
 extern void mem_cgroup_note_reclaim_priority(struct mem_cgroup *mem,
                                                         int priority);
@@ -104,6 +101,8 @@ struct zone_reclaim_stat *mem_cgroup_get_reclaim_stat(struct mem_cgroup *memcg,
                                                       struct zone *zone);
 struct zone_reclaim_stat*
 mem_cgroup_get_reclaim_stat_from_page(struct page *page);
+extern void mem_cgroup_print_oom_info(struct mem_cgroup *memcg,
+                                        struct task_struct *p);
 
 #ifdef CONFIG_CGROUP_MEM_RES_CTLR_SWAP
 extern int do_swap_account;
@@ -156,7 +155,7 @@ static inline void mem_cgroup_uncharge_cache_page(struct page *page)
 {
 }
 
-static inline int mem_cgroup_shrink_usage(struct page *page,
+static inline int mem_cgroup_shmem_charge_fallback(struct page *page,
                         struct mm_struct *mm, gfp_t gfp_mask)
 {
         return 0;
@@ -209,16 +208,6 @@ static inline void mem_cgroup_end_migration(struct mem_cgroup *mem,
 {
 }
 
-static inline int mem_cgroup_calc_mapped_ratio(struct mem_cgroup *mem)
-{
-        return 0;
-}
-
-static inline int mem_cgroup_reclaim_imbalance(struct mem_cgroup *mem)
-{
-        return 0;
-}
-
 static inline int mem_cgroup_get_reclaim_priority(struct mem_cgroup *mem)
 {
         return 0;
@@ -270,6 +259,11 @@ mem_cgroup_get_reclaim_stat_from_page(struct page *page)
         return NULL;
 }
 
+static inline void
+mem_cgroup_print_oom_info(struct mem_cgroup *memcg, struct task_struct *p)
+{
+}
+
 #endif /* CONFIG_CGROUP_MEM_CONT */
 
 #endif /* _LINUX_MEMCONTROL_H */
diff --git a/include/linux/memory.h b/include/linux/memory.h
index 3fdc10806d31..37fa19b34ef5 100644
--- a/include/linux/memory.h
+++ b/include/linux/memory.h
@@ -99,4 +99,21 @@ enum mem_add_context { BOOT, HOTPLUG };
 #define hotplug_memory_notifier(fn, pri) do { } while (0)
 #endif
 
+/*
+ * 'struct memory_accessor' is a generic interface to provide
+ * in-kernel access to persistent memory such as i2c or SPI EEPROMs
+ */
+struct memory_accessor {
+        ssize_t (*read)(struct memory_accessor *, char *buf, off_t offset,
+                        size_t count);
+        ssize_t (*write)(struct memory_accessor *, const char *buf,
+                         off_t offset, size_t count);
+};
+
+/*
+ * Kernel text modification mutex, used for code patching. Users of this lock
+ * can sleep.
+ */
+extern struct mutex text_mutex;
+
 #endif /* _LINUX_MEMORY_H_ */
diff --git a/include/linux/mfd/ds1wm.h b/include/linux/mfd/ds1wm.h
new file mode 100644
index 000000000000..be469a357cbb
--- /dev/null
+++ b/include/linux/mfd/ds1wm.h
@@ -0,0 +1,6 @@
+/* MFD cell driver data for the DS1WM driver */
+
+struct ds1wm_driver_data {
+        int active_high;
+        int clock_rate;
+};
diff --git a/include/linux/mfd/htc-pasic3.h b/include/linux/mfd/htc-pasic3.h
index b4294f12c4f8..3d3ed67bd969 100644
--- a/include/linux/mfd/htc-pasic3.h
+++ b/include/linux/mfd/htc-pasic3.h
@@ -48,7 +48,6 @@ struct pasic3_leds_machinfo {
 
 struct pasic3_platform_data {
         struct pasic3_leds_machinfo *led_pdata;
-        unsigned int                 bus_shift;
         unsigned int                 clock_rate;
 };
 
diff --git a/include/linux/mfd/pcf50633/core.h b/include/linux/mfd/pcf50633/core.h
index 4455b212d75a..c8f51c3c0a72 100644
--- a/include/linux/mfd/pcf50633/core.h
+++ b/include/linux/mfd/pcf50633/core.h
@@ -29,6 +29,8 @@ struct pcf50633_platform_data {
         char **batteries;
         int num_batteries;
 
+        int charging_restart_interval;
+
         /* Callbacks */
         void (*probe_done)(struct pcf50633 *);
         void (*mbc_event_callback)(struct pcf50633 *, int);
diff --git a/include/linux/mfd/pcf50633/mbc.h b/include/linux/mfd/pcf50633/mbc.h
index 6e17619b773a..4119579acf2c 100644
--- a/include/linux/mfd/pcf50633/mbc.h
+++ b/include/linux/mfd/pcf50633/mbc.h
@@ -128,7 +128,6 @@ enum pcf50633_reg_mbcs3 {
 int pcf50633_mbc_usb_curlim_set(struct pcf50633 *pcf, int ma);
 
 int pcf50633_mbc_get_status(struct pcf50633 *);
-void pcf50633_mbc_set_status(struct pcf50633 *, int what, int status);
 
 #endif
 
diff --git a/include/linux/mfd/wm8350/core.h b/include/linux/mfd/wm8350/core.h
index 980669d50dca..42cca672f340 100644
--- a/include/linux/mfd/wm8350/core.h
+++ b/include/linux/mfd/wm8350/core.h
@@ -640,9 +640,11 @@ struct wm8350 {
  *
  * @init: Function called during driver initialisation.  Should be
  *        used by the platform to configure GPIO functions and similar.
+ * @irq_high: Set if WM8350 IRQ is active high.
  */
 struct wm8350_platform_data {
         int (*init)(struct wm8350 *wm8350);
+        int irq_high;
 };
 
 
diff --git a/include/linux/mg_disk.h b/include/linux/mg_disk.h
new file mode 100644
index 000000000000..1f76b1ebf627
--- /dev/null
+++ b/include/linux/mg_disk.h
@@ -0,0 +1,206 @@
+/*
+ *  include/linux/mg_disk.c
+ *
+ *  Support for the mGine m[g]flash IO mode.
+ *  Based on legacy hd.c
+ *
+ * (c) 2008 mGine Co.,LTD
+ * (c) 2008 unsik Kim <donari75@gmail.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 __MG_DISK_H__
+#define __MG_DISK_H__
+
+#include <linux/blkdev.h>
+#include <linux/ata.h>
+
+/* name for block device */
+#define MG_DISK_NAME "mgd"
+/* name for platform device */
+#define MG_DEV_NAME "mg_disk"
+
+#define MG_DISK_MAJ 0
+#define MG_DISK_MAX_PART 16
+#define MG_SECTOR_SIZE 512
+#define MG_MAX_SECTS 256
+
+/* Register offsets */
+#define MG_BUFF_OFFSET                  0x8000
+#define MG_STORAGE_BUFFER_SIZE          0x200
+#define MG_REG_OFFSET                   0xC000
+#define MG_REG_FEATURE                  (MG_REG_OFFSET + 2)     /* write case */
+#define MG_REG_ERROR                    (MG_REG_OFFSET + 2)     /* read case */
+#define MG_REG_SECT_CNT                 (MG_REG_OFFSET + 4)
+#define MG_REG_SECT_NUM                 (MG_REG_OFFSET + 6)
+#define MG_REG_CYL_LOW                  (MG_REG_OFFSET + 8)
+#define MG_REG_CYL_HIGH                 (MG_REG_OFFSET + 0xA)
+#define MG_REG_DRV_HEAD                 (MG_REG_OFFSET + 0xC)
+#define MG_REG_COMMAND                  (MG_REG_OFFSET + 0xE)   /* write case */
+#define MG_REG_STATUS                   (MG_REG_OFFSET + 0xE)   /* read  case */
+#define MG_REG_DRV_CTRL                 (MG_REG_OFFSET + 0x10)
+#define MG_REG_BURST_CTRL               (MG_REG_OFFSET + 0x12)
+
+/* "Drive Select/Head Register" bit values */
+#define MG_REG_HEAD_MUST_BE_ON          0xA0 /* These 2 bits are always on */
+#define MG_REG_HEAD_DRIVE_MASTER        (0x00 | MG_REG_HEAD_MUST_BE_ON)
+#define MG_REG_HEAD_DRIVE_SLAVE         (0x10 | MG_REG_HEAD_MUST_BE_ON)
+#define MG_REG_HEAD_LBA_MODE            (0x40 | MG_REG_HEAD_MUST_BE_ON)
+
+
+/* "Device Control Register" bit values */
+#define MG_REG_CTRL_INTR_ENABLE                 0x0
+#define MG_REG_CTRL_INTR_DISABLE                (0x1<<1)
+#define MG_REG_CTRL_RESET                       (0x1<<2)
+#define MG_REG_CTRL_INTR_POLA_ACTIVE_HIGH       0x0
+#define MG_REG_CTRL_INTR_POLA_ACTIVE_LOW        (0x1<<4)
+#define MG_REG_CTRL_DPD_POLA_ACTIVE_LOW         0x0
+#define MG_REG_CTRL_DPD_POLA_ACTIVE_HIGH        (0x1<<5)
+#define MG_REG_CTRL_DPD_DISABLE                 0x0
+#define MG_REG_CTRL_DPD_ENABLE                  (0x1<<6)
+
+/* Status register bit */
+/* error bit in status register */
+#define MG_REG_STATUS_BIT_ERROR                 0x01
+/* corrected error in status register */
+#define MG_REG_STATUS_BIT_CORRECTED_ERROR       0x04
+/* data request bit in status register */
+#define MG_REG_STATUS_BIT_DATA_REQ              0x08
+/* DSC - Drive Seek Complete */
+#define MG_REG_STATUS_BIT_SEEK_DONE             0x10
+/* DWF - Drive Write Fault */
+#define MG_REG_STATUS_BIT_WRITE_FAULT           0x20
+#define MG_REG_STATUS_BIT_READY                 0x40
+#define MG_REG_STATUS_BIT_BUSY                  0x80
+
+/* handy status */
+#define MG_STAT_READY   (MG_REG_STATUS_BIT_READY | MG_REG_STATUS_BIT_SEEK_DONE)
+#define MG_READY_OK(s)  (((s) & (MG_STAT_READY | \
+                                (MG_REG_STATUS_BIT_BUSY | \
+                                 MG_REG_STATUS_BIT_WRITE_FAULT | \
+                                 MG_REG_STATUS_BIT_ERROR))) == MG_STAT_READY)
+
+/* Error register */
+#define MG_REG_ERR_AMNF         0x01
+#define MG_REG_ERR_ABRT         0x04
+#define MG_REG_ERR_IDNF         0x10
+#define MG_REG_ERR_UNC          0x40
+#define MG_REG_ERR_BBK          0x80
+
+/* error code for others */
+#define MG_ERR_NONE             0
+#define MG_ERR_TIMEOUT          0x100
+#define MG_ERR_INIT_STAT        0x101
+#define MG_ERR_TRANSLATION      0x102
+#define MG_ERR_CTRL_RST         0x103
+#define MG_ERR_INV_STAT         0x104
+#define MG_ERR_RSTOUT           0x105
+
+#define MG_MAX_ERRORS   6       /* Max read/write errors */
+
+/* command */
+#define MG_CMD_RD 0x20
+#define MG_CMD_WR 0x30
+#define MG_CMD_SLEEP 0x99
+#define MG_CMD_WAKEUP 0xC3
+#define MG_CMD_ID 0xEC
+#define MG_CMD_WR_CONF 0x3C
+#define MG_CMD_RD_CONF 0x40
+
+/* operation mode */
+#define MG_OP_CASCADE (1 << 0)
+#define MG_OP_CASCADE_SYNC_RD (1 << 1)
+#define MG_OP_CASCADE_SYNC_WR (1 << 2)
+#define MG_OP_INTERLEAVE (1 << 3)
+
+/* synchronous */
+#define MG_BURST_LAT_4 (3 << 4)
+#define MG_BURST_LAT_5 (4 << 4)
+#define MG_BURST_LAT_6 (5 << 4)
+#define MG_BURST_LAT_7 (6 << 4)
+#define MG_BURST_LAT_8 (7 << 4)
+#define MG_BURST_LEN_4 (1 << 1)
+#define MG_BURST_LEN_8 (2 << 1)
+#define MG_BURST_LEN_16 (3 << 1)
+#define MG_BURST_LEN_32 (4 << 1)
+#define MG_BURST_LEN_CONT (0 << 1)
+
+/* timeout value (unit: ms) */
+#define MG_TMAX_CONF_TO_CMD     1
+#define MG_TMAX_WAIT_RD_DRQ     10
+#define MG_TMAX_WAIT_WR_DRQ     500
+#define MG_TMAX_RST_TO_BUSY     10
+#define MG_TMAX_HDRST_TO_RDY    500
+#define MG_TMAX_SWRST_TO_RDY    500
+#define MG_TMAX_RSTOUT          3000
+
+/* device attribution */
+/* use mflash as boot device */
+#define MG_BOOT_DEV             (1 << 0)
+/* use mflash as storage device */
+#define MG_STORAGE_DEV          (1 << 1)
+/* same as MG_STORAGE_DEV, but bootloader already done reset sequence */
+#define MG_STORAGE_DEV_SKIP_RST (1 << 2)
+
+#define MG_DEV_MASK (MG_BOOT_DEV | MG_STORAGE_DEV | MG_STORAGE_DEV_SKIP_RST)
+
+/* names of GPIO resource */
+#define MG_RST_PIN      "mg_rst"
+/* except MG_BOOT_DEV, reset-out pin should be assigned */
+#define MG_RSTOUT_PIN   "mg_rstout"
+
+/* private driver data */
+struct mg_drv_data {
+        /* disk resource */
+        u32 use_polling;
+
+        /* device attribution */
+        u32 dev_attr;
+
+        /* internally used */
+        struct mg_host *host;
+};
+
+/* main structure for mflash driver */
+struct mg_host {
+        struct device *dev;
+
+        struct request_queue *breq;
+        spinlock_t lock;
+        struct gendisk *gd;
+
+        struct timer_list timer;
+        void (*mg_do_intr) (struct mg_host *);
+
+        u16 id[ATA_ID_WORDS];
+
+        u16 cyls;
+        u16 heads;
+        u16 sectors;
+        u32 n_sectors;
+        u32 nres_sectors;
+
+        void __iomem *dev_base;
+        unsigned int irq;
+        unsigned int rst;
+        unsigned int rstout;
+
+        u32 major;
+        u32 error;
+};
+
+/*
+ * Debugging macro and defines
+ */
+#undef DO_MG_DEBUG
+#ifdef DO_MG_DEBUG
+#  define MG_DBG(fmt, args...) \
+        printk(KERN_DEBUG "%s:%d "fmt, __func__, __LINE__, ##args)
+#else /* CONFIG_MG_DEBUG */
+#  define MG_DBG(fmt, args...) do { } while (0)
+#endif /* CONFIG_MG_DEBUG */
+
+#endif
diff --git a/include/linux/mm.h b/include/linux/mm.h
index 065cdf8c09fb..bff1f0d475c7 100644
--- a/include/linux/mm.h
+++ b/include/linux/mm.h
@@ -104,6 +104,7 @@ extern unsigned int kobjsize(const void *objp);
 #define VM_CAN_NONLINEAR 0x08000000     /* Has ->fault & does nonlinear pages */
 #define VM_MIXEDMAP     0x10000000      /* Can contain "struct page" and pure PFN pages */
 #define VM_SAO          0x20000000      /* Strong Access Ordering (powerpc) */
+#define VM_PFN_AT_MMAP  0x40000000      /* PFNMAP vma that is fully mapped at mmap time */
 
 #ifndef VM_STACK_DEFAULT_FLAGS          /* arch can override this */
 #define VM_STACK_DEFAULT_FLAGS VM_DATA_DEFAULT_FLAGS
@@ -134,6 +135,7 @@ 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 */
+#define FAULT_FLAG_MKWRITE      0x04    /* Fault was mkwrite of existing pte */
 
 /*
  * This interface is used by x86 PAT code to identify a pfn mapping that is
@@ -145,7 +147,7 @@ extern pgprot_t protection_map[16];
  */
 static inline int is_linear_pfn_mapping(struct vm_area_struct *vma)
 {
-        return ((vma->vm_flags & VM_PFNMAP) && vma->vm_pgoff);
+        return (vma->vm_flags & VM_PFN_AT_MMAP);
 }
 
 static inline int is_pfn_mapping(struct vm_area_struct *vma)
@@ -186,7 +188,7 @@ struct vm_operations_struct {
 
         /* notification that a previously read-only page is about to become
          * writable, if an error is returned it will cause a SIGBUS */
-        int (*page_mkwrite)(struct vm_area_struct *vma, struct page *page);
+        int (*page_mkwrite)(struct vm_area_struct *vma, struct vm_fault *vmf);
 
         /* called by access_process_vm when get_user_pages() fails, typically
          * for use by special VMAs that can switch between memory and hardware
@@ -833,6 +835,7 @@ int __set_page_dirty_nobuffers(struct page *page);
 int __set_page_dirty_no_writeback(struct page *page);
 int redirty_page_for_writepage(struct writeback_control *wbc,
                                 struct page *page);
+void account_page_dirtied(struct page *page, struct address_space *mapping);
 int set_page_dirty(struct page *page);
 int set_page_dirty_lock(struct page *page);
 int clear_page_dirty_for_io(struct page *page);
@@ -1076,7 +1079,7 @@ static inline void setup_per_cpu_pageset(void) {}
 #endif
 
 /* nommu.c */
-extern atomic_t mmap_pages_allocated;
+extern atomic_long_t mmap_pages_allocated;
 
 /* prio_tree.c */
 void vma_prio_tree_add(struct vm_area_struct *, struct vm_area_struct *old);
diff --git a/include/linux/mm_types.h b/include/linux/mm_types.h
index d84feb7bdbf0..0e80e26ecf21 100644
--- a/include/linux/mm_types.h
+++ b/include/linux/mm_types.h
@@ -11,6 +11,7 @@
 #include <linux/rwsem.h>
 #include <linux/completion.h>
 #include <linux/cpumask.h>
+#include <linux/page-debug-flags.h>
 #include <asm/page.h>
 #include <asm/mmu.h>
 
@@ -94,6 +95,9 @@ struct page {
         void *virtual;                  /* Kernel virtual address (NULL if
                                            not kmapped, ie. highmem) */
 #endif /* WANT_PAGE_VIRTUAL */
+#ifdef CONFIG_WANT_PAGE_DEBUG_FLAGS
+        unsigned long debug_flags;      /* Use atomic bitops on this */
+#endif
 };
 
 /*
diff --git a/include/linux/mman.h b/include/linux/mman.h
index 30d1073bac3b..9872d6ca58ae 100644
--- a/include/linux/mman.h
+++ b/include/linux/mman.h
@@ -12,21 +12,18 @@
 
 #ifdef __KERNEL__
 #include <linux/mm.h>
+#include <linux/percpu_counter.h>
 
 #include <asm/atomic.h>
 
 extern int sysctl_overcommit_memory;
 extern int sysctl_overcommit_ratio;
-extern atomic_long_t vm_committed_space;
+extern struct percpu_counter vm_committed_as;
 
-#ifdef CONFIG_SMP
-extern void vm_acct_memory(long pages);
-#else
 static inline void vm_acct_memory(long pages)
 {
-        atomic_long_add(pages, &vm_committed_space);
+        percpu_counter_add(&vm_committed_as, pages);
 }
-#endif
 
 static inline void vm_unacct_memory(long pages)
 {
diff --git a/include/linux/mmc/host.h b/include/linux/mmc/host.h
index 4e457256bd33..3e7615e9087e 100644
--- a/include/linux/mmc/host.h
+++ b/include/linux/mmc/host.h
@@ -192,5 +192,10 @@ static inline void mmc_signal_sdio_irq(struct mmc_host *host)
         wake_up_process(host->sdio_irq_thread);
 }
 
+struct regulator;
+
+int mmc_regulator_get_ocrmask(struct regulator *supply);
+int mmc_regulator_set_ocr(struct regulator *supply, unsigned short vdd_bit);
+
 #endif
 
diff --git a/include/linux/mmzone.h b/include/linux/mmzone.h
index 1aca6cebbb78..186ec6ab334d 100644
--- a/include/linux/mmzone.h
+++ b/include/linux/mmzone.h
@@ -764,12 +764,6 @@ extern int numa_zonelist_order_handler(struct ctl_table *, int,
 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
-#define numa_node_id()          (cpu_to_node(raw_smp_processor_id()))
-#endif
-
 #ifndef CONFIG_NEED_MULTIPLE_NODES
 
 extern struct pglist_data contig_page_data;
@@ -806,6 +800,14 @@ extern struct zone *next_zone(struct zone *zone);
              zone;                                      \
              zone = next_zone(zone))
 
+#define for_each_populated_zone(zone)                   \
+        for (zone = (first_online_pgdat())->node_zones; \
+             zone;                                      \
+             zone = next_zone(zone))                    \
+                if (!populated_zone(zone))              \
+                        ; /* do nothing */              \
+                else
+
 static inline struct zone *zonelist_zone(struct zoneref *zoneref)
 {
         return zoneref->zone;
diff --git a/include/linux/mnt_namespace.h b/include/linux/mnt_namespace.h
index 830bbcd449d6..3a059298cc19 100644
--- a/include/linux/mnt_namespace.h
+++ b/include/linux/mnt_namespace.h
@@ -22,6 +22,8 @@ struct proc_mounts {
         int event;
 };
 
+struct fs_struct;
+
 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 145a75528cc1..627ac082e2a6 100644
--- a/include/linux/module.h
+++ b/include/linux/module.h
@@ -248,6 +248,10 @@ struct module
         const unsigned long *crcs;
         unsigned int num_syms;
 
+        /* Kernel parameters. */
+        struct kernel_param *kp;
+        unsigned int num_kp;
+
         /* GPL-only exported symbols. */
         unsigned int num_gpl_syms;
         const struct kernel_symbol *gpl_syms;
@@ -329,6 +333,11 @@ struct module
         unsigned int num_tracepoints;
 #endif
 
+#ifdef CONFIG_TRACING
+        const char **trace_bprintk_fmt_start;
+        unsigned int num_trace_bprintk_fmt;
+#endif
+
 #ifdef CONFIG_MODULE_UNLOAD
         /* What modules depend on me? */
         struct list_head modules_which_use_me;
@@ -350,6 +359,8 @@ struct module
 #define MODULE_ARCH_INIT {}
 #endif
 
+extern struct mutex module_mutex;
+
 /* FIXME: It'd be nice to isolate modules during init, too, so they
    aren't used before they (may) fail.  But presently too much code
    (IDE & SCSI) require entry into the module during init.*/
@@ -358,10 +369,10 @@ static inline int module_is_live(struct module *mod)
         return mod->state != MODULE_STATE_GOING;
 }
 
-/* Is this address in a module? (second is with no locks, for oops) */
-struct module *module_text_address(unsigned long addr);
 struct module *__module_text_address(unsigned long addr);
-int is_module_address(unsigned long addr);
+struct module *__module_address(unsigned long addr);
+bool is_module_address(unsigned long addr);
+bool is_module_text_address(unsigned long addr);
 
 static inline int within_module_core(unsigned long addr, struct module *mod)
 {
@@ -375,6 +386,31 @@ static inline int within_module_init(unsigned long addr, struct module *mod)
                addr < (unsigned long)mod->module_init + mod->init_size;
 }
 
+/* Search for module by name: must hold module_mutex. */
+struct module *find_module(const char *name);
+
+struct symsearch {
+        const struct kernel_symbol *start, *stop;
+        const unsigned long *crcs;
+        enum {
+                NOT_GPL_ONLY,
+                GPL_ONLY,
+                WILL_BE_GPL_ONLY,
+        } licence;
+        bool unused;
+};
+
+/* Search for an exported symbol by name. */
+const struct kernel_symbol *find_symbol(const char *name,
+                                        struct module **owner,
+                                        const unsigned long **crc,
+                                        bool gplok,
+                                        bool warn);
+
+/* Walk the exported symbol table */
+bool each_symbol(bool (*fn)(const struct symsearch *arr, struct module *owner,
+                            unsigned int symnum, void *data), void *data);
+
 /* Returns 0 and fills in value, defined and namebuf, or -ERANGE if
    symnum out of range. */
 int module_get_kallsym(unsigned int symnum, unsigned long *value, char *type,
@@ -383,6 +419,10 @@ int module_get_kallsym(unsigned int symnum, unsigned long *value, char *type,
 /* Look for this name: can be of form module:name. */
 unsigned long module_kallsyms_lookup_name(const char *name);
 
+int module_kallsyms_on_each_symbol(int (*fn)(void *, const char *,
+                                             struct module *, unsigned long),
+                                   void *data);
+
 extern void __module_put_and_exit(struct module *mod, long code)
         __attribute__((noreturn));
 #define module_put_and_exit(code) __module_put_and_exit(THIS_MODULE, code);
@@ -444,6 +484,7 @@ static inline void __module_get(struct module *module)
 #define symbol_put_addr(p) do { } while(0)
 
 #endif /* CONFIG_MODULE_UNLOAD */
+int use_module(struct module *a, struct module *b);
 
 /* This is a #define so the string doesn't get put in every .o file */
 #define module_name(mod)                        \
@@ -490,21 +531,24 @@ search_module_extables(unsigned long addr)
         return NULL;
 }
 
-/* Is this address in a module? */
-static inline struct module *module_text_address(unsigned long addr)
+static inline struct module *__module_address(unsigned long addr)
 {
         return NULL;
 }
 
-/* Is this address in a module? (don't take a lock, we're oopsing) */
 static inline struct module *__module_text_address(unsigned long addr)
 {
         return NULL;
 }
 
-static inline int is_module_address(unsigned long addr)
+static inline bool is_module_address(unsigned long addr)
 {
-        return 0;
+        return false;
+}
+
+static inline bool is_module_text_address(unsigned long addr)
+{
+        return false;
 }
 
 /* Get/put a kernel symbol (calls should be symmetric) */
@@ -559,6 +603,14 @@ static inline unsigned long module_kallsyms_lookup_name(const char *name)
         return 0;
 }
 
+static inline int module_kallsyms_on_each_symbol(int (*fn)(void *, const char *,
+                                                           struct module *,
+                                                           unsigned long),
+                                                 void *data)
+{
+        return 0;
+}
+
 static inline int register_module_notifier(struct notifier_block * nb)
 {
         /* no events will happen anyway, so this can always succeed */
diff --git a/include/linux/moduleparam.h b/include/linux/moduleparam.h
index e4af3399ef48..a4f0b931846c 100644
--- a/include/linux/moduleparam.h
+++ b/include/linux/moduleparam.h
@@ -138,6 +138,16 @@ extern int parse_args(const char *name,
                       unsigned num,
                       int (*unknown)(char *param, char *val));
 
+/* Called by module remove. */
+#ifdef CONFIG_SYSFS
+extern void destroy_params(const struct kernel_param *params, unsigned num);
+#else
+static inline void destroy_params(const struct kernel_param *params,
+                                  unsigned num)
+{
+}
+#endif /* !CONFIG_SYSFS */
+
 /* All the helper functions */
 /* The macros to do compile-time type checking stolen from Jakub
    Jelinek, who IIRC came up with this idea for the 2.4 module init code. */
diff --git a/include/linux/mpage.h b/include/linux/mpage.h
index 5c42821da2d1..068a0c9946af 100644
--- a/include/linux/mpage.h
+++ b/include/linux/mpage.h
@@ -11,21 +11,11 @@
  */
 #ifdef CONFIG_BLOCK
 
-struct mpage_data {
-        struct bio *bio;
-        sector_t last_block_in_bio;
-        get_block_t *get_block;
-        unsigned use_writepage;
-};
-
 struct writeback_control;
 
-struct bio *mpage_bio_submit(int rw, struct bio *bio);
 int mpage_readpages(struct address_space *mapping, struct list_head *pages,
                                 unsigned nr_pages, get_block_t get_block);
 int mpage_readpage(struct page *page, get_block_t get_block);
-int __mpage_writepage(struct page *page, struct writeback_control *wbc,
-                      void *data);
 int mpage_writepages(struct address_space *mapping,
                 struct writeback_control *wbc, get_block_t get_block);
 int mpage_writepage(struct page *page, get_block_t *get_block,
diff --git a/include/linux/msi.h b/include/linux/msi.h
index d2b8a1e8ca11..6991ab5b24d1 100644
--- a/include/linux/msi.h
+++ b/include/linux/msi.h
@@ -20,20 +20,23 @@ extern void write_msi_msg(unsigned int irq, struct msi_msg *msg);
 
 struct msi_desc {
         struct {
-                __u8    type    : 5;    /* {0: unused, 5h:MSI, 11h:MSI-X} */
+                __u8    is_msix : 1;
+                __u8    multiple: 3;    /* log2 number of messages */
                 __u8    maskbit : 1;    /* mask-pending bit supported ?   */
-                __u8    masked  : 1;
                 __u8    is_64   : 1;    /* Address size: 0=32bit 1=64bit  */
                 __u8    pos;            /* Location of the msi capability */
-                __u32   maskbits_mask;  /* mask bits mask */
                 __u16   entry_nr;       /* specific enabled entry         */
                 unsigned default_irq;   /* default pre-assigned irq       */
-        }msi_attrib;
+        } msi_attrib;
 
+        u32 masked;                     /* mask bits */
         unsigned int irq;
         struct list_head list;
 
-        void __iomem *mask_base;
+        union {
+                void __iomem *mask_base;
+                u8 mask_pos;
+        };
         struct pci_dev *dev;
 
         /* Last set MSI message */
diff --git a/include/linux/mtd/mtd.h b/include/linux/mtd/mtd.h
index 3aa5d77c2cdb..5675b63a0631 100644
--- a/include/linux/mtd/mtd.h
+++ b/include/linux/mtd/mtd.h
@@ -11,6 +11,7 @@
 #include <linux/module.h>
 #include <linux/uio.h>
 #include <linux/notifier.h>
+#include <linux/device.h>
 
 #include <linux/mtd/compatmac.h>
 #include <mtd/mtd-abi.h>
@@ -162,6 +163,20 @@ struct mtd_info {
         /* We probably shouldn't allow XIP if the unpoint isn't a NULL */
         void (*unpoint) (struct mtd_info *mtd, loff_t from, size_t len);
 
+        /* Allow NOMMU mmap() to directly map the device (if not NULL)
+         * - return the address to which the offset maps
+         * - return -ENOSYS to indicate refusal to do the mapping
+         */
+        unsigned long (*get_unmapped_area) (struct mtd_info *mtd,
+                                            unsigned long len,
+                                            unsigned long offset,
+                                            unsigned long flags);
+
+        /* Backing device capabilities for this device
+         * - provides mmap capabilities
+         */
+        struct backing_dev_info *backing_dev_info;
+
 
         int (*read) (struct mtd_info *mtd, loff_t from, size_t len, size_t *retlen, u_char *buf);
         int (*write) (struct mtd_info *mtd, loff_t to, size_t len, size_t *retlen, const u_char *buf);
@@ -223,6 +238,7 @@ struct mtd_info {
         void *priv;
 
         struct module *owner;
+        struct device dev;
         int usecount;
 
         /* If the driver is something smart, like UBI, it may need to maintain
@@ -233,6 +249,11 @@ struct mtd_info {
         void (*put_device) (struct mtd_info *mtd);
 };
 
+static inline struct mtd_info *dev_to_mtd(struct device *dev)
+{
+        return dev ? container_of(dev, struct mtd_info, dev) : NULL;
+}
+
 static inline uint32_t mtd_div_by_eb(uint64_t sz, struct mtd_info *mtd)
 {
         if (mtd->erasesize_shift)
diff --git a/include/linux/mtd/nand.h b/include/linux/mtd/nand.h
index db5b63da2a7e..7efb9be34662 100644
--- a/include/linux/mtd/nand.h
+++ b/include/linux/mtd/nand.h
@@ -43,8 +43,8 @@ extern void nand_wait_ready(struct mtd_info *mtd);
  * is supported now. If you add a chip with bigger oobsize/page
  * adjust this accordingly.
  */
-#define NAND_MAX_OOBSIZE        64
-#define NAND_MAX_PAGESIZE       2048
+#define NAND_MAX_OOBSIZE        128
+#define NAND_MAX_PAGESIZE       4096
 
 /*
  * Constants for hardware specific CLE/ALE/NCE function
diff --git a/include/linux/mtd/partitions.h b/include/linux/mtd/partitions.h
index a45dd831b3f8..7535a74083b9 100644
--- a/include/linux/mtd/partitions.h
+++ b/include/linux/mtd/partitions.h
@@ -76,4 +76,16 @@ int __devinit of_mtd_parse_partitions(struct device *dev,
                                       struct device_node *node,
                                       struct mtd_partition **pparts);
 
+#ifdef CONFIG_MTD_PARTITIONS
+static inline int mtd_has_partitions(void) { return 1; }
+#else
+static inline int mtd_has_partitions(void) { return 0; }
+#endif
+
+#ifdef CONFIG_MTD_CMDLINE_PARTS
+static inline int mtd_has_cmdlinepart(void) { return 1; }
+#else
+static inline int mtd_has_cmdlinepart(void) { return 0; }
+#endif
+
 #endif
diff --git a/include/linux/mutex.h b/include/linux/mutex.h
index 7a0e5c4f8072..3069ec7e0ab8 100644
--- a/include/linux/mutex.h
+++ b/include/linux/mutex.h
@@ -50,8 +50,10 @@ struct mutex {
         atomic_t                count;
         spinlock_t              wait_lock;
         struct list_head        wait_list;
-#ifdef CONFIG_DEBUG_MUTEXES
+#if defined(CONFIG_DEBUG_MUTEXES) || defined(CONFIG_SMP)
         struct thread_info      *owner;
+#endif
+#ifdef CONFIG_DEBUG_MUTEXES
         const char              *name;
         void                    *magic;
 #endif
@@ -68,7 +70,6 @@ struct mutex_waiter {
         struct list_head        list;
         struct task_struct      *task;
 #ifdef CONFIG_DEBUG_MUTEXES
-        struct mutex            *lock;
         void                    *magic;
 #endif
 };
diff --git a/include/linux/netdevice.h b/include/linux/netdevice.h
index 2e7783f4a755..5a96a1a406e9 100644
--- a/include/linux/netdevice.h
+++ b/include/linux/netdevice.h
@@ -104,7 +104,7 @@ struct wireless_dev;
 # else
 #  define LL_MAX_HEADER 96
 # endif
-#elif defined(CONFIG_TR)
+#elif defined(CONFIG_TR) || defined(CONFIG_TR_MODULE)
 # define LL_MAX_HEADER 48
 #else
 # define LL_MAX_HEADER 32
@@ -500,7 +500,7 @@ struct netdev_queue {
  *
  * int (*ndo_set_mac_address)(struct net_device *dev, void *addr);
  *      This function  is called when the Media Access Control address
- *      needs to be changed. If not this interface is not defined, the
+ *      needs to be changed. If this interface is not defined, the
  *      mac address can not be changed.
  *
  * int (*ndo_validate_addr)(struct net_device *dev);
diff --git a/include/linux/netfilter/nfnetlink_conntrack.h b/include/linux/netfilter/nfnetlink_conntrack.h
index 29fe9ea1d346..1a865e48b8eb 100644
--- a/include/linux/netfilter/nfnetlink_conntrack.h
+++ b/include/linux/netfilter/nfnetlink_conntrack.h
@@ -100,6 +100,7 @@ enum ctattr_protoinfo_tcp {
 enum ctattr_protoinfo_dccp {
         CTA_PROTOINFO_DCCP_UNSPEC,
         CTA_PROTOINFO_DCCP_STATE,
+        CTA_PROTOINFO_DCCP_ROLE,
         __CTA_PROTOINFO_DCCP_MAX,
 };
 #define CTA_PROTOINFO_DCCP_MAX (__CTA_PROTOINFO_DCCP_MAX - 1)
diff --git a/include/linux/netfilter/x_tables.h b/include/linux/netfilter/x_tables.h
index 7b1a652066c0..c9efe039dc57 100644
--- a/include/linux/netfilter/x_tables.h
+++ b/include/linux/netfilter/x_tables.h
@@ -354,9 +354,6 @@ struct xt_table
         /* What hooks you will enter on */
         unsigned int valid_hooks;
 
-        /* Lock for the curtain */
-        struct mutex lock;
-
         /* Man behind the curtain... */
         struct xt_table_info *private;
 
@@ -434,8 +431,74 @@ extern void xt_proto_fini(struct net *net, u_int8_t af);
 
 extern struct xt_table_info *xt_alloc_table_info(unsigned int size);
 extern void xt_free_table_info(struct xt_table_info *info);
-extern void xt_table_entry_swap_rcu(struct xt_table_info *old,
-                                    struct xt_table_info *new);
+
+/*
+ * Per-CPU spinlock associated with per-cpu table entries, and
+ * with a counter for the "reading" side that allows a recursive
+ * reader to avoid taking the lock and deadlocking.
+ *
+ * "reading" is used by ip/arp/ip6 tables rule processing which runs per-cpu.
+ * It needs to ensure that the rules are not being changed while the packet
+ * is being processed. In some cases, the read lock will be acquired
+ * twice on the same CPU; this is okay because of the count.
+ *
+ * "writing" is used when reading counters.
+ *  During replace any readers that are using the old tables have to complete
+ *  before freeing the old table. This is handled by the write locking
+ *  necessary for reading the counters.
+ */
+struct xt_info_lock {
+        spinlock_t lock;
+        unsigned char readers;
+};
+DECLARE_PER_CPU(struct xt_info_lock, xt_info_locks);
+
+/*
+ * Note: we need to ensure that preemption is disabled before acquiring
+ * the per-cpu-variable, so we do it as a two step process rather than
+ * using "spin_lock_bh()".
+ *
+ * We _also_ need to disable bottom half processing before updating our
+ * nesting count, to make sure that the only kind of re-entrancy is this
+ * code being called by itself: since the count+lock is not an atomic
+ * operation, we can allow no races.
+ *
+ * _Only_ that special combination of being per-cpu and never getting
+ * re-entered asynchronously means that the count is safe.
+ */
+static inline void xt_info_rdlock_bh(void)
+{
+        struct xt_info_lock *lock;
+
+        local_bh_disable();
+        lock = &__get_cpu_var(xt_info_locks);
+        if (likely(!lock->readers++))
+                spin_lock(&lock->lock);
+}
+
+static inline void xt_info_rdunlock_bh(void)
+{
+        struct xt_info_lock *lock = &__get_cpu_var(xt_info_locks);
+
+        if (likely(!--lock->readers))
+                spin_unlock(&lock->lock);
+        local_bh_enable();
+}
+
+/*
+ * The "writer" side needs to get exclusive access to the lock,
+ * regardless of readers.  This must be called with bottom half
+ * processing (and thus also preemption) disabled.
+ */
+static inline void xt_info_wrlock(unsigned int cpu)
+{
+        spin_lock(&per_cpu(xt_info_locks, cpu).lock);
+}
+
+static inline void xt_info_wrunlock(unsigned int cpu)
+{
+        spin_unlock(&per_cpu(xt_info_locks, cpu).lock);
+}
 
 /*
  * This helper is performance critical and must be inlined
diff --git a/include/linux/netpoll.h b/include/linux/netpoll.h
index de99025f2c5d..2524267210d3 100644
--- a/include/linux/netpoll.h
+++ b/include/linux/netpoll.h
@@ -18,7 +18,7 @@ struct netpoll {
         const char *name;
         void (*rx_hook)(struct netpoll *, int, char *, int);
 
-        u32 local_ip, remote_ip;
+        __be32 local_ip, remote_ip;
         u16 local_port, remote_port;
         u8 remote_mac[ETH_ALEN];
 };
diff --git a/include/linux/nfs.h b/include/linux/nfs.h
index 54af92c1c70b..214d499718f7 100644
--- a/include/linux/nfs.h
+++ b/include/linux/nfs.h
@@ -109,7 +109,6 @@
         NFSERR_FILE_OPEN = 10046,      /*       v4 */
         NFSERR_ADMIN_REVOKED = 10047,  /*       v4 */
         NFSERR_CB_PATH_DOWN = 10048,   /*       v4 */
-        NFSERR_REPLAY_ME = 10049        /*       v4 */
 };
 
 /* NFSv2 file types - beware, these are not the same in NFSv3 */
diff --git a/include/linux/nfs4.h b/include/linux/nfs4.h
index b912311a56b1..e3f0cbcbd0db 100644
--- a/include/linux/nfs4.h
+++ b/include/linux/nfs4.h
@@ -21,6 +21,7 @@
 #define NFS4_FHSIZE             128
 #define NFS4_MAXPATHLEN         PATH_MAX
 #define NFS4_MAXNAMLEN          NAME_MAX
+#define NFS4_MAX_SESSIONID_LEN  16
 
 #define NFS4_ACCESS_READ        0x0001
 #define NFS4_ACCESS_LOOKUP      0x0002
@@ -38,6 +39,7 @@
 #define NFS4_OPEN_RESULT_CONFIRM 0x0002
 #define NFS4_OPEN_RESULT_LOCKTYPE_POSIX 0x0004
 
+#define NFS4_SHARE_ACCESS_MASK  0x000F
 #define NFS4_SHARE_ACCESS_READ  0x0001
 #define NFS4_SHARE_ACCESS_WRITE 0x0002
 #define NFS4_SHARE_ACCESS_BOTH  0x0003
@@ -45,6 +47,19 @@
 #define NFS4_SHARE_DENY_WRITE   0x0002
 #define NFS4_SHARE_DENY_BOTH    0x0003
 
+/* nfs41 */
+#define NFS4_SHARE_WANT_MASK            0xFF00
+#define NFS4_SHARE_WANT_NO_PREFERENCE   0x0000
+#define NFS4_SHARE_WANT_READ_DELEG      0x0100
+#define NFS4_SHARE_WANT_WRITE_DELEG     0x0200
+#define NFS4_SHARE_WANT_ANY_DELEG       0x0300
+#define NFS4_SHARE_WANT_NO_DELEG        0x0400
+#define NFS4_SHARE_WANT_CANCEL          0x0500
+
+#define NFS4_SHARE_WHEN_MASK            0xF0000
+#define NFS4_SHARE_SIGNAL_DELEG_WHEN_RESRC_AVAIL        0x10000
+#define NFS4_SHARE_PUSH_DELEG_WHEN_UNCONTENDED          0x20000
+
 #define NFS4_SET_TO_SERVER_TIME 0
 #define NFS4_SET_TO_CLIENT_TIME 1
 
@@ -88,6 +103,31 @@
 #define NFS4_ACE_GENERIC_EXECUTE              0x001200A0
 #define NFS4_ACE_MASK_ALL                     0x001F01FF
 
+#define EXCHGID4_FLAG_SUPP_MOVED_REFER          0x00000001
+#define EXCHGID4_FLAG_SUPP_MOVED_MIGR           0x00000002
+#define EXCHGID4_FLAG_USE_NON_PNFS              0x00010000
+#define EXCHGID4_FLAG_USE_PNFS_MDS              0x00020000
+#define EXCHGID4_FLAG_USE_PNFS_DS               0x00040000
+#define EXCHGID4_FLAG_UPD_CONFIRMED_REC_A       0x40000000
+#define EXCHGID4_FLAG_CONFIRMED_R               0x80000000
+/*
+ * Since the validity of these bits depends on whether
+ * they're set in the argument or response, have separate
+ * invalid flag masks for arg (_A) and resp (_R).
+ */
+#define EXCHGID4_FLAG_MASK_A                    0x40070003
+#define EXCHGID4_FLAG_MASK_R                    0x80070003
+
+#define SEQ4_STATUS_CB_PATH_DOWN                0x00000001
+#define SEQ4_STATUS_CB_GSS_CONTEXTS_EXPIRING    0x00000002
+#define SEQ4_STATUS_CB_GSS_CONTEXTS_EXPIRED     0x00000004
+#define SEQ4_STATUS_EXPIRED_ALL_STATE_REVOKED   0x00000008
+#define SEQ4_STATUS_EXPIRED_SOME_STATE_REVOKED  0x00000010
+#define SEQ4_STATUS_ADMIN_STATE_REVOKED         0x00000020
+#define SEQ4_STATUS_RECALLABLE_STATE_REVOKED    0x00000040
+#define SEQ4_STATUS_LEASE_MOVED                 0x00000080
+#define SEQ4_STATUS_RESTART_RECLAIM_NEEDED      0x00000100
+
 #define NFS4_MAX_UINT64 (~(u64)0)
 
 enum nfs4_acl_whotype {
@@ -154,6 +194,28 @@ enum nfs_opnum4 {
         OP_VERIFY = 37,
         OP_WRITE = 38,
         OP_RELEASE_LOCKOWNER = 39,
+
+        /* nfs41 */
+        OP_BACKCHANNEL_CTL = 40,
+        OP_BIND_CONN_TO_SESSION = 41,
+        OP_EXCHANGE_ID = 42,
+        OP_CREATE_SESSION = 43,
+        OP_DESTROY_SESSION = 44,
+        OP_FREE_STATEID = 45,
+        OP_GET_DIR_DELEGATION = 46,
+        OP_GETDEVICEINFO = 47,
+        OP_GETDEVICELIST = 48,
+        OP_LAYOUTCOMMIT = 49,
+        OP_LAYOUTGET = 50,
+        OP_LAYOUTRETURN = 51,
+        OP_SECINFO_NO_NAME = 52,
+        OP_SEQUENCE = 53,
+        OP_SET_SSV = 54,
+        OP_TEST_STATEID = 55,
+        OP_WANT_DELEGATION = 56,
+        OP_DESTROY_CLIENTID = 57,
+        OP_RECLAIM_COMPLETE = 58,
+
         OP_ILLEGAL = 10044,
 };
 
@@ -230,7 +292,48 @@ enum nfsstat4 {
         NFS4ERR_DEADLOCK = 10045,
         NFS4ERR_FILE_OPEN = 10046,
         NFS4ERR_ADMIN_REVOKED = 10047,
-        NFS4ERR_CB_PATH_DOWN = 10048
+        NFS4ERR_CB_PATH_DOWN = 10048,
+
+        /* nfs41 */
+        NFS4ERR_BADIOMODE       = 10049,
+        NFS4ERR_BADLAYOUT       = 10050,
+        NFS4ERR_BAD_SESSION_DIGEST = 10051,
+        NFS4ERR_BADSESSION      = 10052,
+        NFS4ERR_BADSLOT         = 10053,
+        NFS4ERR_COMPLETE_ALREADY = 10054,
+        NFS4ERR_CONN_NOT_BOUND_TO_SESSION = 10055,
+        NFS4ERR_DELEG_ALREADY_WANTED = 10056,
+        NFS4ERR_BACK_CHAN_BUSY  = 10057,        /* backchan reqs outstanding */
+        NFS4ERR_LAYOUTTRYLATER  = 10058,
+        NFS4ERR_LAYOUTUNAVAILABLE = 10059,
+        NFS4ERR_NOMATCHING_LAYOUT = 10060,
+        NFS4ERR_RECALLCONFLICT  = 10061,
+        NFS4ERR_UNKNOWN_LAYOUTTYPE = 10062,
+        NFS4ERR_SEQ_MISORDERED = 10063,         /* unexpected seq.id in req */
+        NFS4ERR_SEQUENCE_POS    = 10064,        /* [CB_]SEQ. op not 1st op */
+        NFS4ERR_REQ_TOO_BIG     = 10065,        /* request too big */
+        NFS4ERR_REP_TOO_BIG     = 10066,        /* reply too big */
+        NFS4ERR_REP_TOO_BIG_TO_CACHE = 10067,   /* rep. not all cached */
+        NFS4ERR_RETRY_UNCACHED_REP = 10068,     /* retry & rep. uncached */
+        NFS4ERR_UNSAFE_COMPOUND = 10069,        /* retry/recovery too hard */
+        NFS4ERR_TOO_MANY_OPS    = 10070,        /* too many ops in [CB_]COMP */
+        NFS4ERR_OP_NOT_IN_SESSION = 10071,      /* op needs [CB_]SEQ. op */
+        NFS4ERR_HASH_ALG_UNSUPP = 10072,        /* hash alg. not supp. */
+                                                /* Error 10073 is unused. */
+        NFS4ERR_CLIENTID_BUSY   = 10074,        /* clientid has state */
+        NFS4ERR_PNFS_IO_HOLE    = 10075,        /* IO to _SPARSE file hole */
+        NFS4ERR_SEQ_FALSE_RETRY = 10076,        /* retry not origional */
+        NFS4ERR_BAD_HIGH_SLOT   = 10077,        /* sequence arg bad */
+        NFS4ERR_DEADSESSION     = 10078,        /* persistent session dead */
+        NFS4ERR_ENCR_ALG_UNSUPP = 10079,        /* SSV alg mismatch */
+        NFS4ERR_PNFS_NO_LAYOUT  = 10080,        /* direct I/O with no layout */
+        NFS4ERR_NOT_ONLY_OP     = 10081,        /* bad compound */
+        NFS4ERR_WRONG_CRED      = 10082,        /* permissions:state change */
+        NFS4ERR_WRONG_TYPE      = 10083,        /* current operation mismatch */
+        NFS4ERR_DIRDELEG_UNAVAIL = 10084,       /* no directory delegation */
+        NFS4ERR_REJECT_DELEG    = 10085,        /* on callback */
+        NFS4ERR_RETURNCONFLICT  = 10086,        /* outstanding layoutreturn */
+        NFS4ERR_DELEG_REVOKED   = 10087,        /* deleg./layout revoked */
 };
 
 /*
@@ -265,7 +368,13 @@ enum opentype4 {
 enum createmode4 {
         NFS4_CREATE_UNCHECKED = 0,
         NFS4_CREATE_GUARDED = 1,
-        NFS4_CREATE_EXCLUSIVE = 2
+        NFS4_CREATE_EXCLUSIVE = 2,
+        /*
+         * New to NFSv4.1. If session is persistent,
+         * GUARDED4 MUST be used. Otherwise, use
+         * EXCLUSIVE4_1 instead of EXCLUSIVE4.
+         */
+        NFS4_CREATE_EXCLUSIVE4_1 = 3
 };
 
 enum limit_by4 {
@@ -301,6 +410,8 @@ enum lock_type4 {
 #define FATTR4_WORD0_UNIQUE_HANDLES     (1UL << 9)
 #define FATTR4_WORD0_LEASE_TIME         (1UL << 10)
 #define FATTR4_WORD0_RDATTR_ERROR       (1UL << 11)
+/* Mandatory in NFSv4.1 */
+#define FATTR4_WORD2_SUPPATTR_EXCLCREAT (1UL << 11)
 
 /* Recommended Attributes */
 #define FATTR4_WORD0_ACL                (1UL << 12)
@@ -391,6 +502,29 @@ enum {
         NFSPROC4_CLNT_GETACL,
         NFSPROC4_CLNT_SETACL,
         NFSPROC4_CLNT_FS_LOCATIONS,
+
+        /* nfs41 */
+        NFSPROC4_CLNT_EXCHANGE_ID,
+        NFSPROC4_CLNT_CREATE_SESSION,
+        NFSPROC4_CLNT_DESTROY_SESSION,
+        NFSPROC4_CLNT_SEQUENCE,
+        NFSPROC4_CLNT_GET_LEASE_TIME,
+};
+
+/* nfs41 types */
+struct nfs4_sessionid {
+        unsigned char data[NFS4_MAX_SESSIONID_LEN];
+};
+
+/* Create Session Flags */
+#define SESSION4_PERSIST         0x001
+#define SESSION4_BACK_CHAN       0x002
+#define SESSION4_RDMA            0x004
+
+enum state_protect_how4 {
+        SP4_NONE        = 0,
+        SP4_MACH_CRED   = 1,
+        SP4_SSV         = 2
 };
 
 #endif
diff --git a/include/linux/nfs_fs.h b/include/linux/nfs_fs.h
index 8cc8807f77d6..fdffb413b192 100644
--- a/include/linux/nfs_fs.h
+++ b/include/linux/nfs_fs.h
@@ -166,8 +166,7 @@ struct nfs_inode {
          */
         struct radix_tree_root  nfs_page_tree;
 
-        unsigned long           ncommit,
-                                npages;
+        unsigned long           npages;
 
         /* Open contexts for shared mmap writes */
         struct list_head        open_files;
@@ -186,6 +185,9 @@ struct nfs_inode {
         fmode_t                  delegation_state;
         struct rw_semaphore     rwsem;
 #endif /* CONFIG_NFS_V4*/
+#ifdef CONFIG_NFS_FSCACHE
+        struct fscache_cookie   *fscache;
+#endif
         struct inode            vfs_inode;
 };
 
@@ -207,6 +209,9 @@ struct nfs_inode {
 #define NFS_INO_STALE           (1)             /* possible stale inode */
 #define NFS_INO_ACL_LRU_SET     (2)             /* Inode is on the LRU list */
 #define NFS_INO_MOUNTPOINT      (3)             /* inode is remote mountpoint */
+#define NFS_INO_FLUSHING        (4)             /* inode is flushing out data */
+#define NFS_INO_FSCACHE         (5)             /* inode can be cached by FS-Cache */
+#define NFS_INO_FSCACHE_LOCK    (6)             /* FS-Cache cookie management lock */
 
 static inline struct nfs_inode *NFS_I(const struct inode *inode)
 {
@@ -260,6 +265,11 @@ static inline int NFS_STALE(const struct inode *inode)
         return test_bit(NFS_INO_STALE, &NFS_I(inode)->flags);
 }
 
+static inline int NFS_FSCACHE(const struct inode *inode)
+{
+        return test_bit(NFS_INO_FSCACHE, &NFS_I(inode)->flags);
+}
+
 static inline __u64 NFS_FILEID(const struct inode *inode)
 {
         return NFS_I(inode)->fileid;
@@ -506,6 +516,8 @@ extern int  nfs_readpages(struct file *, struct address_space *,
                 struct list_head *, unsigned);
 extern int  nfs_readpage_result(struct rpc_task *, struct nfs_read_data *);
 extern void nfs_readdata_release(void *data);
+extern int  nfs_readpage_async(struct nfs_open_context *, struct inode *,
+                               struct page *);
 
 /*
  * Allocate nfs_read_data structures
@@ -583,6 +595,7 @@ extern void * nfs_root_data(void);
 #define NFSDBG_CALLBACK         0x0100
 #define NFSDBG_CLIENT           0x0200
 #define NFSDBG_MOUNT            0x0400
+#define NFSDBG_FSCACHE          0x0800
 #define NFSDBG_ALL              0xFFFF
 
 #ifdef __KERNEL__
diff --git a/include/linux/nfs_fs_sb.h b/include/linux/nfs_fs_sb.h
index 9bb81aec91cf..6ad75948cbf7 100644
--- a/include/linux/nfs_fs_sb.h
+++ b/include/linux/nfs_fs_sb.h
@@ -64,6 +64,10 @@ struct nfs_client {
         char                    cl_ipaddr[48];
         unsigned char           cl_id_uniquifier;
 #endif
+
+#ifdef CONFIG_NFS_FSCACHE
+        struct fscache_cookie   *fscache;       /* client index cache cookie */
+#endif
 };
 
 /*
@@ -96,16 +100,28 @@ struct nfs_server {
         unsigned int            acdirmin;
         unsigned int            acdirmax;
         unsigned int            namelen;
+        unsigned int            options;        /* extra options enabled by mount */
+#define NFS_OPTION_FSCACHE      0x00000001      /* - local caching enabled */
 
         struct nfs_fsid         fsid;
         __u64                   maxfilesize;    /* maximum file size */
         unsigned long           mount_time;     /* when this fs was mounted */
         dev_t                   s_dev;          /* superblock dev numbers */
 
+#ifdef CONFIG_NFS_FSCACHE
+        struct nfs_fscache_key  *fscache_key;   /* unique key for superblock */
+        struct fscache_cookie   *fscache;       /* superblock cookie */
+#endif
+
 #ifdef CONFIG_NFS_V4
         u32                     attr_bitmask[2];/* V4 bitmask representing the set
                                                    of attributes supported on this
                                                    filesystem */
+        u32                     cache_consistency_bitmask[2];
+                                                /* V4 bitmask representing the subset
+                                                   of change attribute, size, ctime
+                                                   and mtime attributes supported by
+                                                   the server */
         u32                     acl_bitmask;    /* V4 bitmask representing the ACEs
                                                    that are supported on this
                                                    filesystem */
diff --git a/include/linux/nfs_iostat.h b/include/linux/nfs_iostat.h
index 1cb9a3fed2b3..68b10f5f8907 100644
--- a/include/linux/nfs_iostat.h
+++ b/include/linux/nfs_iostat.h
@@ -116,4 +116,16 @@ enum nfs_stat_eventcounters {
         __NFSIOS_COUNTSMAX,
 };
 
+/*
+ * NFS local caching servicing counters
+ */
+enum nfs_stat_fscachecounters {
+        NFSIOS_FSCACHE_PAGES_READ_OK,
+        NFSIOS_FSCACHE_PAGES_READ_FAIL,
+        NFSIOS_FSCACHE_PAGES_WRITTEN_OK,
+        NFSIOS_FSCACHE_PAGES_WRITTEN_FAIL,
+        NFSIOS_FSCACHE_PAGES_UNCACHED,
+        __NFSIOS_FSCACHEMAX,
+};
+
 #endif  /* _LINUX_NFS_IOSTAT */
diff --git a/include/linux/nfs_xdr.h b/include/linux/nfs_xdr.h
index 43a713fce11c..b89c34e40bc2 100644
--- a/include/linux/nfs_xdr.h
+++ b/include/linux/nfs_xdr.h
@@ -27,12 +27,8 @@ static inline int nfs_fsid_equal(const struct nfs_fsid *a, const struct nfs_fsid
 }
 
 struct nfs_fattr {
-        unsigned short          valid;          /* which fields are valid */
-        __u64                   pre_size;       /* pre_op_attr.size       */
-        struct timespec         pre_mtime;      /* pre_op_attr.mtime      */
-        struct timespec         pre_ctime;      /* pre_op_attr.ctime      */
-        enum nfs_ftype          type;           /* always use NFSv2 types */
-        __u32                   mode;
+        unsigned int            valid;          /* which fields are valid */
+        umode_t                 mode;
         __u32                   nlink;
         __u32                   uid;
         __u32                   gid;
@@ -52,19 +48,55 @@ struct nfs_fattr {
         struct timespec         atime;
         struct timespec         mtime;
         struct timespec         ctime;
-        __u32                   bitmap[2];      /* NFSv4 returned attribute bitmap */
         __u64                   change_attr;    /* NFSv4 change attribute */
         __u64                   pre_change_attr;/* pre-op NFSv4 change attribute */
+        __u64                   pre_size;       /* pre_op_attr.size       */
+        struct timespec         pre_mtime;      /* pre_op_attr.mtime      */
+        struct timespec         pre_ctime;      /* pre_op_attr.ctime      */
         unsigned long           time_start;
         unsigned long           gencount;
 };
 
-#define NFS_ATTR_WCC            0x0001          /* pre-op WCC data    */
-#define NFS_ATTR_FATTR          0x0002          /* post-op attributes */
-#define NFS_ATTR_FATTR_V3       0x0004          /* NFSv3 attributes */
-#define NFS_ATTR_FATTR_V4       0x0008          /* NFSv4 change attribute */
-#define NFS_ATTR_WCC_V4         0x0010          /* pre-op change attribute */
-#define NFS_ATTR_FATTR_V4_REFERRAL      0x0020          /* NFSv4 referral */
+#define NFS_ATTR_FATTR_TYPE             (1U << 0)
+#define NFS_ATTR_FATTR_MODE             (1U << 1)
+#define NFS_ATTR_FATTR_NLINK            (1U << 2)
+#define NFS_ATTR_FATTR_OWNER            (1U << 3)
+#define NFS_ATTR_FATTR_GROUP            (1U << 4)
+#define NFS_ATTR_FATTR_RDEV             (1U << 5)
+#define NFS_ATTR_FATTR_SIZE             (1U << 6)
+#define NFS_ATTR_FATTR_PRESIZE          (1U << 7)
+#define NFS_ATTR_FATTR_BLOCKS_USED      (1U << 8)
+#define NFS_ATTR_FATTR_SPACE_USED       (1U << 9)
+#define NFS_ATTR_FATTR_FSID             (1U << 10)
+#define NFS_ATTR_FATTR_FILEID           (1U << 11)
+#define NFS_ATTR_FATTR_ATIME            (1U << 12)
+#define NFS_ATTR_FATTR_MTIME            (1U << 13)
+#define NFS_ATTR_FATTR_CTIME            (1U << 14)
+#define NFS_ATTR_FATTR_PREMTIME         (1U << 15)
+#define NFS_ATTR_FATTR_PRECTIME         (1U << 16)
+#define NFS_ATTR_FATTR_CHANGE           (1U << 17)
+#define NFS_ATTR_FATTR_PRECHANGE        (1U << 18)
+#define NFS_ATTR_FATTR_V4_REFERRAL      (1U << 19)      /* NFSv4 referral */
+
+#define NFS_ATTR_FATTR (NFS_ATTR_FATTR_TYPE \
+                | NFS_ATTR_FATTR_MODE \
+                | NFS_ATTR_FATTR_NLINK \
+                | NFS_ATTR_FATTR_OWNER \
+                | NFS_ATTR_FATTR_GROUP \
+                | NFS_ATTR_FATTR_RDEV \
+                | NFS_ATTR_FATTR_SIZE \
+                | NFS_ATTR_FATTR_FSID \
+                | NFS_ATTR_FATTR_FILEID \
+                | NFS_ATTR_FATTR_ATIME \
+                | NFS_ATTR_FATTR_MTIME \
+                | NFS_ATTR_FATTR_CTIME)
+#define NFS_ATTR_FATTR_V2 (NFS_ATTR_FATTR \
+                | NFS_ATTR_FATTR_BLOCKS_USED)
+#define NFS_ATTR_FATTR_V3 (NFS_ATTR_FATTR \
+                | NFS_ATTR_FATTR_SPACE_USED)
+#define NFS_ATTR_FATTR_V4 (NFS_ATTR_FATTR \
+                | NFS_ATTR_FATTR_SPACE_USED \
+                | NFS_ATTR_FATTR_CHANGE)
 
 /*
  * Info on the file system
@@ -836,6 +868,7 @@ struct nfs_rpc_ops {
         int     (*lock)(struct file *, int, struct file_lock *);
         int     (*lock_check_bounds)(const struct file_lock *);
         void    (*clear_acl_cache)(struct inode *);
+        void    (*close_context)(struct nfs_open_context *ctx, int);
 };
 
 /*
diff --git a/include/linux/nfsd/cache.h b/include/linux/nfsd/cache.h
index 04b355c801d8..5bccaab81056 100644
--- a/include/linux/nfsd/cache.h
+++ b/include/linux/nfsd/cache.h
@@ -76,4 +76,12 @@ void	nfsd_reply_cache_shutdown(void);
 int     nfsd_cache_lookup(struct svc_rqst *, int);
 void    nfsd_cache_update(struct svc_rqst *, int, __be32 *);
 
+#ifdef CONFIG_NFSD_V4
+void    nfsd4_set_statp(struct svc_rqst *rqstp, __be32 *statp);
+#else  /* CONFIG_NFSD_V4 */
+static inline void nfsd4_set_statp(struct svc_rqst *rqstp, __be32 *statp)
+{
+}
+#endif /* CONFIG_NFSD_V4 */
+
 #endif /* NFSCACHE_H */
diff --git a/include/linux/nfsd/nfsd.h b/include/linux/nfsd/nfsd.h
index e19f45991b2e..2b49d676d0c9 100644
--- a/include/linux/nfsd/nfsd.h
+++ b/include/linux/nfsd/nfsd.h
@@ -23,7 +23,7 @@
 /*
  * nfsd version
  */
-#define NFSD_SUPPORTED_MINOR_VERSION    0
+#define NFSD_SUPPORTED_MINOR_VERSION    1
 
 /*
  * Flags for nfsd_permission
@@ -53,6 +53,7 @@ typedef int (*nfsd_dirop_t)(struct inode *, struct dentry *, int, int);
 extern struct svc_program       nfsd_program;
 extern struct svc_version       nfsd_version2, nfsd_version3,
                                 nfsd_version4;
+extern u32                      nfsd_supported_minorversion;
 extern struct mutex             nfsd_mutex;
 extern struct svc_serv          *nfsd_serv;
 
@@ -105,7 +106,7 @@ void		nfsd_close(struct file *);
 __be32          nfsd_read(struct svc_rqst *, struct svc_fh *, struct file *,
                                 loff_t, struct kvec *, int, unsigned long *);
 __be32          nfsd_write(struct svc_rqst *, struct svc_fh *,struct file *,
-                                loff_t, struct kvec *,int, unsigned long, int *);
+                                loff_t, struct kvec *,int, unsigned long *, int *);
 __be32          nfsd_readlink(struct svc_rqst *, struct svc_fh *,
                                 char *, int *);
 __be32          nfsd_symlink(struct svc_rqst *, struct svc_fh *,
@@ -149,6 +150,7 @@ int nfsd_set_posix_acl(struct svc_fh *, int, struct posix_acl *);
 
 enum vers_op {NFSD_SET, NFSD_CLEAR, NFSD_TEST, NFSD_AVAIL };
 int nfsd_vers(int vers, enum vers_op change);
+int nfsd_minorversion(u32 minorversion, enum vers_op change);
 void nfsd_reset_versions(void);
 int nfsd_create_serv(void);
 
@@ -186,78 +188,119 @@ void		nfsd_lockd_shutdown(void);
 /*
  * These macros provide pre-xdr'ed values for faster operation.
  */
-#define nfs_ok                  __constant_htonl(NFS_OK)
-#define nfserr_perm             __constant_htonl(NFSERR_PERM)
-#define nfserr_noent            __constant_htonl(NFSERR_NOENT)
-#define nfserr_io               __constant_htonl(NFSERR_IO)
-#define nfserr_nxio             __constant_htonl(NFSERR_NXIO)
-#define nfserr_eagain           __constant_htonl(NFSERR_EAGAIN)
-#define nfserr_acces            __constant_htonl(NFSERR_ACCES)
-#define nfserr_exist            __constant_htonl(NFSERR_EXIST)
-#define nfserr_xdev             __constant_htonl(NFSERR_XDEV)
-#define nfserr_nodev            __constant_htonl(NFSERR_NODEV)
-#define nfserr_notdir           __constant_htonl(NFSERR_NOTDIR)
-#define nfserr_isdir            __constant_htonl(NFSERR_ISDIR)
-#define nfserr_inval            __constant_htonl(NFSERR_INVAL)
-#define nfserr_fbig             __constant_htonl(NFSERR_FBIG)
-#define nfserr_nospc            __constant_htonl(NFSERR_NOSPC)
-#define nfserr_rofs             __constant_htonl(NFSERR_ROFS)
-#define nfserr_mlink            __constant_htonl(NFSERR_MLINK)
-#define nfserr_opnotsupp        __constant_htonl(NFSERR_OPNOTSUPP)
-#define nfserr_nametoolong      __constant_htonl(NFSERR_NAMETOOLONG)
-#define nfserr_notempty         __constant_htonl(NFSERR_NOTEMPTY)
-#define nfserr_dquot            __constant_htonl(NFSERR_DQUOT)
-#define nfserr_stale            __constant_htonl(NFSERR_STALE)
-#define nfserr_remote           __constant_htonl(NFSERR_REMOTE)
-#define nfserr_wflush           __constant_htonl(NFSERR_WFLUSH)
-#define nfserr_badhandle        __constant_htonl(NFSERR_BADHANDLE)
-#define nfserr_notsync          __constant_htonl(NFSERR_NOT_SYNC)
-#define nfserr_badcookie        __constant_htonl(NFSERR_BAD_COOKIE)
-#define nfserr_notsupp          __constant_htonl(NFSERR_NOTSUPP)
-#define nfserr_toosmall         __constant_htonl(NFSERR_TOOSMALL)
-#define nfserr_serverfault      __constant_htonl(NFSERR_SERVERFAULT)
-#define nfserr_badtype          __constant_htonl(NFSERR_BADTYPE)
-#define nfserr_jukebox          __constant_htonl(NFSERR_JUKEBOX)
-#define nfserr_denied           __constant_htonl(NFSERR_DENIED)
-#define nfserr_deadlock         __constant_htonl(NFSERR_DEADLOCK)
-#define nfserr_expired          __constant_htonl(NFSERR_EXPIRED)
-#define nfserr_bad_cookie       __constant_htonl(NFSERR_BAD_COOKIE)
-#define nfserr_same             __constant_htonl(NFSERR_SAME)
-#define nfserr_clid_inuse       __constant_htonl(NFSERR_CLID_INUSE)
-#define nfserr_stale_clientid   __constant_htonl(NFSERR_STALE_CLIENTID)
-#define nfserr_resource         __constant_htonl(NFSERR_RESOURCE)
-#define nfserr_moved            __constant_htonl(NFSERR_MOVED)
-#define nfserr_nofilehandle     __constant_htonl(NFSERR_NOFILEHANDLE)
-#define nfserr_minor_vers_mismatch      __constant_htonl(NFSERR_MINOR_VERS_MISMATCH)
-#define nfserr_share_denied     __constant_htonl(NFSERR_SHARE_DENIED)
-#define nfserr_stale_stateid    __constant_htonl(NFSERR_STALE_STATEID)
-#define nfserr_old_stateid      __constant_htonl(NFSERR_OLD_STATEID)
-#define nfserr_bad_stateid      __constant_htonl(NFSERR_BAD_STATEID)
-#define nfserr_bad_seqid        __constant_htonl(NFSERR_BAD_SEQID)
-#define nfserr_symlink          __constant_htonl(NFSERR_SYMLINK)
-#define nfserr_not_same         __constant_htonl(NFSERR_NOT_SAME)
-#define nfserr_restorefh        __constant_htonl(NFSERR_RESTOREFH)
-#define nfserr_attrnotsupp      __constant_htonl(NFSERR_ATTRNOTSUPP)
-#define nfserr_bad_xdr          __constant_htonl(NFSERR_BAD_XDR)
-#define nfserr_openmode         __constant_htonl(NFSERR_OPENMODE)
-#define nfserr_locks_held       __constant_htonl(NFSERR_LOCKS_HELD)
-#define nfserr_op_illegal       __constant_htonl(NFSERR_OP_ILLEGAL)
-#define nfserr_grace            __constant_htonl(NFSERR_GRACE)
-#define nfserr_no_grace         __constant_htonl(NFSERR_NO_GRACE)
-#define nfserr_reclaim_bad      __constant_htonl(NFSERR_RECLAIM_BAD)
-#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)
+#define nfs_ok                  cpu_to_be32(NFS_OK)
+#define nfserr_perm             cpu_to_be32(NFSERR_PERM)
+#define nfserr_noent            cpu_to_be32(NFSERR_NOENT)
+#define nfserr_io               cpu_to_be32(NFSERR_IO)
+#define nfserr_nxio             cpu_to_be32(NFSERR_NXIO)
+#define nfserr_eagain           cpu_to_be32(NFSERR_EAGAIN)
+#define nfserr_acces            cpu_to_be32(NFSERR_ACCES)
+#define nfserr_exist            cpu_to_be32(NFSERR_EXIST)
+#define nfserr_xdev             cpu_to_be32(NFSERR_XDEV)
+#define nfserr_nodev            cpu_to_be32(NFSERR_NODEV)
+#define nfserr_notdir           cpu_to_be32(NFSERR_NOTDIR)
+#define nfserr_isdir            cpu_to_be32(NFSERR_ISDIR)
+#define nfserr_inval            cpu_to_be32(NFSERR_INVAL)
+#define nfserr_fbig             cpu_to_be32(NFSERR_FBIG)
+#define nfserr_nospc            cpu_to_be32(NFSERR_NOSPC)
+#define nfserr_rofs             cpu_to_be32(NFSERR_ROFS)
+#define nfserr_mlink            cpu_to_be32(NFSERR_MLINK)
+#define nfserr_opnotsupp        cpu_to_be32(NFSERR_OPNOTSUPP)
+#define nfserr_nametoolong      cpu_to_be32(NFSERR_NAMETOOLONG)
+#define nfserr_notempty         cpu_to_be32(NFSERR_NOTEMPTY)
+#define nfserr_dquot            cpu_to_be32(NFSERR_DQUOT)
+#define nfserr_stale            cpu_to_be32(NFSERR_STALE)
+#define nfserr_remote           cpu_to_be32(NFSERR_REMOTE)
+#define nfserr_wflush           cpu_to_be32(NFSERR_WFLUSH)
+#define nfserr_badhandle        cpu_to_be32(NFSERR_BADHANDLE)
+#define nfserr_notsync          cpu_to_be32(NFSERR_NOT_SYNC)
+#define nfserr_badcookie        cpu_to_be32(NFSERR_BAD_COOKIE)
+#define nfserr_notsupp          cpu_to_be32(NFSERR_NOTSUPP)
+#define nfserr_toosmall         cpu_to_be32(NFSERR_TOOSMALL)
+#define nfserr_serverfault      cpu_to_be32(NFSERR_SERVERFAULT)
+#define nfserr_badtype          cpu_to_be32(NFSERR_BADTYPE)
+#define nfserr_jukebox          cpu_to_be32(NFSERR_JUKEBOX)
+#define nfserr_denied           cpu_to_be32(NFSERR_DENIED)
+#define nfserr_deadlock         cpu_to_be32(NFSERR_DEADLOCK)
+#define nfserr_expired          cpu_to_be32(NFSERR_EXPIRED)
+#define nfserr_bad_cookie       cpu_to_be32(NFSERR_BAD_COOKIE)
+#define nfserr_same             cpu_to_be32(NFSERR_SAME)
+#define nfserr_clid_inuse       cpu_to_be32(NFSERR_CLID_INUSE)
+#define nfserr_stale_clientid   cpu_to_be32(NFSERR_STALE_CLIENTID)
+#define nfserr_resource         cpu_to_be32(NFSERR_RESOURCE)
+#define nfserr_moved            cpu_to_be32(NFSERR_MOVED)
+#define nfserr_nofilehandle     cpu_to_be32(NFSERR_NOFILEHANDLE)
+#define nfserr_minor_vers_mismatch      cpu_to_be32(NFSERR_MINOR_VERS_MISMATCH)
+#define nfserr_share_denied     cpu_to_be32(NFSERR_SHARE_DENIED)
+#define nfserr_stale_stateid    cpu_to_be32(NFSERR_STALE_STATEID)
+#define nfserr_old_stateid      cpu_to_be32(NFSERR_OLD_STATEID)
+#define nfserr_bad_stateid      cpu_to_be32(NFSERR_BAD_STATEID)
+#define nfserr_bad_seqid        cpu_to_be32(NFSERR_BAD_SEQID)
+#define nfserr_symlink          cpu_to_be32(NFSERR_SYMLINK)
+#define nfserr_not_same         cpu_to_be32(NFSERR_NOT_SAME)
+#define nfserr_restorefh        cpu_to_be32(NFSERR_RESTOREFH)
+#define nfserr_attrnotsupp      cpu_to_be32(NFSERR_ATTRNOTSUPP)
+#define nfserr_bad_xdr          cpu_to_be32(NFSERR_BAD_XDR)
+#define nfserr_openmode         cpu_to_be32(NFSERR_OPENMODE)
+#define nfserr_locks_held       cpu_to_be32(NFSERR_LOCKS_HELD)
+#define nfserr_op_illegal       cpu_to_be32(NFSERR_OP_ILLEGAL)
+#define nfserr_grace            cpu_to_be32(NFSERR_GRACE)
+#define nfserr_no_grace         cpu_to_be32(NFSERR_NO_GRACE)
+#define nfserr_reclaim_bad      cpu_to_be32(NFSERR_RECLAIM_BAD)
+#define nfserr_badname          cpu_to_be32(NFSERR_BADNAME)
+#define nfserr_cb_path_down     cpu_to_be32(NFSERR_CB_PATH_DOWN)
+#define nfserr_locked           cpu_to_be32(NFSERR_LOCKED)
+#define nfserr_wrongsec         cpu_to_be32(NFSERR_WRONGSEC)
+#define nfserr_badiomode                cpu_to_be32(NFS4ERR_BADIOMODE)
+#define nfserr_badlayout                cpu_to_be32(NFS4ERR_BADLAYOUT)
+#define nfserr_bad_session_digest       cpu_to_be32(NFS4ERR_BAD_SESSION_DIGEST)
+#define nfserr_badsession               cpu_to_be32(NFS4ERR_BADSESSION)
+#define nfserr_badslot                  cpu_to_be32(NFS4ERR_BADSLOT)
+#define nfserr_complete_already         cpu_to_be32(NFS4ERR_COMPLETE_ALREADY)
+#define nfserr_conn_not_bound_to_session cpu_to_be32(NFS4ERR_CONN_NOT_BOUND_TO_SESSION)
+#define nfserr_deleg_already_wanted     cpu_to_be32(NFS4ERR_DELEG_ALREADY_WANTED)
+#define nfserr_back_chan_busy           cpu_to_be32(NFS4ERR_BACK_CHAN_BUSY)
+#define nfserr_layouttrylater           cpu_to_be32(NFS4ERR_LAYOUTTRYLATER)
+#define nfserr_layoutunavailable        cpu_to_be32(NFS4ERR_LAYOUTUNAVAILABLE)
+#define nfserr_nomatching_layout        cpu_to_be32(NFS4ERR_NOMATCHING_LAYOUT)
+#define nfserr_recallconflict           cpu_to_be32(NFS4ERR_RECALLCONFLICT)
+#define nfserr_unknown_layouttype       cpu_to_be32(NFS4ERR_UNKNOWN_LAYOUTTYPE)
+#define nfserr_seq_misordered           cpu_to_be32(NFS4ERR_SEQ_MISORDERED)
+#define nfserr_sequence_pos             cpu_to_be32(NFS4ERR_SEQUENCE_POS)
+#define nfserr_req_too_big              cpu_to_be32(NFS4ERR_REQ_TOO_BIG)
+#define nfserr_rep_too_big              cpu_to_be32(NFS4ERR_REP_TOO_BIG)
+#define nfserr_rep_too_big_to_cache     cpu_to_be32(NFS4ERR_REP_TOO_BIG_TO_CACHE)
+#define nfserr_retry_uncached_rep       cpu_to_be32(NFS4ERR_RETRY_UNCACHED_REP)
+#define nfserr_unsafe_compound          cpu_to_be32(NFS4ERR_UNSAFE_COMPOUND)
+#define nfserr_too_many_ops             cpu_to_be32(NFS4ERR_TOO_MANY_OPS)
+#define nfserr_op_not_in_session        cpu_to_be32(NFS4ERR_OP_NOT_IN_SESSION)
+#define nfserr_hash_alg_unsupp          cpu_to_be32(NFS4ERR_HASH_ALG_UNSUPP)
+#define nfserr_clientid_busy            cpu_to_be32(NFS4ERR_CLIENTID_BUSY)
+#define nfserr_pnfs_io_hole             cpu_to_be32(NFS4ERR_PNFS_IO_HOLE)
+#define nfserr_seq_false_retry          cpu_to_be32(NFS4ERR_SEQ_FALSE_RETRY)
+#define nfserr_bad_high_slot            cpu_to_be32(NFS4ERR_BAD_HIGH_SLOT)
+#define nfserr_deadsession              cpu_to_be32(NFS4ERR_DEADSESSION)
+#define nfserr_encr_alg_unsupp          cpu_to_be32(NFS4ERR_ENCR_ALG_UNSUPP)
+#define nfserr_pnfs_no_layout           cpu_to_be32(NFS4ERR_PNFS_NO_LAYOUT)
+#define nfserr_not_only_op              cpu_to_be32(NFS4ERR_NOT_ONLY_OP)
+#define nfserr_wrong_cred               cpu_to_be32(NFS4ERR_WRONG_CRED)
+#define nfserr_wrong_type               cpu_to_be32(NFS4ERR_WRONG_TYPE)
+#define nfserr_dirdeleg_unavail         cpu_to_be32(NFS4ERR_DIRDELEG_UNAVAIL)
+#define nfserr_reject_deleg             cpu_to_be32(NFS4ERR_REJECT_DELEG)
+#define nfserr_returnconflict           cpu_to_be32(NFS4ERR_RETURNCONFLICT)
+#define nfserr_deleg_revoked            cpu_to_be32(NFS4ERR_DELEG_REVOKED)
 
 /* error codes for internal use */
 /* if a request fails due to kmalloc failure, it gets dropped.
  *  Client should resend eventually
  */
-#define nfserr_dropit           __constant_htonl(30000)
+#define nfserr_dropit           cpu_to_be32(30000)
 /* end-of-file indicator in readdir */
-#define nfserr_eof              __constant_htonl(30001)
+#define nfserr_eof              cpu_to_be32(30001)
+/* replay detected */
+#define nfserr_replay_me        cpu_to_be32(11001)
+/* nfs41 replay detected */
+#define nfserr_replay_cache     cpu_to_be32(11002)
 
 /* Check for dir entries '.' and '..' */
 #define isdotent(n, l)  (l < 3 && n[0] == '.' && (l == 1 || n[1] == '.'))
@@ -300,7 +343,7 @@ extern struct timeval	nfssvc_boot;
  *    TIME_BACKUP   (unlikely to be supported any time soon)
  *    TIME_CREATE   (unlikely to be supported any time soon)
  */
-#define NFSD_SUPPORTED_ATTRS_WORD0                                                          \
+#define NFSD4_SUPPORTED_ATTRS_WORD0                                                         \
 (FATTR4_WORD0_SUPPORTED_ATTRS   | FATTR4_WORD0_TYPE         | FATTR4_WORD0_FH_EXPIRE_TYPE   \
  | FATTR4_WORD0_CHANGE          | FATTR4_WORD0_SIZE         | FATTR4_WORD0_LINK_SUPPORT     \
  | FATTR4_WORD0_SYMLINK_SUPPORT | FATTR4_WORD0_NAMED_ATTR   | FATTR4_WORD0_FSID             \
@@ -312,7 +355,7 @@ extern struct timeval	nfssvc_boot;
  | FATTR4_WORD0_MAXFILESIZE     | FATTR4_WORD0_MAXLINK      | FATTR4_WORD0_MAXNAME          \
  | FATTR4_WORD0_MAXREAD         | FATTR4_WORD0_MAXWRITE     | FATTR4_WORD0_ACL)
 
-#define NFSD_SUPPORTED_ATTRS_WORD1                                                          \
+#define NFSD4_SUPPORTED_ATTRS_WORD1                                                         \
 (FATTR4_WORD1_MODE              | FATTR4_WORD1_NO_TRUNC     | FATTR4_WORD1_NUMLINKS         \
  | FATTR4_WORD1_OWNER           | FATTR4_WORD1_OWNER_GROUP  | FATTR4_WORD1_RAWDEV           \
  | FATTR4_WORD1_SPACE_AVAIL     | FATTR4_WORD1_SPACE_FREE   | FATTR4_WORD1_SPACE_TOTAL      \
@@ -320,6 +363,35 @@ extern struct timeval	nfssvc_boot;
  | FATTR4_WORD1_TIME_DELTA   | FATTR4_WORD1_TIME_METADATA    \
  | FATTR4_WORD1_TIME_MODIFY     | FATTR4_WORD1_TIME_MODIFY_SET | FATTR4_WORD1_MOUNTED_ON_FILEID)
 
+#define NFSD4_SUPPORTED_ATTRS_WORD2 0
+
+#define NFSD4_1_SUPPORTED_ATTRS_WORD0 \
+        NFSD4_SUPPORTED_ATTRS_WORD0
+
+#define NFSD4_1_SUPPORTED_ATTRS_WORD1 \
+        NFSD4_SUPPORTED_ATTRS_WORD1
+
+#define NFSD4_1_SUPPORTED_ATTRS_WORD2 \
+        (NFSD4_SUPPORTED_ATTRS_WORD2 | FATTR4_WORD2_SUPPATTR_EXCLCREAT)
+
+static inline u32 nfsd_suppattrs0(u32 minorversion)
+{
+        return minorversion ? NFSD4_1_SUPPORTED_ATTRS_WORD0
+                            : NFSD4_SUPPORTED_ATTRS_WORD0;
+}
+
+static inline u32 nfsd_suppattrs1(u32 minorversion)
+{
+        return minorversion ? NFSD4_1_SUPPORTED_ATTRS_WORD1
+                            : NFSD4_SUPPORTED_ATTRS_WORD1;
+}
+
+static inline u32 nfsd_suppattrs2(u32 minorversion)
+{
+        return minorversion ? NFSD4_1_SUPPORTED_ATTRS_WORD2
+                            : NFSD4_SUPPORTED_ATTRS_WORD2;
+}
+
 /* These will return ERR_INVAL if specified in GETATTR or READDIR. */
 #define NFSD_WRITEONLY_ATTRS_WORD1                                                          \
 (FATTR4_WORD1_TIME_ACCESS_SET   | FATTR4_WORD1_TIME_MODIFY_SET)
@@ -330,6 +402,19 @@ extern struct timeval	nfssvc_boot;
 #define NFSD_WRITEABLE_ATTRS_WORD1                                                          \
 (FATTR4_WORD1_MODE              | FATTR4_WORD1_OWNER         | FATTR4_WORD1_OWNER_GROUP     \
  | FATTR4_WORD1_TIME_ACCESS_SET | FATTR4_WORD1_TIME_MODIFY_SET)
+#define NFSD_WRITEABLE_ATTRS_WORD2 0
+
+#define NFSD_SUPPATTR_EXCLCREAT_WORD0 \
+        NFSD_WRITEABLE_ATTRS_WORD0
+/*
+ * we currently store the exclusive create verifier in the v_{a,m}time
+ * attributes so the client can't set these at create time using EXCLUSIVE4_1
+ */
+#define NFSD_SUPPATTR_EXCLCREAT_WORD1 \
+        (NFSD_WRITEABLE_ATTRS_WORD1 & \
+         ~(FATTR4_WORD1_TIME_ACCESS_SET | FATTR4_WORD1_TIME_MODIFY_SET))
+#define NFSD_SUPPATTR_EXCLCREAT_WORD2 \
+        NFSD_WRITEABLE_ATTRS_WORD2
 
 #endif /* CONFIG_NFSD_V4 */
 
diff --git a/include/linux/nfsd/nfsfh.h b/include/linux/nfsd/nfsfh.h
index fa317f6c154b..afa19016c4a8 100644
--- a/include/linux/nfsd/nfsfh.h
+++ b/include/linux/nfsd/nfsfh.h
@@ -269,6 +269,13 @@ fh_copy(struct svc_fh *dst, struct svc_fh *src)
         return dst;
 }
 
+static inline void
+fh_copy_shallow(struct knfsd_fh *dst, struct knfsd_fh *src)
+{
+        dst->fh_size = src->fh_size;
+        memcpy(&dst->fh_base, &src->fh_base, src->fh_size);
+}
+
 static __inline__ struct svc_fh *
 fh_init(struct svc_fh *fhp, int maxsize)
 {
diff --git a/include/linux/nfsd/state.h b/include/linux/nfsd/state.h
index 128298c0362d..4d61c873feed 100644
--- a/include/linux/nfsd/state.h
+++ b/include/linux/nfsd/state.h
@@ -66,8 +66,7 @@ struct nfs4_cb_recall {
         u32                     cbr_ident;
         int                     cbr_trunc;
         stateid_t               cbr_stateid;
-        u32                     cbr_fhlen;
-        char                    cbr_fhval[NFS4_FHSIZE];
+        struct knfsd_fh         cbr_fh;
         struct nfs4_delegation  *cbr_dp;
 };
 
@@ -86,8 +85,7 @@ struct nfs4_delegation {
 };
 
 #define dl_stateid      dl_recall.cbr_stateid
-#define dl_fhlen        dl_recall.cbr_fhlen
-#define dl_fhval        dl_recall.cbr_fhval
+#define dl_fh           dl_recall.cbr_fh
 
 /* client delegation callback info */
 struct nfs4_callback {
@@ -101,6 +99,64 @@ struct nfs4_callback {
         struct rpc_clnt *       cb_client;
 };
 
+/* Maximum number of slots per session. 128 is useful for long haul TCP */
+#define NFSD_MAX_SLOTS_PER_SESSION      128
+/* Maximum number of pages per slot cache entry */
+#define NFSD_PAGES_PER_SLOT     1
+/* Maximum number of operations per session compound */
+#define NFSD_MAX_OPS_PER_COMPOUND       16
+
+struct nfsd4_cache_entry {
+        __be32          ce_status;
+        struct kvec     ce_datav; /* encoded NFSv4.1 data in rq_res.head[0] */
+        struct page     *ce_respages[NFSD_PAGES_PER_SLOT + 1];
+        int             ce_cachethis;
+        short           ce_resused;
+        int             ce_opcnt;
+        int             ce_rpchdrlen;
+};
+
+struct nfsd4_slot {
+        bool                            sl_inuse;
+        u32                             sl_seqid;
+        struct nfsd4_cache_entry        sl_cache_entry;
+};
+
+struct nfsd4_session {
+        struct kref             se_ref;
+        struct list_head        se_hash;        /* hash by sessionid */
+        struct list_head        se_perclnt;
+        u32                     se_flags;
+        struct nfs4_client      *se_client;     /* for expire_client */
+        struct nfs4_sessionid   se_sessionid;
+        u32                     se_fmaxreq_sz;
+        u32                     se_fmaxresp_sz;
+        u32                     se_fmaxresp_cached;
+        u32                     se_fmaxops;
+        u32                     se_fnumslots;
+        struct nfsd4_slot       se_slots[];     /* forward channel slots */
+};
+
+static inline void
+nfsd4_put_session(struct nfsd4_session *ses)
+{
+        extern void free_session(struct kref *kref);
+        kref_put(&ses->se_ref, free_session);
+}
+
+static inline void
+nfsd4_get_session(struct nfsd4_session *ses)
+{
+        kref_get(&ses->se_ref);
+}
+
+/* formatted contents of nfs4_sessionid */
+struct nfsd4_sessionid {
+        clientid_t      clientid;
+        u32             sequence;
+        u32             reserved;
+};
+
 #define HEXDIR_LEN     33 /* hex version of 16 byte md5 of cl_name plus '\0' */
 
 /*
@@ -132,6 +188,12 @@ struct nfs4_client {
         struct nfs4_callback    cl_callback;    /* callback info */
         atomic_t                cl_count;       /* ref count */
         u32                     cl_firststate;  /* recovery dir creation */
+
+        /* for nfs41 */
+        struct list_head        cl_sessions;
+        struct nfsd4_slot       cl_slot;        /* create_session slot */
+        u32                     cl_exchange_flags;
+        struct nfs4_sessionid   cl_sessionid;
 };
 
 /* struct nfs4_client_reset
@@ -168,8 +230,7 @@ struct nfs4_replay {
         unsigned int            rp_buflen;
         char                    *rp_buf;
         unsigned                intrp_allocated;
-        int                     rp_openfh_len;
-        char                    rp_openfh[NFS4_FHSIZE];
+        struct knfsd_fh         rp_openfh;
         char                    rp_ibuf[NFSD4_REPLAY_ISIZE];
 };
 
@@ -217,7 +278,7 @@ struct nfs4_stateowner {
 *      share_acces, share_deny on the file.
 */
 struct nfs4_file {
-        struct kref             fi_ref;
+        atomic_t                fi_ref;
         struct list_head        fi_hash;    /* hash by "struct inode *" */
         struct list_head        fi_stateids;
         struct list_head        fi_delegations;
@@ -259,14 +320,13 @@ struct nfs4_stateid {
 };
 
 /* flags for preprocess_seqid_op() */
-#define CHECK_FH                0x00000001
+#define HAS_SESSION             0x00000001
 #define CONFIRM                 0x00000002
 #define OPEN_STATE              0x00000004
 #define LOCK_STATE              0x00000008
 #define RD_STATE                0x00000010
 #define WR_STATE                0x00000020
 #define CLOSE_STATE             0x00000040
-#define DELEG_RET               0x00000080
 
 #define seqid_mutating_err(err)                       \
         (((err) != nfserr_stale_clientid) &&    \
@@ -274,7 +334,9 @@ struct nfs4_stateid {
         ((err) != nfserr_stale_stateid) &&      \
         ((err) != nfserr_bad_stateid))
 
-extern __be32 nfs4_preprocess_stateid_op(struct svc_fh *current_fh,
+struct nfsd4_compound_state;
+
+extern __be32 nfs4_preprocess_stateid_op(struct nfsd4_compound_state *cstate,
                 stateid_t *stateid, int flags, struct file **filp);
 extern void nfs4_lock_state(void);
 extern void nfs4_unlock_state(void);
@@ -290,7 +352,7 @@ extern void nfsd4_init_recdir(char *recdir_name);
 extern int nfsd4_recdir_load(void);
 extern void nfsd4_shutdown_recdir(void);
 extern int nfs4_client_to_reclaim(const char *name);
-extern int nfs4_has_reclaimed_state(const char *name);
+extern int nfs4_has_reclaimed_state(const char *name, bool use_exchange_id);
 extern void nfsd4_recdir_purge_old(void);
 extern int nfsd4_create_clid_dir(struct nfs4_client *clp);
 extern void nfsd4_remove_clid_dir(struct nfs4_client *clp);
diff --git a/include/linux/nfsd/stats.h b/include/linux/nfsd/stats.h
index 7678cfbe9960..2693ef647df6 100644
--- a/include/linux/nfsd/stats.h
+++ b/include/linux/nfsd/stats.h
@@ -11,6 +11,11 @@
 
 #include <linux/nfs4.h>
 
+/* thread usage wraps very million seconds (approx one fortnight) */
+#define NFSD_USAGE_WRAP (HZ*1000000)
+
+#ifdef __KERNEL__
+
 struct nfsd_stats {
         unsigned int    rchits;         /* repcache hits */
         unsigned int    rcmisses;       /* repcache hits */
@@ -35,10 +40,6 @@ struct nfsd_stats {
 
 };
 
-/* thread usage wraps very million seconds (approx one fortnight) */
-#define NFSD_USAGE_WRAP (HZ*1000000)
-
-#ifdef __KERNEL__
 
 extern struct nfsd_stats        nfsdstats;
 extern struct svc_stat          nfsd_svcstats;
diff --git a/include/linux/nfsd/xdr4.h b/include/linux/nfsd/xdr4.h
index 27bd3e38ec5a..f80d6013fdc3 100644
--- a/include/linux/nfsd/xdr4.h
+++ b/include/linux/nfsd/xdr4.h
@@ -45,10 +45,22 @@
 #define XDR_LEN(n)                     (((n) + 3) & ~3)
 
 struct nfsd4_compound_state {
-        struct svc_fh current_fh;
-        struct svc_fh save_fh;
-        struct nfs4_stateowner *replay_owner;
-};
+        struct svc_fh           current_fh;
+        struct svc_fh           save_fh;
+        struct nfs4_stateowner  *replay_owner;
+        /* For sessions DRC */
+        struct nfsd4_session    *session;
+        struct nfsd4_slot       *slot;
+        __be32                  *statp;
+        size_t                  iovlen;
+        u32                     minorversion;
+        u32                     status;
+};
+
+static inline bool nfsd4_has_session(struct nfsd4_compound_state *cs)
+{
+        return cs->slot != NULL;
+}
 
 struct nfsd4_change_info {
         u32             atomic;
@@ -90,7 +102,7 @@ struct nfsd4_create {
                         u32 specdata2;
                 } dev;    /* NF4BLK, NF4CHR */
         } u;
-        u32             cr_bmval[2];        /* request */
+        u32             cr_bmval[3];        /* request */
         struct iattr    cr_iattr;           /* request */
         struct nfsd4_change_info  cr_cinfo; /* response */
         struct nfs4_acl *cr_acl;
@@ -105,7 +117,7 @@ struct nfsd4_delegreturn {
 };
 
 struct nfsd4_getattr {
-        u32             ga_bmval[2];        /* request */
+        u32             ga_bmval[3];        /* request */
         struct svc_fh   *ga_fhp;            /* response */
 };
 
@@ -206,11 +218,9 @@ struct nfsd4_open {
         stateid_t       op_delegate_stateid; /* request - response */
         u32             op_create;          /* request */
         u32             op_createmode;      /* request */
-        u32             op_bmval[2];        /* request */
-        union {                             /* request */
-                struct iattr    iattr;                      /* UNCHECKED4,GUARDED4 */
-                nfs4_verifier   verf;                                /* EXCLUSIVE4 */
-        } u;
+        u32             op_bmval[3];        /* request */
+        struct iattr    iattr;              /* UNCHECKED4, GUARDED4, EXCLUSIVE4_1 */
+        nfs4_verifier   verf;               /* EXCLUSIVE4 */
         clientid_t      op_clientid;        /* request */
         struct xdr_netobj op_owner;           /* request */
         u32             op_seqid;           /* request */
@@ -224,8 +234,8 @@ struct nfsd4_open {
         struct nfs4_stateowner *op_stateowner; /* used during processing */
         struct nfs4_acl *op_acl;
 };
-#define op_iattr        u.iattr
-#define op_verf         u.verf
+#define op_iattr        iattr
+#define op_verf         verf
 
 struct nfsd4_open_confirm {
         stateid_t       oc_req_stateid          /* request */;
@@ -259,7 +269,7 @@ struct nfsd4_readdir {
         nfs4_verifier   rd_verf;            /* request */
         u32             rd_dircount;        /* request */
         u32             rd_maxcount;        /* request */
-        u32             rd_bmval[2];        /* request */
+        u32             rd_bmval[3];        /* request */
         struct svc_rqst *rd_rqstp;          /* response */
         struct svc_fh * rd_fhp;             /* response */
 
@@ -301,7 +311,7 @@ struct nfsd4_secinfo {
 
 struct nfsd4_setattr {
         stateid_t       sa_stateid;         /* request */
-        u32             sa_bmval[2];        /* request */
+        u32             sa_bmval[3];        /* request */
         struct iattr    sa_iattr;           /* request */
         struct nfs4_acl *sa_acl;
 };
@@ -327,7 +337,7 @@ struct nfsd4_setclientid_confirm {
 
 /* also used for NVERIFY */
 struct nfsd4_verify {
-        u32             ve_bmval[2];        /* request */
+        u32             ve_bmval[3];        /* request */
         u32             ve_attrlen;         /* request */
         char *          ve_attrval;         /* request */
 };
@@ -344,6 +354,54 @@ struct nfsd4_write {
         nfs4_verifier   wr_verifier;        /* response */
 };
 
+struct nfsd4_exchange_id {
+        nfs4_verifier   verifier;
+        struct xdr_netobj clname;
+        u32             flags;
+        clientid_t      clientid;
+        u32             seqid;
+        int             spa_how;
+};
+
+struct nfsd4_channel_attrs {
+        u32             headerpadsz;
+        u32             maxreq_sz;
+        u32             maxresp_sz;
+        u32             maxresp_cached;
+        u32             maxops;
+        u32             maxreqs;
+        u32             nr_rdma_attrs;
+        u32             rdma_attrs;
+};
+
+struct nfsd4_create_session {
+        clientid_t              clientid;
+        struct nfs4_sessionid   sessionid;
+        u32                     seqid;
+        u32                     flags;
+        struct nfsd4_channel_attrs fore_channel;
+        struct nfsd4_channel_attrs back_channel;
+        u32                     callback_prog;
+        u32                     uid;
+        u32                     gid;
+};
+
+struct nfsd4_sequence {
+        struct nfs4_sessionid   sessionid;              /* request/response */
+        u32                     seqid;                  /* request/response */
+        u32                     slotid;                 /* request/response */
+        u32                     maxslots;               /* request/response */
+        u32                     cachethis;              /* request */
+#if 0
+        u32                     target_maxslots;        /* response */
+        u32                     status_flags;           /* response */
+#endif /* not yet */
+};
+
+struct nfsd4_destroy_session {
+        struct nfs4_sessionid   sessionid;
+};
+
 struct nfsd4_op {
         int                                     opnum;
         __be32                                  status;
@@ -378,6 +436,12 @@ struct nfsd4_op {
                 struct nfsd4_verify             verify;
                 struct nfsd4_write              write;
                 struct nfsd4_release_lockowner  release_lockowner;
+
+                /* NFSv4.1 */
+                struct nfsd4_exchange_id        exchange_id;
+                struct nfsd4_create_session     create_session;
+                struct nfsd4_destroy_session    destroy_session;
+                struct nfsd4_sequence           sequence;
         } u;
         struct nfs4_replay *                    replay;
 };
@@ -416,9 +480,22 @@ struct nfsd4_compoundres {
         u32                             taglen;
         char *                          tag;
         u32                             opcnt;
-        __be32 *                        tagp; /* where to encode tag and  opcount */
+        __be32 *                        tagp; /* tag, opcount encode location */
+        struct nfsd4_compound_state     cstate;
 };
 
+static inline bool nfsd4_is_solo_sequence(struct nfsd4_compoundres *resp)
+{
+        struct nfsd4_compoundargs *args = resp->rqstp->rq_argp;
+        return args->opcnt == 1;
+}
+
+static inline bool nfsd4_not_cached(struct nfsd4_compoundres *resp)
+{
+        return !resp->cstate.slot->sl_cache_entry.ce_cachethis ||
+                        nfsd4_is_solo_sequence(resp);
+}
+
 #define NFS4_SVC_XDRSIZE                sizeof(struct nfsd4_compoundargs)
 
 static inline void
@@ -448,7 +525,23 @@ extern __be32 nfsd4_setclientid(struct svc_rqst *rqstp,
 extern __be32 nfsd4_setclientid_confirm(struct svc_rqst *rqstp,
                 struct nfsd4_compound_state *,
                 struct nfsd4_setclientid_confirm *setclientid_confirm);
-extern __be32 nfsd4_process_open1(struct nfsd4_open *open);
+extern void nfsd4_store_cache_entry(struct nfsd4_compoundres *resp);
+extern __be32 nfsd4_replay_cache_entry(struct nfsd4_compoundres *resp,
+                struct nfsd4_sequence *seq);
+extern __be32 nfsd4_exchange_id(struct svc_rqst *rqstp,
+                struct nfsd4_compound_state *,
+struct nfsd4_exchange_id *);
+                extern __be32 nfsd4_create_session(struct svc_rqst *,
+                struct nfsd4_compound_state *,
+                struct nfsd4_create_session *);
+extern __be32 nfsd4_sequence(struct svc_rqst *,
+                struct nfsd4_compound_state *,
+                struct nfsd4_sequence *);
+extern __be32 nfsd4_destroy_session(struct svc_rqst *,
+                struct nfsd4_compound_state *,
+                struct nfsd4_destroy_session *);
+extern __be32 nfsd4_process_open1(struct nfsd4_compound_state *,
+                struct nfsd4_open *open);
 extern __be32 nfsd4_process_open2(struct svc_rqst *rqstp,
                 struct svc_fh *current_fh, struct nfsd4_open *open);
 extern __be32 nfsd4_open_confirm(struct svc_rqst *rqstp,
diff --git a/include/linux/nilfs2_fs.h b/include/linux/nilfs2_fs.h
new file mode 100644
index 000000000000..79fec6af3f9f
--- /dev/null
+++ b/include/linux/nilfs2_fs.h
@@ -0,0 +1,801 @@
+/*
+ * nilfs2_fs.h - NILFS2 on-disk structures and common declarations.
+ *
+ * Copyright (C) 2005-2008 Nippon Telegraph and Telephone Corporation.
+ *
+ * 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., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
+ *
+ * Written by Koji Sato <koji@osrg.net>
+ *            Ryusuke Konishi <ryusuke@osrg.net>
+ */
+/*
+ *  linux/include/linux/ext2_fs.h
+ *
+ * Copyright (C) 1992, 1993, 1994, 1995
+ * Remy Card (card@masi.ibp.fr)
+ * Laboratoire MASI - Institut Blaise Pascal
+ * Universite Pierre et Marie Curie (Paris VI)
+ *
+ *  from
+ *
+ *  linux/include/linux/minix_fs.h
+ *
+ *  Copyright (C) 1991, 1992  Linus Torvalds
+ */
+
+#ifndef _LINUX_NILFS_FS_H
+#define _LINUX_NILFS_FS_H
+
+#include <linux/types.h>
+#include <linux/ioctl.h>
+
+/*
+ * Inode flags stored in nilfs_inode and on-memory nilfs inode
+ *
+ * We define these flags based on ext2-fs because of the
+ * compatibility reason; to avoid problems in chattr(1)
+ */
+#define NILFS_SECRM_FL          0x00000001 /* Secure deletion */
+#define NILFS_UNRM_FL           0x00000002 /* Undelete */
+#define NILFS_SYNC_FL           0x00000008 /* Synchronous updates */
+#define NILFS_IMMUTABLE_FL      0x00000010 /* Immutable file */
+#define NILFS_APPEND_FL         0x00000020 /* writes to file may only append */
+#define NILFS_NODUMP_FL         0x00000040 /* do not dump file */
+#define NILFS_NOATIME_FL        0x00000080 /* do not update atime */
+/* Reserved for compression usage... */
+#define NILFS_NOTAIL_FL         0x00008000 /* file tail should not be merged */
+#define NILFS_DIRSYNC_FL        0x00010000 /* dirsync behaviour */
+
+#define NILFS_FL_USER_VISIBLE   0x0003DFFF /* User visible flags */
+#define NILFS_FL_USER_MODIFIABLE        0x000380FF /* User modifiable flags */
+
+
+#define NILFS_INODE_BMAP_SIZE   7
+/**
+ * struct nilfs_inode - structure of an inode on disk
+ * @i_blocks: blocks count
+ * @i_size: size in bytes
+ * @i_ctime: creation time (seconds)
+ * @i_mtime: modification time (seconds)
+ * @i_ctime_nsec: creation time (nano seconds)
+ * @i_mtime_nsec: modification time (nano seconds)
+ * @i_uid: user id
+ * @i_gid: group id
+ * @i_mode: file mode
+ * @i_links_count: links count
+ * @i_flags: file flags
+ * @i_bmap: block mapping
+ * @i_xattr: extended attributes
+ * @i_generation: file generation (for NFS)
+ * @i_pad:      padding
+ */
+struct nilfs_inode {
+        __le64  i_blocks;
+        __le64  i_size;
+        __le64  i_ctime;
+        __le64  i_mtime;
+        __le32  i_ctime_nsec;
+        __le32  i_mtime_nsec;
+        __le32  i_uid;
+        __le32  i_gid;
+        __le16  i_mode;
+        __le16  i_links_count;
+        __le32  i_flags;
+        __le64  i_bmap[NILFS_INODE_BMAP_SIZE];
+#define i_device_code   i_bmap[0]
+        __le64  i_xattr;
+        __le32  i_generation;
+        __le32  i_pad;
+};
+
+/**
+ * struct nilfs_super_root - structure of super root
+ * @sr_sum: check sum
+ * @sr_bytes: byte count of the structure
+ * @sr_flags: flags (reserved)
+ * @sr_nongc_ctime: write time of the last segment not for cleaner operation
+ * @sr_dat: DAT file inode
+ * @sr_cpfile: checkpoint file inode
+ * @sr_sufile: segment usage file inode
+ */
+struct nilfs_super_root {
+        __le32 sr_sum;
+        __le16 sr_bytes;
+        __le16 sr_flags;
+        __le64 sr_nongc_ctime;
+        struct nilfs_inode sr_dat;
+        struct nilfs_inode sr_cpfile;
+        struct nilfs_inode sr_sufile;
+};
+
+#define NILFS_SR_MDT_OFFSET(inode_size, i)  \
+        ((unsigned long)&((struct nilfs_super_root *)0)->sr_dat + \
+                        (inode_size) * (i))
+#define NILFS_SR_DAT_OFFSET(inode_size)     NILFS_SR_MDT_OFFSET(inode_size, 0)
+#define NILFS_SR_CPFILE_OFFSET(inode_size)  NILFS_SR_MDT_OFFSET(inode_size, 1)
+#define NILFS_SR_SUFILE_OFFSET(inode_size)  NILFS_SR_MDT_OFFSET(inode_size, 2)
+#define NILFS_SR_BYTES                  (sizeof(struct nilfs_super_root))
+
+/*
+ * Maximal mount counts
+ */
+#define NILFS_DFL_MAX_MNT_COUNT         50      /* 50 mounts */
+
+/*
+ * File system states (sbp->s_state, nilfs->ns_mount_state)
+ */
+#define NILFS_VALID_FS                  0x0001  /* Unmounted cleanly */
+#define NILFS_ERROR_FS                  0x0002  /* Errors detected */
+#define NILFS_RESIZE_FS                 0x0004  /* Resize required */
+
+/*
+ * Mount flags (sbi->s_mount_opt)
+ */
+#define NILFS_MOUNT_ERROR_MODE          0x0070  /* Error mode mask */
+#define NILFS_MOUNT_ERRORS_CONT         0x0010  /* Continue on errors */
+#define NILFS_MOUNT_ERRORS_RO           0x0020  /* Remount fs ro on errors */
+#define NILFS_MOUNT_ERRORS_PANIC        0x0040  /* Panic on errors */
+#define NILFS_MOUNT_SNAPSHOT            0x0080  /* Snapshot flag */
+#define NILFS_MOUNT_BARRIER             0x1000  /* Use block barriers */
+#define NILFS_MOUNT_STRICT_ORDER        0x2000  /* Apply strict in-order
+                                                   semantics also for data */
+
+
+/**
+ * struct nilfs_super_block - structure of super block on disk
+ */
+struct nilfs_super_block {
+        __le32  s_rev_level;            /* Revision level */
+        __le16  s_minor_rev_level;      /* minor revision level */
+        __le16  s_magic;                /* Magic signature */
+
+        __le16  s_bytes;                /* Bytes count of CRC calculation
+                                           for this structure. s_reserved
+                                           is excluded. */
+        __le16  s_flags;                /* flags */
+        __le32  s_crc_seed;             /* Seed value of CRC calculation */
+        __le32  s_sum;                  /* Check sum of super block */
+
+        __le32  s_log_block_size;       /* Block size represented as follows
+                                           blocksize =
+                                               1 << (s_log_block_size + 10) */
+        __le64  s_nsegments;            /* Number of segments in filesystem */
+        __le64  s_dev_size;             /* block device size in bytes */
+        __le64  s_first_data_block;     /* 1st seg disk block number */
+        __le32  s_blocks_per_segment;   /* number of blocks per full segment */
+        __le32  s_r_segments_percentage; /* Reserved segments percentage */
+
+        __le64  s_last_cno;             /* Last checkpoint number */
+        __le64  s_last_pseg;            /* disk block addr pseg written last */
+        __le64  s_last_seq;             /* seq. number of seg written last */
+        __le64  s_free_blocks_count;    /* Free blocks count */
+
+        __le64  s_ctime;                /* Creation time (execution time of
+                                           newfs) */
+        __le64  s_mtime;                /* Mount time */
+        __le64  s_wtime;                /* Write time */
+        __le16  s_mnt_count;            /* Mount count */
+        __le16  s_max_mnt_count;        /* Maximal mount count */
+        __le16  s_state;                /* File system state */
+        __le16  s_errors;               /* Behaviour when detecting errors */
+        __le64  s_lastcheck;            /* time of last check */
+
+        __le32  s_checkinterval;        /* max. time between checks */
+        __le32  s_creator_os;           /* OS */
+        __le16  s_def_resuid;           /* Default uid for reserved blocks */
+        __le16  s_def_resgid;           /* Default gid for reserved blocks */
+        __le32  s_first_ino;            /* First non-reserved inode */
+
+        __le16  s_inode_size;           /* Size of an inode */
+        __le16  s_dat_entry_size;       /* Size of a dat entry */
+        __le16  s_checkpoint_size;      /* Size of a checkpoint */
+        __le16  s_segment_usage_size;   /* Size of a segment usage */
+
+        __u8    s_uuid[16];             /* 128-bit uuid for volume */
+        char    s_volume_name[16];      /* volume name */
+        char    s_last_mounted[64];     /* directory where last mounted */
+
+        __le32  s_c_interval;           /* Commit interval of segment */
+        __le32  s_c_block_max;          /* Threshold of data amount for
+                                           the segment construction */
+        __u32   s_reserved[192];        /* padding to the end of the block */
+};
+
+/*
+ * Codes for operating systems
+ */
+#define NILFS_OS_LINUX          0
+/* Codes from 1 to 4 are reserved to keep compatibility with ext2 creator-OS */
+
+/*
+ * Revision levels
+ */
+#define NILFS_CURRENT_REV       2       /* current major revision */
+#define NILFS_MINOR_REV         0       /* minor revision */
+
+/*
+ * Bytes count of super_block for CRC-calculation
+ */
+#define NILFS_SB_BYTES  \
+        ((long)&((struct nilfs_super_block *)0)->s_reserved)
+
+/*
+ * Special inode number
+ */
+#define NILFS_ROOT_INO          2       /* Root file inode */
+#define NILFS_DAT_INO           3       /* DAT file */
+#define NILFS_CPFILE_INO        4       /* checkpoint file */
+#define NILFS_SUFILE_INO        5       /* segment usage file */
+#define NILFS_IFILE_INO         6       /* ifile */
+#define NILFS_ATIME_INO         7       /* Atime file (reserved) */
+#define NILFS_XATTR_INO         8       /* Xattribute file (reserved) */
+#define NILFS_SKETCH_INO        10      /* Sketch file */
+#define NILFS_USER_INO          11      /* Fisrt user's file inode number */
+
+#define NILFS_SB_OFFSET_BYTES   1024    /* byte offset of nilfs superblock */
+#define NILFS_SUPER_MAGIC       0x3434  /* NILFS filesystem  magic number */
+
+#define NILFS_SEG_MIN_BLOCKS    16      /* Minimum number of blocks in
+                                           a full segment */
+#define NILFS_PSEG_MIN_BLOCKS   2       /* Minimum number of blocks in
+                                           a partial segment */
+#define NILFS_MIN_NRSVSEGS      8       /* Minimum number of reserved
+                                           segments */
+
+/*
+ * bytes offset of secondary super block
+ */
+#define NILFS_SB2_OFFSET_BYTES(devsize) ((((devsize) >> 12) - 1) << 12)
+
+/*
+ * Maximal count of links to a file
+ */
+#define NILFS_LINK_MAX          32000
+
+/*
+ * Structure of a directory entry
+ *  (Same as ext2)
+ */
+
+#define NILFS_NAME_LEN 255
+
+/*
+ * The new version of the directory entry.  Since V0 structures are
+ * stored in intel byte order, and the name_len field could never be
+ * bigger than 255 chars, it's safe to reclaim the extra byte for the
+ * file_type field.
+ */
+struct nilfs_dir_entry {
+        __le64  inode;                  /* Inode number */
+        __le16  rec_len;                /* Directory entry length */
+        __u8    name_len;               /* Name length */
+        __u8    file_type;
+        char    name[NILFS_NAME_LEN];   /* File name */
+        char    pad;
+};
+
+/*
+ * NILFS directory file types.  Only the low 3 bits are used.  The
+ * other bits are reserved for now.
+ */
+enum {
+        NILFS_FT_UNKNOWN,
+        NILFS_FT_REG_FILE,
+        NILFS_FT_DIR,
+        NILFS_FT_CHRDEV,
+        NILFS_FT_BLKDEV,
+        NILFS_FT_FIFO,
+        NILFS_FT_SOCK,
+        NILFS_FT_SYMLINK,
+        NILFS_FT_MAX
+};
+
+/*
+ * NILFS_DIR_PAD defines the directory entries boundaries
+ *
+ * NOTE: It must be a multiple of 8
+ */
+#define NILFS_DIR_PAD                   8
+#define NILFS_DIR_ROUND                 (NILFS_DIR_PAD - 1)
+#define NILFS_DIR_REC_LEN(name_len)     (((name_len) + 12 + NILFS_DIR_ROUND) & \
+                                        ~NILFS_DIR_ROUND)
+
+
+/**
+ * struct nilfs_finfo - file information
+ * @fi_ino: inode number
+ * @fi_cno: checkpoint number
+ * @fi_nblocks: number of blocks (including intermediate blocks)
+ * @fi_ndatablk: number of file data blocks
+ */
+struct nilfs_finfo {
+        __le64 fi_ino;
+        __le64 fi_cno;
+        __le32 fi_nblocks;
+        __le32 fi_ndatablk;
+        /* array of virtual block numbers */
+};
+
+/**
+ * struct nilfs_binfo_v - information for the block to which a virtual block number is assigned
+ * @bi_vblocknr: virtual block number
+ * @bi_blkoff: block offset
+ */
+struct nilfs_binfo_v {
+        __le64 bi_vblocknr;
+        __le64 bi_blkoff;
+};
+
+/**
+ * struct nilfs_binfo_dat - information for the block which belongs to the DAT file
+ * @bi_blkoff: block offset
+ * @bi_level: level
+ * @bi_pad: padding
+ */
+struct nilfs_binfo_dat {
+        __le64 bi_blkoff;
+        __u8 bi_level;
+        __u8 bi_pad[7];
+};
+
+/**
+ * union nilfs_binfo: block information
+ * @bi_v: nilfs_binfo_v structure
+ * @bi_dat: nilfs_binfo_dat structure
+ */
+union nilfs_binfo {
+        struct nilfs_binfo_v bi_v;
+        struct nilfs_binfo_dat bi_dat;
+};
+
+/**
+ * struct nilfs_segment_summary - segment summary
+ * @ss_datasum: checksum of data
+ * @ss_sumsum: checksum of segment summary
+ * @ss_magic: magic number
+ * @ss_bytes: size of this structure in bytes
+ * @ss_flags: flags
+ * @ss_seq: sequence number
+ * @ss_create: creation timestamp
+ * @ss_next: next segment
+ * @ss_nblocks: number of blocks
+ * @ss_nfinfo: number of finfo structures
+ * @ss_sumbytes: total size of segment summary in bytes
+ * @ss_pad: padding
+ */
+struct nilfs_segment_summary {
+        __le32 ss_datasum;
+        __le32 ss_sumsum;
+        __le32 ss_magic;
+        __le16 ss_bytes;
+        __le16 ss_flags;
+        __le64 ss_seq;
+        __le64 ss_create;
+        __le64 ss_next;
+        __le32 ss_nblocks;
+        __le32 ss_nfinfo;
+        __le32 ss_sumbytes;
+        __le32 ss_pad;
+        /* array of finfo structures */
+};
+
+#define NILFS_SEGSUM_MAGIC      0x1eaffa11  /* segment summary magic number */
+
+/*
+ * Segment summary flags
+ */
+#define NILFS_SS_LOGBGN 0x0001  /* begins a logical segment */
+#define NILFS_SS_LOGEND 0x0002  /* ends a logical segment */
+#define NILFS_SS_SR     0x0004  /* has super root */
+#define NILFS_SS_SYNDT  0x0008  /* includes data only updates */
+#define NILFS_SS_GC     0x0010  /* segment written for cleaner operation */
+
+/**
+ * struct nilfs_palloc_group_desc - block group descriptor
+ * @pg_nfrees: number of free entries in block group
+ */
+struct nilfs_palloc_group_desc {
+        __le32 pg_nfrees;
+};
+
+/**
+ * struct nilfs_dat_entry - disk address translation entry
+ * @dt_blocknr: block number
+ * @dt_start: start checkpoint number
+ * @dt_end: end checkpoint number
+ * @dt_rsv: reserved for future use
+ */
+struct nilfs_dat_entry {
+        __le64 de_blocknr;
+        __le64 de_start;
+        __le64 de_end;
+        __le64 de_rsv;
+};
+
+/**
+ * struct nilfs_dat_group_desc - block group descriptor
+ * @dg_nfrees: number of free virtual block numbers in block group
+ */
+struct nilfs_dat_group_desc {
+        __le32 dg_nfrees;
+};
+
+
+/**
+ * struct nilfs_snapshot_list - snapshot list
+ * @ssl_next: next checkpoint number on snapshot list
+ * @ssl_prev: previous checkpoint number on snapshot list
+ */
+struct nilfs_snapshot_list {
+        __le64 ssl_next;
+        __le64 ssl_prev;
+};
+
+/**
+ * struct nilfs_checkpoint - checkpoint structure
+ * @cp_flags: flags
+ * @cp_checkpoints_count: checkpoints count in a block
+ * @cp_snapshot_list: snapshot list
+ * @cp_cno: checkpoint number
+ * @cp_create: creation timestamp
+ * @cp_nblk_inc: number of blocks incremented by this checkpoint
+ * @cp_inodes_count: inodes count
+ * @cp_blocks_count: blocks count
+ * @cp_ifile_inode: inode of ifile
+ */
+struct nilfs_checkpoint {
+        __le32 cp_flags;
+        __le32 cp_checkpoints_count;
+        struct nilfs_snapshot_list cp_snapshot_list;
+        __le64 cp_cno;
+        __le64 cp_create;
+        __le64 cp_nblk_inc;
+        __le64 cp_inodes_count;
+        __le64 cp_blocks_count;         /* Reserved (might be deleted) */
+
+        /* Do not change the byte offset of ifile inode.
+           To keep the compatibility of the disk format,
+           additional fields should be added behind cp_ifile_inode. */
+        struct nilfs_inode cp_ifile_inode;
+};
+
+/* checkpoint flags */
+enum {
+        NILFS_CHECKPOINT_SNAPSHOT,
+        NILFS_CHECKPOINT_INVALID,
+        NILFS_CHECKPOINT_SKETCH,
+        NILFS_CHECKPOINT_MINOR,
+};
+
+#define NILFS_CHECKPOINT_FNS(flag, name)                                \
+static inline void                                                      \
+nilfs_checkpoint_set_##name(struct nilfs_checkpoint *cp)                \
+{                                                                       \
+        cp->cp_flags = cpu_to_le32(le32_to_cpu(cp->cp_flags) |          \
+                                   (1UL << NILFS_CHECKPOINT_##flag));   \
+}                                                                       \
+static inline void                                                      \
+nilfs_checkpoint_clear_##name(struct nilfs_checkpoint *cp)              \
+{                                                                       \
+        cp->cp_flags = cpu_to_le32(le32_to_cpu(cp->cp_flags) &          \
+                                   ~(1UL << NILFS_CHECKPOINT_##flag));  \
+}                                                                       \
+static inline int                                                       \
+nilfs_checkpoint_##name(const struct nilfs_checkpoint *cp)              \
+{                                                                       \
+        return !!(le32_to_cpu(cp->cp_flags) &                           \
+                  (1UL << NILFS_CHECKPOINT_##flag));                    \
+}
+
+NILFS_CHECKPOINT_FNS(SNAPSHOT, snapshot)
+NILFS_CHECKPOINT_FNS(INVALID, invalid)
+NILFS_CHECKPOINT_FNS(MINOR, minor)
+
+/**
+ * struct nilfs_cpinfo - checkpoint information
+ * @ci_flags: flags
+ * @ci_pad: padding
+ * @ci_cno: checkpoint number
+ * @ci_create: creation timestamp
+ * @ci_nblk_inc: number of blocks incremented by this checkpoint
+ * @ci_inodes_count: inodes count
+ * @ci_blocks_count: blocks count
+ * @ci_next: next checkpoint number in snapshot list
+ */
+struct nilfs_cpinfo {
+        __u32 ci_flags;
+        __u32 ci_pad;
+        __u64 ci_cno;
+        __u64 ci_create;
+        __u64 ci_nblk_inc;
+        __u64 ci_inodes_count;
+        __u64 ci_blocks_count;
+        __u64 ci_next;
+};
+
+#define NILFS_CPINFO_FNS(flag, name)                                    \
+static inline int                                                       \
+nilfs_cpinfo_##name(const struct nilfs_cpinfo *cpinfo)                  \
+{                                                                       \
+        return !!(cpinfo->ci_flags & (1UL << NILFS_CHECKPOINT_##flag)); \
+}
+
+NILFS_CPINFO_FNS(SNAPSHOT, snapshot)
+NILFS_CPINFO_FNS(INVALID, invalid)
+NILFS_CPINFO_FNS(MINOR, minor)
+
+
+/**
+ * struct nilfs_cpfile_header - checkpoint file header
+ * @ch_ncheckpoints: number of checkpoints
+ * @ch_nsnapshots: number of snapshots
+ * @ch_snapshot_list: snapshot list
+ */
+struct nilfs_cpfile_header {
+        __le64 ch_ncheckpoints;
+        __le64 ch_nsnapshots;
+        struct nilfs_snapshot_list ch_snapshot_list;
+};
+
+#define NILFS_CPFILE_FIRST_CHECKPOINT_OFFSET    \
+        ((sizeof(struct nilfs_cpfile_header) +                          \
+          sizeof(struct nilfs_checkpoint) - 1) /                        \
+                        sizeof(struct nilfs_checkpoint))
+
+/**
+ * struct nilfs_segment_usage - segment usage
+ * @su_lastmod: last modified timestamp
+ * @su_nblocks: number of blocks in segment
+ * @su_flags: flags
+ */
+struct nilfs_segment_usage {
+        __le64 su_lastmod;
+        __le32 su_nblocks;
+        __le32 su_flags;
+};
+
+/* segment usage flag */
+enum {
+        NILFS_SEGMENT_USAGE_ACTIVE,
+        NILFS_SEGMENT_USAGE_DIRTY,
+        NILFS_SEGMENT_USAGE_ERROR,
+
+        /* ... */
+};
+
+#define NILFS_SEGMENT_USAGE_FNS(flag, name)                             \
+static inline void                                                      \
+nilfs_segment_usage_set_##name(struct nilfs_segment_usage *su)          \
+{                                                                       \
+        su->su_flags = cpu_to_le32(le32_to_cpu(su->su_flags) |          \
+                                   (1UL << NILFS_SEGMENT_USAGE_##flag));\
+}                                                                       \
+static inline void                                                      \
+nilfs_segment_usage_clear_##name(struct nilfs_segment_usage *su)        \
+{                                                                       \
+        su->su_flags =                                                  \
+                cpu_to_le32(le32_to_cpu(su->su_flags) &                 \
+                            ~(1UL << NILFS_SEGMENT_USAGE_##flag));      \
+}                                                                       \
+static inline int                                                       \
+nilfs_segment_usage_##name(const struct nilfs_segment_usage *su)        \
+{                                                                       \
+        return !!(le32_to_cpu(su->su_flags) &                           \
+                  (1UL << NILFS_SEGMENT_USAGE_##flag));                 \
+}
+
+NILFS_SEGMENT_USAGE_FNS(ACTIVE, active)
+NILFS_SEGMENT_USAGE_FNS(DIRTY, dirty)
+NILFS_SEGMENT_USAGE_FNS(ERROR, error)
+
+static inline void
+nilfs_segment_usage_set_clean(struct nilfs_segment_usage *su)
+{
+        su->su_lastmod = cpu_to_le64(0);
+        su->su_nblocks = cpu_to_le32(0);
+        su->su_flags = cpu_to_le32(0);
+}
+
+static inline int
+nilfs_segment_usage_clean(const struct nilfs_segment_usage *su)
+{
+        return !le32_to_cpu(su->su_flags);
+}
+
+/**
+ * struct nilfs_sufile_header - segment usage file header
+ * @sh_ncleansegs: number of clean segments
+ * @sh_ndirtysegs: number of dirty segments
+ * @sh_last_alloc: last allocated segment number
+ */
+struct nilfs_sufile_header {
+        __le64 sh_ncleansegs;
+        __le64 sh_ndirtysegs;
+        __le64 sh_last_alloc;
+        /* ... */
+};
+
+#define NILFS_SUFILE_FIRST_SEGMENT_USAGE_OFFSET \
+        ((sizeof(struct nilfs_sufile_header) +                          \
+          sizeof(struct nilfs_segment_usage) - 1) /                     \
+                         sizeof(struct nilfs_segment_usage))
+
+/**
+ * nilfs_suinfo - segment usage information
+ * @sui_lastmod:
+ * @sui_nblocks:
+ * @sui_flags:
+ */
+struct nilfs_suinfo {
+        __u64 sui_lastmod;
+        __u32 sui_nblocks;
+        __u32 sui_flags;
+};
+
+#define NILFS_SUINFO_FNS(flag, name)                                    \
+static inline int                                                       \
+nilfs_suinfo_##name(const struct nilfs_suinfo *si)                      \
+{                                                                       \
+        return si->sui_flags & (1UL << NILFS_SEGMENT_USAGE_##flag);     \
+}
+
+NILFS_SUINFO_FNS(ACTIVE, active)
+NILFS_SUINFO_FNS(DIRTY, dirty)
+NILFS_SUINFO_FNS(ERROR, error)
+
+static inline int nilfs_suinfo_clean(const struct nilfs_suinfo *si)
+{
+        return !si->sui_flags;
+}
+
+/* ioctl */
+enum {
+        NILFS_CHECKPOINT,
+        NILFS_SNAPSHOT,
+};
+
+/**
+ * struct nilfs_cpmode -
+ * @cc_cno:
+ * @cc_mode:
+ */
+struct nilfs_cpmode {
+        __u64 cm_cno;
+        __u32 cm_mode;
+        __u32 cm_pad;
+};
+
+/**
+ * struct nilfs_argv - argument vector
+ * @v_base:
+ * @v_nmembs:
+ * @v_size:
+ * @v_flags:
+ * @v_index:
+ */
+struct nilfs_argv {
+        __u64 v_base;
+        __u32 v_nmembs; /* number of members */
+        __u16 v_size;   /* size of members */
+        __u16 v_flags;
+        __u64 v_index;
+};
+
+/**
+ * struct nilfs_period -
+ * @p_start:
+ * @p_end:
+ */
+struct nilfs_period {
+        __u64 p_start;
+        __u64 p_end;
+};
+
+/**
+ * struct nilfs_cpstat -
+ * @cs_cno: checkpoint number
+ * @cs_ncps: number of checkpoints
+ * @cs_nsss: number of snapshots
+ */
+struct nilfs_cpstat {
+        __u64 cs_cno;
+        __u64 cs_ncps;
+        __u64 cs_nsss;
+};
+
+/**
+ * struct nilfs_sustat -
+ * @ss_nsegs: number of segments
+ * @ss_ncleansegs: number of clean segments
+ * @ss_ndirtysegs: number of dirty segments
+ * @ss_ctime: creation time of the last segment
+ * @ss_nongc_ctime: creation time of the last segment not for GC
+ * @ss_prot_seq: least sequence number of segments which must not be reclaimed
+ */
+struct nilfs_sustat {
+        __u64 ss_nsegs;
+        __u64 ss_ncleansegs;
+        __u64 ss_ndirtysegs;
+        __u64 ss_ctime;
+        __u64 ss_nongc_ctime;
+        __u64 ss_prot_seq;
+};
+
+/**
+ * struct nilfs_vinfo - virtual block number information
+ * @vi_vblocknr:
+ * @vi_start:
+ * @vi_end:
+ * @vi_blocknr:
+ */
+struct nilfs_vinfo {
+        __u64 vi_vblocknr;
+        __u64 vi_start;
+        __u64 vi_end;
+        __u64 vi_blocknr;
+};
+
+/**
+ * struct nilfs_vdesc -
+ */
+struct nilfs_vdesc {
+        __u64 vd_ino;
+        __u64 vd_cno;
+        __u64 vd_vblocknr;
+        struct nilfs_period vd_period;
+        __u64 vd_blocknr;
+        __u64 vd_offset;
+        __u32 vd_flags;
+        __u32 vd_pad;
+};
+
+/**
+ * struct nilfs_bdesc -
+ */
+struct nilfs_bdesc {
+        __u64 bd_ino;
+        __u64 bd_oblocknr;
+        __u64 bd_blocknr;
+        __u64 bd_offset;
+        __u32 bd_level;
+        __u32 bd_pad;
+};
+
+#define NILFS_IOCTL_IDENT               'n'
+
+#define NILFS_IOCTL_CHANGE_CPMODE  \
+        _IOW(NILFS_IOCTL_IDENT, 0x80, struct nilfs_cpmode)
+#define NILFS_IOCTL_DELETE_CHECKPOINT  \
+        _IOW(NILFS_IOCTL_IDENT, 0x81, __u64)
+#define NILFS_IOCTL_GET_CPINFO  \
+        _IOR(NILFS_IOCTL_IDENT, 0x82, struct nilfs_argv)
+#define NILFS_IOCTL_GET_CPSTAT  \
+        _IOR(NILFS_IOCTL_IDENT, 0x83, struct nilfs_cpstat)
+#define NILFS_IOCTL_GET_SUINFO  \
+        _IOR(NILFS_IOCTL_IDENT, 0x84, struct nilfs_argv)
+#define NILFS_IOCTL_GET_SUSTAT  \
+        _IOR(NILFS_IOCTL_IDENT, 0x85, struct nilfs_sustat)
+#define NILFS_IOCTL_GET_VINFO  \
+        _IOWR(NILFS_IOCTL_IDENT, 0x86, struct nilfs_argv)
+#define NILFS_IOCTL_GET_BDESCS  \
+        _IOWR(NILFS_IOCTL_IDENT, 0x87, struct nilfs_argv)
+#define NILFS_IOCTL_CLEAN_SEGMENTS  \
+        _IOW(NILFS_IOCTL_IDENT, 0x88, struct nilfs_argv[5])
+#define NILFS_IOCTL_SYNC  \
+        _IOR(NILFS_IOCTL_IDENT, 0x8A, __u64)
+#define NILFS_IOCTL_RESIZE  \
+        _IOW(NILFS_IOCTL_IDENT, 0x8B, __u64)
+
+#endif  /* _LINUX_NILFS_FS_H */
diff --git a/include/linux/nsproxy.h b/include/linux/nsproxy.h
index afad7dec1b36..7b370c7cfeff 100644
--- a/include/linux/nsproxy.h
+++ b/include/linux/nsproxy.h
@@ -8,6 +8,7 @@ struct mnt_namespace;
 struct uts_namespace;
 struct ipc_namespace;
 struct pid_namespace;
+struct fs_struct;
 
 /*
  * A structure to contain pointers to all per-process
diff --git a/include/linux/of_platform.h b/include/linux/of_platform.h
index 3d327b67d7e2..908406651330 100644
--- a/include/linux/of_platform.h
+++ b/include/linux/of_platform.h
@@ -51,6 +51,16 @@ extern int of_register_driver(struct of_platform_driver *drv,
                               struct bus_type *bus);
 extern void of_unregister_driver(struct of_platform_driver *drv);
 
+/* Platform drivers register/unregister */
+static inline int of_register_platform_driver(struct of_platform_driver *drv)
+{
+        return of_register_driver(drv, &of_platform_bus_type);
+}
+static inline void of_unregister_platform_driver(struct of_platform_driver *drv)
+{
+        of_unregister_driver(drv);
+}
+
 #include <asm/of_platform.h>
 
 extern struct of_device *of_find_device_by_node(struct device_node *np);
diff --git a/include/linux/page-debug-flags.h b/include/linux/page-debug-flags.h
new file mode 100644
index 000000000000..b0638fd91e92
--- /dev/null
+++ b/include/linux/page-debug-flags.h
@@ -0,0 +1,30 @@
+#ifndef LINUX_PAGE_DEBUG_FLAGS_H
+#define  LINUX_PAGE_DEBUG_FLAGS_H
+
+/*
+ * page->debug_flags bits:
+ *
+ * PAGE_DEBUG_FLAG_POISON is set for poisoned pages. This is used to
+ * implement generic debug pagealloc feature. The pages are filled with
+ * poison patterns and set this flag after free_pages(). The poisoned
+ * pages are verified whether the patterns are not corrupted and clear
+ * the flag before alloc_pages().
+ */
+
+enum page_debug_flags {
+        PAGE_DEBUG_FLAG_POISON,         /* Page is poisoned */
+};
+
+/*
+ * Ensure that CONFIG_WANT_PAGE_DEBUG_FLAGS reliably
+ * gets turned off when no debug features are enabling it!
+ */
+
+#ifdef CONFIG_WANT_PAGE_DEBUG_FLAGS
+#if !defined(CONFIG_PAGE_POISONING) \
+/* && !defined(CONFIG_PAGE_DEBUG_SOMETHING_ELSE) && ... */
+#error WANT_PAGE_DEBUG_FLAGS is turned on with no debug features!
+#endif
+#endif /* CONFIG_WANT_PAGE_DEBUG_FLAGS */
+
+#endif /* LINUX_PAGE_DEBUG_FLAGS_H */
diff --git a/include/linux/page-flags.h b/include/linux/page-flags.h
index 219a523ecdb0..62214c7d2d93 100644
--- a/include/linux/page-flags.h
+++ b/include/linux/page-flags.h
@@ -82,6 +82,7 @@ enum pageflags {
         PG_arch_1,
         PG_reserved,
         PG_private,             /* If pagecache, has fs-private data */
+        PG_private_2,           /* If pagecache, has fs aux data */
         PG_writeback,           /* Page is under writeback */
 #ifdef CONFIG_PAGEFLAGS_EXTENDED
         PG_head,                /* A head page */
@@ -96,6 +97,8 @@ enum pageflags {
         PG_swapbacked,          /* Page is backed by RAM/swap */
 #ifdef CONFIG_UNEVICTABLE_LRU
         PG_unevictable,         /* Page is "unevictable"  */
+#endif
+#ifdef CONFIG_HAVE_MLOCKED_PAGE_BIT
         PG_mlocked,             /* Page is vma mlocked */
 #endif
 #ifdef CONFIG_IA64_UNCACHED_ALLOCATOR
@@ -106,6 +109,12 @@ enum pageflags {
         /* Filesystems */
         PG_checked = PG_owner_priv_1,
 
+        /* Two page bits are conscripted by FS-Cache to maintain local caching
+         * state.  These bits are set on pages belonging to the netfs's inodes
+         * when those inodes are being locally cached.
+         */
+        PG_fscache = PG_private_2,      /* page backed by cache */
+
         /* XEN */
         PG_pinned = PG_owner_priv_1,
         PG_savepinned = PG_dirty,
@@ -180,7 +189,7 @@ static inline int TestClearPage##uname(struct page *page) { return 0; }
 
 struct page;    /* forward declaration */
 
-TESTPAGEFLAG(Locked, locked)
+TESTPAGEFLAG(Locked, locked) TESTSETFLAG(Locked, locked)
 PAGEFLAG(Error, error)
 PAGEFLAG(Referenced, referenced) TESTCLEARFLAG(Referenced, referenced)
 PAGEFLAG(Dirty, dirty) TESTSCFLAG(Dirty, dirty) __CLEARPAGEFLAG(Dirty, dirty)
@@ -192,8 +201,6 @@ PAGEFLAG(Checked, checked)		/* Used by some filesystems */
 PAGEFLAG(Pinned, pinned) TESTSCFLAG(Pinned, pinned)     /* Xen */
 PAGEFLAG(SavePinned, savepinned);                       /* Xen */
 PAGEFLAG(Reserved, reserved) __CLEARPAGEFLAG(Reserved, reserved)
-PAGEFLAG(Private, private) __CLEARPAGEFLAG(Private, private)
-        __SETPAGEFLAG(Private, private)
 PAGEFLAG(SwapBacked, swapbacked) __CLEARPAGEFLAG(SwapBacked, swapbacked)
 
 __PAGEFLAG(SlobPage, slob_page)
@@ -203,6 +210,16 @@ __PAGEFLAG(SlubFrozen, slub_frozen)
 __PAGEFLAG(SlubDebug, slub_debug)
 
 /*
+ * Private page markings that may be used by the filesystem that owns the page
+ * for its own purposes.
+ * - PG_private and PG_private_2 cause releasepage() and co to be invoked
+ */
+PAGEFLAG(Private, private) __SETPAGEFLAG(Private, private)
+        __CLEARPAGEFLAG(Private, private)
+PAGEFLAG(Private2, private_2) TESTSCFLAG(Private2, private_2)
+PAGEFLAG(OwnerPriv1, owner_priv_1) TESTCLEARFLAG(OwnerPriv1, owner_priv_1)
+
+/*
  * Only test-and-set exist for PG_writeback.  The unconditional operators are
  * risky: they bypass page accounting.
  */
@@ -234,20 +251,20 @@ PAGEFLAG_FALSE(SwapCache)
 #ifdef CONFIG_UNEVICTABLE_LRU
 PAGEFLAG(Unevictable, unevictable) __CLEARPAGEFLAG(Unevictable, unevictable)
         TESTCLEARFLAG(Unevictable, unevictable)
+#else
+PAGEFLAG_FALSE(Unevictable) TESTCLEARFLAG_FALSE(Unevictable)
+        SETPAGEFLAG_NOOP(Unevictable) CLEARPAGEFLAG_NOOP(Unevictable)
+        __CLEARPAGEFLAG_NOOP(Unevictable)
+#endif
 
+#ifdef CONFIG_HAVE_MLOCKED_PAGE_BIT
 #define MLOCK_PAGES 1
 PAGEFLAG(Mlocked, mlocked) __CLEARPAGEFLAG(Mlocked, mlocked)
         TESTSCFLAG(Mlocked, mlocked)
-
 #else
-
 #define MLOCK_PAGES 0
 PAGEFLAG_FALSE(Mlocked)
         SETPAGEFLAG_NOOP(Mlocked) TESTCLEARFLAG_FALSE(Mlocked)
-
-PAGEFLAG_FALSE(Unevictable) TESTCLEARFLAG_FALSE(Unevictable)
-        SETPAGEFLAG_NOOP(Unevictable) CLEARPAGEFLAG_NOOP(Unevictable)
-        __CLEARPAGEFLAG_NOOP(Unevictable)
 #endif
 
 #ifdef CONFIG_IA64_UNCACHED_ALLOCATOR
@@ -367,9 +384,13 @@ static inline void __ClearPageTail(struct page *page)
 
 #ifdef CONFIG_UNEVICTABLE_LRU
 #define __PG_UNEVICTABLE        (1 << PG_unevictable)
-#define __PG_MLOCKED            (1 << PG_mlocked)
 #else
 #define __PG_UNEVICTABLE        0
+#endif
+
+#ifdef CONFIG_HAVE_MLOCKED_PAGE_BIT
+#define __PG_MLOCKED            (1 << PG_mlocked)
+#else
 #define __PG_MLOCKED            0
 #endif
 
@@ -378,9 +399,10 @@ static inline void __ClearPageTail(struct page *page)
  * these flags set.  It they are, there is a problem.
  */
 #define PAGE_FLAGS_CHECK_AT_FREE \
-        (1 << PG_lru   | 1 << PG_private   | 1 << PG_locked | \
-         1 << PG_buddy | 1 << PG_writeback | 1 << PG_reserved | \
-         1 << PG_slab  | 1 << PG_swapcache | 1 << PG_active | \
+        (1 << PG_lru     | 1 << PG_locked    | \
+         1 << PG_private | 1 << PG_private_2 | \
+         1 << PG_buddy   | 1 << PG_writeback | 1 << PG_reserved | \
+         1 << PG_slab    | 1 << PG_swapcache | 1 << PG_active | \
          __PG_UNEVICTABLE | __PG_MLOCKED)
 
 /*
@@ -391,4 +413,16 @@ static inline void __ClearPageTail(struct page *page)
 #define PAGE_FLAGS_CHECK_AT_PREP        ((1 << NR_PAGEFLAGS) - 1)
 
 #endif /* !__GENERATING_BOUNDS_H */
+
+/**
+ * page_has_private - Determine if page has private stuff
+ * @page: The page to be checked
+ *
+ * Determine if a page has private stuff, indicating that release routines
+ * should be invoked upon it.
+ */
+#define page_has_private(page)                  \
+        ((page)->flags & ((1 << PG_private) |   \
+                          (1 << PG_private_2)))
+
 #endif  /* PAGE_FLAGS_H */
diff --git a/include/linux/page_cgroup.h b/include/linux/page_cgroup.h
index 602cc1fdee90..7339c7bf7331 100644
--- a/include/linux/page_cgroup.h
+++ b/include/linux/page_cgroup.h
@@ -91,24 +91,23 @@ static inline void page_cgroup_init(void)
 
 #ifdef CONFIG_CGROUP_MEM_RES_CTLR_SWAP
 #include <linux/swap.h>
-extern struct mem_cgroup *
-swap_cgroup_record(swp_entry_t ent, struct mem_cgroup *mem);
-extern struct mem_cgroup *lookup_swap_cgroup(swp_entry_t ent);
+extern unsigned short swap_cgroup_record(swp_entry_t ent, unsigned short id);
+extern unsigned short lookup_swap_cgroup(swp_entry_t ent);
 extern int swap_cgroup_swapon(int type, unsigned long max_pages);
 extern void swap_cgroup_swapoff(int type);
 #else
 #include <linux/swap.h>
 
 static inline
-struct mem_cgroup *swap_cgroup_record(swp_entry_t ent, struct mem_cgroup *mem)
+unsigned short swap_cgroup_record(swp_entry_t ent, unsigned short id)
 {
-        return NULL;
+        return 0;
 }
 
 static inline
-struct mem_cgroup *lookup_swap_cgroup(swp_entry_t ent)
+unsigned short lookup_swap_cgroup(swp_entry_t ent)
 {
-        return NULL;
+        return 0;
 }
 
 static inline int
diff --git a/include/linux/pagemap.h b/include/linux/pagemap.h
index 01ca0856caff..34da5230faab 100644
--- a/include/linux/pagemap.h
+++ b/include/linux/pagemap.h
@@ -18,9 +18,14 @@
  * Bits in mapping->flags.  The lower __GFP_BITS_SHIFT bits are the page
  * allocation mode flags.
  */
-#define AS_EIO          (__GFP_BITS_SHIFT + 0)  /* IO error on async write */
-#define AS_ENOSPC       (__GFP_BITS_SHIFT + 1)  /* ENOSPC on async write */
-#define AS_MM_ALL_LOCKS (__GFP_BITS_SHIFT + 2)  /* under mm_take_all_locks() */
+enum mapping_flags {
+        AS_EIO          = __GFP_BITS_SHIFT + 0, /* IO error on async write */
+        AS_ENOSPC       = __GFP_BITS_SHIFT + 1, /* ENOSPC on async write */
+        AS_MM_ALL_LOCKS = __GFP_BITS_SHIFT + 2, /* under mm_take_all_locks() */
+#ifdef CONFIG_UNEVICTABLE_LRU
+        AS_UNEVICTABLE  = __GFP_BITS_SHIFT + 3, /* e.g., ramdisk, SHM_LOCK */
+#endif
+};
 
 static inline void mapping_set_error(struct address_space *mapping, int error)
 {
@@ -33,7 +38,6 @@ static inline void mapping_set_error(struct address_space *mapping, int error)
 }
 
 #ifdef CONFIG_UNEVICTABLE_LRU
-#define AS_UNEVICTABLE  (__GFP_BITS_SHIFT + 2)  /* e.g., ramdisk, SHM_LOCK */
 
 static inline void mapping_set_unevictable(struct address_space *mapping)
 {
@@ -380,6 +384,11 @@ static inline void wait_on_page_writeback(struct page *page)
 extern void end_page_writeback(struct page *page);
 
 /*
+ * Add an arbitrary waiter to a page's wait queue
+ */
+extern void add_page_wait_queue(struct page *page, wait_queue_t *waiter);
+
+/*
  * Fault a userspace page into pagetables.  Return non-zero on a fault.
  *
  * This assumes that two userspace pages are always sufficient.  That's
diff --git a/include/linux/pagevec.h b/include/linux/pagevec.h
index 7b2886fa7fdc..bab82f4c571c 100644
--- a/include/linux/pagevec.h
+++ b/include/linux/pagevec.h
@@ -24,7 +24,6 @@ void __pagevec_release(struct pagevec *pvec);
 void __pagevec_free(struct pagevec *pvec);
 void ____pagevec_lru_add(struct pagevec *pvec, enum lru_list lru);
 void pagevec_strip(struct pagevec *pvec);
-void pagevec_swap_free(struct pagevec *pvec);
 unsigned pagevec_lookup(struct pagevec *pvec, struct address_space *mapping,
                 pgoff_t start, unsigned nr_pages);
 unsigned pagevec_lookup_tag(struct pagevec *pvec,
diff --git a/include/linux/parport_pc.h b/include/linux/parport_pc.h
index ea8c6d84996d..cc1767f5cca8 100644
--- a/include/linux/parport_pc.h
+++ b/include/linux/parport_pc.h
@@ -228,10 +228,11 @@ extern void parport_pc_release_resources(struct parport *p);
 extern int parport_pc_claim_resources(struct parport *p);
 
 /* PCMCIA code will want to get us to look at a port.  Provide a mechanism. */
-extern struct parport *parport_pc_probe_port (unsigned long base,
-                                              unsigned long base_hi,
-                                              int irq, int dma,
-                                              struct device *dev);
-extern void parport_pc_unregister_port (struct parport *p);
+extern struct parport *parport_pc_probe_port(unsigned long base,
+                                             unsigned long base_hi,
+                                             int irq, int dma,
+                                             struct device *dev,
+                                             int irqflags);
+extern void parport_pc_unregister_port(struct parport *p);
 
 #endif
diff --git a/include/linux/pci-acpi.h b/include/linux/pci-acpi.h
index 042c166f65d5..092e82e0048c 100644
--- a/include/linux/pci-acpi.h
+++ b/include/linux/pci-acpi.h
@@ -10,72 +10,25 @@
 
 #include <linux/acpi.h>
 
-#define OSC_QUERY_TYPE                  0
-#define OSC_SUPPORT_TYPE                1
-#define OSC_CONTROL_TYPE                2
-#define OSC_SUPPORT_MASKS               0x1f
-
-/*
- * _OSC DW0 Definition 
- */
-#define OSC_QUERY_ENABLE                1
-#define OSC_REQUEST_ERROR               2
-#define OSC_INVALID_UUID_ERROR          4
-#define OSC_INVALID_REVISION_ERROR      8
-#define OSC_CAPABILITIES_MASK_ERROR     16
-
-/*
- * _OSC DW1 Definition (OS Support Fields)
- */
-#define OSC_EXT_PCI_CONFIG_SUPPORT              1
-#define OSC_ACTIVE_STATE_PWR_SUPPORT            2
-#define OSC_CLOCK_PWR_CAPABILITY_SUPPORT        4
-#define OSC_PCI_SEGMENT_GROUPS_SUPPORT          8
-#define OSC_MSI_SUPPORT                         16
-
-/*
- * _OSC DW1 Definition (OS Control Fields)
- */
-#define OSC_PCI_EXPRESS_NATIVE_HP_CONTROL       1
-#define OSC_SHPC_NATIVE_HP_CONTROL              2
-#define OSC_PCI_EXPRESS_PME_CONTROL             4
-#define OSC_PCI_EXPRESS_AER_CONTROL             8
-#define OSC_PCI_EXPRESS_CAP_STRUCTURE_CONTROL   16
-
-#define OSC_CONTROL_MASKS       (OSC_PCI_EXPRESS_NATIVE_HP_CONTROL |    \
-                                OSC_SHPC_NATIVE_HP_CONTROL |            \
-                                OSC_PCI_EXPRESS_PME_CONTROL |           \
-                                OSC_PCI_EXPRESS_AER_CONTROL |           \
-                                OSC_PCI_EXPRESS_CAP_STRUCTURE_CONTROL)
-
 #ifdef CONFIG_ACPI
-extern acpi_status pci_osc_control_set(acpi_handle handle, u32 flags);
-int pci_acpi_osc_support(acpi_handle handle, u32 flags);
 static inline acpi_handle acpi_find_root_bridge_handle(struct pci_dev *pdev)
 {
-        /* Find root host bridge */
-        while (pdev->bus->self)
-                pdev = pdev->bus->self;
-
-        return acpi_get_pci_rootbridge_handle(pci_domain_nr(pdev->bus),
-                        pdev->bus->number);
+        struct pci_bus *pbus = pdev->bus;
+        /* Find a PCI root bus */
+        while (pbus->parent)
+                pbus = pbus->parent;
+        return acpi_get_pci_rootbridge_handle(pci_domain_nr(pbus),
+                                              pbus->number);
 }
 
 static inline acpi_handle acpi_pci_get_bridge_handle(struct pci_bus *pbus)
 {
-        int seg = pci_domain_nr(pbus), busnr = pbus->number;
-        struct pci_dev *bridge = pbus->self;
-        if (bridge)
-                return DEVICE_ACPI_HANDLE(&(bridge->dev));
-        return acpi_get_pci_rootbridge_handle(seg, busnr);
+        if (pbus->parent)
+                return DEVICE_ACPI_HANDLE(&(pbus->self->dev));
+        return acpi_get_pci_rootbridge_handle(pci_domain_nr(pbus),
+                                              pbus->number);
 }
 #else
-#if !defined(AE_ERROR)
-typedef u32             acpi_status;
-#define AE_ERROR        (acpi_status) (0x0001)
-#endif    
-static inline acpi_status pci_osc_control_set(acpi_handle handle, u32 flags)
-{return AE_ERROR;}
 static inline acpi_handle acpi_find_root_bridge_handle(struct pci_dev *pdev)
 { return NULL; }
 #endif
diff --git a/include/linux/pci.h b/include/linux/pci.h
index 7bd624bfdcfd..72698d89e767 100644
--- a/include/linux/pci.h
+++ b/include/linux/pci.h
@@ -52,6 +52,7 @@
 #include <asm/atomic.h>
 #include <linux/device.h>
 #include <linux/io.h>
+#include <linux/irqreturn.h>
 
 /* Include the ID list */
 #include <linux/pci_ids.h>
@@ -93,6 +94,12 @@ enum {
         /* #6: expansion ROM resource */
         PCI_ROM_RESOURCE,
 
+        /* device specific resources */
+#ifdef CONFIG_PCI_IOV
+        PCI_IOV_RESOURCES,
+        PCI_IOV_RESOURCE_END = PCI_IOV_RESOURCES + PCI_SRIOV_NUM_BARS - 1,
+#endif
+
         /* resources assigned to buses behind the bridge */
 #define PCI_BRIDGE_RESOURCE_NUM 4
 
@@ -180,6 +187,7 @@ struct pci_cap_saved_state {
 
 struct pcie_link_state;
 struct pci_vpd;
+struct pci_sriov;
 
 /*
  * The pci_dev structure is used to describe PCI devices.
@@ -257,6 +265,8 @@ struct pci_dev {
         unsigned int    is_managed:1;
         unsigned int    is_pcie:1;
         unsigned int    state_saved:1;
+        unsigned int    is_physfn:1;
+        unsigned int    is_virtfn:1;
         pci_dev_flags_t dev_flags;
         atomic_t        enable_cnt;     /* pci_enable_device has been called */
 
@@ -270,6 +280,12 @@ struct pci_dev {
         struct list_head msi_list;
 #endif
         struct pci_vpd *vpd;
+#ifdef CONFIG_PCI_IOV
+        union {
+                struct pci_sriov *sriov;        /* SR-IOV capability related */
+                struct pci_dev *physfn; /* the PF this VF is associated with */
+        };
+#endif
 };
 
 extern struct pci_dev *alloc_pci_dev(void);
@@ -341,6 +357,15 @@ struct pci_bus {
 #define pci_bus_b(n)    list_entry(n, struct pci_bus, node)
 #define to_pci_bus(n)   container_of(n, struct pci_bus, dev)
 
+/*
+ * Returns true if the pci bus is root (behind host-pci bridge),
+ * false otherwise
+ */
+static inline bool pci_is_root_bus(struct pci_bus *pbus)
+{
+        return !(pbus->parent);
+}
+
 #ifdef CONFIG_PCI_MSI
 static inline bool pci_dev_msi_enabled(struct pci_dev *pci_dev)
 {
@@ -528,7 +553,7 @@ void pcibios_update_irq(struct pci_dev *, int irq);
 /* Generic PCI functions used internally */
 
 extern struct pci_bus *pci_find_bus(int domain, int busnr);
-void pci_bus_add_devices(struct pci_bus *bus);
+void pci_bus_add_devices(const struct pci_bus *bus);
 struct pci_bus *pci_scan_bus_parented(struct device *parent, int bus,
                                       struct pci_ops *ops, void *sysdata);
 static inline struct pci_bus * __devinit pci_scan_bus(int bus, struct pci_ops *ops,
@@ -649,6 +674,11 @@ int __must_check pci_reenable_device(struct pci_dev *);
 int __must_check pcim_enable_device(struct pci_dev *pdev);
 void pcim_pin_device(struct pci_dev *pdev);
 
+static inline int pci_is_enabled(struct pci_dev *pdev)
+{
+        return (atomic_read(&pdev->enable_cnt) > 0);
+}
+
 static inline int pci_is_managed(struct pci_dev *pdev)
 {
         return pdev->is_managed;
@@ -689,6 +719,7 @@ size_t pci_get_rom_size(struct pci_dev *pdev, void __iomem *rom, size_t size);
 /* Power management related routines */
 int pci_save_state(struct pci_dev *dev);
 int pci_restore_state(struct pci_dev *dev);
+int __pci_complete_power_transition(struct pci_dev *dev, pci_power_t state);
 int pci_set_power_state(struct pci_dev *dev, pci_power_t state);
 pci_power_t pci_choose_state(struct pci_dev *dev, pm_message_t state);
 bool pci_pme_capable(struct pci_dev *dev, pci_power_t state);
@@ -701,6 +732,9 @@ int pci_back_from_sleep(struct pci_dev *dev);
 
 /* Functions for PCI Hotplug drivers to use */
 int pci_bus_find_capability(struct pci_bus *bus, unsigned int devfn, int cap);
+#ifdef CONFIG_HOTPLUG
+unsigned int pci_rescan_bus(struct pci_bus *bus);
+#endif
 
 /* Vital product data routines */
 ssize_t pci_read_vpd(struct pci_dev *dev, loff_t pos, size_t count, void *buf);
@@ -708,7 +742,7 @@ ssize_t pci_write_vpd(struct pci_dev *dev, loff_t pos, size_t count, const void
 int pci_vpd_truncate(struct pci_dev *dev, size_t size);
 
 /* Helper functions for low-level code (drivers/pci/setup-[bus,res].c) */
-void pci_bus_assign_resources(struct pci_bus *bus);
+void pci_bus_assign_resources(const struct pci_bus *bus);
 void pci_bus_size_bridges(struct pci_bus *bus);
 int pci_claim_resource(struct pci_dev *, int);
 void pci_assign_unassigned_resources(void);
@@ -789,7 +823,7 @@ struct msix_entry {
 
 
 #ifndef CONFIG_PCI_MSI
-static inline int pci_enable_msi(struct pci_dev *dev)
+static inline int pci_enable_msi_block(struct pci_dev *dev, unsigned int nvec)
 {
         return -1;
 }
@@ -799,6 +833,10 @@ static inline void pci_msi_shutdown(struct pci_dev *dev)
 static inline void pci_disable_msi(struct pci_dev *dev)
 { }
 
+static inline int pci_msix_table_size(struct pci_dev *dev)
+{
+        return 0;
+}
 static inline int pci_enable_msix(struct pci_dev *dev,
                                   struct msix_entry *entries, int nvec)
 {
@@ -820,9 +858,10 @@ static inline int pci_msi_enabled(void)
         return 0;
 }
 #else
-extern int pci_enable_msi(struct pci_dev *dev);
+extern int pci_enable_msi_block(struct pci_dev *dev, unsigned int nvec);
 extern void pci_msi_shutdown(struct pci_dev *dev);
 extern void pci_disable_msi(struct pci_dev *dev);
+extern int pci_msix_table_size(struct pci_dev *dev);
 extern int pci_enable_msix(struct pci_dev *dev,
         struct msix_entry *entries, int nvec);
 extern void pci_msix_shutdown(struct pci_dev *dev);
@@ -841,6 +880,8 @@ static inline int pcie_aspm_enabled(void)
 extern int pcie_aspm_enabled(void);
 #endif
 
+#define pci_enable_msi(pdev)    pci_enable_msi_block(pdev, 1)
+
 #ifdef CONFIG_HT_IRQ
 /* The functions a driver should call */
 int  ht_create_irq(struct pci_dev *dev, int idx);
@@ -1194,5 +1235,23 @@ int pci_ext_cfg_avail(struct pci_dev *dev);
 
 void __iomem *pci_ioremap_bar(struct pci_dev *pdev, int bar);
 
+#ifdef CONFIG_PCI_IOV
+extern int pci_enable_sriov(struct pci_dev *dev, int nr_virtfn);
+extern void pci_disable_sriov(struct pci_dev *dev);
+extern irqreturn_t pci_sriov_migration(struct pci_dev *dev);
+#else
+static inline int pci_enable_sriov(struct pci_dev *dev, int nr_virtfn)
+{
+        return -ENODEV;
+}
+static inline void pci_disable_sriov(struct pci_dev *dev)
+{
+}
+static inline irqreturn_t pci_sriov_migration(struct pci_dev *dev)
+{
+        return IRQ_NONE;
+}
+#endif
+
 #endif /* __KERNEL__ */
 #endif /* LINUX_PCI_H */
diff --git a/include/linux/pci_ids.h b/include/linux/pci_ids.h
index 2c9e8080da5e..06ba90c211a5 100644
--- a/include/linux/pci_ids.h
+++ b/include/linux/pci_ids.h
@@ -526,6 +526,7 @@
 #define PCI_DEVICE_ID_AMD_OPUS_7443     0x7443
 #define PCI_DEVICE_ID_AMD_VIPER_7443    0x7443
 #define PCI_DEVICE_ID_AMD_OPUS_7445     0x7445
+#define PCI_DEVICE_ID_AMD_8111_PCI      0x7460
 #define PCI_DEVICE_ID_AMD_8111_LPC      0x7468
 #define PCI_DEVICE_ID_AMD_8111_IDE      0x7469
 #define PCI_DEVICE_ID_AMD_8111_SMBUS2   0x746a
@@ -943,6 +944,32 @@
 #define PCI_DEVICE_ID_SUN_TOMATILLO     0xa801
 #define PCI_DEVICE_ID_SUN_CASSINI       0xabba
 
+#define PCI_VENDOR_ID_NI                0x1093
+#define PCI_DEVICE_ID_NI_PCI2322        0xd130
+#define PCI_DEVICE_ID_NI_PCI2324        0xd140
+#define PCI_DEVICE_ID_NI_PCI2328        0xd150
+#define PCI_DEVICE_ID_NI_PXI8422_2322   0xd190
+#define PCI_DEVICE_ID_NI_PXI8422_2324   0xd1a0
+#define PCI_DEVICE_ID_NI_PXI8420_2322   0xd1d0
+#define PCI_DEVICE_ID_NI_PXI8420_2324   0xd1e0
+#define PCI_DEVICE_ID_NI_PXI8420_2328   0xd1f0
+#define PCI_DEVICE_ID_NI_PXI8420_23216  0xd1f1
+#define PCI_DEVICE_ID_NI_PCI2322I       0xd250
+#define PCI_DEVICE_ID_NI_PCI2324I       0xd270
+#define PCI_DEVICE_ID_NI_PCI23216       0xd2b0
+#define PCI_DEVICE_ID_NI_PXI8430_2322   0x7080
+#define PCI_DEVICE_ID_NI_PCI8430_2322   0x70db
+#define PCI_DEVICE_ID_NI_PXI8430_2324   0x70dd
+#define PCI_DEVICE_ID_NI_PCI8430_2324   0x70df
+#define PCI_DEVICE_ID_NI_PXI8430_2328   0x70e2
+#define PCI_DEVICE_ID_NI_PCI8430_2328   0x70e4
+#define PCI_DEVICE_ID_NI_PXI8430_23216  0x70e6
+#define PCI_DEVICE_ID_NI_PCI8430_23216  0x70e7
+#define PCI_DEVICE_ID_NI_PXI8432_2322   0x70e8
+#define PCI_DEVICE_ID_NI_PCI8432_2322   0x70ea
+#define PCI_DEVICE_ID_NI_PXI8432_2324   0x70ec
+#define PCI_DEVICE_ID_NI_PCI8432_2324   0x70ee
+
 #define PCI_VENDOR_ID_CMD               0x1095
 #define PCI_DEVICE_ID_CMD_643           0x0643
 #define PCI_DEVICE_ID_CMD_646           0x0646
@@ -2232,6 +2259,14 @@
 #define PCI_DEVICE_ID_TDI_EHCI          0x0101
 
 #define PCI_VENDOR_ID_FREESCALE         0x1957
+#define PCI_DEVICE_ID_MPC8315E          0x00b4
+#define PCI_DEVICE_ID_MPC8315           0x00b5
+#define PCI_DEVICE_ID_MPC8314E          0x00b6
+#define PCI_DEVICE_ID_MPC8314           0x00b7
+#define PCI_DEVICE_ID_MPC8378E          0x00c4
+#define PCI_DEVICE_ID_MPC8378           0x00c5
+#define PCI_DEVICE_ID_MPC8377E          0x00c6
+#define PCI_DEVICE_ID_MPC8377           0x00c7
 #define PCI_DEVICE_ID_MPC8548E          0x0012
 #define PCI_DEVICE_ID_MPC8548           0x0013
 #define PCI_DEVICE_ID_MPC8543E          0x0014
@@ -2388,6 +2423,7 @@
 #define PCI_DEVICE_ID_INTEL_82801CA_12  0x248c
 #define PCI_DEVICE_ID_INTEL_82801DB_0   0x24c0
 #define PCI_DEVICE_ID_INTEL_82801DB_1   0x24c1
+#define PCI_DEVICE_ID_INTEL_82801DB_2   0x24c2
 #define PCI_DEVICE_ID_INTEL_82801DB_3   0x24c3
 #define PCI_DEVICE_ID_INTEL_82801DB_5   0x24c5
 #define PCI_DEVICE_ID_INTEL_82801DB_6   0x24c6
@@ -2478,6 +2514,8 @@
 #define PCI_DEVICE_ID_INTEL_IOAT_TBG3   0x3433
 #define PCI_DEVICE_ID_INTEL_82830_HB    0x3575
 #define PCI_DEVICE_ID_INTEL_82830_CGC   0x3577
+#define PCI_DEVICE_ID_INTEL_82854_HB    0x358c
+#define PCI_DEVICE_ID_INTEL_82854_IG    0x358e
 #define PCI_DEVICE_ID_INTEL_82855GM_HB  0x3580
 #define PCI_DEVICE_ID_INTEL_82855GM_IG  0x3582
 #define PCI_DEVICE_ID_INTEL_E7520_MCH   0x3590
diff --git a/include/linux/pci_regs.h b/include/linux/pci_regs.h
index 027815b4635e..616bf8b3c8b5 100644
--- a/include/linux/pci_regs.h
+++ b/include/linux/pci_regs.h
@@ -235,7 +235,7 @@
 #define  PCI_PM_CAP_PME_SHIFT   11      /* Start of the PME Mask in PMC */
 #define PCI_PM_CTRL             4       /* PM control and status register */
 #define  PCI_PM_CTRL_STATE_MASK 0x0003  /* Current power state (D0 to D3) */
-#define  PCI_PM_CTRL_NO_SOFT_RESET      0x0004  /* No reset for D3hot->D0 */
+#define  PCI_PM_CTRL_NO_SOFT_RESET      0x0008  /* No reset for D3hot->D0 */
 #define  PCI_PM_CTRL_PME_ENABLE 0x0100  /* PME pin enable */
 #define  PCI_PM_CTRL_DATA_SEL_MASK      0x1e00  /* Data select (??) */
 #define  PCI_PM_CTRL_DATA_SCALE_MASK    0x6000  /* Data scale (??) */
@@ -375,6 +375,8 @@
 #define  PCI_EXP_TYPE_UPSTREAM  0x5     /* Upstream Port */
 #define  PCI_EXP_TYPE_DOWNSTREAM 0x6    /* Downstream Port */
 #define  PCI_EXP_TYPE_PCI_BRIDGE 0x7    /* PCI/PCI-X Bridge */
+#define  PCI_EXP_TYPE_RC_END    0x9     /* Root Complex Integrated Endpoint */
+#define  PCI_EXP_TYPE_RC_EC     0x10    /* Root Complex Event Collector */
 #define PCI_EXP_FLAGS_SLOT      0x0100  /* Slot implemented */
 #define PCI_EXP_FLAGS_IRQ       0x3e00  /* Interrupt message number */
 #define PCI_EXP_DEVCAP          4       /* Device capabilities */
@@ -487,6 +489,8 @@
 #define  PCI_EXP_DEVCAP2_ARI    0x20    /* Alternative Routing-ID */
 #define PCI_EXP_DEVCTL2         40      /* Device Control 2 */
 #define  PCI_EXP_DEVCTL2_ARI    0x20    /* Alternative Routing-ID */
+#define PCI_EXP_LNKCTL2         48      /* Link Control 2 */
+#define PCI_EXP_SLTCTL2         56      /* Slot Control 2 */
 
 /* Extended Capabilities (PCI-X 2.0 and Express) */
 #define PCI_EXT_CAP_ID(header)          (header & 0x0000ffff)
@@ -498,6 +502,7 @@
 #define PCI_EXT_CAP_ID_DSN      3
 #define PCI_EXT_CAP_ID_PWR      4
 #define PCI_EXT_CAP_ID_ARI      14
+#define PCI_EXT_CAP_ID_SRIOV    16
 
 /* Advanced Error Reporting */
 #define PCI_ERR_UNCOR_STATUS    4       /* Uncorrectable Error Status */
@@ -615,4 +620,35 @@
 #define  PCI_ARI_CTRL_ACS       0x0002  /* ACS Function Groups Enable */
 #define  PCI_ARI_CTRL_FG(x)     (((x) >> 4) & 7) /* Function Group */
 
+/* Single Root I/O Virtualization */
+#define PCI_SRIOV_CAP           0x04    /* SR-IOV Capabilities */
+#define  PCI_SRIOV_CAP_VFM      0x01    /* VF Migration Capable */
+#define  PCI_SRIOV_CAP_INTR(x)  ((x) >> 21) /* Interrupt Message Number */
+#define PCI_SRIOV_CTRL          0x08    /* SR-IOV Control */
+#define  PCI_SRIOV_CTRL_VFE     0x01    /* VF Enable */
+#define  PCI_SRIOV_CTRL_VFM     0x02    /* VF Migration Enable */
+#define  PCI_SRIOV_CTRL_INTR    0x04    /* VF Migration Interrupt Enable */
+#define  PCI_SRIOV_CTRL_MSE     0x08    /* VF Memory Space Enable */
+#define  PCI_SRIOV_CTRL_ARI     0x10    /* ARI Capable Hierarchy */
+#define PCI_SRIOV_STATUS        0x0a    /* SR-IOV Status */
+#define  PCI_SRIOV_STATUS_VFM   0x01    /* VF Migration Status */
+#define PCI_SRIOV_INITIAL_VF    0x0c    /* Initial VFs */
+#define PCI_SRIOV_TOTAL_VF      0x0e    /* Total VFs */
+#define PCI_SRIOV_NUM_VF        0x10    /* Number of VFs */
+#define PCI_SRIOV_FUNC_LINK     0x12    /* Function Dependency Link */
+#define PCI_SRIOV_VF_OFFSET     0x14    /* First VF Offset */
+#define PCI_SRIOV_VF_STRIDE     0x16    /* Following VF Stride */
+#define PCI_SRIOV_VF_DID        0x1a    /* VF Device ID */
+#define PCI_SRIOV_SUP_PGSIZE    0x1c    /* Supported Page Sizes */
+#define PCI_SRIOV_SYS_PGSIZE    0x20    /* System Page Size */
+#define PCI_SRIOV_BAR           0x24    /* VF BAR0 */
+#define  PCI_SRIOV_NUM_BARS     6       /* Number of VF BARs */
+#define PCI_SRIOV_VFM           0x3c    /* VF Migration State Array Offset*/
+#define  PCI_SRIOV_VFM_BIR(x)   ((x) & 7)       /* State BIR */
+#define  PCI_SRIOV_VFM_OFFSET(x) ((x) & ~7)     /* State Offset */
+#define  PCI_SRIOV_VFM_UA       0x0     /* Inactive.Unavailable */
+#define  PCI_SRIOV_VFM_MI       0x1     /* Dormant.MigrateIn */
+#define  PCI_SRIOV_VFM_MO       0x2     /* Active.MigrateOut */
+#define  PCI_SRIOV_VFM_AV       0x3     /* Active.Available */
+
 #endif /* LINUX_PCI_REGS_H */
diff --git a/include/linux/pcieport_if.h b/include/linux/pcieport_if.h
index 6cd91e3f9820..b4c79545330b 100644
--- a/include/linux/pcieport_if.h
+++ b/include/linux/pcieport_if.h
@@ -16,29 +16,30 @@
 #define PCIE_ANY_PORT                   7
 
 /* Service Type */
-#define PCIE_PORT_SERVICE_PME           1       /* Power Management Event */
-#define PCIE_PORT_SERVICE_AER           2       /* Advanced Error Reporting */
-#define PCIE_PORT_SERVICE_HP            4       /* Native Hotplug */
-#define PCIE_PORT_SERVICE_VC            8       /* Virtual Channel */
+#define PCIE_PORT_SERVICE_PME_SHIFT     0       /* Power Management Event */
+#define PCIE_PORT_SERVICE_PME           (1 << PCIE_PORT_SERVICE_PME_SHIFT)
+#define PCIE_PORT_SERVICE_AER_SHIFT     1       /* Advanced Error Reporting */
+#define PCIE_PORT_SERVICE_AER           (1 << PCIE_PORT_SERVICE_AER_SHIFT)
+#define PCIE_PORT_SERVICE_HP_SHIFT      2       /* Native Hotplug */
+#define PCIE_PORT_SERVICE_HP            (1 << PCIE_PORT_SERVICE_HP_SHIFT)
+#define PCIE_PORT_SERVICE_VC_SHIFT      3       /* Virtual Channel */
+#define PCIE_PORT_SERVICE_VC            (1 << PCIE_PORT_SERVICE_VC_SHIFT)
 
 /* Root/Upstream/Downstream Port's Interrupt Mode */
+#define PCIE_PORT_NO_IRQ                (-1)
 #define PCIE_PORT_INTx_MODE             0
 #define PCIE_PORT_MSI_MODE              1
 #define PCIE_PORT_MSIX_MODE             2
 
-struct pcie_port_service_id {
-        __u32 vendor, device;           /* Vendor and device ID or PCI_ANY_ID*/
-        __u32 subvendor, subdevice;     /* Subsystem ID's or PCI_ANY_ID */
-        __u32 class, class_mask;        /* (class,subclass,prog-if) triplet */
-        __u32 port_type, service_type;  /* Port Entity */
-        kernel_ulong_t driver_data;
+struct pcie_port_data {
+        int port_type;          /* Type of the port */
+        int port_irq_mode;      /* [0:INTx | 1:MSI | 2:MSI-X] */
 };
 
 struct pcie_device {
         int             irq;        /* Service IRQ/MSI/MSI-X Vector */
-        int             interrupt_mode; /* [0:INTx | 1:MSI | 2:MSI-X] */        
-        struct pcie_port_service_id id; /* Service ID */
-        struct pci_dev  *port;      /* Root/Upstream/Downstream Port */
+        struct pci_dev *port;       /* Root/Upstream/Downstream Port */
+        u32             service;    /* Port service this device represents */
         void            *priv_data; /* Service Private Data */
         struct device   device;     /* Generic Device Interface */
 };
@@ -56,10 +57,9 @@ static inline void* get_service_data(struct pcie_device *dev)
 
 struct pcie_port_service_driver {
         const char *name;
-        int (*probe) (struct pcie_device *dev, 
-                const struct pcie_port_service_id *id);
+        int (*probe) (struct pcie_device *dev);
         void (*remove) (struct pcie_device *dev);
-        int (*suspend) (struct pcie_device *dev, pm_message_t state);
+        int (*suspend) (struct pcie_device *dev);
         int (*resume) (struct pcie_device *dev);
 
         /* Service Error Recovery Handler */
@@ -68,7 +68,9 @@ struct pcie_port_service_driver {
         /* Link Reset Capability - AER service driver specific */
         pci_ers_result_t (*reset_link) (struct pci_dev *dev);
 
-        const struct pcie_port_service_id *id_table;
+        int port_type;  /* Type of the port this driver can handle */
+        u32 service;    /* Port service this device represents */
+
         struct device_driver driver;
 };
 #define to_service_driver(d) \
diff --git a/include/linux/pda_power.h b/include/linux/pda_power.h
index cb7d10f30763..d4cf7a2ceb3e 100644
--- a/include/linux/pda_power.h
+++ b/include/linux/pda_power.h
@@ -31,6 +31,8 @@ struct pda_power_pdata {
         unsigned int wait_for_status; /* msecs, default is 500 */
         unsigned int wait_for_charger; /* msecs, default is 500 */
         unsigned int polling_interval; /* msecs, default is 2000 */
+
+        unsigned long ac_max_uA; /* current to draw when on AC */
 };
 
 #endif /* __PDA_POWER_H__ */
diff --git a/include/linux/percpu-defs.h b/include/linux/percpu-defs.h
new file mode 100644
index 000000000000..8f921d74f49f
--- /dev/null
+++ b/include/linux/percpu-defs.h
@@ -0,0 +1,84 @@
+#ifndef _LINUX_PERCPU_DEFS_H
+#define _LINUX_PERCPU_DEFS_H
+
+/*
+ * Determine the real variable name from the name visible in the
+ * kernel sources.
+ */
+#define per_cpu_var(var) per_cpu__##var
+
+/*
+ * Base implementations of per-CPU variable declarations and definitions, where
+ * the section in which the variable is to be placed is provided by the
+ * 'section' argument.  This may be used to affect the parameters governing the
+ * variable's storage.
+ *
+ * NOTE!  The sections for the DECLARE and for the DEFINE must match, lest
+ * linkage errors occur due the compiler generating the wrong code to access
+ * that section.
+ */
+#define DECLARE_PER_CPU_SECTION(type, name, section)                    \
+        extern                                                          \
+        __attribute__((__section__(PER_CPU_BASE_SECTION section)))      \
+        PER_CPU_ATTRIBUTES __typeof__(type) per_cpu__##name
+
+#define DEFINE_PER_CPU_SECTION(type, name, section)                     \
+        __attribute__((__section__(PER_CPU_BASE_SECTION section)))      \
+        PER_CPU_ATTRIBUTES __typeof__(type) per_cpu__##name
+
+/*
+ * Variant on the per-CPU variable declaration/definition theme used for
+ * ordinary per-CPU variables.
+ */
+#define DECLARE_PER_CPU(type, name)                                     \
+        DECLARE_PER_CPU_SECTION(type, name, "")
+
+#define DEFINE_PER_CPU(type, name)                                      \
+        DEFINE_PER_CPU_SECTION(type, name, "")
+
+/*
+ * Declaration/definition used for per-CPU variables that must come first in
+ * the set of variables.
+ */
+#define DECLARE_PER_CPU_FIRST(type, name)                               \
+        DECLARE_PER_CPU_SECTION(type, name, PER_CPU_FIRST_SECTION)
+
+#define DEFINE_PER_CPU_FIRST(type, name)                                \
+        DEFINE_PER_CPU_SECTION(type, name, PER_CPU_FIRST_SECTION)
+
+/*
+ * Declaration/definition used for per-CPU variables that must be cacheline
+ * aligned under SMP conditions so that, whilst a particular instance of the
+ * data corresponds to a particular CPU, inefficiencies due to direct access by
+ * other CPUs are reduced by preventing the data from unnecessarily spanning
+ * cachelines.
+ *
+ * An example of this would be statistical data, where each CPU's set of data
+ * is updated by that CPU alone, but the data from across all CPUs is collated
+ * by a CPU processing a read from a proc file.
+ */
+#define DECLARE_PER_CPU_SHARED_ALIGNED(type, name)                      \
+        DECLARE_PER_CPU_SECTION(type, name, PER_CPU_SHARED_ALIGNED_SECTION) \
+        ____cacheline_aligned_in_smp
+
+#define DEFINE_PER_CPU_SHARED_ALIGNED(type, name)                       \
+        DEFINE_PER_CPU_SECTION(type, name, PER_CPU_SHARED_ALIGNED_SECTION) \
+        ____cacheline_aligned_in_smp
+
+/*
+ * Declaration/definition used for per-CPU variables that must be page aligned.
+ */
+#define DECLARE_PER_CPU_PAGE_ALIGNED(type, name)                                \
+        DECLARE_PER_CPU_SECTION(type, name, ".page_aligned")
+
+#define DEFINE_PER_CPU_PAGE_ALIGNED(type, name)                         \
+        DEFINE_PER_CPU_SECTION(type, name, ".page_aligned")
+
+/*
+ * Intermodule exports for per-CPU variables.
+ */
+#define EXPORT_PER_CPU_SYMBOL(var) EXPORT_SYMBOL(per_cpu__##var)
+#define EXPORT_PER_CPU_SYMBOL_GPL(var) EXPORT_SYMBOL_GPL(per_cpu__##var)
+
+
+#endif /* _LINUX_PERCPU_DEFS_H */
diff --git a/include/linux/percpu.h b/include/linux/percpu.h
index ee5615d65211..1581ff235c7e 100644
--- a/include/linux/percpu.h
+++ b/include/linux/percpu.h
@@ -9,50 +9,6 @@
 
 #include <asm/percpu.h>
 
-#ifndef PER_CPU_BASE_SECTION
-#ifdef CONFIG_SMP
-#define PER_CPU_BASE_SECTION ".data.percpu"
-#else
-#define PER_CPU_BASE_SECTION ".data"
-#endif
-#endif
-
-#ifdef CONFIG_SMP
-
-#ifdef MODULE
-#define PER_CPU_SHARED_ALIGNED_SECTION ""
-#else
-#define PER_CPU_SHARED_ALIGNED_SECTION ".shared_aligned"
-#endif
-#define PER_CPU_FIRST_SECTION ".first"
-
-#else
-
-#define PER_CPU_SHARED_ALIGNED_SECTION ""
-#define PER_CPU_FIRST_SECTION ""
-
-#endif
-
-#define DEFINE_PER_CPU_SECTION(type, name, section)                     \
-        __attribute__((__section__(PER_CPU_BASE_SECTION section)))      \
-        PER_CPU_ATTRIBUTES __typeof__(type) per_cpu__##name
-
-#define DEFINE_PER_CPU(type, name)                                      \
-        DEFINE_PER_CPU_SECTION(type, name, "")
-
-#define DEFINE_PER_CPU_SHARED_ALIGNED(type, name)                       \
-        DEFINE_PER_CPU_SECTION(type, name, PER_CPU_SHARED_ALIGNED_SECTION) \
-        ____cacheline_aligned_in_smp
-
-#define DEFINE_PER_CPU_PAGE_ALIGNED(type, name)                         \
-        DEFINE_PER_CPU_SECTION(type, name, ".page_aligned")
-
-#define DEFINE_PER_CPU_FIRST(type, name)                                \
-        DEFINE_PER_CPU_SECTION(type, name, PER_CPU_FIRST_SECTION)
-
-#define EXPORT_PER_CPU_SYMBOL(var) EXPORT_SYMBOL(per_cpu__##var)
-#define EXPORT_PER_CPU_SYMBOL_GPL(var) EXPORT_SYMBOL_GPL(per_cpu__##var)
-
 /* enough to cover all DEFINE_PER_CPUs in modules */
 #ifdef CONFIG_MODULES
 #define PERCPU_MODULE_RESERVE           (8 << 10)
@@ -168,4 +124,56 @@ static inline void free_percpu(void *p)
 #define alloc_percpu(type)      (type *)__alloc_percpu(sizeof(type), \
                                                        __alignof__(type))
 
+/*
+ * Optional methods for optimized non-lvalue per-cpu variable access.
+ *
+ * @var can be a percpu variable or a field of it and its size should
+ * equal char, int or long.  percpu_read() evaluates to a lvalue and
+ * all others to void.
+ *
+ * These operations are guaranteed to be atomic w.r.t. preemption.
+ * The generic versions use plain get/put_cpu_var().  Archs are
+ * encouraged to implement single-instruction alternatives which don't
+ * require preemption protection.
+ */
+#ifndef percpu_read
+# define percpu_read(var)                                               \
+  ({                                                                    \
+        typeof(per_cpu_var(var)) __tmp_var__;                           \
+        __tmp_var__ = get_cpu_var(var);                                 \
+        put_cpu_var(var);                                               \
+        __tmp_var__;                                                    \
+  })
+#endif
+
+#define __percpu_generic_to_op(var, val, op)                            \
+do {                                                                    \
+        get_cpu_var(var) op val;                                        \
+        put_cpu_var(var);                                               \
+} while (0)
+
+#ifndef percpu_write
+# define percpu_write(var, val)         __percpu_generic_to_op(var, (val), =)
+#endif
+
+#ifndef percpu_add
+# define percpu_add(var, val)           __percpu_generic_to_op(var, (val), +=)
+#endif
+
+#ifndef percpu_sub
+# define percpu_sub(var, val)           __percpu_generic_to_op(var, (val), -=)
+#endif
+
+#ifndef percpu_and
+# define percpu_and(var, val)           __percpu_generic_to_op(var, (val), &=)
+#endif
+
+#ifndef percpu_or
+# define percpu_or(var, val)            __percpu_generic_to_op(var, (val), |=)
+#endif
+
+#ifndef percpu_xor
+# define percpu_xor(var, val)           __percpu_generic_to_op(var, (val), ^=)
+#endif
+
 #endif /* __LINUX_PERCPU_H */
diff --git a/include/linux/phy.h b/include/linux/phy.h
index 32cf14a4b034..97e40cb6b588 100644
--- a/include/linux/phy.h
+++ b/include/linux/phy.h
@@ -388,6 +388,12 @@ struct phy_driver {
         /* Enables or disables interrupts */
         int (*config_intr)(struct phy_device *phydev);
 
+        /*
+         * Checks if the PHY generated an interrupt.
+         * For multi-PHY devices with shared PHY interrupt pin
+         */
+        int (*did_interrupt)(struct phy_device *phydev);
+
         /* Clears up any memory if needed */
         void (*remove)(struct phy_device *phydev);
 
diff --git a/include/linux/pipe_fs_i.h b/include/linux/pipe_fs_i.h
index 8e4120285f72..c8f038554e80 100644
--- a/include/linux/pipe_fs_i.h
+++ b/include/linux/pipe_fs_i.h
@@ -134,6 +134,11 @@ struct pipe_buf_operations {
    memory allocation, whereas PIPE_BUF makes atomicity guarantees.  */
 #define PIPE_SIZE               PAGE_SIZE
 
+/* Pipe lock and unlock operations */
+void pipe_lock(struct pipe_inode_info *);
+void pipe_unlock(struct pipe_inode_info *);
+void pipe_double_lock(struct pipe_inode_info *, struct pipe_inode_info *);
+
 /* Drop the inode semaphore and wait for a pipe event, atomically */
 void pipe_wait(struct pipe_inode_info *pipe);
 
diff --git a/include/linux/pktcdvd.h b/include/linux/pktcdvd.h
index 04b4d7330e6d..d745f5b6c7b0 100644
--- a/include/linux/pktcdvd.h
+++ b/include/linux/pktcdvd.h
@@ -113,6 +113,7 @@ struct pkt_ctrl_command {
 #include <linux/cdrom.h>
 #include <linux/kobject.h>
 #include <linux/sysfs.h>
+#include <linux/mempool.h>
 
 /* default bio write queue congestion marks */
 #define PKT_WRITE_CONGESTION_ON    10000
diff --git a/include/linux/platform_device.h b/include/linux/platform_device.h
index 76e470a299bf..72736fd8223c 100644
--- a/include/linux/platform_device.h
+++ b/include/linux/platform_device.h
@@ -77,4 +77,46 @@ extern int platform_driver_probe(struct platform_driver *driver,
 #define platform_get_drvdata(_dev)      dev_get_drvdata(&(_dev)->dev)
 #define platform_set_drvdata(_dev,data) dev_set_drvdata(&(_dev)->dev, (data))
 
+/* early platform driver interface */
+struct early_platform_driver {
+        const char *class_str;
+        struct platform_driver *pdrv;
+        struct list_head list;
+        int requested_id;
+};
+
+#define EARLY_PLATFORM_ID_UNSET -2
+#define EARLY_PLATFORM_ID_ERROR -3
+
+extern int early_platform_driver_register(struct early_platform_driver *epdrv,
+                                          char *buf);
+extern void early_platform_add_devices(struct platform_device **devs, int num);
+
+static inline int is_early_platform_device(struct platform_device *pdev)
+{
+        return !pdev->dev.driver;
+}
+
+extern void early_platform_driver_register_all(char *class_str);
+extern int early_platform_driver_probe(char *class_str,
+                                       int nr_probe, int user_only);
+extern void early_platform_cleanup(void);
+
+
+#ifndef MODULE
+#define early_platform_init(class_string, platform_driver)              \
+static __initdata struct early_platform_driver early_driver = {         \
+        .class_str = class_string,                                      \
+        .pdrv = platform_driver,                                        \
+        .requested_id = EARLY_PLATFORM_ID_UNSET,                        \
+};                                                                      \
+static int __init early_platform_driver_setup_func(char *buf)           \
+{                                                                       \
+        return early_platform_driver_register(&early_driver, buf);      \
+}                                                                       \
+early_param(class_string, early_platform_driver_setup_func)
+#else /* MODULE */
+#define early_platform_init(class_string, platform_driver)
+#endif /* MODULE */
+
 #endif /* _PLATFORM_DEVICE_H_ */
diff --git a/include/linux/poison.h b/include/linux/poison.h
index 9f31683728fd..6729f7dcd60e 100644
--- a/include/linux/poison.h
+++ b/include/linux/poison.h
@@ -17,6 +17,9 @@
  */
 #define TIMER_ENTRY_STATIC      ((void *) 0x74737461)
 
+/********** mm/debug-pagealloc.c **********/
+#define PAGE_POISON 0xaa
+
 /********** mm/slab.c **********/
 /*
  * Magic nums for obj red zoning.
diff --git a/include/linux/power_supply.h b/include/linux/power_supply.h
index 8ff25e0e7f7a..594c494ac3f0 100644
--- a/include/linux/power_supply.h
+++ b/include/linux/power_supply.h
@@ -73,6 +73,8 @@ enum power_supply_property {
         POWER_SUPPLY_PROP_VOLTAGE_AVG,
         POWER_SUPPLY_PROP_CURRENT_NOW,
         POWER_SUPPLY_PROP_CURRENT_AVG,
+        POWER_SUPPLY_PROP_POWER_NOW,
+        POWER_SUPPLY_PROP_POWER_AVG,
         POWER_SUPPLY_PROP_CHARGE_FULL_DESIGN,
         POWER_SUPPLY_PROP_CHARGE_EMPTY_DESIGN,
         POWER_SUPPLY_PROP_CHARGE_FULL,
diff --git a/include/linux/proc_fs.h b/include/linux/proc_fs.h
index b8bdb96eff78..fbfa3d44d33d 100644
--- a/include/linux/proc_fs.h
+++ b/include/linux/proc_fs.h
@@ -41,9 +41,6 @@ enum {
  * while parent/subdir create the directory structure (every
  * /proc file has a parent, but "subdir" is NULL for all
  * non-directory entries).
- *
- * "owner" is used to protect module
- * from unloading while proc_dir_entry is in use
  */
 
 typedef int (read_proc_t)(char *page, char **start, off_t off,
@@ -70,7 +67,6 @@ struct proc_dir_entry {
          * somewhere.
          */
         const struct file_operations *proc_fops;
-        struct module *owner;
         struct proc_dir_entry *next, *parent, *subdir;
         void *data;
         read_proc_t *read_proc;
diff --git a/include/linux/ptrace.h b/include/linux/ptrace.h
index 98b93ca4db06..67c15653fc23 100644
--- a/include/linux/ptrace.h
+++ b/include/linux/ptrace.h
@@ -94,6 +94,7 @@ extern void ptrace_notify(int exit_code);
 extern void __ptrace_link(struct task_struct *child,
                           struct task_struct *new_parent);
 extern void __ptrace_unlink(struct task_struct *child);
+extern void exit_ptrace(struct task_struct *tracer);
 extern void ptrace_fork(struct task_struct *task, unsigned long clone_flags);
 #define PTRACE_MODE_READ   1
 #define PTRACE_MODE_ATTACH 2
diff --git a/include/linux/pwm.h b/include/linux/pwm.h
index 3945f803d514..7c775751392c 100644
--- a/include/linux/pwm.h
+++ b/include/linux/pwm.h
@@ -28,4 +28,4 @@ int pwm_enable(struct pwm_device *pwm);
  */
 void pwm_disable(struct pwm_device *pwm);
 
-#endif /* __ASM_ARCH_PWM_H */
+#endif /* __LINUX_PWM_H */
diff --git a/include/linux/raid/bitmap.h b/include/linux/raid/bitmap.h
deleted file mode 100644
index e98900671ca9..000000000000
--- a/include/linux/raid/bitmap.h
+++ /dev/null
@@ -1,288 +0,0 @@
-/*
- * bitmap.h: Copyright (C) Peter T. Breuer (ptb@ot.uc3m.es) 2003
- *
- * additions: Copyright (C) 2003-2004, Paul Clements, SteelEye Technology, Inc.
- */
-#ifndef BITMAP_H
-#define BITMAP_H 1
-
-#define BITMAP_MAJOR_LO 3
-/* version 4 insists the bitmap is in little-endian order
- * with version 3, it is host-endian which is non-portable
- */
-#define BITMAP_MAJOR_HI 4
-#define BITMAP_MAJOR_HOSTENDIAN 3
-
-#define BITMAP_MINOR 39
-
-/*
- * in-memory bitmap:
- *
- * Use 16 bit block counters to track pending writes to each "chunk".
- * The 2 high order bits are special-purpose, the first is a flag indicating
- * whether a resync is needed.  The second is a flag indicating whether a
- * resync is active.
- * This means that the counter is actually 14 bits:
- *
- * +--------+--------+------------------------------------------------+
- * | resync | resync |               counter                          |
- * | needed | active |                                                |
- * |  (0-1) |  (0-1) |              (0-16383)                         |
- * +--------+--------+------------------------------------------------+
- *
- * The "resync needed" bit is set when:
- *    a '1' bit is read from storage at startup.
- *    a write request fails on some drives
- *    a resync is aborted on a chunk with 'resync active' set
- * It is cleared (and resync-active set) when a resync starts across all drives
- * of the chunk.
- *
- *
- * The "resync active" bit is set when:
- *    a resync is started on all drives, and resync_needed is set.
- *       resync_needed will be cleared (as long as resync_active wasn't already set).
- * It is cleared when a resync completes.
- *
- * The counter counts pending write requests, plus the on-disk bit.
- * When the counter is '1' and the resync bits are clear, the on-disk
- * bit can be cleared aswell, thus setting the counter to 0.
- * When we set a bit, or in the counter (to start a write), if the fields is
- * 0, we first set the disk bit and set the counter to 1.
- *
- * If the counter is 0, the on-disk bit is clear and the stipe is clean
- * Anything that dirties the stipe pushes the counter to 2 (at least)
- * and sets the on-disk bit (lazily).
- * If a periodic sweep find the counter at 2, it is decremented to 1.
- * If the sweep find the counter at 1, the on-disk bit is cleared and the
- * counter goes to zero.
- *
- * Also, we'll hijack the "map" pointer itself and use it as two 16 bit block
- * counters as a fallback when "page" memory cannot be allocated:
- *
- * Normal case (page memory allocated):
- *
- *     page pointer (32-bit)
- *
- *     [ ] ------+
- *               |
- *               +-------> [   ][   ]..[   ] (4096 byte page == 2048 counters)
- *                          c1   c2    c2048
- *
- * Hijacked case (page memory allocation failed):
- *
- *     hijacked page pointer (32-bit)
- *
- *     [                  ][              ] (no page memory allocated)
- *      counter #1 (16-bit) counter #2 (16-bit)
- *
- */
-
-#ifdef __KERNEL__
-
-#define PAGE_BITS (PAGE_SIZE << 3)
-#define PAGE_BIT_SHIFT (PAGE_SHIFT + 3)
-
-typedef __u16 bitmap_counter_t;
-#define COUNTER_BITS 16
-#define COUNTER_BIT_SHIFT 4
-#define COUNTER_BYTE_RATIO (COUNTER_BITS / 8)
-#define COUNTER_BYTE_SHIFT (COUNTER_BIT_SHIFT - 3)
-
-#define NEEDED_MASK ((bitmap_counter_t) (1 << (COUNTER_BITS - 1)))
-#define RESYNC_MASK ((bitmap_counter_t) (1 << (COUNTER_BITS - 2)))
-#define COUNTER_MAX ((bitmap_counter_t) RESYNC_MASK - 1)
-#define NEEDED(x) (((bitmap_counter_t) x) & NEEDED_MASK)
-#define RESYNC(x) (((bitmap_counter_t) x) & RESYNC_MASK)
-#define COUNTER(x) (((bitmap_counter_t) x) & COUNTER_MAX)
-
-/* how many counters per page? */
-#define PAGE_COUNTER_RATIO (PAGE_BITS / COUNTER_BITS)
-/* same, except a shift value for more efficient bitops */
-#define PAGE_COUNTER_SHIFT (PAGE_BIT_SHIFT - COUNTER_BIT_SHIFT)
-/* same, except a mask value for more efficient bitops */
-#define PAGE_COUNTER_MASK  (PAGE_COUNTER_RATIO - 1)
-
-#define BITMAP_BLOCK_SIZE 512
-#define BITMAP_BLOCK_SHIFT 9
-
-/* how many blocks per chunk? (this is variable) */
-#define CHUNK_BLOCK_RATIO(bitmap) ((bitmap)->chunksize >> BITMAP_BLOCK_SHIFT)
-#define CHUNK_BLOCK_SHIFT(bitmap) ((bitmap)->chunkshift - BITMAP_BLOCK_SHIFT)
-#define CHUNK_BLOCK_MASK(bitmap) (CHUNK_BLOCK_RATIO(bitmap) - 1)
-
-/* when hijacked, the counters and bits represent even larger "chunks" */
-/* there will be 1024 chunks represented by each counter in the page pointers */
-#define PAGEPTR_BLOCK_RATIO(bitmap) \
-                        (CHUNK_BLOCK_RATIO(bitmap) << PAGE_COUNTER_SHIFT >> 1)
-#define PAGEPTR_BLOCK_SHIFT(bitmap) \
-                        (CHUNK_BLOCK_SHIFT(bitmap) + PAGE_COUNTER_SHIFT - 1)
-#define PAGEPTR_BLOCK_MASK(bitmap) (PAGEPTR_BLOCK_RATIO(bitmap) - 1)
-
-/*
- * on-disk bitmap:
- *
- * Use one bit per "chunk" (block set). We do the disk I/O on the bitmap
- * file a page at a time. There's a superblock at the start of the file.
- */
-
-/* map chunks (bits) to file pages - offset by the size of the superblock */
-#define CHUNK_BIT_OFFSET(chunk) ((chunk) + (sizeof(bitmap_super_t) << 3))
-
-#endif
-
-/*
- * bitmap structures:
- */
-
-#define BITMAP_MAGIC 0x6d746962
-
-/* use these for bitmap->flags and bitmap->sb->state bit-fields */
-enum bitmap_state {
-        BITMAP_STALE  = 0x002,  /* the bitmap file is out of date or had -EIO */
-        BITMAP_WRITE_ERROR = 0x004, /* A write error has occurred */
-        BITMAP_HOSTENDIAN = 0x8000,
-};
-
-/* the superblock at the front of the bitmap file -- little endian */
-typedef struct bitmap_super_s {
-        __le32 magic;        /*  0  BITMAP_MAGIC */
-        __le32 version;      /*  4  the bitmap major for now, could change... */
-        __u8  uuid[16];      /*  8  128 bit uuid - must match md device uuid */
-        __le64 events;       /* 24  event counter for the bitmap (1)*/
-        __le64 events_cleared;/*32  event counter when last bit cleared (2) */
-        __le64 sync_size;    /* 40  the size of the md device's sync range(3) */
-        __le32 state;        /* 48  bitmap state information */
-        __le32 chunksize;    /* 52  the bitmap chunk size in bytes */
-        __le32 daemon_sleep; /* 56  seconds between disk flushes */
-        __le32 write_behind; /* 60  number of outstanding write-behind writes */
-
-        __u8  pad[256 - 64]; /* set to zero */
-} bitmap_super_t;
-
-/* notes:
- * (1) This event counter is updated before the eventcounter in the md superblock
- *    When a bitmap is loaded, it is only accepted if this event counter is equal
- *    to, or one greater than, the event counter in the superblock.
- * (2) This event counter is updated when the other one is *if*and*only*if* the
- *    array is not degraded.  As bits are not cleared when the array is degraded,
- *    this represents the last time that any bits were cleared.
- *    If a device is being added that has an event count with this value or
- *    higher, it is accepted as conforming to the bitmap.
- * (3)This is the number of sectors represented by the bitmap, and is the range that
- *    resync happens across.  For raid1 and raid5/6 it is the size of individual
- *    devices.  For raid10 it is the size of the array.
- */
-
-#ifdef __KERNEL__
-
-/* the in-memory bitmap is represented by bitmap_pages */
-struct bitmap_page {
-        /*
-         * map points to the actual memory page
-         */
-        char *map;
-        /*
-         * in emergencies (when map cannot be alloced), hijack the map
-         * pointer and use it as two counters itself
-         */
-        unsigned int hijacked:1;
-        /*
-         * count of dirty bits on the page
-         */
-        unsigned int  count:31;
-};
-
-/* keep track of bitmap file pages that have pending writes on them */
-struct page_list {
-        struct list_head list;
-        struct page *page;
-};
-
-/* the main bitmap structure - one per mddev */
-struct bitmap {
-        struct bitmap_page *bp;
-        unsigned long pages; /* total number of pages in the bitmap */
-        unsigned long missing_pages; /* number of pages not yet allocated */
-
-        mddev_t *mddev; /* the md device that the bitmap is for */
-
-        int counter_bits; /* how many bits per block counter */
-
-        /* bitmap chunksize -- how much data does each bit represent? */
-        unsigned long chunksize;
-        unsigned long chunkshift; /* chunksize = 2^chunkshift (for bitops) */
-        unsigned long chunks; /* total number of data chunks for the array */
-
-        /* We hold a count on the chunk currently being synced, and drop
-         * it when the last block is started.  If the resync is aborted
-         * midway, we need to be able to drop that count, so we remember
-         * the counted chunk..
-         */
-        unsigned long syncchunk;
-
-        __u64   events_cleared;
-        int need_sync;
-
-        /* bitmap spinlock */
-        spinlock_t lock;
-
-        long offset; /* offset from superblock if file is NULL */
-        struct file *file; /* backing disk file */
-        struct page *sb_page; /* cached copy of the bitmap file superblock */
-        struct page **filemap; /* list of cache pages for the file */
-        unsigned long *filemap_attr; /* attributes associated w/ filemap pages */
-        unsigned long file_pages; /* number of pages in the file */
-        int last_page_size; /* bytes in the last page */
-
-        unsigned long flags;
-
-        int allclean;
-
-        unsigned long max_write_behind; /* write-behind mode */
-        atomic_t behind_writes;
-
-        /*
-         * the bitmap daemon - periodically wakes up and sweeps the bitmap
-         * file, cleaning up bits and flushing out pages to disk as necessary
-         */
-        unsigned long daemon_lastrun; /* jiffies of last run */
-        unsigned long daemon_sleep; /* how many seconds between updates? */
-        unsigned long last_end_sync; /* when we lasted called end_sync to
-                                      * update bitmap with resync progress */
-
-        atomic_t pending_writes; /* pending writes to the bitmap file */
-        wait_queue_head_t write_wait;
-        wait_queue_head_t overflow_wait;
-
-};
-
-/* the bitmap API */
-
-/* these are used only by md/bitmap */
-int  bitmap_create(mddev_t *mddev);
-void bitmap_flush(mddev_t *mddev);
-void bitmap_destroy(mddev_t *mddev);
-
-void bitmap_print_sb(struct bitmap *bitmap);
-void bitmap_update_sb(struct bitmap *bitmap);
-
-int  bitmap_setallbits(struct bitmap *bitmap);
-void bitmap_write_all(struct bitmap *bitmap);
-
-void bitmap_dirty_bits(struct bitmap *bitmap, unsigned long s, unsigned long e);
-
-/* these are exported */
-int bitmap_startwrite(struct bitmap *bitmap, sector_t offset,
-                        unsigned long sectors, int behind);
-void bitmap_endwrite(struct bitmap *bitmap, sector_t offset,
-                        unsigned long sectors, int success, int behind);
-int bitmap_start_sync(struct bitmap *bitmap, sector_t offset, int *blocks, int degraded);
-void bitmap_end_sync(struct bitmap *bitmap, sector_t offset, int *blocks, int aborted);
-void bitmap_close_sync(struct bitmap *bitmap);
-void bitmap_cond_end_sync(struct bitmap *bitmap, sector_t sector);
-
-void bitmap_unplug(struct bitmap *bitmap);
-void bitmap_daemon_work(struct bitmap *bitmap);
-#endif
-
-#endif
diff --git a/include/linux/raid/linear.h b/include/linux/raid/linear.h
deleted file mode 100644
index f38b9c586afb..000000000000
--- a/include/linux/raid/linear.h
+++ /dev/null
@@ -1,31 +0,0 @@
-#ifndef _LINEAR_H
-#define _LINEAR_H
-
-#include <linux/raid/md.h>
-
-struct dev_info {
-        mdk_rdev_t      *rdev;
-        sector_t        num_sectors;
-        sector_t        start_sector;
-};
-
-typedef struct dev_info dev_info_t;
-
-struct linear_private_data
-{
-        struct linear_private_data *prev;       /* earlier version */
-        dev_info_t              **hash_table;
-        sector_t                spacing;
-        sector_t                array_sectors;
-        int                     sector_shift;   /* shift before dividing
-                                                 * by spacing
-                                                 */
-        dev_info_t              disks[0];
-};
-
-
-typedef struct linear_private_data linear_conf_t;
-
-#define mddev_to_conf(mddev) ((linear_conf_t *) mddev->private)
-
-#endif
diff --git a/include/linux/raid/md.h b/include/linux/raid/md.h
deleted file mode 100644
index 82bea14cae1a..000000000000
--- a/include/linux/raid/md.h
+++ /dev/null
@@ -1,81 +0,0 @@
-/*
-   md.h : Multiple Devices driver for Linux
-          Copyright (C) 1996-98 Ingo Molnar, Gadi Oxman
-          Copyright (C) 1994-96 Marc ZYNGIER
-          <zyngier@ufr-info-p7.ibp.fr> or
-          <maz@gloups.fdn.fr>
-          
-   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, or (at your option)
-   any later version.
-   
-   You should have received a copy of the GNU General Public License
-   (for example /usr/src/linux/COPYING); if not, write to the Free
-   Software Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.  
-*/
-
-#ifndef _MD_H
-#define _MD_H
-
-#include <linux/blkdev.h>
-#include <linux/seq_file.h>
-
-/*
- * 'md_p.h' holds the 'physical' layout of RAID devices
- * 'md_u.h' holds the user <=> kernel API
- *
- * 'md_k.h' holds kernel internal definitions
- */
-
-#include <linux/raid/md_p.h>
-#include <linux/raid/md_u.h>
-#include <linux/raid/md_k.h>
-
-#ifdef CONFIG_MD
-
-/*
- * Different major versions are not compatible.
- * Different minor versions are only downward compatible.
- * Different patchlevel versions are downward and upward compatible.
- */
-#define MD_MAJOR_VERSION                0
-#define MD_MINOR_VERSION                90
-/*
- * MD_PATCHLEVEL_VERSION indicates kernel functionality.
- * >=1 means different superblock formats are selectable using SET_ARRAY_INFO
- *     and major_version/minor_version accordingly
- * >=2 means that Internal bitmaps are supported by setting MD_SB_BITMAP_PRESENT
- *     in the super status byte
- * >=3 means that bitmap superblock version 4 is supported, which uses
- *     little-ending representation rather than host-endian
- */
-#define MD_PATCHLEVEL_VERSION           3
-
-extern int mdp_major;
-
-extern int register_md_personality(struct mdk_personality *p);
-extern int unregister_md_personality(struct mdk_personality *p);
-extern mdk_thread_t * md_register_thread(void (*run) (mddev_t *mddev),
-                                mddev_t *mddev, const char *name);
-extern void md_unregister_thread(mdk_thread_t *thread);
-extern void md_wakeup_thread(mdk_thread_t *thread);
-extern void md_check_recovery(mddev_t *mddev);
-extern void md_write_start(mddev_t *mddev, struct bio *bi);
-extern void md_write_end(mddev_t *mddev);
-extern void md_done_sync(mddev_t *mddev, int blocks, int ok);
-extern void md_error(mddev_t *mddev, mdk_rdev_t *rdev);
-
-extern void md_super_write(mddev_t *mddev, mdk_rdev_t *rdev,
-                           sector_t sector, int size, struct page *page);
-extern void md_super_wait(mddev_t *mddev);
-extern int sync_page_io(struct block_device *bdev, sector_t sector, int size,
-                        struct page *page, int rw);
-extern void md_do_sync(mddev_t *mddev);
-extern void md_new_event(mddev_t *mddev);
-extern int md_allow_write(mddev_t *mddev);
-extern void md_wait_for_blocked_rdev(mdk_rdev_t *rdev, mddev_t *mddev);
-
-#endif /* CONFIG_MD */
-#endif 
-
diff --git a/include/linux/raid/md_k.h b/include/linux/raid/md_k.h
deleted file mode 100644
index 9743e4dbc918..000000000000
--- a/include/linux/raid/md_k.h
+++ /dev/null
@@ -1,402 +0,0 @@
-/*
-   md_k.h : kernel internal structure of the Linux MD driver
-          Copyright (C) 1996-98 Ingo Molnar, Gadi Oxman
-          
-   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, or (at your option)
-   any later version.
-   
-   You should have received a copy of the GNU General Public License
-   (for example /usr/src/linux/COPYING); if not, write to the Free
-   Software Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.  
-*/
-
-#ifndef _MD_K_H
-#define _MD_K_H
-
-/* and dm-bio-list.h is not under include/linux because.... ??? */
-#include "../../../drivers/md/dm-bio-list.h"
-
-#ifdef CONFIG_BLOCK
-
-#define LEVEL_MULTIPATH         (-4)
-#define LEVEL_LINEAR            (-1)
-#define LEVEL_FAULTY            (-5)
-
-/* we need a value for 'no level specified' and 0
- * means 'raid0', so we need something else.  This is
- * for internal use only
- */
-#define LEVEL_NONE              (-1000000)
-
-#define MaxSector (~(sector_t)0)
-
-typedef struct mddev_s mddev_t;
-typedef struct mdk_rdev_s mdk_rdev_t;
-
-/*
- * options passed in raidrun:
- */
-
-/* Currently this must fit in an 'int' */
-#define MAX_CHUNK_SIZE (1<<30)
-
-/*
- * MD's 'extended' device
- */
-struct mdk_rdev_s
-{
-        struct list_head same_set;      /* RAID devices within the same set */
-
-        sector_t size;                  /* Device size (in blocks) */
-        mddev_t *mddev;                 /* RAID array if running */
-        long last_events;               /* IO event timestamp */
-
-        struct block_device *bdev;      /* block device handle */
-
-        struct page     *sb_page;
-        int             sb_loaded;
-        __u64           sb_events;
-        sector_t        data_offset;    /* start of data in array */
-        sector_t        sb_start;       /* offset of the super block (in 512byte sectors) */
-        int             sb_size;        /* bytes in the superblock */
-        int             preferred_minor;        /* autorun support */
-
-        struct kobject  kobj;
-
-        /* A device can be in one of three states based on two flags:
-         * Not working:   faulty==1 in_sync==0
-         * Fully working: faulty==0 in_sync==1
-         * Working, but not
-         * in sync with array
-         *                faulty==0 in_sync==0
-         *
-         * It can never have faulty==1, in_sync==1
-         * This reduces the burden of testing multiple flags in many cases
-         */
-
-        unsigned long   flags;
-#define Faulty          1               /* device is known to have a fault */
-#define In_sync         2               /* device is in_sync with rest of array */
-#define WriteMostly     4               /* Avoid reading if at all possible */
-#define BarriersNotsupp 5               /* BIO_RW_BARRIER is not supported */
-#define AllReserved     6               /* If whole device is reserved for
-                                         * one array */
-#define AutoDetected    7               /* added by auto-detect */
-#define Blocked         8               /* An error occured on an externally
-                                         * managed array, don't allow writes
-                                         * until it is cleared */
-#define StateChanged    9               /* Faulty or Blocked has changed during
-                                         * interrupt, so it needs to be
-                                         * notified by the thread */
-        wait_queue_head_t blocked_wait;
-
-        int desc_nr;                    /* descriptor index in the superblock */
-        int raid_disk;                  /* role of device in array */
-        int saved_raid_disk;            /* role that device used to have in the
-                                         * array and could again if we did a partial
-                                         * resync from the bitmap
-                                         */
-        sector_t        recovery_offset;/* If this device has been partially
-                                         * recovered, this is where we were
-                                         * up to.
-                                         */
-
-        atomic_t        nr_pending;     /* number of pending requests.
-                                         * only maintained for arrays that
-                                         * support hot removal
-                                         */
-        atomic_t        read_errors;    /* number of consecutive read errors that
-                                         * we have tried to ignore.
-                                         */
-        atomic_t        corrected_errors; /* number of corrected read errors,
-                                           * for reporting to userspace and storing
-                                           * in superblock.
-                                           */
-        struct work_struct del_work;    /* used for delayed sysfs removal */
-
-        struct sysfs_dirent *sysfs_state; /* handle for 'state'
-                                           * sysfs entry */
-};
-
-struct mddev_s
-{
-        void                            *private;
-        struct mdk_personality          *pers;
-        dev_t                           unit;
-        int                             md_minor;
-        struct list_head                disks;
-        unsigned long                   flags;
-#define MD_CHANGE_DEVS  0       /* Some device status has changed */
-#define MD_CHANGE_CLEAN 1       /* transition to or from 'clean' */
-#define MD_CHANGE_PENDING 2     /* superblock update in progress */
-
-        int                             ro;
-
-        struct gendisk                  *gendisk;
-
-        struct kobject                  kobj;
-        int                             hold_active;
-#define UNTIL_IOCTL     1
-#define UNTIL_STOP      2
-
-        /* Superblock information */
-        int                             major_version,
-                                        minor_version,
-                                        patch_version;
-        int                             persistent;
-        int                             external;       /* metadata is
-                                                         * managed externally */
-        char                            metadata_type[17]; /* externally set*/
-        int                             chunk_size;
-        time_t                          ctime, utime;
-        int                             level, layout;
-        char                            clevel[16];
-        int                             raid_disks;
-        int                             max_disks;
-        sector_t                        size; /* used size of component devices */
-        sector_t                        array_sectors; /* exported array size */
-        __u64                           events;
-
-        char                            uuid[16];
-
-        /* If the array is being reshaped, we need to record the
-         * new shape and an indication of where we are up to.
-         * This is written to the superblock.
-         * If reshape_position is MaxSector, then no reshape is happening (yet).
-         */
-        sector_t                        reshape_position;
-        int                             delta_disks, new_level, new_layout, new_chunk;
-
-        struct mdk_thread_s             *thread;        /* management thread */
-        struct mdk_thread_s             *sync_thread;   /* doing resync or reconstruct */
-        sector_t                        curr_resync;    /* last block scheduled */
-        unsigned long                   resync_mark;    /* a recent timestamp */
-        sector_t                        resync_mark_cnt;/* blocks written at resync_mark */
-        sector_t                        curr_mark_cnt; /* blocks scheduled now */
-
-        sector_t                        resync_max_sectors; /* may be set by personality */
-
-        sector_t                        resync_mismatches; /* count of sectors where
-                                                            * parity/replica mismatch found
-                                                            */
-
-        /* allow user-space to request suspension of IO to regions of the array */
-        sector_t                        suspend_lo;
-        sector_t                        suspend_hi;
-        /* if zero, use the system-wide default */
-        int                             sync_speed_min;
-        int                             sync_speed_max;
-
-        /* resync even though the same disks are shared among md-devices */
-        int                             parallel_resync;
-
-        int                             ok_start_degraded;
-        /* recovery/resync flags 
-         * NEEDED:   we might need to start a resync/recover
-         * RUNNING:  a thread is running, or about to be started
-         * SYNC:     actually doing a resync, not a recovery
-         * RECOVER:  doing recovery, or need to try it.
-         * INTR:     resync needs to be aborted for some reason
-         * DONE:     thread is done and is waiting to be reaped
-         * REQUEST:  user-space has requested a sync (used with SYNC)
-         * CHECK:    user-space request for for check-only, no repair
-         * RESHAPE:  A reshape is happening
-         *
-         * If neither SYNC or RESHAPE are set, then it is a recovery.
-         */
-#define MD_RECOVERY_RUNNING     0
-#define MD_RECOVERY_SYNC        1
-#define MD_RECOVERY_RECOVER     2
-#define MD_RECOVERY_INTR        3
-#define MD_RECOVERY_DONE        4
-#define MD_RECOVERY_NEEDED      5
-#define MD_RECOVERY_REQUESTED   6
-#define MD_RECOVERY_CHECK       7
-#define MD_RECOVERY_RESHAPE     8
-#define MD_RECOVERY_FROZEN      9
-
-        unsigned long                   recovery;
-        int                             recovery_disabled; /* if we detect that recovery
-                                                            * will always fail, set this
-                                                            * so we don't loop trying */
-
-        int                             in_sync;        /* know to not need resync */
-        struct mutex                    reconfig_mutex;
-        atomic_t                        active;         /* general refcount */
-        atomic_t                        openers;        /* number of active opens */
-
-        int                             changed;        /* true if we might need to reread partition info */
-        int                             degraded;       /* whether md should consider
-                                                         * adding a spare
-                                                         */
-        int                             barriers_work;  /* initialised to true, cleared as soon
-                                                         * as a barrier request to slave
-                                                         * fails.  Only supported
-                                                         */
-        struct bio                      *biolist;       /* bios that need to be retried
-                                                         * because BIO_RW_BARRIER is not supported
-                                                         */
-
-        atomic_t                        recovery_active; /* blocks scheduled, but not written */
-        wait_queue_head_t               recovery_wait;
-        sector_t                        recovery_cp;
-        sector_t                        resync_min;     /* user requested sync
-                                                         * starts here */
-        sector_t                        resync_max;     /* resync should pause
-                                                         * when it gets here */
-
-        struct sysfs_dirent             *sysfs_state;   /* handle for 'array_state'
-                                                         * file in sysfs.
-                                                         */
-        struct sysfs_dirent             *sysfs_action;  /* handle for 'sync_action' */
-
-        struct work_struct del_work;    /* used for delayed sysfs removal */
-
-        spinlock_t                      write_lock;
-        wait_queue_head_t               sb_wait;        /* for waiting on superblock updates */
-        atomic_t                        pending_writes; /* number of active superblock writes */
-
-        unsigned int                    safemode;       /* if set, update "clean" superblock
-                                                         * when no writes pending.
-                                                         */ 
-        unsigned int                    safemode_delay;
-        struct timer_list               safemode_timer;
-        atomic_t                        writes_pending; 
-        struct request_queue            *queue; /* for plugging ... */
-
-        atomic_t                        write_behind; /* outstanding async IO */
-        unsigned int                    max_write_behind; /* 0 = sync */
-
-        struct bitmap                   *bitmap; /* the bitmap for the device */
-        struct file                     *bitmap_file; /* the bitmap file */
-        long                            bitmap_offset; /* offset from superblock of
-                                                        * start of bitmap. May be
-                                                        * negative, but not '0'
-                                                        */
-        long                            default_bitmap_offset; /* this is the offset to use when
-                                                                * hot-adding a bitmap.  It should
-                                                                * eventually be settable by sysfs.
-                                                                */
-
-        struct list_head                all_mddevs;
-};
-
-
-static inline void rdev_dec_pending(mdk_rdev_t *rdev, mddev_t *mddev)
-{
-        int faulty = test_bit(Faulty, &rdev->flags);
-        if (atomic_dec_and_test(&rdev->nr_pending) && faulty)
-                set_bit(MD_RECOVERY_NEEDED, &mddev->recovery);
-}
-
-static inline void md_sync_acct(struct block_device *bdev, unsigned long nr_sectors)
-{
-        atomic_add(nr_sectors, &bdev->bd_contains->bd_disk->sync_io);
-}
-
-struct mdk_personality
-{
-        char *name;
-        int level;
-        struct list_head list;
-        struct module *owner;
-        int (*make_request)(struct request_queue *q, struct bio *bio);
-        int (*run)(mddev_t *mddev);
-        int (*stop)(mddev_t *mddev);
-        void (*status)(struct seq_file *seq, mddev_t *mddev);
-        /* error_handler must set ->faulty and clear ->in_sync
-         * if appropriate, and should abort recovery if needed 
-         */
-        void (*error_handler)(mddev_t *mddev, mdk_rdev_t *rdev);
-        int (*hot_add_disk) (mddev_t *mddev, mdk_rdev_t *rdev);
-        int (*hot_remove_disk) (mddev_t *mddev, int number);
-        int (*spare_active) (mddev_t *mddev);
-        sector_t (*sync_request)(mddev_t *mddev, sector_t sector_nr, int *skipped, int go_faster);
-        int (*resize) (mddev_t *mddev, sector_t sectors);
-        int (*check_reshape) (mddev_t *mddev);
-        int (*start_reshape) (mddev_t *mddev);
-        int (*reconfig) (mddev_t *mddev, int layout, int chunk_size);
-        /* quiesce moves between quiescence states
-         * 0 - fully active
-         * 1 - no new requests allowed
-         * others - reserved
-         */
-        void (*quiesce) (mddev_t *mddev, int state);
-};
-
-
-struct md_sysfs_entry {
-        struct attribute attr;
-        ssize_t (*show)(mddev_t *, char *);
-        ssize_t (*store)(mddev_t *, const char *, size_t);
-};
-
-
-static inline char * mdname (mddev_t * mddev)
-{
-        return mddev->gendisk ? mddev->gendisk->disk_name : "mdX";
-}
-
-/*
- * iterates through some rdev ringlist. It's safe to remove the
- * current 'rdev'. Dont touch 'tmp' though.
- */
-#define rdev_for_each_list(rdev, tmp, head)                             \
-        list_for_each_entry_safe(rdev, tmp, head, same_set)
-
-/*
- * iterates through the 'same array disks' ringlist
- */
-#define rdev_for_each(rdev, tmp, mddev)                         \
-        list_for_each_entry_safe(rdev, tmp, &((mddev)->disks), same_set)
-
-#define rdev_for_each_rcu(rdev, mddev)                          \
-        list_for_each_entry_rcu(rdev, &((mddev)->disks), same_set)
-
-typedef struct mdk_thread_s {
-        void                    (*run) (mddev_t *mddev);
-        mddev_t                 *mddev;
-        wait_queue_head_t       wqueue;
-        unsigned long           flags;
-        struct task_struct      *tsk;
-        unsigned long           timeout;
-} mdk_thread_t;
-
-#define THREAD_WAKEUP  0
-
-#define __wait_event_lock_irq(wq, condition, lock, cmd)                 \
-do {                                                                    \
-        wait_queue_t __wait;                                            \
-        init_waitqueue_entry(&__wait, current);                         \
-                                                                        \
-        add_wait_queue(&wq, &__wait);                                   \
-        for (;;) {                                                      \
-                set_current_state(TASK_UNINTERRUPTIBLE);                \
-                if (condition)                                          \
-                        break;                                          \
-                spin_unlock_irq(&lock);                                 \
-                cmd;                                                    \
-                schedule();                                             \
-                spin_lock_irq(&lock);                                   \
-        }                                                               \
-        current->state = TASK_RUNNING;                                  \
-        remove_wait_queue(&wq, &__wait);                                \
-} while (0)
-
-#define wait_event_lock_irq(wq, condition, lock, cmd)                   \
-do {                                                                    \
-        if (condition)                                                  \
-                break;                                                  \
-        __wait_event_lock_irq(wq, condition, lock, cmd);                \
-} while (0)
-
-static inline void safe_put_page(struct page *p)
-{
-        if (p) put_page(p);
-}
-
-#endif /* CONFIG_BLOCK */
-#endif
-
diff --git a/include/linux/raid/md_u.h b/include/linux/raid/md_u.h
index 7192035fc4b0..fb1abb3367e9 100644
--- a/include/linux/raid/md_u.h
+++ b/include/linux/raid/md_u.h
@@ -15,6 +15,24 @@
 #ifndef _MD_U_H
 #define _MD_U_H
 
+/*
+ * Different major versions are not compatible.
+ * Different minor versions are only downward compatible.
+ * Different patchlevel versions are downward and upward compatible.
+ */
+#define MD_MAJOR_VERSION                0
+#define MD_MINOR_VERSION                90
+/*
+ * MD_PATCHLEVEL_VERSION indicates kernel functionality.
+ * >=1 means different superblock formats are selectable using SET_ARRAY_INFO
+ *     and major_version/minor_version accordingly
+ * >=2 means that Internal bitmaps are supported by setting MD_SB_BITMAP_PRESENT
+ *     in the super status byte
+ * >=3 means that bitmap superblock version 4 is supported, which uses
+ *     little-ending representation rather than host-endian
+ */
+#define MD_PATCHLEVEL_VERSION           3
+
 /* ioctls */
 
 /* status */
@@ -46,6 +64,12 @@
 #define STOP_ARRAY_RO           _IO (MD_MAJOR, 0x33)
 #define RESTART_ARRAY_RW        _IO (MD_MAJOR, 0x34)
 
+/* 63 partitions with the alternate major number (mdp) */
+#define MdpMinorShift 6
+#ifdef __KERNEL__
+extern int mdp_major;
+#endif
+
 typedef struct mdu_version_s {
         int major;
         int minor;
@@ -85,6 +109,17 @@ typedef struct mdu_array_info_s {
 
 } mdu_array_info_t;
 
+/* non-obvious values for 'level' */
+#define LEVEL_MULTIPATH         (-4)
+#define LEVEL_LINEAR            (-1)
+#define LEVEL_FAULTY            (-5)
+
+/* we need a value for 'no level specified' and 0
+ * means 'raid0', so we need something else.  This is
+ * for internal use only
+ */
+#define LEVEL_NONE              (-1000000)
+
 typedef struct mdu_disk_info_s {
         /*
          * configuration/status of one particular disk
diff --git a/include/linux/raid/multipath.h b/include/linux/raid/multipath.h
deleted file mode 100644
index 6f53fc177a47..000000000000
--- a/include/linux/raid/multipath.h
+++ /dev/null
@@ -1,42 +0,0 @@
-#ifndef _MULTIPATH_H
-#define _MULTIPATH_H
-
-#include <linux/raid/md.h>
-
-struct multipath_info {
-        mdk_rdev_t      *rdev;
-};
-
-struct multipath_private_data {
-        mddev_t                 *mddev;
-        struct multipath_info   *multipaths;
-        int                     raid_disks;
-        int                     working_disks;
-        spinlock_t              device_lock;
-        struct list_head        retry_list;
-
-        mempool_t               *pool;
-};
-
-typedef struct multipath_private_data multipath_conf_t;
-
-/*
- * this is the only point in the RAID code where we violate
- * C type safety. mddev->private is an 'opaque' pointer.
- */
-#define mddev_to_conf(mddev) ((multipath_conf_t *) mddev->private)
-
-/*
- * this is our 'private' 'collective' MULTIPATH buffer head.
- * it contains information about what kind of IO operations were started
- * for this MULTIPATH operation, and about their status:
- */
-
-struct multipath_bh {
-        mddev_t                 *mddev;
-        struct bio              *master_bio;
-        struct bio              bio;
-        int                     path;
-        struct list_head        retry_list;
-};
-#endif
diff --git a/include/linux/raid/pq.h b/include/linux/raid/pq.h
new file mode 100644
index 000000000000..d92480f8285c
--- /dev/null
+++ b/include/linux/raid/pq.h
@@ -0,0 +1,132 @@
+/* -*- linux-c -*- ------------------------------------------------------- *
+ *
+ *   Copyright 2003 H. Peter Anvin - All Rights Reserved
+ *
+ *   This program is free software; you can redistribute it and/or modify
+ *   it under the terms of the GNU General Public License as published by
+ *   the Free Software Foundation, Inc., 53 Temple Place Ste 330,
+ *   Boston MA 02111-1307, USA; either version 2 of the License, or
+ *   (at your option) any later version; incorporated herein by reference.
+ *
+ * ----------------------------------------------------------------------- */
+
+#ifndef LINUX_RAID_RAID6_H
+#define LINUX_RAID_RAID6_H
+
+#ifdef __KERNEL__
+
+/* Set to 1 to use kernel-wide empty_zero_page */
+#define RAID6_USE_EMPTY_ZERO_PAGE 0
+#include <linux/blkdev.h>
+
+/* We need a pre-zeroed page... if we don't want to use the kernel-provided
+   one define it here */
+#if RAID6_USE_EMPTY_ZERO_PAGE
+# define raid6_empty_zero_page empty_zero_page
+#else
+extern const char raid6_empty_zero_page[PAGE_SIZE];
+#endif
+
+#else /* ! __KERNEL__ */
+/* Used for testing in user space */
+
+#include <errno.h>
+#include <inttypes.h>
+#include <limits.h>
+#include <stddef.h>
+#include <sys/mman.h>
+#include <sys/types.h>
+
+/* Not standard, but glibc defines it */
+#define BITS_PER_LONG __WORDSIZE
+
+typedef uint8_t  u8;
+typedef uint16_t u16;
+typedef uint32_t u32;
+typedef uint64_t u64;
+
+#ifndef PAGE_SIZE
+# define PAGE_SIZE 4096
+#endif
+extern const char raid6_empty_zero_page[PAGE_SIZE];
+
+#define __init
+#define __exit
+#define __attribute_const__ __attribute__((const))
+#define noinline __attribute__((noinline))
+
+#define preempt_enable()
+#define preempt_disable()
+#define cpu_has_feature(x) 1
+#define enable_kernel_altivec()
+#define disable_kernel_altivec()
+
+#define EXPORT_SYMBOL(sym)
+#define MODULE_LICENSE(licence)
+#define subsys_initcall(x)
+#define module_exit(x)
+#endif /* __KERNEL__ */
+
+/* Routine choices */
+struct raid6_calls {
+        void (*gen_syndrome)(int, size_t, void **);
+        int  (*valid)(void);    /* Returns 1 if this routine set is usable */
+        const char *name;       /* Name of this routine set */
+        int prefer;             /* Has special performance attribute */
+};
+
+/* Selected algorithm */
+extern struct raid6_calls raid6_call;
+
+/* Algorithm list */
+extern const struct raid6_calls * const raid6_algos[];
+int raid6_select_algo(void);
+
+/* Return values from chk_syndrome */
+#define RAID6_OK        0
+#define RAID6_P_BAD     1
+#define RAID6_Q_BAD     2
+#define RAID6_PQ_BAD    3
+
+/* Galois field tables */
+extern const u8 raid6_gfmul[256][256] __attribute__((aligned(256)));
+extern const u8 raid6_gfexp[256]      __attribute__((aligned(256)));
+extern const u8 raid6_gfinv[256]      __attribute__((aligned(256)));
+extern const u8 raid6_gfexi[256]      __attribute__((aligned(256)));
+
+/* Recovery routines */
+void raid6_2data_recov(int disks, size_t bytes, int faila, int failb,
+                       void **ptrs);
+void raid6_datap_recov(int disks, size_t bytes, int faila, void **ptrs);
+void raid6_dual_recov(int disks, size_t bytes, int faila, int failb,
+                      void **ptrs);
+
+/* Some definitions to allow code to be compiled for testing in userspace */
+#ifndef __KERNEL__
+
+# define jiffies        raid6_jiffies()
+# define printk         printf
+# define GFP_KERNEL     0
+# define __get_free_pages(x, y) ((unsigned long)mmap(NULL, PAGE_SIZE << (y), \
+                                                     PROT_READ|PROT_WRITE,   \
+                                                     MAP_PRIVATE|MAP_ANONYMOUS,\
+                                                     0, 0))
+# define free_pages(x, y)       munmap((void *)(x), (y)*PAGE_SIZE)
+
+static inline void cpu_relax(void)
+{
+        /* Nothing */
+}
+
+#undef  HZ
+#define HZ 1000
+static inline uint32_t raid6_jiffies(void)
+{
+        struct timeval tv;
+        gettimeofday(&tv, NULL);
+        return tv.tv_sec*1000 + tv.tv_usec/1000;
+}
+
+#endif /* ! __KERNEL__ */
+
+#endif /* LINUX_RAID_RAID6_H */
diff --git a/include/linux/raid/raid0.h b/include/linux/raid/raid0.h
deleted file mode 100644
index fd42aa87c391..000000000000
--- a/include/linux/raid/raid0.h
+++ /dev/null
@@ -1,30 +0,0 @@
-#ifndef _RAID0_H
-#define _RAID0_H
-
-#include <linux/raid/md.h>
-
-struct strip_zone
-{
-        sector_t zone_start;    /* Zone offset in md_dev (in sectors) */
-        sector_t dev_start;     /* Zone offset in real dev (in sectors) */
-        sector_t sectors;       /* Zone size in sectors */
-        int nb_dev;             /* # of devices attached to the zone */
-        mdk_rdev_t **dev;       /* Devices attached to the zone */
-};
-
-struct raid0_private_data
-{
-        struct strip_zone **hash_table; /* Table of indexes into strip_zone */
-        struct strip_zone *strip_zone;
-        mdk_rdev_t **devlist; /* lists of rdevs, pointed to by strip_zone->dev */
-        int nr_strip_zones;
-
-        sector_t spacing;
-        int sector_shift; /* shift this before divide by spacing */
-};
-
-typedef struct raid0_private_data raid0_conf_t;
-
-#define mddev_to_conf(mddev) ((raid0_conf_t *) mddev->private)
-
-#endif
diff --git a/include/linux/raid/raid1.h b/include/linux/raid/raid1.h
deleted file mode 100644
index 0a9ba7c3302e..000000000000
--- a/include/linux/raid/raid1.h
+++ /dev/null
@@ -1,134 +0,0 @@
-#ifndef _RAID1_H
-#define _RAID1_H
-
-#include <linux/raid/md.h>
-
-typedef struct mirror_info mirror_info_t;
-
-struct mirror_info {
-        mdk_rdev_t      *rdev;
-        sector_t        head_position;
-};
-
-/*
- * memory pools need a pointer to the mddev, so they can force an unplug
- * when memory is tight, and a count of the number of drives that the
- * pool was allocated for, so they know how much to allocate and free.
- * mddev->raid_disks cannot be used, as it can change while a pool is active
- * These two datums are stored in a kmalloced struct.
- */
-
-struct pool_info {
-        mddev_t *mddev;
-        int     raid_disks;
-};
-
-
-typedef struct r1bio_s r1bio_t;
-
-struct r1_private_data_s {
-        mddev_t                 *mddev;
-        mirror_info_t           *mirrors;
-        int                     raid_disks;
-        int                     last_used;
-        sector_t                next_seq_sect;
-        spinlock_t              device_lock;
-
-        struct list_head        retry_list;
-        /* queue pending writes and submit them on unplug */
-        struct bio_list         pending_bio_list;
-        /* queue of writes that have been unplugged */
-        struct bio_list         flushing_bio_list;
-
-        /* for use when syncing mirrors: */
-
-        spinlock_t              resync_lock;
-        int                     nr_pending;
-        int                     nr_waiting;
-        int                     nr_queued;
-        int                     barrier;
-        sector_t                next_resync;
-        int                     fullsync;  /* set to 1 if a full sync is needed,
-                                            * (fresh device added).
-                                            * Cleared when a sync completes.
-                                            */
-
-        wait_queue_head_t       wait_barrier;
-
-        struct pool_info        *poolinfo;
-
-        struct page             *tmppage;
-
-        mempool_t *r1bio_pool;
-        mempool_t *r1buf_pool;
-};
-
-typedef struct r1_private_data_s conf_t;
-
-/*
- * this is the only point in the RAID code where we violate
- * C type safety. mddev->private is an 'opaque' pointer.
- */
-#define mddev_to_conf(mddev) ((conf_t *) mddev->private)
-
-/*
- * this is our 'private' RAID1 bio.
- *
- * it contains information about what kind of IO operations were started
- * for this RAID1 operation, and about their status:
- */
-
-struct r1bio_s {
-        atomic_t                remaining; /* 'have we finished' count,
-                                            * used from IRQ handlers
-                                            */
-        atomic_t                behind_remaining; /* number of write-behind ios remaining
-                                                 * in this BehindIO request
-                                                 */
-        sector_t                sector;
-        int                     sectors;
-        unsigned long           state;
-        mddev_t                 *mddev;
-        /*
-         * original bio going to /dev/mdx
-         */
-        struct bio              *master_bio;
-        /*
-         * if the IO is in READ direction, then this is where we read
-         */
-        int                     read_disk;
-
-        struct list_head        retry_list;
-        struct bitmap_update    *bitmap_update;
-        /*
-         * if the IO is in WRITE direction, then multiple bios are used.
-         * We choose the number when they are allocated.
-         */
-        struct bio              *bios[0];
-        /* DO NOT PUT ANY NEW FIELDS HERE - bios array is contiguously alloced*/
-};
-
-/* when we get a read error on a read-only array, we redirect to another
- * device without failing the first device, or trying to over-write to
- * correct the read error.  To keep track of bad blocks on a per-bio
- * level, we store IO_BLOCKED in the appropriate 'bios' pointer
- */
-#define IO_BLOCKED ((struct bio*)1)
-
-/* bits for r1bio.state */
-#define R1BIO_Uptodate  0
-#define R1BIO_IsSync    1
-#define R1BIO_Degraded  2
-#define R1BIO_BehindIO  3
-#define R1BIO_Barrier   4
-#define R1BIO_BarrierRetry 5
-/* For write-behind requests, we call bi_end_io when
- * the last non-write-behind device completes, providing
- * any write was successful.  Otherwise we call when
- * any write-behind write succeeds, otherwise we call
- * with failure when last write completes (and all failed).
- * Record that bi_end_io was called with this flag...
- */
-#define R1BIO_Returned 6
-
-#endif
diff --git a/include/linux/raid/raid10.h b/include/linux/raid/raid10.h
deleted file mode 100644
index e9091cfeb286..000000000000
--- a/include/linux/raid/raid10.h
+++ /dev/null
@@ -1,123 +0,0 @@
-#ifndef _RAID10_H
-#define _RAID10_H
-
-#include <linux/raid/md.h>
-
-typedef struct mirror_info mirror_info_t;
-
-struct mirror_info {
-        mdk_rdev_t      *rdev;
-        sector_t        head_position;
-};
-
-typedef struct r10bio_s r10bio_t;
-
-struct r10_private_data_s {
-        mddev_t                 *mddev;
-        mirror_info_t           *mirrors;
-        int                     raid_disks;
-        spinlock_t              device_lock;
-
-        /* geometry */
-        int                     near_copies;  /* number of copies layed out raid0 style */
-        int                     far_copies;   /* number of copies layed out
-                                               * at large strides across drives
-                                               */
-        int                     far_offset;   /* far_copies are offset by 1 stripe
-                                               * instead of many
-                                               */
-        int                     copies;       /* near_copies * far_copies.
-                                               * must be <= raid_disks
-                                               */
-        sector_t                stride;       /* distance between far copies.
-                                               * This is size / far_copies unless
-                                               * far_offset, in which case it is
-                                               * 1 stripe.
-                                               */
-
-        int chunk_shift; /* shift from chunks to sectors */
-        sector_t chunk_mask;
-
-        struct list_head        retry_list;
-        /* queue pending writes and submit them on unplug */
-        struct bio_list         pending_bio_list;
-
-
-        spinlock_t              resync_lock;
-        int nr_pending;
-        int nr_waiting;
-        int nr_queued;
-        int barrier;
-        sector_t                next_resync;
-        int                     fullsync;  /* set to 1 if a full sync is needed,
-                                            * (fresh device added).
-                                            * Cleared when a sync completes.
-                                            */
-
-        wait_queue_head_t       wait_barrier;
-
-        mempool_t *r10bio_pool;
-        mempool_t *r10buf_pool;
-        struct page             *tmppage;
-};
-
-typedef struct r10_private_data_s conf_t;
-
-/*
- * this is the only point in the RAID code where we violate
- * C type safety. mddev->private is an 'opaque' pointer.
- */
-#define mddev_to_conf(mddev) ((conf_t *) mddev->private)
-
-/*
- * this is our 'private' RAID10 bio.
- *
- * it contains information about what kind of IO operations were started
- * for this RAID10 operation, and about their status:
- */
-
-struct r10bio_s {
-        atomic_t                remaining; /* 'have we finished' count,
-                                            * used from IRQ handlers
-                                            */
-        sector_t                sector; /* virtual sector number */
-        int                     sectors;
-        unsigned long           state;
-        mddev_t                 *mddev;
-        /*
-         * original bio going to /dev/mdx
-         */
-        struct bio              *master_bio;
-        /*
-         * if the IO is in READ direction, then this is where we read
-         */
-        int                     read_slot;
-
-        struct list_head        retry_list;
-        /*
-         * if the IO is in WRITE direction, then multiple bios are used,
-         * one for each copy.
-         * When resyncing we also use one for each copy.
-         * When reconstructing, we use 2 bios, one for read, one for write.
-         * We choose the number when they are allocated.
-         */
-        struct {
-                struct bio              *bio;
-                sector_t addr;
-                int devnum;
-        } devs[0];
-};
-
-/* when we get a read error on a read-only array, we redirect to another
- * device without failing the first device, or trying to over-write to
- * correct the read error.  To keep track of bad blocks on a per-bio
- * level, we store IO_BLOCKED in the appropriate 'bios' pointer
- */
-#define IO_BLOCKED ((struct bio*)1)
-
-/* bits for r10bio.state */
-#define R10BIO_Uptodate 0
-#define R10BIO_IsSync   1
-#define R10BIO_IsRecover 2
-#define R10BIO_Degraded 3
-#endif
diff --git a/include/linux/raid/raid5.h b/include/linux/raid/raid5.h
deleted file mode 100644
index 3b2672792457..000000000000
--- a/include/linux/raid/raid5.h
+++ /dev/null
@@ -1,402 +0,0 @@
-#ifndef _RAID5_H
-#define _RAID5_H
-
-#include <linux/raid/md.h>
-#include <linux/raid/xor.h>
-
-/*
- *
- * Each stripe contains one buffer per disc.  Each buffer can be in
- * one of a number of states stored in "flags".  Changes between
- * these states happen *almost* exclusively under a per-stripe
- * spinlock.  Some very specific changes can happen in bi_end_io, and
- * these are not protected by the spin lock.
- *
- * The flag bits that are used to represent these states are:
- *   R5_UPTODATE and R5_LOCKED
- *
- * State Empty == !UPTODATE, !LOCK
- *        We have no data, and there is no active request
- * State Want == !UPTODATE, LOCK
- *        A read request is being submitted for this block
- * State Dirty == UPTODATE, LOCK
- *        Some new data is in this buffer, and it is being written out
- * State Clean == UPTODATE, !LOCK
- *        We have valid data which is the same as on disc
- *
- * The possible state transitions are:
- *
- *  Empty -> Want   - on read or write to get old data for  parity calc
- *  Empty -> Dirty  - on compute_parity to satisfy write/sync request.(RECONSTRUCT_WRITE)
- *  Empty -> Clean  - on compute_block when computing a block for failed drive
- *  Want  -> Empty  - on failed read
- *  Want  -> Clean  - on successful completion of read request
- *  Dirty -> Clean  - on successful completion of write request
- *  Dirty -> Clean  - on failed write
- *  Clean -> Dirty  - on compute_parity to satisfy write/sync (RECONSTRUCT or RMW)
- *
- * The Want->Empty, Want->Clean, Dirty->Clean, transitions
- * all happen in b_end_io at interrupt time.
- * Each sets the Uptodate bit before releasing the Lock bit.
- * This leaves one multi-stage transition:
- *    Want->Dirty->Clean
- * This is safe because thinking that a Clean buffer is actually dirty
- * will at worst delay some action, and the stripe will be scheduled
- * for attention after the transition is complete.
- *
- * There is one possibility that is not covered by these states.  That
- * is if one drive has failed and there is a spare being rebuilt.  We
- * can't distinguish between a clean block that has been generated
- * from parity calculations, and a clean block that has been
- * successfully written to the spare ( or to parity when resyncing).
- * To distingush these states we have a stripe bit STRIPE_INSYNC that
- * is set whenever a write is scheduled to the spare, or to the parity
- * disc if there is no spare.  A sync request clears this bit, and
- * when we find it set with no buffers locked, we know the sync is
- * complete.
- *
- * Buffers for the md device that arrive via make_request are attached
- * to the appropriate stripe in one of two lists linked on b_reqnext.
- * One list (bh_read) for read requests, one (bh_write) for write.
- * There should never be more than one buffer on the two lists
- * together, but we are not guaranteed of that so we allow for more.
- *
- * If a buffer is on the read list when the associated cache buffer is
- * Uptodate, the data is copied into the read buffer and it's b_end_io
- * routine is called.  This may happen in the end_request routine only
- * if the buffer has just successfully been read.  end_request should
- * remove the buffers from the list and then set the Uptodate bit on
- * the buffer.  Other threads may do this only if they first check
- * that the Uptodate bit is set.  Once they have checked that they may
- * take buffers off the read queue.
- *
- * When a buffer on the write list is committed for write it is copied
- * into the cache buffer, which is then marked dirty, and moved onto a
- * third list, the written list (bh_written).  Once both the parity
- * block and the cached buffer are successfully written, any buffer on
- * a written list can be returned with b_end_io.
- *
- * The write list and read list both act as fifos.  The read list is
- * protected by the device_lock.  The write and written lists are
- * protected by the stripe lock.  The device_lock, which can be
- * claimed while the stipe lock is held, is only for list
- * manipulations and will only be held for a very short time.  It can
- * be claimed from interrupts.
- *
- *
- * Stripes in the stripe cache can be on one of two lists (or on
- * neither).  The "inactive_list" contains stripes which are not
- * currently being used for any request.  They can freely be reused
- * for another stripe.  The "handle_list" contains stripes that need
- * to be handled in some way.  Both of these are fifo queues.  Each
- * stripe is also (potentially) linked to a hash bucket in the hash
- * table so that it can be found by sector number.  Stripes that are
- * not hashed must be on the inactive_list, and will normally be at
- * the front.  All stripes start life this way.
- *
- * The inactive_list, handle_list and hash bucket lists are all protected by the
- * device_lock.
- *  - stripes on the inactive_list never have their stripe_lock held.
- *  - stripes have a reference counter. If count==0, they are on a list.
- *  - If a stripe might need handling, STRIPE_HANDLE is set.
- *  - When refcount reaches zero, then if STRIPE_HANDLE it is put on
- *    handle_list else inactive_list
- *
- * This, combined with the fact that STRIPE_HANDLE is only ever
- * cleared while a stripe has a non-zero count means that if the
- * refcount is 0 and STRIPE_HANDLE is set, then it is on the
- * handle_list and if recount is 0 and STRIPE_HANDLE is not set, then
- * the stripe is on inactive_list.
- *
- * The possible transitions are:
- *  activate an unhashed/inactive stripe (get_active_stripe())
- *     lockdev check-hash unlink-stripe cnt++ clean-stripe hash-stripe unlockdev
- *  activate a hashed, possibly active stripe (get_active_stripe())
- *     lockdev check-hash if(!cnt++)unlink-stripe unlockdev
- *  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/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, 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.
- */
-
-/*
- * Operations state - intermediate states that are visible outside of sh->lock
- * In general _idle indicates nothing is running, _run indicates a data
- * processing operation is active, and _result means the data processing result
- * is stable and can be acted upon.  For simple operations like biofill and
- * compute that only have an _idle and _run state they are indicated with
- * sh->state flags (STRIPE_BIOFILL_RUN and STRIPE_COMPUTE_RUN)
- */
-/**
- * enum check_states - handles syncing / repairing a stripe
- * @check_state_idle - check operations are quiesced
- * @check_state_run - check operation is running
- * @check_state_result - set outside lock when check result is valid
- * @check_state_compute_run - check failed and we are repairing
- * @check_state_compute_result - set outside lock when compute result is valid
- */
-enum check_states {
-        check_state_idle = 0,
-        check_state_run, /* parity check */
-        check_state_check_result,
-        check_state_compute_run, /* parity repair */
-        check_state_compute_result,
-};
-
-/**
- * enum reconstruct_states - handles writing or expanding a stripe
- */
-enum reconstruct_states {
-        reconstruct_state_idle = 0,
-        reconstruct_state_prexor_drain_run,     /* prexor-write */
-        reconstruct_state_drain_run,            /* write */
-        reconstruct_state_run,                  /* expand */
-        reconstruct_state_prexor_drain_result,
-        reconstruct_state_drain_result,
-        reconstruct_state_result,
-};
-
-struct stripe_head {
-        struct hlist_node       hash;
-        struct list_head        lru;                    /* inactive_list or handle_list */
-        struct raid5_private_data       *raid_conf;
-        sector_t                sector;                 /* sector of this row */
-        int                     pd_idx;                 /* parity disk index */
-        unsigned long           state;                  /* state flags */
-        atomic_t                count;                  /* nr of active thread/requests */
-        spinlock_t              lock;
-        int                     bm_seq; /* sequence number for bitmap flushes */
-        int                     disks;                  /* disks in stripe */
-        enum check_states       check_state;
-        enum reconstruct_states reconstruct_state;
-        /* stripe_operations
-         * @target - STRIPE_OP_COMPUTE_BLK target
-         */
-        struct stripe_operations {
-                int                target;
-                u32                zero_sum_result;
-        } ops;
-        struct r5dev {
-                struct bio      req;
-                struct bio_vec  vec;
-                struct page     *page;
-                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;
-        unsigned long ops_request;
-};
-
-/* 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" */
-#define R5_OVERWRITE    2       /* towrite covers whole page */
-/* and some that are internal to handle_stripe */
-#define R5_Insync       3       /* rdev && rdev->in_sync at start */
-#define R5_Wantread     4       /* want to schedule a read */
-#define R5_Wantwrite    5
-#define R5_Overlap      7       /* There is a pending overlapping request on this block */
-#define R5_ReadError    8       /* seen a read error here recently */
-#define R5_ReWrite      9       /* have tried to over-write the readerror */
-
-#define R5_Expanded     10      /* This block now has post-expand data */
-#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_Wantdrain    13 /* dev->towrite needs to be drained */
-/*
- * Write method
- */
-#define RECONSTRUCT_WRITE       1
-#define READ_MODIFY_WRITE       2
-/* not a write method, but a compute_parity mode */
-#define CHECK_PARITY            3
-
-/*
- * Stripe state
- */
-#define STRIPE_HANDLE           2
-#define STRIPE_SYNCING          3
-#define STRIPE_INSYNC           4
-#define STRIPE_PREREAD_ACTIVE   5
-#define STRIPE_DELAYED          6
-#define STRIPE_DEGRADED         7
-#define STRIPE_BIT_DELAY        8
-#define STRIPE_EXPANDING        9
-#define STRIPE_EXPAND_SOURCE    10
-#define STRIPE_EXPAND_READY     11
-#define STRIPE_IO_STARTED       12 /* do not count towards 'bypass_count' */
-#define STRIPE_FULL_WRITE       13 /* all blocks are set to be overwritten */
-#define STRIPE_BIOFILL_RUN      14
-#define STRIPE_COMPUTE_RUN      15
-/*
- * Operation request flags
- */
-#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
-
-/*
- * Plugging:
- *
- * To improve write throughput, we need to delay the handling of some
- * stripes until there has been a chance that several write requests
- * for the one stripe have all been collected.
- * In particular, any write request that would require pre-reading
- * is put on a "delayed" queue until there are no stripes currently
- * in a pre-read phase.  Further, if the "delayed" queue is empty when
- * a stripe is put on it then we "plug" the queue and do not process it
- * until an unplug call is made. (the unplug_io_fn() is called).
- *
- * When preread is initiated on a stripe, we set PREREAD_ACTIVE and add
- * it to the count of prereading stripes.
- * When write is initiated, or the stripe refcnt == 0 (just in case) we
- * clear the PREREAD_ACTIVE flag and decrement the count
- * Whenever the 'handle' queue is empty and the device is not plugged, we
- * move any strips from delayed to handle and clear the DELAYED flag and set
- * PREREAD_ACTIVE.
- * In stripe_handle, if we find pre-reading is necessary, we do it if
- * PREREAD_ACTIVE is set, else we set DELAYED which will send it to the delayed queue.
- * HANDLE gets cleared if stripe_handle leave nothing locked.
- */
- 
-
-struct disk_info {
-        mdk_rdev_t      *rdev;
-};
-
-struct raid5_private_data {
-        struct hlist_head       *stripe_hashtbl;
-        mddev_t                 *mddev;
-        struct disk_info        *spare;
-        int                     chunk_size, level, algorithm;
-        int                     max_degraded;
-        int                     raid_disks;
-        int                     max_nr_stripes;
-
-        /* used during an expand */
-        sector_t                expand_progress;        /* MaxSector when no expand happening */
-        sector_t                expand_lo; /* from here up to expand_progress it out-of-bounds
-                                            * as we haven't flushed the metadata yet
-                                            */
-        int                     previous_raid_disks;
-
-        struct list_head        handle_list; /* stripes needing handling */
-        struct list_head        hold_list; /* preread ready stripes */
-        struct list_head        delayed_list; /* stripes that have plugged requests */
-        struct list_head        bitmap_list; /* stripes delaying awaiting bitmap update */
-        struct bio              *retry_read_aligned; /* currently retrying aligned bios   */
-        struct bio              *retry_read_aligned_list; /* aligned bios retry list  */
-        atomic_t                preread_active_stripes; /* stripes with scheduled io */
-        atomic_t                active_aligned_reads;
-        atomic_t                pending_full_writes; /* full write backlog */
-        int                     bypass_count; /* bypassed prereads */
-        int                     bypass_threshold; /* preread nice */
-        struct list_head        *last_hold; /* detect hold_list promotions */
-
-        atomic_t                reshape_stripes; /* stripes with pending writes for reshape */
-        /* unfortunately we need two cache names as we temporarily have
-         * two caches.
-         */
-        int                     active_name;
-        char                    cache_name[2][20];
-        struct kmem_cache               *slab_cache; /* for allocating stripes */
-
-        int                     seq_flush, seq_write;
-        int                     quiesce;
-
-        int                     fullsync;  /* set to 1 if a full sync is needed,
-                                            * (fresh device added).
-                                            * Cleared when a sync completes.
-                                            */
-
-        struct page             *spare_page; /* Used when checking P/Q in raid6 */
-
-        /*
-         * Free stripes pool
-         */
-        atomic_t                active_stripes;
-        struct list_head        inactive_list;
-        wait_queue_head_t       wait_for_stripe;
-        wait_queue_head_t       wait_for_overlap;
-        int                     inactive_blocked;       /* release of inactive stripes blocked,
-                                                         * waiting for 25% to be free
-                                                         */
-        int                     pool_size; /* number of disks in stripeheads in pool */
-        spinlock_t              device_lock;
-        struct disk_info        *disks;
-};
-
-typedef struct raid5_private_data raid5_conf_t;
-
-#define mddev_to_conf(mddev) ((raid5_conf_t *) mddev->private)
-
-/*
- * Our supported algorithms
- */
-#define ALGORITHM_LEFT_ASYMMETRIC       0
-#define ALGORITHM_RIGHT_ASYMMETRIC      1
-#define ALGORITHM_LEFT_SYMMETRIC        2
-#define ALGORITHM_RIGHT_SYMMETRIC       3
-
-#endif
diff --git a/include/linux/raid/xor.h b/include/linux/raid/xor.h
index 3e120587eada..5a210959e3f8 100644
--- a/include/linux/raid/xor.h
+++ b/include/linux/raid/xor.h
@@ -1,8 +1,6 @@
 #ifndef _XOR_H
 #define _XOR_H
 
-#include <linux/raid/md.h>
-
 #define MAX_XOR_BLOCKS 4
 
 extern void xor_blocks(unsigned int count, unsigned int bytes,
diff --git a/include/linux/rcuclassic.h b/include/linux/rcuclassic.h
index 80044a4f3ab9..bfd92e1e5d2c 100644
--- a/include/linux/rcuclassic.h
+++ b/include/linux/rcuclassic.h
@@ -36,7 +36,6 @@
 #include <linux/cache.h>
 #include <linux/spinlock.h>
 #include <linux/threads.h>
-#include <linux/percpu.h>
 #include <linux/cpumask.h>
 #include <linux/seqlock.h>
 
@@ -108,25 +107,14 @@ struct rcu_data {
         struct rcu_head barrier;
 };
 
-DECLARE_PER_CPU(struct rcu_data, rcu_data);
-DECLARE_PER_CPU(struct rcu_data, rcu_bh_data);
-
 /*
  * Increment the quiescent state counter.
  * The counter is a bit degenerated: We do not need to know
  * how many quiescent states passed, just if there was at least
  * one since the start of the grace period. Thus just a flag.
  */
-static inline void rcu_qsctr_inc(int cpu)
-{
-        struct rcu_data *rdp = &per_cpu(rcu_data, cpu);
-        rdp->passed_quiesc = 1;
-}
-static inline void rcu_bh_qsctr_inc(int cpu)
-{
-        struct rcu_data *rdp = &per_cpu(rcu_bh_data, cpu);
-        rdp->passed_quiesc = 1;
-}
+extern void rcu_qsctr_inc(int cpu);
+extern void rcu_bh_qsctr_inc(int cpu);
 
 extern int rcu_pending(int cpu);
 extern int rcu_needs_cpu(int cpu);
diff --git a/include/linux/rcupdate.h b/include/linux/rcupdate.h
index 528343e6da51..15fbb3ca634d 100644
--- a/include/linux/rcupdate.h
+++ b/include/linux/rcupdate.h
@@ -36,7 +36,6 @@
 #include <linux/cache.h>
 #include <linux/spinlock.h>
 #include <linux/threads.h>
-#include <linux/percpu.h>
 #include <linux/cpumask.h>
 #include <linux/seqlock.h>
 #include <linux/lockdep.h>
diff --git a/include/linux/rcupreempt.h b/include/linux/rcupreempt.h
index 74304b4538d8..fce522782ffa 100644
--- a/include/linux/rcupreempt.h
+++ b/include/linux/rcupreempt.h
@@ -36,34 +36,19 @@
 #include <linux/cache.h>
 #include <linux/spinlock.h>
 #include <linux/threads.h>
-#include <linux/percpu.h>
+#include <linux/smp.h>
 #include <linux/cpumask.h>
 #include <linux/seqlock.h>
 
-struct rcu_dyntick_sched {
-        int dynticks;
-        int dynticks_snap;
-        int sched_qs;
-        int sched_qs_snap;
-        int sched_dynticks_snap;
-};
-
-DECLARE_PER_CPU(struct rcu_dyntick_sched, rcu_dyntick_sched);
-
-static inline void rcu_qsctr_inc(int cpu)
-{
-        struct rcu_dyntick_sched *rdssp = &per_cpu(rcu_dyntick_sched, cpu);
-
-        rdssp->sched_qs++;
-}
-#define rcu_bh_qsctr_inc(cpu)
+extern void rcu_qsctr_inc(int cpu);
+static inline void rcu_bh_qsctr_inc(int cpu) { }
 
 /*
  * Someone might want to pass call_rcu_bh as a function pointer.
  * So this needs to just be a rename and not a macro function.
  *  (no parentheses)
  */
-#define call_rcu_bh             call_rcu
+#define call_rcu_bh             call_rcu
 
 /**
  * call_rcu_sched - Queue RCU callback for invocation after sched grace period.
@@ -117,30 +102,12 @@ extern struct rcupreempt_trace *rcupreempt_trace_cpu(int cpu);
 struct softirq_action;
 
 #ifdef CONFIG_NO_HZ
-
-static inline void rcu_enter_nohz(void)
-{
-        static DEFINE_RATELIMIT_STATE(rs, 10 * HZ, 1);
-
-        smp_mb(); /* CPUs seeing ++ must see prior RCU read-side crit sects */
-        __get_cpu_var(rcu_dyntick_sched).dynticks++;
-        WARN_ON_RATELIMIT(__get_cpu_var(rcu_dyntick_sched).dynticks & 0x1, &rs);
-}
-
-static inline void rcu_exit_nohz(void)
-{
-        static DEFINE_RATELIMIT_STATE(rs, 10 * HZ, 1);
-
-        __get_cpu_var(rcu_dyntick_sched).dynticks++;
-        smp_mb(); /* CPUs seeing ++ must see later RCU read-side crit sects */
-        WARN_ON_RATELIMIT(!(__get_cpu_var(rcu_dyntick_sched).dynticks & 0x1),
-                                &rs);
-}
-
-#else /* CONFIG_NO_HZ */
-#define rcu_enter_nohz()        do { } while (0)
-#define rcu_exit_nohz()         do { } while (0)
-#endif /* CONFIG_NO_HZ */
+extern void rcu_enter_nohz(void);
+extern void rcu_exit_nohz(void);
+#else
+# define rcu_enter_nohz()       do { } while (0)
+# define rcu_exit_nohz()        do { } while (0)
+#endif
 
 /*
  * A context switch is a grace period for rcupreempt synchronize_rcu()
diff --git a/include/linux/rcutree.h b/include/linux/rcutree.h
index a722fb67bb2d..58b2aa5312b9 100644
--- a/include/linux/rcutree.h
+++ b/include/linux/rcutree.h
@@ -33,7 +33,6 @@
 #include <linux/cache.h>
 #include <linux/spinlock.h>
 #include <linux/threads.h>
-#include <linux/percpu.h>
 #include <linux/cpumask.h>
 #include <linux/seqlock.h>
 
@@ -162,9 +161,8 @@ struct rcu_data {
         unsigned long offline_fqs;      /* Kicked due to being offline. */
         unsigned long resched_ipi;      /* Sent a resched IPI. */
 
-        /* 5) state to allow this CPU to force_quiescent_state on others */
+        /* 5) For future __rcu_pending statistics. */
         long n_rcu_pending;             /* rcu_pending() calls since boot. */
-        long n_rcu_pending_force_qs;    /* when to force quiescent states. */
 
         int cpu;
 };
@@ -236,30 +234,8 @@ struct rcu_state {
 #endif /* #ifdef CONFIG_NO_HZ */
 };
 
-extern struct rcu_state rcu_state;
-DECLARE_PER_CPU(struct rcu_data, rcu_data);
-
-extern struct rcu_state rcu_bh_state;
-DECLARE_PER_CPU(struct rcu_data, rcu_bh_data);
-
-/*
- * Increment the quiescent state counter.
- * The counter is a bit degenerated: We do not need to know
- * how many quiescent states passed, just if there was at least
- * one since the start of the grace period. Thus just a flag.
- */
-static inline void rcu_qsctr_inc(int cpu)
-{
-        struct rcu_data *rdp = &per_cpu(rcu_data, cpu);
-        rdp->passed_quiesc = 1;
-        rdp->passed_quiesc_completed = rdp->completed;
-}
-static inline void rcu_bh_qsctr_inc(int cpu)
-{
-        struct rcu_data *rdp = &per_cpu(rcu_bh_data, cpu);
-        rdp->passed_quiesc = 1;
-        rdp->passed_quiesc_completed = rdp->completed;
-}
+extern void rcu_qsctr_inc(int cpu);
+extern void rcu_bh_qsctr_inc(int cpu);
 
 extern int rcu_pending(int cpu);
 extern int rcu_needs_cpu(int cpu);
diff --git a/include/linux/regulator/bq24022.h b/include/linux/regulator/bq24022.h
index e84b0a9feda5..a6d014005d49 100644
--- a/include/linux/regulator/bq24022.h
+++ b/include/linux/regulator/bq24022.h
@@ -10,6 +10,8 @@
  *
  */
 
+struct regulator_init_data;
+
 /**
  * bq24022_mach_info - platform data for bq24022
  * @gpio_nce: GPIO line connected to the nCE pin, used to enable / disable charging
@@ -18,4 +20,5 @@
 struct bq24022_mach_info {
         int gpio_nce;
         int gpio_iset2;
+        struct regulator_init_data *init_data;
 };
diff --git a/include/linux/regulator/consumer.h b/include/linux/regulator/consumer.h
index 801bf77ff4e2..277f4b964df5 100644
--- a/include/linux/regulator/consumer.h
+++ b/include/linux/regulator/consumer.h
@@ -3,7 +3,7 @@
  *
  * Copyright (C) 2007, 2008 Wolfson Microelectronics PLC.
  *
- * Author: Liam Girdwood <lg@opensource.wolfsonmicro.com>
+ * Author: Liam Girdwood <lrg@slimlogic.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
@@ -88,6 +88,7 @@
  * FAIL           Regulator output has failed.
  * OVER_TEMP      Regulator over temp.
  * FORCE_DISABLE  Regulator shut down by software.
+ * VOLTAGE_CHANGE Regulator voltage changed.
  *
  * NOTE: These events can be OR'ed together when passed into handler.
  */
@@ -98,6 +99,7 @@
 #define REGULATOR_EVENT_FAIL                    0x08
 #define REGULATOR_EVENT_OVER_TEMP               0x10
 #define REGULATOR_EVENT_FORCE_DISABLE           0x20
+#define REGULATOR_EVENT_VOLTAGE_CHANGE          0x40
 
 struct regulator;
 
@@ -140,6 +142,8 @@ int regulator_bulk_disable(int num_consumers,
 void regulator_bulk_free(int num_consumers,
                          struct regulator_bulk_data *consumers);
 
+int regulator_count_voltages(struct regulator *regulator);
+int regulator_list_voltage(struct regulator *regulator, unsigned selector);
 int regulator_set_voltage(struct regulator *regulator, int min_uV, int max_uV);
 int regulator_get_voltage(struct regulator *regulator);
 int regulator_set_current_limit(struct regulator *regulator,
diff --git a/include/linux/regulator/driver.h b/include/linux/regulator/driver.h
index 2dae05705f13..225f733e7533 100644
--- a/include/linux/regulator/driver.h
+++ b/include/linux/regulator/driver.h
@@ -3,7 +3,7 @@
  *
  * Copyright (C) 2007, 2008 Wolfson Microelectronics PLC.
  *
- * Author: Liam Girdwood <lg@opensource.wolfsonmicro.com>
+ * Author: Liam Girdwood <lrg@slimlogic.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
@@ -21,25 +21,39 @@
 struct regulator_dev;
 struct regulator_init_data;
 
+enum regulator_status {
+        REGULATOR_STATUS_OFF,
+        REGULATOR_STATUS_ON,
+        REGULATOR_STATUS_ERROR,
+        /* fast/normal/idle/standby are flavors of "on" */
+        REGULATOR_STATUS_FAST,
+        REGULATOR_STATUS_NORMAL,
+        REGULATOR_STATUS_IDLE,
+        REGULATOR_STATUS_STANDBY,
+};
+
 /**
  * struct regulator_ops - regulator operations.
  *
- * This struct describes regulator operations which can be implemented by
- * regulator chip drivers.
- *
- * @enable: Enable the regulator.
- * @disable: Disable the regulator.
+ * @enable: Configure the regulator as enabled.
+ * @disable: Configure the regulator as disabled.
  * @is_enabled: Return 1 if the regulator is enabled, 0 otherwise.
  *
  * @set_voltage: Set the voltage for the regulator within the range specified.
  *               The driver should select the voltage closest to min_uV.
  * @get_voltage: Return the currently configured voltage for the regulator.
+ * @list_voltage: Return one of the supported voltages, in microvolts; zero
+ *      if the selector indicates a voltage that is unusable on this system;
+ *      or negative errno.  Selectors range from zero to one less than
+ *      regulator_desc.n_voltages.  Voltages may be reported in any order.
  *
  * @set_current_limit: Configure a limit for a current-limited regulator.
- * @get_current_limit: Get the limit for a current-limited regulator.
+ * @get_current_limit: Get the configured limit for a current-limited regulator.
  *
- * @set_mode: Set the operating mode for the regulator.
- * @get_mode: Get the current operating mode for the regulator.
+ * @set_mode: Set the configured operating mode for the regulator.
+ * @get_mode: Get the configured operating mode for the regulator.
+ * @get_status: Return actual (not as-configured) status of regulator, as a
+ *      REGULATOR_STATUS value (or negative errno)
  * @get_optimum_mode: Get the most efficient operating mode for the regulator
  *                    when running with the specified parameters.
  *
@@ -51,9 +65,15 @@ struct regulator_init_data;
  *                       suspended.
  * @set_suspend_mode: Set the operating mode for the regulator when the
  *                    system is suspended.
+ *
+ * This struct describes regulator operations which can be implemented by
+ * regulator chip drivers.
  */
 struct regulator_ops {
 
+        /* enumerate supported voltages */
+        int (*list_voltage) (struct regulator_dev *, unsigned selector);
+
         /* get/set regulator voltage */
         int (*set_voltage) (struct regulator_dev *, int min_uV, int max_uV);
         int (*get_voltage) (struct regulator_dev *);
@@ -72,6 +92,13 @@ struct regulator_ops {
         int (*set_mode) (struct regulator_dev *, unsigned int mode);
         unsigned int (*get_mode) (struct regulator_dev *);
 
+        /* report regulator status ... most other accessors report
+         * control inputs, this reports results of combining inputs
+         * from Linux (and other sources) with the actual load.
+         * returns REGULATOR_STATUS_* or negative errno.
+         */
+        int (*get_status)(struct regulator_dev *);
+
         /* get most efficient regulator operating mode for load */
         unsigned int (*get_optimum_mode) (struct regulator_dev *, int input_uV,
                                           int output_uV, int load_uA);
@@ -106,6 +133,7 @@ enum regulator_type {
  *
  * @name: Identifying name for the regulator.
  * @id: Numerical identifier for the regulator.
+ * @n_voltages: Number of selectors available for ops.list_voltage().
  * @ops: Regulator operations table.
  * @irq: Interrupt number for the regulator.
  * @type: Indicates if the regulator is a voltage or current regulator.
@@ -114,14 +142,48 @@ enum regulator_type {
 struct regulator_desc {
         const char *name;
         int id;
+        unsigned n_voltages;
         struct regulator_ops *ops;
         int irq;
         enum regulator_type type;
         struct module *owner;
 };
 
+/*
+ * struct regulator_dev
+ *
+ * Voltage / Current regulator class device. One for each
+ * regulator.
+ *
+ * This should *not* be used directly by anything except the regulator
+ * core and notification injection (which should take the mutex and do
+ * no other direct access).
+ */
+struct regulator_dev {
+        struct regulator_desc *desc;
+        int use_count;
+
+        /* lists we belong to */
+        struct list_head list; /* list of all regulators */
+        struct list_head slist; /* list of supplied regulators */
+
+        /* lists we own */
+        struct list_head consumer_list; /* consumers we supply */
+        struct list_head supply_list; /* regulators we supply */
+
+        struct blocking_notifier_head notifier;
+        struct mutex mutex; /* consumer lock */
+        struct module *owner;
+        struct device dev;
+        struct regulation_constraints *constraints;
+        struct regulator_dev *supply;   /* for tree */
+
+        void *reg_data;         /* regulator_dev data */
+};
+
 struct regulator_dev *regulator_register(struct regulator_desc *regulator_desc,
-        struct device *dev, void *driver_data);
+        struct device *dev, struct regulator_init_data *init_data,
+        void *driver_data);
 void regulator_unregister(struct regulator_dev *rdev);
 
 int regulator_notifier_call_chain(struct regulator_dev *rdev,
diff --git a/include/linux/regulator/fixed.h b/include/linux/regulator/fixed.h
index 1387a5d2190e..91b4da31f1b5 100644
--- a/include/linux/regulator/fixed.h
+++ b/include/linux/regulator/fixed.h
@@ -14,9 +14,12 @@
 #ifndef __REGULATOR_FIXED_H
 #define __REGULATOR_FIXED_H
 
+struct regulator_init_data;
+
 struct fixed_voltage_config {
         const char *supply_name;
         int microvolts;
+        struct regulator_init_data *init_data;
 };
 
 #endif
diff --git a/include/linux/regulator/machine.h b/include/linux/regulator/machine.h
index 3794773b23d2..bac64fa390f2 100644
--- a/include/linux/regulator/machine.h
+++ b/include/linux/regulator/machine.h
@@ -3,7 +3,7 @@
  *
  * Copyright (C) 2007, 2008 Wolfson Microelectronics PLC.
  *
- * Author: Liam Girdwood <lg@opensource.wolfsonmicro.com>
+ * Author: Liam Girdwood <lrg@slimlogic.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
@@ -73,7 +73,9 @@ struct regulator_state {
  *
  * @always_on: Set if the regulator should never be disabled.
  * @boot_on: Set if the regulator is enabled when the system is initially
- *           started.
+ *           started.  If the regulator is not enabled by the hardware or
+ *           bootloader then it will be enabled when the constraints are
+ *           applied.
  * @apply_uV: Apply the voltage constraint when initialising.
  *
  * @input_uV: Input voltage for regulator when supplied by another regulator.
@@ -83,6 +85,7 @@ struct regulator_state {
  * @state_standby: State for regulator when system is suspended in standby
  *                 mode.
  * @initial_state: Suspend state to set by default.
+ * @initial_mode: Mode to set at startup.
  */
 struct regulation_constraints {
 
@@ -111,6 +114,9 @@ struct regulation_constraints {
         struct regulator_state state_standby;
         suspend_state_t initial_state; /* suspend state to set at init */
 
+        /* mode to set on startup */
+        unsigned int initial_mode;
+
         /* constriant flags */
         unsigned always_on:1;   /* regulator never off when system is on */
         unsigned boot_on:1;     /* bootloader/firmware enabled regulator */
@@ -160,4 +166,6 @@ struct regulator_init_data {
 
 int regulator_suspend_prepare(suspend_state_t state);
 
+void regulator_has_full_constraints(void);
+
 #endif
diff --git a/include/linux/reiserfs_acl.h b/include/linux/reiserfs_acl.h
index fe00f781a622..8cc65757e47a 100644
--- a/include/linux/reiserfs_acl.h
+++ b/include/linux/reiserfs_acl.h
@@ -49,13 +49,12 @@ static inline int reiserfs_acl_count(size_t size)
 #ifdef CONFIG_REISERFS_FS_POSIX_ACL
 struct posix_acl *reiserfs_get_acl(struct inode *inode, int type);
 int reiserfs_acl_chmod(struct inode *inode);
-int reiserfs_inherit_default_acl(struct inode *dir, struct dentry *dentry,
+int reiserfs_inherit_default_acl(struct reiserfs_transaction_handle *th,
+                                 struct inode *dir, struct dentry *dentry,
                                  struct inode *inode);
 int reiserfs_cache_default_acl(struct inode *dir);
-extern int reiserfs_xattr_posix_acl_init(void) __init;
-extern int reiserfs_xattr_posix_acl_exit(void);
-extern struct reiserfs_xattr_handler posix_acl_default_handler;
-extern struct reiserfs_xattr_handler posix_acl_access_handler;
+extern struct xattr_handler reiserfs_posix_acl_default_handler;
+extern struct xattr_handler reiserfs_posix_acl_access_handler;
 
 static inline void reiserfs_init_acl_access(struct inode *inode)
 {
@@ -75,23 +74,14 @@ static inline struct posix_acl *reiserfs_get_acl(struct inode *inode, int type)
         return NULL;
 }
 
-static inline int reiserfs_xattr_posix_acl_init(void)
-{
-        return 0;
-}
-
-static inline int reiserfs_xattr_posix_acl_exit(void)
-{
-        return 0;
-}
-
 static inline int reiserfs_acl_chmod(struct inode *inode)
 {
         return 0;
 }
 
 static inline int
-reiserfs_inherit_default_acl(const struct inode *dir, struct dentry *dentry,
+reiserfs_inherit_default_acl(struct reiserfs_transaction_handle *th,
+                             const struct inode *dir, struct dentry *dentry,
                              struct inode *inode)
 {
         return 0;
diff --git a/include/linux/reiserfs_fs.h b/include/linux/reiserfs_fs.h
index e356c99f0659..2245c78d5876 100644
--- a/include/linux/reiserfs_fs.h
+++ b/include/linux/reiserfs_fs.h
@@ -58,8 +58,6 @@
 #define reiserfs_write_lock( sb ) lock_kernel()
 #define reiserfs_write_unlock( sb ) unlock_kernel()
 
-/* xattr stuff */
-#define REISERFS_XATTR_DIR_SEM(s) (REISERFS_SB(s)->xattr_dir_sem)
 struct fid;
 
 /* in reading the #defines, it may help to understand that they employ
@@ -104,15 +102,21 @@ struct fid;
 */
 #define REISERFS_DEBUG_CODE 5   /* extra messages to help find/debug errors */
 
-void reiserfs_warning(struct super_block *s, const char *fmt, ...);
+void __reiserfs_warning(struct super_block *s, const char *id,
+                         const char *func, const char *fmt, ...);
+#define reiserfs_warning(s, id, fmt, args...) \
+         __reiserfs_warning(s, id, __func__, fmt, ##args)
 /* assertions handling */
 
 /** always check a condition and panic if it's false. */
-#define __RASSERT( cond, scond, format, args... )                                       \
-if( !( cond ) )                                                                 \
-  reiserfs_panic( NULL, "reiserfs[%i]: assertion " scond " failed at "  \
-                  __FILE__ ":%i:%s: " format "\n",              \
-                  in_interrupt() ? -1 : task_pid_nr(current), __LINE__ , __func__ , ##args )
+#define __RASSERT(cond, scond, format, args...)                 \
+do {                                                                    \
+        if (!(cond))                                                    \
+                reiserfs_panic(NULL, "assertion failure", "(" #cond ") at " \
+                               __FILE__ ":%i:%s: " format "\n",         \
+                               in_interrupt() ? -1 : task_pid_nr(current), \
+                               __LINE__, __func__ , ##args);            \
+} while (0)
 
 #define RASSERT(cond, format, args...) __RASSERT(cond, #cond, format, ##args)
 
@@ -196,7 +200,11 @@ struct reiserfs_super_block {
         __le32 s_flags;         /* Right now used only by inode-attributes, if enabled */
         unsigned char s_uuid[16];       /* filesystem unique identifier */
         unsigned char s_label[16];      /* filesystem volume label */
-        char s_unused[88];      /* zero filled by mkreiserfs and
+        __le16 s_mnt_count;             /* Count of mounts since last fsck */
+        __le16 s_max_mnt_count;         /* Maximum mounts before check */
+        __le32 s_lastcheck;             /* Timestamp of last fsck */
+        __le32 s_check_interval;        /* Interval between checks */
+        char s_unused[76];      /* zero filled by mkreiserfs and
                                  * reiserfs_convert_objectid_map_v1()
                                  * so any additions must be updated
                                  * there as well. */
@@ -578,10 +586,8 @@ static inline int uniqueness2type(__u32 uniqueness)
                 return TYPE_DIRECT;
         case V1_DIRENTRY_UNIQUENESS:
                 return TYPE_DIRENTRY;
-        default:
-                reiserfs_warning(NULL, "vs-500: unknown uniqueness %d",
-                                 uniqueness);
         case V1_ANY_UNIQUENESS:
+        default:
                 return TYPE_ANY;
         }
 }
@@ -598,9 +604,8 @@ static inline __u32 type2uniqueness(int type)
                 return V1_DIRECT_UNIQUENESS;
         case TYPE_DIRENTRY:
                 return V1_DIRENTRY_UNIQUENESS;
-        default:
-                reiserfs_warning(NULL, "vs-501: unknown type %d", type);
         case TYPE_ANY:
+        default:
                 return V1_ANY_UNIQUENESS;
         }
 }
@@ -712,9 +717,9 @@ static inline void cpu_key_k_offset_dec(struct cpu_key *key)
 #define is_indirect_cpu_ih(ih) (is_indirect_cpu_key (&((ih)->ih_key)))
 #define is_statdata_cpu_ih(ih) (is_statdata_cpu_key (&((ih)->ih_key)))
 
-#define I_K_KEY_IN_ITEM(p_s_ih, p_s_key, n_blocksize) \
-    ( ! COMP_SHORT_KEYS(p_s_ih, p_s_key) && \
-          I_OFF_BYTE_IN_ITEM(p_s_ih, k_offset (p_s_key), n_blocksize) )
+#define I_K_KEY_IN_ITEM(ih, key, n_blocksize) \
+    (!COMP_SHORT_KEYS(ih, key) && \
+          I_OFF_BYTE_IN_ITEM(ih, k_offset(key), n_blocksize))
 
 /* maximal length of item */
 #define MAX_ITEM_LEN(block_size) (block_size - BLKH_SIZE - IH_SIZE)
@@ -770,25 +775,25 @@ struct block_head {
 #define DISK_LEAF_NODE_LEVEL  1 /* Leaf node level. */
 
 /* Given the buffer head of a formatted node, resolve to the block head of that node. */
-#define B_BLK_HEAD(p_s_bh)            ((struct block_head *)((p_s_bh)->b_data))
+#define B_BLK_HEAD(bh)                  ((struct block_head *)((bh)->b_data))
 /* Number of items that are in buffer. */
-#define B_NR_ITEMS(p_s_bh)            (blkh_nr_item(B_BLK_HEAD(p_s_bh)))
-#define B_LEVEL(p_s_bh)               (blkh_level(B_BLK_HEAD(p_s_bh)))
-#define B_FREE_SPACE(p_s_bh)          (blkh_free_space(B_BLK_HEAD(p_s_bh)))
+#define B_NR_ITEMS(bh)                  (blkh_nr_item(B_BLK_HEAD(bh)))
+#define B_LEVEL(bh)                     (blkh_level(B_BLK_HEAD(bh)))
+#define B_FREE_SPACE(bh)                (blkh_free_space(B_BLK_HEAD(bh)))
 
-#define PUT_B_NR_ITEMS(p_s_bh,val)    do { set_blkh_nr_item(B_BLK_HEAD(p_s_bh),val); } while (0)
-#define PUT_B_LEVEL(p_s_bh,val)       do { set_blkh_level(B_BLK_HEAD(p_s_bh),val); } while (0)
-#define PUT_B_FREE_SPACE(p_s_bh,val)  do { set_blkh_free_space(B_BLK_HEAD(p_s_bh),val); } while (0)
+#define PUT_B_NR_ITEMS(bh, val)         do { set_blkh_nr_item(B_BLK_HEAD(bh), val); } while (0)
+#define PUT_B_LEVEL(bh, val)            do { set_blkh_level(B_BLK_HEAD(bh), val); } while (0)
+#define PUT_B_FREE_SPACE(bh, val)       do { set_blkh_free_space(B_BLK_HEAD(bh), val); } while (0)
 
 /* Get right delimiting key. -- little endian */
-#define B_PRIGHT_DELIM_KEY(p_s_bh)   (&(blk_right_delim_key(B_BLK_HEAD(p_s_bh))))
+#define B_PRIGHT_DELIM_KEY(bh)          (&(blk_right_delim_key(B_BLK_HEAD(bh))))
 
 /* Does the buffer contain a disk leaf. */
-#define B_IS_ITEMS_LEVEL(p_s_bh)     (B_LEVEL(p_s_bh) == DISK_LEAF_NODE_LEVEL)
+#define B_IS_ITEMS_LEVEL(bh)            (B_LEVEL(bh) == DISK_LEAF_NODE_LEVEL)
 
 /* Does the buffer contain a disk internal node */
-#define B_IS_KEYS_LEVEL(p_s_bh)      (B_LEVEL(p_s_bh) > DISK_LEAF_NODE_LEVEL \
-                                            && B_LEVEL(p_s_bh) <= MAX_HEIGHT)
+#define B_IS_KEYS_LEVEL(bh)      (B_LEVEL(bh) > DISK_LEAF_NODE_LEVEL \
+                                            && B_LEVEL(bh) <= MAX_HEIGHT)
 
 /***************************************************************************/
 /*                             STAT DATA                                   */
@@ -1138,12 +1143,13 @@ struct disk_child {
 #define put_dc_size(dc_p, val)   do { (dc_p)->dc_size = cpu_to_le16(val); } while(0)
 
 /* Get disk child by buffer header and position in the tree node. */
-#define B_N_CHILD(p_s_bh,n_pos)  ((struct disk_child *)\
-((p_s_bh)->b_data+BLKH_SIZE+B_NR_ITEMS(p_s_bh)*KEY_SIZE+DC_SIZE*(n_pos)))
+#define B_N_CHILD(bh, n_pos)  ((struct disk_child *)\
+((bh)->b_data + BLKH_SIZE + B_NR_ITEMS(bh) * KEY_SIZE + DC_SIZE * (n_pos)))
 
 /* Get disk child number by buffer header and position in the tree node. */
-#define B_N_CHILD_NUM(p_s_bh,n_pos) (dc_block_number(B_N_CHILD(p_s_bh,n_pos)))
-#define PUT_B_N_CHILD_NUM(p_s_bh,n_pos, val) (put_dc_block_number(B_N_CHILD(p_s_bh,n_pos), val ))
+#define B_N_CHILD_NUM(bh, n_pos) (dc_block_number(B_N_CHILD(bh, n_pos)))
+#define PUT_B_N_CHILD_NUM(bh, n_pos, val) \
+                                (put_dc_block_number(B_N_CHILD(bh, n_pos), val))
 
  /* maximal value of field child_size in structure disk_child */
  /* child size is the combined size of all items and their headers */
@@ -1214,33 +1220,33 @@ struct treepath {
 struct treepath var = {.path_length = ILLEGAL_PATH_ELEMENT_OFFSET, .reada = 0,}
 
 /* Get path element by path and path position. */
-#define PATH_OFFSET_PELEMENT(p_s_path,n_offset)  ((p_s_path)->path_elements +(n_offset))
+#define PATH_OFFSET_PELEMENT(path, n_offset)  ((path)->path_elements + (n_offset))
 
 /* Get buffer header at the path by path and path position. */
-#define PATH_OFFSET_PBUFFER(p_s_path,n_offset)   (PATH_OFFSET_PELEMENT(p_s_path,n_offset)->pe_buffer)
+#define PATH_OFFSET_PBUFFER(path, n_offset)   (PATH_OFFSET_PELEMENT(path, n_offset)->pe_buffer)
 
 /* Get position in the element at the path by path and path position. */
-#define PATH_OFFSET_POSITION(p_s_path,n_offset) (PATH_OFFSET_PELEMENT(p_s_path,n_offset)->pe_position)
+#define PATH_OFFSET_POSITION(path, n_offset) (PATH_OFFSET_PELEMENT(path, n_offset)->pe_position)
 
-#define PATH_PLAST_BUFFER(p_s_path) (PATH_OFFSET_PBUFFER((p_s_path), (p_s_path)->path_length))
+#define PATH_PLAST_BUFFER(path) (PATH_OFFSET_PBUFFER((path), (path)->path_length))
                                 /* you know, to the person who didn't
                                    write this the macro name does not
                                    at first suggest what it does.
                                    Maybe POSITION_FROM_PATH_END? Or
                                    maybe we should just focus on
                                    dumping paths... -Hans */
-#define PATH_LAST_POSITION(p_s_path) (PATH_OFFSET_POSITION((p_s_path), (p_s_path)->path_length))
+#define PATH_LAST_POSITION(path) (PATH_OFFSET_POSITION((path), (path)->path_length))
 
-#define PATH_PITEM_HEAD(p_s_path)    B_N_PITEM_HEAD(PATH_PLAST_BUFFER(p_s_path),PATH_LAST_POSITION(p_s_path))
+#define PATH_PITEM_HEAD(path)    B_N_PITEM_HEAD(PATH_PLAST_BUFFER(path), PATH_LAST_POSITION(path))
 
 /* in do_balance leaf has h == 0 in contrast with path structure,
    where root has level == 0. That is why we need these defines */
-#define PATH_H_PBUFFER(p_s_path, h) PATH_OFFSET_PBUFFER (p_s_path, p_s_path->path_length - (h)) /* tb->S[h] */
+#define PATH_H_PBUFFER(path, h) PATH_OFFSET_PBUFFER (path, path->path_length - (h))     /* tb->S[h] */
 #define PATH_H_PPARENT(path, h) PATH_H_PBUFFER (path, (h) + 1)  /* tb->F[h] or tb->S[0]->b_parent */
 #define PATH_H_POSITION(path, h) PATH_OFFSET_POSITION (path, path->path_length - (h))
 #define PATH_H_B_ITEM_ORDER(path, h) PATH_H_POSITION(path, h + 1)       /* tb->S[h]->b_item_order */
 
-#define PATH_H_PATH_OFFSET(p_s_path, n_h) ((p_s_path)->path_length - (n_h))
+#define PATH_H_PATH_OFFSET(path, n_h) ((path)->path_length - (n_h))
 
 #define get_last_bh(path) PATH_PLAST_BUFFER(path)
 #define get_ih(path) PATH_PITEM_HEAD(path)
@@ -1470,6 +1476,16 @@ struct buffer_info {
         int bi_position;
 };
 
+static inline struct super_block *sb_from_tb(struct tree_balance *tb)
+{
+        return tb ? tb->tb_sb : NULL;
+}
+
+static inline struct super_block *sb_from_bi(struct buffer_info *bi)
+{
+        return bi ? sb_from_tb(bi->tb) : NULL;
+}
+
 /* there are 4 types of items: stat data, directory item, indirect, direct.
 +-------------------+------------+--------------+------------+
 |                   |  k_offset  | k_uniqueness | mergeable? |
@@ -1520,7 +1536,7 @@ extern struct item_operations *item_ops[TYPE_ANY + 1];
 #define COMP_SHORT_KEYS comp_short_keys
 
 /* number of blocks pointed to by the indirect item */
-#define I_UNFM_NUM(p_s_ih)      ( ih_item_len(p_s_ih) / UNFM_P_SIZE )
+#define I_UNFM_NUM(ih)  (ih_item_len(ih) / UNFM_P_SIZE)
 
 /* the used space within the unformatted node corresponding to pos within the item pointed to by ih */
 #define I_POS_UNFM_SIZE(ih,pos,size) (((pos) == I_UNFM_NUM(ih) - 1 ) ? (size) - ih_free_space(ih) : (size))
@@ -1623,6 +1639,10 @@ struct reiserfs_journal_header {
 #define JOURNAL_MAX_COMMIT_AGE 30
 #define JOURNAL_MAX_TRANS_AGE 30
 #define JOURNAL_PER_BALANCE_CNT (3 * (MAX_HEIGHT-2) + 9)
+#define JOURNAL_BLOCKS_PER_OBJECT(sb)  (JOURNAL_PER_BALANCE_CNT * 3 + \
+                                         2 * (REISERFS_QUOTA_INIT_BLOCKS(sb) + \
+                                              REISERFS_QUOTA_TRANS_BLOCKS(sb)))
+
 #ifdef CONFIG_QUOTA
 /* We need to update data and inode (atime) */
 #define REISERFS_QUOTA_TRANS_BLOCKS(s) (REISERFS_SB(s)->s_mount_opt & (1<<REISERFS_QUOTA) ? 2 : 0)
@@ -1697,7 +1717,7 @@ struct reiserfs_transaction_handle {
         int t_refcount;
         int t_blocks_logged;    /* number of blocks this writer has logged */
         int t_blocks_allocated; /* number of blocks this writer allocated */
-        unsigned long t_trans_id;       /* sanity check, equals the current trans id */
+        unsigned int t_trans_id;        /* sanity check, equals the current trans id */
         void *t_handle_save;    /* save existing current->journal_info */
         unsigned displace_new_blocks:1; /* if new block allocation occurres, that block
                                            should be displaced from others */
@@ -1773,13 +1793,13 @@ int journal_end_sync(struct reiserfs_transaction_handle *, struct super_block *,
 int journal_mark_freed(struct reiserfs_transaction_handle *,
                        struct super_block *, b_blocknr_t blocknr);
 int journal_transaction_should_end(struct reiserfs_transaction_handle *, int);
-int reiserfs_in_journal(struct super_block *p_s_sb, unsigned int bmap_nr,
-                        int bit_nr, int searchall, b_blocknr_t *next);
+int reiserfs_in_journal(struct super_block *sb, unsigned int bmap_nr,
+                         int bit_nr, int searchall, b_blocknr_t *next);
 int journal_begin(struct reiserfs_transaction_handle *,
-                  struct super_block *p_s_sb, unsigned long);
+                  struct super_block *sb, unsigned long);
 int journal_join_abort(struct reiserfs_transaction_handle *,
-                       struct super_block *p_s_sb, unsigned long);
-void reiserfs_journal_abort(struct super_block *sb, int errno);
+                       struct super_block *sb, unsigned long);
+void reiserfs_abort_journal(struct super_block *sb, int errno);
 void reiserfs_abort(struct super_block *sb, int errno, const char *fmt, ...);
 int reiserfs_allocate_list_bitmaps(struct super_block *s,
                                    struct reiserfs_list_bitmap *, unsigned int);
@@ -1796,8 +1816,8 @@ int reiserfs_convert_objectid_map_v1(struct super_block *);
 
 /* stree.c */
 int B_IS_IN_TREE(const struct buffer_head *);
-extern void copy_item_head(struct item_head *p_v_to,
-                           const struct item_head *p_v_from);
+extern void copy_item_head(struct item_head *to,
+                           const struct item_head *from);
 
 // first key is in cpu form, second - le
 extern int comp_short_keys(const struct reiserfs_key *le_key,
@@ -1832,20 +1852,20 @@ static inline void copy_key(struct reiserfs_key *to,
         memcpy(to, from, KEY_SIZE);
 }
 
-int comp_items(const struct item_head *stored_ih, const struct treepath *p_s_path);
-const struct reiserfs_key *get_rkey(const struct treepath *p_s_chk_path,
-                                    const struct super_block *p_s_sb);
+int comp_items(const struct item_head *stored_ih, const struct treepath *path);
+const struct reiserfs_key *get_rkey(const struct treepath *chk_path,
+                                    const struct super_block *sb);
 int search_by_key(struct super_block *, const struct cpu_key *,
                   struct treepath *, int);
 #define search_item(s,key,path) search_by_key (s, key, path, DISK_LEAF_NODE_LEVEL)
-int search_for_position_by_key(struct super_block *p_s_sb,
-                               const struct cpu_key *p_s_cpu_key,
-                               struct treepath *p_s_search_path);
-extern void decrement_bcount(struct buffer_head *p_s_bh);
-void decrement_counters_in_path(struct treepath *p_s_search_path);
-void pathrelse(struct treepath *p_s_search_path);
+int search_for_position_by_key(struct super_block *sb,
+                               const struct cpu_key *cpu_key,
+                               struct treepath *search_path);
+extern void decrement_bcount(struct buffer_head *bh);
+void decrement_counters_in_path(struct treepath *search_path);
+void pathrelse(struct treepath *search_path);
 int reiserfs_check_path(struct treepath *p);
-void pathrelse_and_restore(struct super_block *s, struct treepath *p_s_search_path);
+void pathrelse_and_restore(struct super_block *s, struct treepath *search_path);
 
 int reiserfs_insert_item(struct reiserfs_transaction_handle *th,
                          struct treepath *path,
@@ -1868,14 +1888,14 @@ int reiserfs_cut_from_item(struct reiserfs_transaction_handle *th,
 int reiserfs_delete_item(struct reiserfs_transaction_handle *th,
                          struct treepath *path,
                          const struct cpu_key *key,
-                         struct inode *inode, struct buffer_head *p_s_un_bh);
+                         struct inode *inode, struct buffer_head *un_bh);
 
 void reiserfs_delete_solid_item(struct reiserfs_transaction_handle *th,
                                 struct inode *inode, struct reiserfs_key *key);
 int reiserfs_delete_object(struct reiserfs_transaction_handle *th,
-                           struct inode *p_s_inode);
+                           struct inode *inode);
 int reiserfs_do_truncate(struct reiserfs_transaction_handle *th,
-                         struct inode *p_s_inode, struct page *,
+                         struct inode *inode, struct page *,
                          int update_timestamps);
 
 #define i_block_size(inode) ((inode)->i_sb->s_blocksize)
@@ -1919,10 +1939,12 @@ void make_le_item_head(struct item_head *ih, const struct cpu_key *key,
                        loff_t offset, int type, int length, int entry_count);
 struct inode *reiserfs_iget(struct super_block *s, const struct cpu_key *key);
 
+struct reiserfs_security_handle;
 int reiserfs_new_inode(struct reiserfs_transaction_handle *th,
                        struct inode *dir, int mode,
                        const char *symname, loff_t i_size,
-                       struct dentry *dentry, struct inode *inode);
+                       struct dentry *dentry, struct inode *inode,
+                       struct reiserfs_security_handle *security);
 
 void reiserfs_update_sd_size(struct reiserfs_transaction_handle *th,
                              struct inode *inode, loff_t size);
@@ -1980,7 +2002,7 @@ int reiserfs_global_version_in_proc(char *buffer, char **start, off_t offset,
 #define PROC_INFO_MAX( sb, field, value ) VOID_V
 #define PROC_INFO_INC( sb, field ) VOID_V
 #define PROC_INFO_ADD( sb, field, val ) VOID_V
-#define PROC_INFO_BH_STAT( p_s_sb, p_s_bh, n_node_level ) VOID_V
+#define PROC_INFO_BH_STAT(sb, bh, n_node_level) VOID_V
 #endif
 
 /* dir.c */
@@ -1988,6 +2010,7 @@ extern const struct inode_operations reiserfs_dir_inode_operations;
 extern const struct inode_operations reiserfs_symlink_inode_operations;
 extern const struct inode_operations reiserfs_special_inode_operations;
 extern const struct file_operations reiserfs_dir_operations;
+int reiserfs_readdir_dentry(struct dentry *, void *, filldir_t, loff_t *);
 
 /* tail_conversion.c */
 int direct2indirect(struct reiserfs_transaction_handle *, struct inode *,
@@ -2004,13 +2027,20 @@ extern const struct address_space_operations reiserfs_address_space_operations;
 
 /* fix_nodes.c */
 
-int fix_nodes(int n_op_mode, struct tree_balance *p_s_tb,
-              struct item_head *p_s_ins_ih, const void *);
+int fix_nodes(int n_op_mode, struct tree_balance *tb,
+              struct item_head *ins_ih, const void *);
 void unfix_nodes(struct tree_balance *);
 
 /* prints.c */
-void reiserfs_panic(struct super_block *s, const char *fmt, ...)
+void __reiserfs_panic(struct super_block *s, const char *id,
+                      const char *function, const char *fmt, ...)
     __attribute__ ((noreturn));
+#define reiserfs_panic(s, id, fmt, args...) \
+        __reiserfs_panic(s, id, __func__, fmt, ##args)
+void __reiserfs_error(struct super_block *s, const char *id,
+                      const char *function, const char *fmt, ...);
+#define reiserfs_error(s, id, fmt, args...) \
+         __reiserfs_error(s, id, __func__, fmt, ##args)
 void reiserfs_info(struct super_block *s, const char *fmt, ...);
 void reiserfs_debug(struct super_block *s, int level, const char *fmt, ...);
 void print_indirect_item(struct buffer_head *bh, int item_num);
@@ -2047,7 +2077,7 @@ void leaf_paste_in_buffer(struct buffer_info *bi, int pasted_item_num,
                           int zeros_number);
 void leaf_cut_from_buffer(struct buffer_info *bi, int cut_item_num,
                           int pos_in_item, int cut_size);
-void leaf_paste_entries(struct buffer_head *bh, int item_num, int before,
+void leaf_paste_entries(struct buffer_info *bi, int item_num, int before,
                         int new_entry_count, struct reiserfs_de_head *new_dehs,
                         const char *records, int paste_size);
 /* ibalance.c */
@@ -2203,6 +2233,6 @@ long reiserfs_compat_ioctl(struct file *filp,
                    unsigned int cmd, unsigned long arg);
 int reiserfs_unpack(struct inode *inode, struct file *filp);
 
-
 #endif /* __KERNEL__ */
+
 #endif                          /* _LINUX_REISER_FS_H */
diff --git a/include/linux/reiserfs_fs_i.h b/include/linux/reiserfs_fs_i.h
index ce3663fb0101..76360b36ac33 100644
--- a/include/linux/reiserfs_fs_i.h
+++ b/include/linux/reiserfs_fs_i.h
@@ -51,7 +51,7 @@ struct reiserfs_inode_info {
         /* we use these for fsync or O_SYNC to decide which transaction
          ** needs to be committed in order for this inode to be properly
          ** flushed */
-        unsigned long i_trans_id;
+        unsigned int i_trans_id;
         struct reiserfs_journal_list *i_jl;
         struct mutex i_mmap;
 #ifdef CONFIG_REISERFS_FS_POSIX_ACL
@@ -59,7 +59,7 @@ struct reiserfs_inode_info {
         struct posix_acl *i_acl_default;
 #endif
 #ifdef CONFIG_REISERFS_FS_XATTR
-        struct rw_semaphore xattr_sem;
+        struct rw_semaphore i_xattr_sem;
 #endif
         struct inode vfs_inode;
 };
diff --git a/include/linux/reiserfs_fs_sb.h b/include/linux/reiserfs_fs_sb.h
index bda6b562a1e0..6b361d23a499 100644
--- a/include/linux/reiserfs_fs_sb.h
+++ b/include/linux/reiserfs_fs_sb.h
@@ -14,7 +14,7 @@ typedef enum {
 } reiserfs_super_block_flags;
 
 /* struct reiserfs_super_block accessors/mutators
- * since this is a disk structure, it will always be in 
+ * since this is a disk structure, it will always be in
  * little endian format. */
 #define sb_block_count(sbp)         (le32_to_cpu((sbp)->s_v1.s_block_count))
 #define set_sb_block_count(sbp,v)   ((sbp)->s_v1.s_block_count = cpu_to_le32(v))
@@ -73,6 +73,9 @@ typedef enum {
 #define sb_version(sbp)            (le16_to_cpu((sbp)->s_v1.s_version))
 #define set_sb_version(sbp,v)      ((sbp)->s_v1.s_version = cpu_to_le16(v))
 
+#define sb_mnt_count(sbp)          (le16_to_cpu((sbp)->s_mnt_count))
+#define set_sb_mnt_count(sbp, v)   ((sbp)->s_mnt_count = cpu_to_le16(v))
+
 #define sb_reserved_for_journal(sbp) \
               (le16_to_cpu((sbp)->s_v1.s_reserved_for_journal))
 #define set_sb_reserved_for_journal(sbp,v) \
@@ -80,16 +83,16 @@ typedef enum {
 
 /* LOGGING -- */
 
-/* These all interelate for performance.  
+/* These all interelate for performance.
 **
-** If the journal block count is smaller than n transactions, you lose speed. 
+** If the journal block count is smaller than n transactions, you lose speed.
 ** I don't know what n is yet, I'm guessing 8-16.
 **
 ** typical transaction size depends on the application, how often fsync is
-** called, and how many metadata blocks you dirty in a 30 second period.  
+** called, and how many metadata blocks you dirty in a 30 second period.
 ** The more small files (<16k) you use, the larger your transactions will
 ** be.
-** 
+**
 ** If your journal fills faster than dirty buffers get flushed to disk, it must flush them before allowing the journal
 ** to wrap, which slows things down.  If you need high speed meta data updates, the journal should be big enough
 ** to prevent wrapping before dirty meta blocks get to disk.
@@ -153,7 +156,7 @@ struct reiserfs_journal_list {
         atomic_t j_commit_left;
         atomic_t j_older_commits_done;  /* all commits older than this on disk */
         struct mutex j_commit_mutex;
-        unsigned long j_trans_id;
+        unsigned int j_trans_id;
         time_t j_timestamp;
         struct reiserfs_list_bitmap *j_list_bitmap;
         struct buffer_head *j_commit_bh;        /* commit buffer head */
@@ -182,7 +185,7 @@ struct reiserfs_journal {
         int j_1st_reserved_block;       /* first block on s_dev of reserved area journal */
 
         unsigned long j_state;
-        unsigned long j_trans_id;
+        unsigned int j_trans_id;
         unsigned long j_mount_id;
         unsigned long j_start;  /* start of current waiting commit (index into j_ap_blocks) */
         unsigned long j_len;    /* length of current waiting commit */
@@ -190,7 +193,7 @@ struct reiserfs_journal {
         atomic_t j_wcount;      /* count of writers for current commit */
         unsigned long j_bcount; /* batch count. allows turning X transactions into 1 */
         unsigned long j_first_unflushed_offset; /* first unflushed transactions offset */
-        unsigned long j_last_flush_trans_id;    /* last fully flushed journal timestamp */
+        unsigned j_last_flush_trans_id; /* last fully flushed journal timestamp */
         struct buffer_head *j_header_bh;
 
         time_t j_trans_start_time;      /* time this transaction started */
@@ -223,10 +226,10 @@ struct reiserfs_journal {
         int j_num_work_lists;   /* number that need attention from kreiserfsd */
 
         /* debugging to make sure things are flushed in order */
-        int j_last_flush_id;
+        unsigned int j_last_flush_id;
 
         /* debugging to make sure things are committed in order */
-        int j_last_commit_id;
+        unsigned int j_last_commit_id;
 
         struct list_head j_bitmap_nodes;
         struct list_head j_dirty_buffers;
@@ -239,7 +242,7 @@ struct reiserfs_journal {
 
         struct reiserfs_list_bitmap j_list_bitmap[JOURNAL_NUM_BITMAPS]; /* array of bitmaps to record the deleted blocks */
         struct reiserfs_journal_cnode *j_hash_table[JOURNAL_HASH_SIZE]; /* hash table for real buffer heads in current trans */
-        struct reiserfs_journal_cnode *j_list_hash_table[JOURNAL_HASH_SIZE];    /* hash table for all the real buffer heads in all 
+        struct reiserfs_journal_cnode *j_list_hash_table[JOURNAL_HASH_SIZE];    /* hash table for all the real buffer heads in all
                                                                                    the transactions */
         struct list_head j_prealloc_list;       /* list of inodes which have preallocated blocks */
         int j_persistent_trans;
@@ -399,10 +402,7 @@ struct reiserfs_sb_info {
         int reserved_blocks;    /* amount of blocks reserved for further allocations */
         spinlock_t bitmap_lock; /* this lock on now only used to protect reserved_blocks variable */
         struct dentry *priv_root;       /* root of /.reiserfs_priv */
-#ifdef CONFIG_REISERFS_FS_XATTR
         struct dentry *xattr_root;      /* root of /.reiserfs_priv/.xa */
-        struct rw_semaphore xattr_dir_sem;
-#endif
         int j_errno;
 #ifdef CONFIG_QUOTA
         char *s_qf_names[MAXQUOTAS];
@@ -426,7 +426,7 @@ enum reiserfs_mount_options {
                                    partition will be dealt with in a
                                    manner of 3.5.x */
 
-/* -o hash={tea, rupasov, r5, detect} is meant for properly mounting 
+/* -o hash={tea, rupasov, r5, detect} is meant for properly mounting
 ** reiserfs disks from 3.5.19 or earlier.  99% of the time, this option
 ** is not required.  If the normal autodection code can't determine which
 ** hash to use (because both hashes had the same value for a file)
@@ -451,7 +451,6 @@ enum reiserfs_mount_options {
         REISERFS_NO_UNHASHED_RELOCATION,
         REISERFS_HASHED_RELOCATION,
         REISERFS_ATTRS,
-        REISERFS_XATTRS,
         REISERFS_XATTRS_USER,
         REISERFS_POSIXACL,
         REISERFS_BARRIER_NONE,
@@ -489,7 +488,7 @@ enum reiserfs_mount_options {
 #define reiserfs_data_log(s) (REISERFS_SB(s)->s_mount_opt & (1 << REISERFS_DATA_LOG))
 #define reiserfs_data_ordered(s) (REISERFS_SB(s)->s_mount_opt & (1 << REISERFS_DATA_ORDERED))
 #define reiserfs_data_writeback(s) (REISERFS_SB(s)->s_mount_opt & (1 << REISERFS_DATA_WRITEBACK))
-#define reiserfs_xattrs(s) (REISERFS_SB(s)->s_mount_opt & (1 << REISERFS_XATTRS))
+#define reiserfs_xattrs(s) ((s)->s_xattr != NULL)
 #define reiserfs_xattrs_user(s) (REISERFS_SB(s)->s_mount_opt & (1 << REISERFS_XATTRS_USER))
 #define reiserfs_posixacl(s) (REISERFS_SB(s)->s_mount_opt & (1 << REISERFS_POSIXACL))
 #define reiserfs_xattrs_optional(s) (reiserfs_xattrs_user(s) || reiserfs_posixacl(s))
diff --git a/include/linux/reiserfs_xattr.h b/include/linux/reiserfs_xattr.h
index af135ae895db..dcae01e63e40 100644
--- a/include/linux/reiserfs_xattr.h
+++ b/include/linux/reiserfs_xattr.h
@@ -15,6 +15,12 @@ struct reiserfs_xattr_header {
         __le32 h_hash;          /* hash of the value */
 };
 
+struct reiserfs_security_handle {
+        char *name;
+        void *value;
+        size_t length;
+};
+
 #ifdef __KERNEL__
 
 #include <linux/init.h>
@@ -29,22 +35,13 @@ struct iattr;
 struct super_block;
 struct nameidata;
 
-struct reiserfs_xattr_handler {
-        char *prefix;
-        int (*init) (void);
-        void (*exit) (void);
-        int (*get) (struct inode * inode, const char *name, void *buffer,
-                    size_t size);
-        int (*set) (struct inode * inode, const char *name, const void *buffer,
-                    size_t size, int flags);
-        int (*del) (struct inode * inode, const char *name);
-        int (*list) (struct inode * inode, const char *name, int namelen,
-                     char *out);
-        struct list_head handlers;
-};
+int reiserfs_xattr_register_handlers(void) __init;
+void reiserfs_xattr_unregister_handlers(void);
+int reiserfs_xattr_init(struct super_block *sb, int mount_flags);
+int reiserfs_delete_xattrs(struct inode *inode);
+int reiserfs_chown_xattrs(struct inode *inode, struct iattr *attrs);
 
 #ifdef CONFIG_REISERFS_FS_XATTR
-#define is_reiserfs_priv_object(inode) IS_PRIVATE(inode)
 #define has_xattr_dir(inode) (REISERFS_I(inode)->i_flags & i_has_xattr_dir)
 ssize_t reiserfs_getxattr(struct dentry *dentry, const char *name,
                           void *buffer, size_t size);
@@ -52,104 +49,97 @@ int reiserfs_setxattr(struct dentry *dentry, const char *name,
                       const void *value, size_t size, int flags);
 ssize_t reiserfs_listxattr(struct dentry *dentry, char *buffer, size_t size);
 int reiserfs_removexattr(struct dentry *dentry, const char *name);
-int reiserfs_delete_xattrs(struct inode *inode);
-int reiserfs_chown_xattrs(struct inode *inode, struct iattr *attrs);
-int reiserfs_xattr_init(struct super_block *sb, int mount_flags);
 int reiserfs_permission(struct inode *inode, int mask);
 
-int reiserfs_xattr_del(struct inode *, const char *);
-int reiserfs_xattr_get(const struct inode *, const char *, void *, size_t);
+int reiserfs_xattr_get(struct inode *, const char *, void *, size_t);
 int reiserfs_xattr_set(struct inode *, const char *, const void *, size_t, int);
-
-extern struct reiserfs_xattr_handler user_handler;
-extern struct reiserfs_xattr_handler trusted_handler;
-extern struct reiserfs_xattr_handler security_handler;
-
-int reiserfs_xattr_register_handlers(void) __init;
-void reiserfs_xattr_unregister_handlers(void);
-
-static inline void reiserfs_write_lock_xattrs(struct super_block *sb)
-{
-        down_write(&REISERFS_XATTR_DIR_SEM(sb));
-}
-static inline void reiserfs_write_unlock_xattrs(struct super_block *sb)
-{
-        up_write(&REISERFS_XATTR_DIR_SEM(sb));
-}
-static inline void reiserfs_read_lock_xattrs(struct super_block *sb)
-{
-        down_read(&REISERFS_XATTR_DIR_SEM(sb));
-}
-
-static inline void reiserfs_read_unlock_xattrs(struct super_block *sb)
+int reiserfs_xattr_set_handle(struct reiserfs_transaction_handle *,
+                              struct inode *, const char *, const void *,
+                              size_t, int);
+
+extern struct xattr_handler reiserfs_xattr_user_handler;
+extern struct xattr_handler reiserfs_xattr_trusted_handler;
+extern struct xattr_handler reiserfs_xattr_security_handler;
+#ifdef CONFIG_REISERFS_FS_SECURITY
+int reiserfs_security_init(struct inode *dir, struct inode *inode,
+                           struct reiserfs_security_handle *sec);
+int reiserfs_security_write(struct reiserfs_transaction_handle *th,
+                            struct inode *inode,
+                            struct reiserfs_security_handle *sec);
+void reiserfs_security_free(struct reiserfs_security_handle *sec);
+#endif
+
+#define xattr_size(size) ((size) + sizeof(struct reiserfs_xattr_header))
+static inline loff_t reiserfs_xattr_nblocks(struct inode *inode, loff_t size)
 {
-        up_read(&REISERFS_XATTR_DIR_SEM(sb));
+        loff_t ret = 0;
+        if (reiserfs_file_data_log(inode)) {
+                ret = _ROUND_UP(xattr_size(size), inode->i_sb->s_blocksize);
+                ret >>= inode->i_sb->s_blocksize_bits;
+        }
+        return ret;
 }
 
-static inline void reiserfs_write_lock_xattr_i(struct inode *inode)
-{
-        down_write(&REISERFS_I(inode)->xattr_sem);
-}
-static inline void reiserfs_write_unlock_xattr_i(struct inode *inode)
+/* We may have to create up to 3 objects: xattr root, xattr dir, xattr file.
+ * Let's try to be smart about it.
+ * xattr root: We cache it. If it's not cached, we may need to create it.
+ * xattr dir: If anything has been loaded for this inode, we can set a flag
+ *            saying so.
+ * xattr file: Since we don't cache xattrs, we can't tell. We always include
+ *             blocks for it.
+ *
+ * However, since root and dir can be created between calls - YOU MUST SAVE
+ * THIS VALUE.
+ */
+static inline size_t reiserfs_xattr_jcreate_nblocks(struct inode *inode)
 {
-        up_write(&REISERFS_I(inode)->xattr_sem);
-}
-static inline void reiserfs_read_lock_xattr_i(struct inode *inode)
-{
-        down_read(&REISERFS_I(inode)->xattr_sem);
-}
+        size_t nblocks = JOURNAL_BLOCKS_PER_OBJECT(inode->i_sb);
 
-static inline void reiserfs_read_unlock_xattr_i(struct inode *inode)
-{
-        up_read(&REISERFS_I(inode)->xattr_sem);
-}
+        if ((REISERFS_I(inode)->i_flags & i_has_xattr_dir) == 0) {
+                nblocks += JOURNAL_BLOCKS_PER_OBJECT(inode->i_sb);
+                if (REISERFS_SB(inode->i_sb)->xattr_root == NULL)
+                        nblocks += JOURNAL_BLOCKS_PER_OBJECT(inode->i_sb);
+        }
 
-static inline void reiserfs_mark_inode_private(struct inode *inode)
-{
-        inode->i_flags |= S_PRIVATE;
+        return nblocks;
 }
 
 static inline void reiserfs_init_xattr_rwsem(struct inode *inode)
 {
-        init_rwsem(&REISERFS_I(inode)->xattr_sem);
+        init_rwsem(&REISERFS_I(inode)->i_xattr_sem);
 }
 
 #else
 
-#define is_reiserfs_priv_object(inode) 0
-#define reiserfs_mark_inode_private(inode) do {;} while(0)
 #define reiserfs_getxattr NULL
 #define reiserfs_setxattr NULL
 #define reiserfs_listxattr NULL
 #define reiserfs_removexattr NULL
-#define reiserfs_write_lock_xattrs(sb) do {;} while(0)
-#define reiserfs_write_unlock_xattrs(sb) do {;} while(0)
-#define reiserfs_read_lock_xattrs(sb)
-#define reiserfs_read_unlock_xattrs(sb)
 
 #define reiserfs_permission NULL
 
-#define reiserfs_xattr_register_handlers() 0
-#define reiserfs_xattr_unregister_handlers()
-
-static inline int reiserfs_delete_xattrs(struct inode *inode)
+static inline void reiserfs_init_xattr_rwsem(struct inode *inode)
 {
-        return 0;
-};
-static inline int reiserfs_chown_xattrs(struct inode *inode,
-                                        struct iattr *attrs)
+}
+#endif  /*  CONFIG_REISERFS_FS_XATTR  */
+
+#ifndef CONFIG_REISERFS_FS_SECURITY
+static inline int reiserfs_security_init(struct inode *dir,
+                                         struct inode *inode,
+                                         struct reiserfs_security_handle *sec)
 {
         return 0;
-};
-static inline int reiserfs_xattr_init(struct super_block *sb, int mount_flags)
+}
+static inline int
+reiserfs_security_write(struct reiserfs_transaction_handle *th,
+                        struct inode *inode,
+                        struct reiserfs_security_handle *sec)
 {
-        sb->s_flags = (sb->s_flags & ~MS_POSIXACL);     /* to be sure */
         return 0;
-};
-static inline void reiserfs_init_xattr_rwsem(struct inode *inode)
-{
 }
-#endif  /*  CONFIG_REISERFS_FS_XATTR  */
+static inline void reiserfs_security_free(struct reiserfs_security_handle *sec)
+{}
+#endif
 
 #endif  /*  __KERNEL__  */
 
diff --git a/include/linux/ring_buffer.h b/include/linux/ring_buffer.h
index b3b359660082..e1b7b2173885 100644
--- a/include/linux/ring_buffer.h
+++ b/include/linux/ring_buffer.h
@@ -8,7 +8,7 @@ struct ring_buffer;
 struct ring_buffer_iter;
 
 /*
- * Don't reference this struct directly, use functions below.
+ * Don't refer to this struct directly, use functions below.
  */
 struct ring_buffer_event {
         u32             type:2, len:3, time_delta:27;
@@ -18,10 +18,13 @@ struct ring_buffer_event {
 /**
  * enum ring_buffer_type - internal ring buffer types
  *
- * @RINGBUF_TYPE_PADDING:       Left over page padding
- *                               array is ignored
- *                               size is variable depending on how much
+ * @RINGBUF_TYPE_PADDING:       Left over page padding or discarded event
+ *                               If time_delta is 0:
+ *                                array is ignored
+ *                                size is variable depending on how much
  *                                padding is needed
+ *                               If time_delta is non zero:
+ *                                everything else same as RINGBUF_TYPE_DATA
  *
  * @RINGBUF_TYPE_TIME_EXTEND:   Extend the time delta
  *                               array[0] = time delta (28 .. 59)
@@ -65,6 +68,8 @@ ring_buffer_event_time_delta(struct ring_buffer_event *event)
         return event->time_delta;
 }
 
+void ring_buffer_event_discard(struct ring_buffer_event *event);
+
 /*
  * size is in bytes for each per CPU buffer.
  */
@@ -74,13 +79,10 @@ void ring_buffer_free(struct ring_buffer *buffer);
 
 int ring_buffer_resize(struct ring_buffer *buffer, unsigned long size);
 
-struct ring_buffer_event *
-ring_buffer_lock_reserve(struct ring_buffer *buffer,
-                         unsigned long length,
-                         unsigned long *flags);
+struct ring_buffer_event *ring_buffer_lock_reserve(struct ring_buffer *buffer,
+                                                   unsigned long length);
 int ring_buffer_unlock_commit(struct ring_buffer *buffer,
-                              struct ring_buffer_event *event,
-                              unsigned long flags);
+                              struct ring_buffer_event *event);
 int ring_buffer_write(struct ring_buffer *buffer,
                       unsigned long length, void *data);
 
@@ -121,17 +123,19 @@ unsigned long ring_buffer_overruns(struct ring_buffer *buffer);
 unsigned long ring_buffer_entries_cpu(struct ring_buffer *buffer, int cpu);
 unsigned long ring_buffer_overrun_cpu(struct ring_buffer *buffer, int cpu);
 
-u64 ring_buffer_time_stamp(int cpu);
-void ring_buffer_normalize_time_stamp(int cpu, u64 *ts);
+u64 ring_buffer_time_stamp(struct ring_buffer *buffer, int cpu);
+void ring_buffer_normalize_time_stamp(struct ring_buffer *buffer,
+                                      int cpu, u64 *ts);
+void ring_buffer_set_clock(struct ring_buffer *buffer,
+                           u64 (*clock)(void));
+
+size_t ring_buffer_page_len(void *page);
 
-void tracing_on(void);
-void tracing_off(void);
-void tracing_off_permanent(void);
 
 void *ring_buffer_alloc_read_page(struct ring_buffer *buffer);
 void ring_buffer_free_read_page(struct ring_buffer *buffer, void *data);
-int ring_buffer_read_page(struct ring_buffer *buffer,
-                          void **data_page, int cpu, int full);
+int ring_buffer_read_page(struct ring_buffer *buffer, void **data_page,
+                          size_t len, int cpu, int full);
 
 enum ring_buffer_flags {
         RB_FL_OVERWRITE         = 1 << 0,
diff --git a/include/linux/rotary_encoder.h b/include/linux/rotary_encoder.h
new file mode 100644
index 000000000000..12d63a30c347
--- /dev/null
+++ b/include/linux/rotary_encoder.h
@@ -0,0 +1,13 @@
+#ifndef __ROTARY_ENCODER_H__
+#define __ROTARY_ENCODER_H__
+
+struct rotary_encoder_platform_data {
+        unsigned int steps;
+        unsigned int axis;
+        unsigned int gpio_a;
+        unsigned int gpio_b;
+        unsigned int inverted_a;
+        unsigned int inverted_b;
+};
+
+#endif /* __ROTARY_ENCODER_H__ */
diff --git a/include/linux/rtc-v3020.h b/include/linux/rtc-v3020.h
index bf74e63c98fe..8ba646e610d9 100644
--- a/include/linux/rtc-v3020.h
+++ b/include/linux/rtc-v3020.h
@@ -14,6 +14,12 @@
  * is used depends on the board. */
 struct v3020_platform_data {
         int leftshift; /* (1<<(leftshift)) & readl() */
+
+        int use_gpio:1;
+        unsigned int gpio_cs;
+        unsigned int gpio_wr;
+        unsigned int gpio_rd;
+        unsigned int gpio_io;
 };
 
 #define V3020_STATUS_0  0x00
diff --git a/include/linux/rtc.h b/include/linux/rtc.h
index 4046b75563c1..60f88a7fb13d 100644
--- a/include/linux/rtc.h
+++ b/include/linux/rtc.h
@@ -99,6 +99,7 @@ struct rtc_pll_info {
 
 #ifdef __KERNEL__
 
+#include <linux/types.h>
 #include <linux/interrupt.h>
 
 extern int rtc_month_days(unsigned int month, unsigned int year);
@@ -232,6 +233,11 @@ int rtc_register(rtc_task_t *task);
 int rtc_unregister(rtc_task_t *task);
 int rtc_control(rtc_task_t *t, unsigned int cmd, unsigned long arg);
 
+static inline bool is_leap_year(unsigned int year)
+{
+        return (!(year % 4) && (year % 100)) || !(year % 400);
+}
+
 #endif /* __KERNEL__ */
 
 #endif /* _LINUX_RTC_H_ */
diff --git a/include/linux/sched.h b/include/linux/sched.h
index d3b787c7aef3..3fa82b353c98 100644
--- a/include/linux/sched.h
+++ b/include/linux/sched.h
@@ -68,7 +68,7 @@ struct sched_param {
 #include <linux/smp.h>
 #include <linux/sem.h>
 #include <linux/signal.h>
-#include <linux/fs_struct.h>
+#include <linux/path.h>
 #include <linux/compiler.h>
 #include <linux/completion.h>
 #include <linux/pid.h>
@@ -97,6 +97,7 @@ struct futex_pi_state;
 struct robust_list_head;
 struct bio;
 struct bts_tracer;
+struct fs_struct;
 
 /*
  * List of flags we want to share for kernel threads,
@@ -137,6 +138,8 @@ extern unsigned long nr_uninterruptible(void);
 extern unsigned long nr_active(void);
 extern unsigned long nr_iowait(void);
 
+extern unsigned long get_parent_ip(unsigned long addr);
+
 struct seq_file;
 struct cfs_rq;
 struct task_group;
@@ -202,7 +205,8 @@ extern unsigned long long time_sync_thresh;
 #define task_is_stopped_or_traced(task) \
                         ((task->state & (__TASK_STOPPED | __TASK_TRACED)) != 0)
 #define task_contributes_to_load(task)  \
-                                ((task->state & TASK_UNINTERRUPTIBLE) != 0)
+                                ((task->state & TASK_UNINTERRUPTIBLE) != 0 && \
+                                 (task->flags & PF_FROZEN) == 0)
 
 #define __set_task_state(tsk, state_value)              \
         do { (tsk)->state = (state_value); } while (0)
@@ -297,17 +301,11 @@ extern int proc_dosoftlockup_thresh(struct ctl_table *table, int write,
                                     struct file *filp, void __user *buffer,
                                     size_t *lenp, loff_t *ppos);
 extern unsigned int  softlockup_panic;
-extern unsigned long sysctl_hung_task_check_count;
-extern unsigned long sysctl_hung_task_timeout_secs;
-extern unsigned long sysctl_hung_task_warnings;
 extern int softlockup_thresh;
 #else
 static inline void softlockup_tick(void)
 {
 }
-static inline void spawn_softlockup_task(void)
-{
-}
 static inline void touch_softlockup_watchdog(void)
 {
 }
@@ -316,6 +314,15 @@ static inline void touch_all_softlockup_watchdogs(void)
 }
 #endif
 
+#ifdef CONFIG_DETECT_HUNG_TASK
+extern unsigned int  sysctl_hung_task_panic;
+extern unsigned long sysctl_hung_task_check_count;
+extern unsigned long sysctl_hung_task_timeout_secs;
+extern unsigned long sysctl_hung_task_warnings;
+extern int proc_dohung_task_timeout_secs(struct ctl_table *table, int write,
+                                         struct file *filp, void __user *buffer,
+                                         size_t *lenp, loff_t *ppos);
+#endif
 
 /* Attach to any functions which should be ignored in wchan output. */
 #define __sched         __attribute__((__section__(".sched.text")))
@@ -331,7 +338,9 @@ extern signed long schedule_timeout(signed long timeout);
 extern signed long schedule_timeout_interruptible(signed long timeout);
 extern signed long schedule_timeout_killable(signed long timeout);
 extern signed long schedule_timeout_uninterruptible(signed long timeout);
+asmlinkage void __schedule(void);
 asmlinkage void schedule(void);
+extern int mutex_spin_on_owner(struct mutex *lock, struct thread_info *owner);
 
 struct nsproxy;
 struct user_namespace;
@@ -389,8 +398,15 @@ extern void arch_unmap_area_topdown(struct mm_struct *, unsigned long);
                 (mm)->hiwater_vm = (mm)->total_vm;      \
 } while (0)
 
-#define get_mm_hiwater_rss(mm)  max((mm)->hiwater_rss, get_mm_rss(mm))
-#define get_mm_hiwater_vm(mm)   max((mm)->hiwater_vm, (mm)->total_vm)
+static inline unsigned long get_mm_hiwater_rss(struct mm_struct *mm)
+{
+        return max(mm->hiwater_rss, get_mm_rss(mm));
+}
+
+static inline unsigned long get_mm_hiwater_vm(struct mm_struct *mm)
+{
+        return max(mm->hiwater_vm, mm->total_vm);
+}
 
 extern void set_dumpable(struct mm_struct *mm, int value);
 extern int get_dumpable(struct mm_struct *mm);
@@ -538,25 +554,8 @@ struct signal_struct {
 
         struct list_head cpu_timers[3];
 
-        /* job control IDs */
-
-        /*
-         * pgrp and session fields are deprecated.
-         * use the task_session_Xnr and task_pgrp_Xnr routines below
-         */
-
-        union {
-                pid_t pgrp __deprecated;
-                pid_t __pgrp;
-        };
-
         struct pid *tty_old_pgrp;
 
-        union {
-                pid_t session __deprecated;
-                pid_t __session;
-        };
-
         /* boolean value for session group leader */
         int leader;
 
@@ -1260,9 +1259,8 @@ struct task_struct {
 /* ipc stuff */
         struct sysv_sem sysvsem;
 #endif
-#ifdef CONFIG_DETECT_SOFTLOCKUP
+#ifdef CONFIG_DETECT_HUNG_TASK
 /* hung task detection */
-        unsigned long last_switch_timestamp;
         unsigned long last_switch_count;
 #endif
 /* CPU-specific state of this task */
@@ -1299,6 +1297,11 @@ struct task_struct {
 /* Protection of (de-)allocation: mm, files, fs, tty, keyrings */
         spinlock_t alloc_lock;
 
+#ifdef CONFIG_GENERIC_HARDIRQS
+        /* IRQ handler threads */
+        struct irqaction *irqaction;
+#endif
+
         /* Protection of the PI data structures: */
         spinlock_t pi_lock;
 
@@ -1334,6 +1337,7 @@ struct task_struct {
         int lockdep_depth;
         unsigned int lockdep_recursion;
         struct held_lock held_locks[MAX_LOCK_DEPTH];
+        gfp_t lockdep_reclaim_gfp;
 #endif
 
 /* journalling filesystem info */
@@ -1411,6 +1415,8 @@ struct task_struct {
         int curr_ret_stack;
         /* Stack of return addresses for return function tracing */
         struct ftrace_ret_stack *ret_stack;
+        /* time stamp for last schedule */
+        unsigned long long ftrace_timestamp;
         /*
          * Number of functions that haven't been traced
          * because of depth overrun.
@@ -1459,16 +1465,6 @@ static inline int rt_task(struct task_struct *p)
         return rt_prio(p->prio);
 }
 
-static inline void set_task_session(struct task_struct *tsk, pid_t session)
-{
-        tsk->signal->__session = session;
-}
-
-static inline void set_task_pgrp(struct task_struct *tsk, pid_t pgrp)
-{
-        tsk->signal->__pgrp = pgrp;
-}
-
 static inline struct pid *task_pid(struct task_struct *task)
 {
         return task->pids[PIDTYPE_PID].pid;
@@ -1479,6 +1475,11 @@ static inline struct pid *task_tgid(struct task_struct *task)
         return task->group_leader->pids[PIDTYPE_PID].pid;
 }
 
+/*
+ * Without tasklist or rcu lock it is not safe to dereference
+ * the result of task_pgrp/task_session even if task == current,
+ * we can race with another thread doing sys_setsid/sys_setpgid.
+ */
 static inline struct pid *task_pgrp(struct task_struct *task)
 {
         return task->group_leader->pids[PIDTYPE_PGID].pid;
@@ -1504,17 +1505,23 @@ struct pid_namespace;
  *
  * see also pid_nr() etc in include/linux/pid.h
  */
+pid_t __task_pid_nr_ns(struct task_struct *task, enum pid_type type,
+                        struct pid_namespace *ns);
 
 static inline pid_t task_pid_nr(struct task_struct *tsk)
 {
         return tsk->pid;
 }
 
-pid_t task_pid_nr_ns(struct task_struct *tsk, struct pid_namespace *ns);
+static inline pid_t task_pid_nr_ns(struct task_struct *tsk,
+                                        struct pid_namespace *ns)
+{
+        return __task_pid_nr_ns(tsk, PIDTYPE_PID, ns);
+}
 
 static inline pid_t task_pid_vnr(struct task_struct *tsk)
 {
-        return pid_vnr(task_pid(tsk));
+        return __task_pid_nr_ns(tsk, PIDTYPE_PID, NULL);
 }
 
 
@@ -1531,31 +1538,34 @@ static inline pid_t task_tgid_vnr(struct task_struct *tsk)
 }
 
 
-static inline pid_t task_pgrp_nr(struct task_struct *tsk)
+static inline pid_t task_pgrp_nr_ns(struct task_struct *tsk,
+                                        struct pid_namespace *ns)
 {
-        return tsk->signal->__pgrp;
+        return __task_pid_nr_ns(tsk, PIDTYPE_PGID, ns);
 }
 
-pid_t task_pgrp_nr_ns(struct task_struct *tsk, struct pid_namespace *ns);
-
 static inline pid_t task_pgrp_vnr(struct task_struct *tsk)
 {
-        return pid_vnr(task_pgrp(tsk));
+        return __task_pid_nr_ns(tsk, PIDTYPE_PGID, NULL);
 }
 
 
-static inline pid_t task_session_nr(struct task_struct *tsk)
+static inline pid_t task_session_nr_ns(struct task_struct *tsk,
+                                        struct pid_namespace *ns)
 {
-        return tsk->signal->__session;
+        return __task_pid_nr_ns(tsk, PIDTYPE_SID, ns);
 }
 
-pid_t task_session_nr_ns(struct task_struct *tsk, struct pid_namespace *ns);
-
 static inline pid_t task_session_vnr(struct task_struct *tsk)
 {
-        return pid_vnr(task_session(tsk));
+        return __task_pid_nr_ns(tsk, PIDTYPE_SID, NULL);
 }
 
+/* obsolete, do not use */
+static inline pid_t task_pgrp_nr(struct task_struct *tsk)
+{
+        return task_pgrp_nr_ns(tsk, &init_pid_ns);
+}
 
 /**
  * pid_alive - check that a task structure is not stale
@@ -1966,7 +1976,8 @@ extern void mm_release(struct task_struct *, struct mm_struct *);
 /* Allocate a new mm structure and copy contents from tsk->mm */
 extern struct mm_struct *dup_mm(struct task_struct *tsk);
 
-extern int  copy_thread(int, unsigned long, unsigned long, unsigned long, struct task_struct *, struct pt_regs *);
+extern int copy_thread(unsigned long, unsigned long, unsigned long,
+                        struct task_struct *, struct pt_regs *);
 extern void flush_thread(void);
 extern void exit_thread(void);
 
@@ -2051,6 +2062,11 @@ static inline int thread_group_empty(struct task_struct *p)
 #define delay_group_leader(p) \
                 (thread_group_leader(p) && !thread_group_empty(p))
 
+static inline int task_detached(struct task_struct *p)
+{
+        return p->exit_signal == -1;
+}
+
 /*
  * Protects ->fs, ->files, ->mm, ->group_info, ->comm, keyring
  * subscriptions and synchronises with wait4().  Also used in procfs.  Also
diff --git a/include/linux/seccomp.h b/include/linux/seccomp.h
index 262a8dccfa81..167c33361d9c 100644
--- a/include/linux/seccomp.h
+++ b/include/linux/seccomp.h
@@ -21,6 +21,8 @@ extern long prctl_set_seccomp(unsigned long);
 
 #else /* CONFIG_SECCOMP */
 
+#include <linux/errno.h>
+
 typedef struct { } seccomp_t;
 
 #define secure_computing(x) do { } while (0)
diff --git a/include/linux/section-names.h b/include/linux/section-names.h
new file mode 100644
index 000000000000..c956f4eb2adf
--- /dev/null
+++ b/include/linux/section-names.h
@@ -0,0 +1,6 @@
+#ifndef __LINUX_SECTION_NAMES_H
+#define __LINUX_SECTION_NAMES_H
+
+#define HEAD_TEXT_SECTION .head.text
+
+#endif /* !__LINUX_SECTION_NAMES_H */
diff --git a/include/linux/security.h b/include/linux/security.h
index 54ed15799a83..d5fd6163606f 100644
--- a/include/linux/security.h
+++ b/include/linux/security.h
@@ -32,6 +32,7 @@
 #include <linux/sched.h>
 #include <linux/key.h>
 #include <linux/xfrm.h>
+#include <linux/gfp.h>
 #include <net/flow.h>
 
 /* Maximum number of letters for an LSM name string */
@@ -2953,5 +2954,28 @@ static inline void securityfs_remove(struct dentry *dentry)
 
 #endif
 
+#ifdef CONFIG_SECURITY
+
+static inline char *alloc_secdata(void)
+{
+        return (char *)get_zeroed_page(GFP_KERNEL);
+}
+
+static inline void free_secdata(void *secdata)
+{
+        free_page((unsigned long)secdata);
+}
+
+#else
+
+static inline char *alloc_secdata(void)
+{
+        return (char *)1;
+}
+
+static inline void free_secdata(void *secdata)
+{ }
+#endif /* CONFIG_SECURITY */
+
 #endif /* ! __LINUX_SECURITY_H */
 
diff --git a/include/linux/seq_file.h b/include/linux/seq_file.h
index f616f31576d7..004f3b3342c5 100644
--- a/include/linux/seq_file.h
+++ b/include/linux/seq_file.h
@@ -55,7 +55,7 @@ int seq_bitmap(struct seq_file *m, const unsigned long *bits,
                                    unsigned int nr_bits);
 static inline int seq_cpumask(struct seq_file *m, const struct cpumask *mask)
 {
-        return seq_bitmap(m, mask->bits, nr_cpu_ids);
+        return seq_bitmap(m, cpumask_bits(mask), nr_cpu_ids);
 }
 
 static inline int seq_nodemask(struct seq_file *m, nodemask_t *mask)
@@ -63,12 +63,13 @@ static inline int seq_nodemask(struct seq_file *m, nodemask_t *mask)
         return seq_bitmap(m, mask->bits, MAX_NUMNODES);
 }
 
-int seq_bitmap_list(struct seq_file *m, unsigned long *bits,
+int seq_bitmap_list(struct seq_file *m, const unsigned long *bits,
                 unsigned int nr_bits);
 
-static inline int seq_cpumask_list(struct seq_file *m, cpumask_t *mask)
+static inline int seq_cpumask_list(struct seq_file *m,
+                                   const struct cpumask *mask)
 {
-        return seq_bitmap_list(m, mask->bits, NR_CPUS);
+        return seq_bitmap_list(m, cpumask_bits(mask), nr_cpu_ids);
 }
 
 static inline int seq_nodemask_list(struct seq_file *m, nodemask_t *mask)
diff --git a/include/linux/serial_core.h b/include/linux/serial_core.h
index df9245c7bd3b..57a97e52e58d 100644
--- a/include/linux/serial_core.h
+++ b/include/linux/serial_core.h
@@ -164,6 +164,9 @@
 /* NWPSERIAL */
 #define PORT_NWPSERIAL  85
 
+/* MAX3100 */
+#define PORT_MAX3100    86
+
 #ifdef __KERNEL__
 
 #include <linux/compiler.h>
@@ -277,7 +280,7 @@ struct uart_port {
         struct uart_icount      icount;                 /* statistics */
 
         struct console          *cons;                  /* struct console, if any */
-#ifdef CONFIG_SERIAL_CORE_CONSOLE
+#if defined(CONFIG_SERIAL_CORE_CONSOLE) || defined(SUPPORT_SYSRQ)
         unsigned long           sysrq;                  /* sysrq timeout */
 #endif
 
diff --git a/include/linux/serial_max3100.h b/include/linux/serial_max3100.h
new file mode 100644
index 000000000000..4976befb6aeb
--- /dev/null
+++ b/include/linux/serial_max3100.h
@@ -0,0 +1,52 @@
+/*
+ *
+ *  Copyright (C) 2007 Christian Pellegrin
+ *
+ * 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_SERIAL_MAX3100_H
+#define _LINUX_SERIAL_MAX3100_H 1
+
+
+/**
+ * struct plat_max3100 - MAX3100 SPI UART platform data
+ * @loopback:            force MAX3100 in loopback
+ * @crystal:             1 for 3.6864 Mhz, 0 for 1.8432
+ * @max3100_hw_suspend:  MAX3100 has a shutdown pin. This is a hook
+ *                       called on suspend and resume to activate it.
+ * @poll_time:           poll time for CTS signal in ms, 0 disables (so no hw
+ *                       flow ctrl is possible but you have less CPU usage)
+ *
+ * You should use this structure in your machine description to specify
+ * how the MAX3100 is connected. Example:
+ *
+ * static struct plat_max3100 max3100_plat_data = {
+ *  .loopback = 0,
+ *  .crystal = 0,
+ *  .poll_time = 100,
+ * };
+ *
+ * static struct spi_board_info spi_board_info[] = {
+ * {
+ *  .modalias   = "max3100",
+ *  .platform_data      = &max3100_plat_data,
+ *  .irq                = IRQ_EINT12,
+ *  .max_speed_hz       = 5*1000*1000,
+ *  .chip_select        = 0,
+ * },
+ * };
+ *
+ **/
+struct plat_max3100 {
+        int loopback;
+        int crystal;
+        void (*max3100_hw_suspend) (int suspend);
+        int poll_time;
+};
+
+#endif
diff --git a/include/linux/sht15.h b/include/linux/sht15.h
new file mode 100644
index 000000000000..046bce05ecab
--- /dev/null
+++ b/include/linux/sht15.h
@@ -0,0 +1,24 @@
+/*
+ * sht15.h - support for the SHT15 Temperature and Humidity Sensor
+ *
+ * Copyright (c) 2009 Jonathan Cameron
+ *
+ * Copyright (c) 2007 Wouter Horre
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License version 2 as
+ * published by the Free Software Foundation.
+ */
+
+/**
+ * struct sht15_platform_data - sht15 connectivity info
+ * @gpio_data:  no. of gpio to which bidirectional data line is connected
+ * @gpio_sck:   no. of gpio to which the data clock is connected.
+ * @supply_mv:  supply voltage in mv. Overridden by regulator if available.
+ **/
+struct sht15_platform_data {
+        int gpio_data;
+        int gpio_sck;
+        int supply_mv;
+};
+
diff --git a/include/linux/skbuff.h b/include/linux/skbuff.h
index 55d67300fa10..5fd389162f01 100644
--- a/include/linux/skbuff.h
+++ b/include/linux/skbuff.h
@@ -168,6 +168,7 @@ struct skb_shared_hwtstamps {
  * @software:           generate software time stamp
  * @in_progress:        device driver is going to provide
  *                      hardware time stamp
+ * @flags:              all shared_tx flags
  *
  * These flags are attached to packets as part of the
  * &skb_shared_info. Use skb_tx() to get a pointer.
diff --git a/include/linux/slab_def.h b/include/linux/slab_def.h
index 6ca6a7b66d75..5ac9b0bcaf9a 100644
--- a/include/linux/slab_def.h
+++ b/include/linux/slab_def.h
@@ -14,6 +14,7 @@
 #include <asm/page.h>           /* kmalloc_sizes.h needs PAGE_SIZE */
 #include <asm/cache.h>          /* kmalloc_sizes.h needs L1_CACHE_BYTES */
 #include <linux/compiler.h>
+#include <trace/kmemtrace.h>
 
 /* Size description struct for general caches. */
 struct cache_sizes {
@@ -28,8 +29,26 @@ 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)
+#ifdef CONFIG_KMEMTRACE
+extern void *kmem_cache_alloc_notrace(struct kmem_cache *cachep, gfp_t flags);
+extern size_t slab_buffer_size(struct kmem_cache *cachep);
+#else
+static __always_inline void *
+kmem_cache_alloc_notrace(struct kmem_cache *cachep, gfp_t flags)
 {
+        return kmem_cache_alloc(cachep, flags);
+}
+static inline size_t slab_buffer_size(struct kmem_cache *cachep)
+{
+        return 0;
+}
+#endif
+
+static __always_inline void *kmalloc(size_t size, gfp_t flags)
+{
+        struct kmem_cache *cachep;
+        void *ret;
+
         if (__builtin_constant_p(size)) {
                 int i = 0;
 
@@ -47,10 +66,17 @@ static inline void *kmalloc(size_t size, gfp_t flags)
 found:
 #ifdef CONFIG_ZONE_DMA
                 if (flags & GFP_DMA)
-                        return kmem_cache_alloc(malloc_sizes[i].cs_dmacachep,
-                                                flags);
+                        cachep = malloc_sizes[i].cs_dmacachep;
+                else
 #endif
-                return kmem_cache_alloc(malloc_sizes[i].cs_cachep, flags);
+                        cachep = malloc_sizes[i].cs_cachep;
+
+                ret = kmem_cache_alloc_notrace(cachep, flags);
+
+                trace_kmalloc(_THIS_IP_, ret,
+                              size, slab_buffer_size(cachep), flags);
+
+                return ret;
         }
         return __kmalloc(size, flags);
 }
@@ -59,8 +85,25 @@ found:
 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)
+#ifdef CONFIG_KMEMTRACE
+extern void *kmem_cache_alloc_node_notrace(struct kmem_cache *cachep,
+                                           gfp_t flags,
+                                           int nodeid);
+#else
+static __always_inline void *
+kmem_cache_alloc_node_notrace(struct kmem_cache *cachep,
+                              gfp_t flags,
+                              int nodeid)
+{
+        return kmem_cache_alloc_node(cachep, flags, nodeid);
+}
+#endif
+
+static __always_inline void *kmalloc_node(size_t size, gfp_t flags, int node)
 {
+        struct kmem_cache *cachep;
+        void *ret;
+
         if (__builtin_constant_p(size)) {
                 int i = 0;
 
@@ -78,11 +121,18 @@ static inline void *kmalloc_node(size_t size, gfp_t flags, int node)
 found:
 #ifdef CONFIG_ZONE_DMA
                 if (flags & GFP_DMA)
-                        return kmem_cache_alloc_node(malloc_sizes[i].cs_dmacachep,
-                                                flags, node);
+                        cachep = malloc_sizes[i].cs_dmacachep;
+                else
 #endif
-                return kmem_cache_alloc_node(malloc_sizes[i].cs_cachep,
-                                                flags, node);
+                        cachep = malloc_sizes[i].cs_cachep;
+
+                ret = kmem_cache_alloc_node_notrace(cachep, flags, node);
+
+                trace_kmalloc_node(_THIS_IP_, ret,
+                                   size, slab_buffer_size(cachep),
+                                   flags, node);
+
+                return ret;
         }
         return __kmalloc_node(size, flags, node);
 }
diff --git a/include/linux/slob_def.h b/include/linux/slob_def.h
index 59a3fa476ab9..0ec00b39d006 100644
--- a/include/linux/slob_def.h
+++ b/include/linux/slob_def.h
@@ -3,14 +3,15 @@
 
 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)
+static __always_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)
+static __always_inline void *kmalloc_node(size_t size, gfp_t flags, int node)
 {
         return __kmalloc_node(size, flags, node);
 }
@@ -23,12 +24,12 @@ static inline void *kmalloc_node(size_t size, gfp_t flags, int node)
  * kmalloc is the normal method of allocating memory
  * in the kernel.
  */
-static inline void *kmalloc(size_t size, gfp_t flags)
+static __always_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)
+static __always_inline void *__kmalloc(size_t size, gfp_t flags)
 {
         return kmalloc(size, flags);
 }
diff --git a/include/linux/slow-work.h b/include/linux/slow-work.h
new file mode 100644
index 000000000000..b65c8881f07a
--- /dev/null
+++ b/include/linux/slow-work.h
@@ -0,0 +1,95 @@
+/* Worker thread pool for slow items, such as filesystem lookups or mkdirs
+ *
+ * Copyright (C) 2008 Red Hat, Inc. All Rights Reserved.
+ * Written by David Howells (dhowells@redhat.com)
+ *
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU General Public Licence
+ * as published by the Free Software Foundation; either version
+ * 2 of the Licence, or (at your option) any later version.
+ *
+ * See Documentation/slow-work.txt
+ */
+
+#ifndef _LINUX_SLOW_WORK_H
+#define _LINUX_SLOW_WORK_H
+
+#ifdef CONFIG_SLOW_WORK
+
+#include <linux/sysctl.h>
+
+struct slow_work;
+
+/*
+ * The operations used to support slow work items
+ */
+struct slow_work_ops {
+        /* get a ref on a work item
+         * - return 0 if successful, -ve if not
+         */
+        int (*get_ref)(struct slow_work *work);
+
+        /* discard a ref to a work item */
+        void (*put_ref)(struct slow_work *work);
+
+        /* execute a work item */
+        void (*execute)(struct slow_work *work);
+};
+
+/*
+ * A slow work item
+ * - A reference is held on the parent object by the thread pool when it is
+ *   queued
+ */
+struct slow_work {
+        unsigned long           flags;
+#define SLOW_WORK_PENDING       0       /* item pending (further) execution */
+#define SLOW_WORK_EXECUTING     1       /* item currently executing */
+#define SLOW_WORK_ENQ_DEFERRED  2       /* item enqueue deferred */
+#define SLOW_WORK_VERY_SLOW     3       /* item is very slow */
+        const struct slow_work_ops *ops; /* operations table for this item */
+        struct list_head        link;   /* link in queue */
+};
+
+/**
+ * slow_work_init - Initialise a slow work item
+ * @work: The work item to initialise
+ * @ops: The operations to use to handle the slow work item
+ *
+ * Initialise a slow work item.
+ */
+static inline void slow_work_init(struct slow_work *work,
+                                  const struct slow_work_ops *ops)
+{
+        work->flags = 0;
+        work->ops = ops;
+        INIT_LIST_HEAD(&work->link);
+}
+
+/**
+ * vslow_work_init - Initialise a very slow work item
+ * @work: The work item to initialise
+ * @ops: The operations to use to handle the slow work item
+ *
+ * Initialise a very slow work item.  This item will be restricted such that
+ * only a certain number of the pool threads will be able to execute items of
+ * this type.
+ */
+static inline void vslow_work_init(struct slow_work *work,
+                                   const struct slow_work_ops *ops)
+{
+        work->flags = 1 << SLOW_WORK_VERY_SLOW;
+        work->ops = ops;
+        INIT_LIST_HEAD(&work->link);
+}
+
+extern int slow_work_enqueue(struct slow_work *work);
+extern int slow_work_register_user(void);
+extern void slow_work_unregister_user(void);
+
+#ifdef CONFIG_SYSCTL
+extern ctl_table slow_work_sysctls[];
+#endif
+
+#endif /* CONFIG_SLOW_WORK */
+#endif /* _LINUX_SLOW_WORK_H */
diff --git a/include/linux/slub_def.h b/include/linux/slub_def.h
index e37b6aa8a9fb..5046f90c1171 100644
--- a/include/linux/slub_def.h
+++ b/include/linux/slub_def.h
@@ -10,6 +10,7 @@
 #include <linux/gfp.h>
 #include <linux/workqueue.h>
 #include <linux/kobject.h>
+#include <trace/kmemtrace.h>
 
 enum stat_item {
         ALLOC_FASTPATH,         /* Allocation from cpu slab */
@@ -217,13 +218,30 @@ static __always_inline struct kmem_cache *kmalloc_slab(size_t size)
 void *kmem_cache_alloc(struct kmem_cache *, gfp_t);
 void *__kmalloc(size_t size, gfp_t flags);
 
+#ifdef CONFIG_KMEMTRACE
+extern void *kmem_cache_alloc_notrace(struct kmem_cache *s, gfp_t gfpflags);
+#else
+static __always_inline void *
+kmem_cache_alloc_notrace(struct kmem_cache *s, gfp_t gfpflags)
+{
+        return kmem_cache_alloc(s, gfpflags);
+}
+#endif
+
 static __always_inline void *kmalloc_large(size_t size, gfp_t flags)
 {
-        return (void *)__get_free_pages(flags | __GFP_COMP, get_order(size));
+        unsigned int order = get_order(size);
+        void *ret = (void *) __get_free_pages(flags | __GFP_COMP, order);
+
+        trace_kmalloc(_THIS_IP_, ret, size, PAGE_SIZE << order, flags);
+
+        return ret;
 }
 
 static __always_inline void *kmalloc(size_t size, gfp_t flags)
 {
+        void *ret;
+
         if (__builtin_constant_p(size)) {
                 if (size > SLUB_MAX_SIZE)
                         return kmalloc_large(size, flags);
@@ -234,7 +252,11 @@ static __always_inline void *kmalloc(size_t size, gfp_t flags)
                         if (!s)
                                 return ZERO_SIZE_PTR;
 
-                        return kmem_cache_alloc(s, flags);
+                        ret = kmem_cache_alloc_notrace(s, flags);
+
+                        trace_kmalloc(_THIS_IP_, ret, size, s->size, flags);
+
+                        return ret;
                 }
         }
         return __kmalloc(size, flags);
@@ -244,8 +266,24 @@ static __always_inline void *kmalloc(size_t size, gfp_t flags)
 void *__kmalloc_node(size_t size, gfp_t flags, int node);
 void *kmem_cache_alloc_node(struct kmem_cache *, gfp_t flags, int node);
 
+#ifdef CONFIG_KMEMTRACE
+extern void *kmem_cache_alloc_node_notrace(struct kmem_cache *s,
+                                           gfp_t gfpflags,
+                                           int node);
+#else
+static __always_inline void *
+kmem_cache_alloc_node_notrace(struct kmem_cache *s,
+                              gfp_t gfpflags,
+                              int node)
+{
+        return kmem_cache_alloc_node(s, gfpflags, node);
+}
+#endif
+
 static __always_inline void *kmalloc_node(size_t size, gfp_t flags, int node)
 {
+        void *ret;
+
         if (__builtin_constant_p(size) &&
                 size <= SLUB_MAX_SIZE && !(flags & SLUB_DMA)) {
                         struct kmem_cache *s = kmalloc_slab(size);
@@ -253,7 +291,12 @@ static __always_inline void *kmalloc_node(size_t size, gfp_t flags, int node)
                 if (!s)
                         return ZERO_SIZE_PTR;
 
-                return kmem_cache_alloc_node(s, flags, node);
+                ret = kmem_cache_alloc_node_notrace(s, flags, node);
+
+                trace_kmalloc_node(_THIS_IP_, ret,
+                                   size, s->size, flags, node);
+
+                return ret;
         }
         return __kmalloc_node(size, flags, node);
 }
diff --git a/include/linux/smp.h b/include/linux/smp.h
index bbacb7baa446..a69db820eed6 100644
--- a/include/linux/smp.h
+++ b/include/linux/smp.h
@@ -38,7 +38,7 @@ int smp_call_function_single(int cpuid, void (*func) (void *info), void *info,
 /*
  * main cross-CPU interfaces, handles INIT, TLB flush, STOP, etc.
  * (defined in asm header):
- */ 
+ */
 
 /*
  * stops all CPUs but the current one:
@@ -82,7 +82,8 @@ smp_call_function_mask(cpumask_t mask, void(*func)(void *info), void *info,
         return 0;
 }
 
-void __smp_call_function_single(int cpuid, struct call_single_data *data);
+void __smp_call_function_single(int cpuid, struct call_single_data *data,
+                                int wait);
 
 /*
  * Generic and arch helpers
@@ -121,6 +122,8 @@ extern unsigned int setup_max_cpus;
 
 #else /* !SMP */
 
+static inline void smp_send_stop(void) { }
+
 /*
  *      These macros fold the SMP functionality into a single CPU system
  */
diff --git a/include/linux/sonypi.h b/include/linux/sonypi.h
index f41ffd7c2dd9..34c4475ac4a2 100644
--- a/include/linux/sonypi.h
+++ b/include/linux/sonypi.h
@@ -103,6 +103,14 @@
 #define SONYPI_EVENT_WIRELESS_OFF               61
 #define SONYPI_EVENT_ZOOM_IN_PRESSED            62
 #define SONYPI_EVENT_ZOOM_OUT_PRESSED           63
+#define SONYPI_EVENT_CD_EJECT_PRESSED           64
+#define SONYPI_EVENT_MODEKEY_PRESSED            65
+#define SONYPI_EVENT_PKEY_P4                    66
+#define SONYPI_EVENT_PKEY_P5                    67
+#define SONYPI_EVENT_SETTINGKEY_PRESSED         68
+#define SONYPI_EVENT_VOLUME_INC_PRESSED         69
+#define SONYPI_EVENT_VOLUME_DEC_PRESSED         70
+#define SONYPI_EVENT_BRIGHTNESS_PRESSED         71
 
 /* get/set brightness */
 #define SONYPI_IOCGBRT          _IOR('v', 0, __u8)
diff --git a/include/linux/spi/ad7879.h b/include/linux/spi/ad7879.h
new file mode 100644
index 000000000000..4231104c9afa
--- /dev/null
+++ b/include/linux/spi/ad7879.h
@@ -0,0 +1,35 @@
+/* linux/spi/ad7879.h */
+
+/* Touchscreen characteristics vary between boards and models.  The
+ * platform_data for the device's "struct device" holds this information.
+ *
+ * It's OK if the min/max values are zero.
+ */
+struct ad7879_platform_data {
+        u16     model;                  /* 7879 */
+        u16     x_plate_ohms;
+        u16     x_min, x_max;
+        u16     y_min, y_max;
+        u16     pressure_min, pressure_max;
+
+        /* [0..255] 0=OFF Starts at 1=550us and goes
+         * all the way to 9.440ms in steps of 35us.
+         */
+        u8      pen_down_acc_interval;
+        /* [0..15] Starts at 0=128us and goes all the
+         * way to 4.096ms in steps of 128us.
+         */
+        u8      first_conversion_delay;
+        /* [0..3] 0 = 2us, 1 = 4us, 2 = 8us, 3 = 16us */
+        u8      acquisition_time;
+        /* [0..3] Average X middle samples 0 = 2, 1 = 4, 2 = 8, 3 = 16 */
+        u8      averaging;
+        /* [0..3] Perform X measurements 0 = OFF,
+         * 1 = 4, 2 = 8, 3 = 16 (median > averaging)
+         */
+        u8      median;
+        /* 1 = AUX/VBAT/GPIO set to GPIO Output */
+        u8      gpio_output;
+        /* Initial GPIO pin state (valid if gpio_output = 1) */
+        u8      gpio_default;
+};
diff --git a/include/linux/spi/ads7846.h b/include/linux/spi/ads7846.h
index 05eab2f11e63..2ea20320c093 100644
--- a/include/linux/spi/ads7846.h
+++ b/include/linux/spi/ads7846.h
@@ -51,5 +51,6 @@ struct ads7846_platform_data {
                                  void **filter_data);
         int     (*filter)       (void *filter_data, int data_idx, int *val);
         void    (*filter_cleanup)(void *filter_data);
+        void    (*wait_for_sync)(void);
 };
 
diff --git a/include/linux/spi/eeprom.h b/include/linux/spi/eeprom.h
index 1085212c446e..306e7b1c69ed 100644
--- a/include/linux/spi/eeprom.h
+++ b/include/linux/spi/eeprom.h
@@ -1,6 +1,8 @@
 #ifndef __LINUX_SPI_EEPROM_H
 #define __LINUX_SPI_EEPROM_H
 
+#include <linux/memory.h>
+
 /*
  * Put one of these structures in platform_data for SPI EEPROMS handled
  * by the "at25" driver.  On SPI, most EEPROMS understand the same core
@@ -17,6 +19,10 @@ struct spi_eeprom {
 #define EE_ADDR2        0x0002                  /* 16 bit addrs */
 #define EE_ADDR3        0x0004                  /* 24 bit addrs */
 #define EE_READONLY     0x0008                  /* disallow writes */
+
+        /* for exporting this chip's data to other kernel code */
+        void (*setup)(struct memory_accessor *mem, void *context);
+        void *context;
 };
 
 #endif /* __LINUX_SPI_EEPROM_H */
diff --git a/include/linux/spi/spi.h b/include/linux/spi/spi.h
index 68bb1c501d0d..a0faa18f7b1b 100644
--- a/include/linux/spi/spi.h
+++ b/include/linux/spi/spi.h
@@ -204,6 +204,7 @@ static inline void spi_unregister_driver(struct spi_driver *sdrv)
  *      SPI slaves, and are numbered from zero to num_chipselects.
  *      each slave has a chipselect signal, but it's common that not
  *      every chipselect is connected to a slave.
+ * @dma_alignment: SPI controller constraint on DMA buffers alignment.
  * @setup: updates the device mode and clocking records used by a
  *      device's SPI controller; protocol code may call this.  This
  *      must fail if an unrecognized or unsupported mode is requested.
@@ -239,7 +240,17 @@ struct spi_master {
          */
         u16                     num_chipselect;
 
-        /* setup mode and clock, etc (spi driver may call many times) */
+        /* some SPI controllers pose alignment requirements on DMAable
+         * buffers; let protocol drivers know about these requirements.
+         */
+        u16                     dma_alignment;
+
+        /* Setup mode and clock, etc (spi driver may call many times).
+         *
+         * IMPORTANT:  this may be called when transfers to another
+         * device are active.  DO NOT UPDATE SHARED REGISTERS in ways
+         * which could break those transfers.
+         */
         int                     (*setup)(struct spi_device *spi);
 
         /* bidirectional bulk transfers
diff --git a/include/linux/spi/spi_gpio.h b/include/linux/spi/spi_gpio.h
index 0f01a0f1f40c..ca6782ee4b9f 100644
--- a/include/linux/spi/spi_gpio.h
+++ b/include/linux/spi/spi_gpio.h
@@ -25,10 +25,16 @@
  *      ...
  *      };
  *
+ * If chipselect is not used (there's only one device on the bus), assign
+ * SPI_GPIO_NO_CHIPSELECT to the controller_data:
+ *              .controller_data = (void *) SPI_GPIO_NO_CHIPSELECT;
+ *
  * If the bitbanged bus is later switched to a "native" controller,
  * that platform_device and controller_data should be removed.
  */
 
+#define SPI_GPIO_NO_CHIPSELECT          ((unsigned long)-1l)
+
 /**
  * struct spi_gpio_platform_data - parameter for bitbanged SPI master
  * @sck: number of the GPIO used for clock output
diff --git a/include/linux/spinlock.h b/include/linux/spinlock.h
index a0c66a2e00ad..252b245cfcf4 100644
--- a/include/linux/spinlock.h
+++ b/include/linux/spinlock.h
@@ -153,9 +153,11 @@ do {								\
  extern int _raw_spin_trylock(spinlock_t *lock);
  extern void _raw_spin_unlock(spinlock_t *lock);
  extern void _raw_read_lock(rwlock_t *lock);
+#define _raw_read_lock_flags(lock, flags) _raw_read_lock(lock)
  extern int _raw_read_trylock(rwlock_t *lock);
  extern void _raw_read_unlock(rwlock_t *lock);
  extern void _raw_write_lock(rwlock_t *lock);
+#define _raw_write_lock_flags(lock, flags) _raw_write_lock(lock)
  extern int _raw_write_trylock(rwlock_t *lock);
  extern void _raw_write_unlock(rwlock_t *lock);
 #else
@@ -165,9 +167,13 @@ do {								\
 # define _raw_spin_trylock(lock)        __raw_spin_trylock(&(lock)->raw_lock)
 # define _raw_spin_unlock(lock)         __raw_spin_unlock(&(lock)->raw_lock)
 # define _raw_read_lock(rwlock)         __raw_read_lock(&(rwlock)->raw_lock)
+# define _raw_read_lock_flags(lock, flags) \
+                __raw_read_lock_flags(&(lock)->raw_lock, *(flags))
 # define _raw_read_trylock(rwlock)      __raw_read_trylock(&(rwlock)->raw_lock)
 # define _raw_read_unlock(rwlock)       __raw_read_unlock(&(rwlock)->raw_lock)
 # define _raw_write_lock(rwlock)        __raw_write_lock(&(rwlock)->raw_lock)
+# define _raw_write_lock_flags(lock, flags) \
+                __raw_write_lock_flags(&(lock)->raw_lock, *(flags))
 # define _raw_write_trylock(rwlock)     __raw_write_trylock(&(rwlock)->raw_lock)
 # define _raw_write_unlock(rwlock)      __raw_write_unlock(&(rwlock)->raw_lock)
 #endif
diff --git a/include/linux/splice.h b/include/linux/splice.h
index 528dcb93c2f2..5f3faa9d15ae 100644
--- a/include/linux/splice.h
+++ b/include/linux/splice.h
@@ -36,6 +36,8 @@ struct splice_desc {
                 void *data;             /* cookie */
         } u;
         loff_t pos;                     /* file position */
+        size_t num_spliced;             /* number of bytes already spliced */
+        bool need_wakeup;               /* need to wake up writer */
 };
 
 struct partial_page {
@@ -66,6 +68,16 @@ extern ssize_t splice_from_pipe(struct pipe_inode_info *, struct file *,
                                 splice_actor *);
 extern ssize_t __splice_from_pipe(struct pipe_inode_info *,
                                   struct splice_desc *, splice_actor *);
+extern int splice_from_pipe_feed(struct pipe_inode_info *, struct splice_desc *,
+                                 splice_actor *);
+extern int splice_from_pipe_next(struct pipe_inode_info *,
+                                 struct splice_desc *);
+extern void splice_from_pipe_begin(struct splice_desc *);
+extern void splice_from_pipe_end(struct pipe_inode_info *,
+                                 struct splice_desc *);
+extern int pipe_to_file(struct pipe_inode_info *, struct pipe_buffer *,
+                        struct splice_desc *);
+
 extern ssize_t splice_to_pipe(struct pipe_inode_info *,
                               struct splice_pipe_desc *);
 extern ssize_t splice_direct_to_actor(struct file *, struct splice_desc *,
diff --git a/include/linux/string.h b/include/linux/string.h
index d18fc198aa2f..489019ef1694 100644
--- a/include/linux/string.h
+++ b/include/linux/string.h
@@ -10,8 +10,10 @@
 #include <linux/compiler.h>     /* for inline */
 #include <linux/types.h>        /* for size_t */
 #include <linux/stddef.h>       /* for NULL */
+#include <stdarg.h>
 
 extern char *strndup_user(const char __user *, long);
+extern void *memdup_user(const void __user *, size_t);
 
 /*
  * Include machine specific inline routines
@@ -111,8 +113,23 @@ extern void argv_free(char **argv);
 
 extern bool sysfs_streq(const char *s1, const char *s2);
 
+#ifdef CONFIG_BINARY_PRINTF
+int vbin_printf(u32 *bin_buf, size_t size, const char *fmt, va_list args);
+int bstr_printf(char *buf, size_t size, const char *fmt, const u32 *bin_buf);
+int bprintf(u32 *bin_buf, size_t size, const char *fmt, ...) __printf(3, 4);
+#endif
+
 extern ssize_t memory_read_from_buffer(void *to, size_t count, loff_t *ppos,
                         const void *from, size_t available);
 
+/**
+ * strstarts - does @str start with @prefix?
+ * @str: string to examine
+ * @prefix: prefix to look for.
+ */
+static inline bool strstarts(const char *str, const char *prefix)
+{
+        return strncmp(str, prefix, strlen(prefix)) == 0;
+}
 #endif
 #endif /* _LINUX_STRING_H_ */
diff --git a/include/linux/stringify.h b/include/linux/stringify.h
index 0b4388356c87..841cec8ed525 100644
--- a/include/linux/stringify.h
+++ b/include/linux/stringify.h
@@ -6,7 +6,7 @@
  * converts to "bar".
  */
 
-#define __stringify_1(x)        #x
-#define __stringify(x)          __stringify_1(x)
+#define __stringify_1(x...)     #x
+#define __stringify(x...)       __stringify_1(x)
 
 #endif  /* !__LINUX_STRINGIFY_H */
diff --git a/include/linux/sunrpc/svc.h b/include/linux/sunrpc/svc.h
index 3435d24bfe55..2a30775959e9 100644
--- a/include/linux/sunrpc/svc.h
+++ b/include/linux/sunrpc/svc.h
@@ -24,6 +24,15 @@
  */
 typedef int             (*svc_thread_fn)(void *);
 
+/* statistics for svc_pool structures */
+struct svc_pool_stats {
+        unsigned long   packets;
+        unsigned long   sockets_queued;
+        unsigned long   threads_woken;
+        unsigned long   overloads_avoided;
+        unsigned long   threads_timedout;
+};
+
 /*
  *
  * RPC service thread pool.
@@ -41,6 +50,8 @@ struct svc_pool {
         struct list_head        sp_sockets;     /* pending sockets */
         unsigned int            sp_nrthreads;   /* # of threads in pool */
         struct list_head        sp_all_threads; /* all server threads */
+        int                     sp_nwaking;     /* number of threads woken but not yet active */
+        struct svc_pool_stats   sp_stats;       /* statistics on pool operation */
 } ____cacheline_aligned_in_smp;
 
 /*
@@ -69,7 +80,6 @@ struct svc_serv {
         struct list_head        sv_tempsocks;   /* all temporary sockets */
         int                     sv_tmpcnt;      /* count of temporary sockets */
         struct timer_list       sv_temptimer;   /* timer for aging temporary sockets */
-        sa_family_t             sv_family;      /* listener's address family */
 
         char *                  sv_name;        /* service name */
 
@@ -84,6 +94,8 @@ struct svc_serv {
         struct module *         sv_module;      /* optional module to count when
                                                  * adding threads */
         svc_thread_fn           sv_function;    /* main function for threads */
+        unsigned int            sv_drc_max_pages; /* Total pages for DRC */
+        unsigned int            sv_drc_pages_used;/* DRC pages used */
 };
 
 /*
@@ -219,6 +231,7 @@ struct svc_rqst {
         struct svc_cred         rq_cred;        /* auth info */
         void *                  rq_xprt_ctxt;   /* transport specific context ptr */
         struct svc_deferred_req*rq_deferred;    /* deferred request we are replaying */
+        int                     rq_usedeferral; /* use deferral */
 
         size_t                  rq_xprt_hlen;   /* xprt header len */
         struct xdr_buf          rq_arg;
@@ -264,6 +277,7 @@ struct svc_rqst {
                                                  * cache pages */
         wait_queue_head_t       rq_wait;        /* synchronization */
         struct task_struct      *rq_task;       /* service thread */
+        int                     rq_waking;      /* 1 if thread is being woken */
 };
 
 /*
@@ -385,19 +399,20 @@ struct svc_procedure {
 /*
  * Function prototypes.
  */
-struct svc_serv *svc_create(struct svc_program *, unsigned int, sa_family_t,
+struct svc_serv *svc_create(struct svc_program *, unsigned int,
                             void (*shutdown)(struct svc_serv *));
 struct svc_rqst *svc_prepare_thread(struct svc_serv *serv,
                                         struct svc_pool *pool);
 void               svc_exit_thread(struct svc_rqst *);
 struct svc_serv *  svc_create_pooled(struct svc_program *, unsigned int,
-                        sa_family_t, void (*shutdown)(struct svc_serv *),
+                        void (*shutdown)(struct svc_serv *),
                         svc_thread_fn, struct module *);
 int                svc_set_num_threads(struct svc_serv *, struct svc_pool *, int);
+int                svc_pool_stats_open(struct svc_serv *serv, struct file *file);
 void               svc_destroy(struct svc_serv *);
 int                svc_process(struct svc_rqst *);
-int                svc_register(const struct svc_serv *, const unsigned short,
-                                const unsigned short);
+int                svc_register(const struct svc_serv *, const int,
+                                const unsigned short, const unsigned short);
 
 void               svc_wake_up(struct svc_serv *);
 void               svc_reserve(struct svc_rqst *rqstp, int space);
diff --git a/include/linux/sunrpc/svc_xprt.h b/include/linux/sunrpc/svc_xprt.h
index 0127daca4354..0d9cb6ef28b0 100644
--- a/include/linux/sunrpc/svc_xprt.h
+++ b/include/linux/sunrpc/svc_xprt.h
@@ -71,7 +71,8 @@ int	svc_reg_xprt_class(struct svc_xprt_class *);
 void    svc_unreg_xprt_class(struct svc_xprt_class *);
 void    svc_xprt_init(struct svc_xprt_class *, struct svc_xprt *,
                       struct svc_serv *);
-int     svc_create_xprt(struct svc_serv *, char *, unsigned short, int);
+int     svc_create_xprt(struct svc_serv *, const char *, const int,
+                        const unsigned short, int);
 void    svc_xprt_enqueue(struct svc_xprt *xprt);
 void    svc_xprt_received(struct svc_xprt *);
 void    svc_xprt_put(struct svc_xprt *xprt);
@@ -80,7 +81,8 @@ void	svc_close_xprt(struct svc_xprt *xprt);
 void    svc_delete_xprt(struct svc_xprt *xprt);
 int     svc_port_is_privileged(struct sockaddr *sin);
 int     svc_print_xprts(char *buf, int maxlen);
-struct  svc_xprt *svc_find_xprt(struct svc_serv *, char *, int, int);
+struct  svc_xprt *svc_find_xprt(struct svc_serv *serv, const char *xcl_name,
+                        const sa_family_t af, const unsigned short port);
 int     svc_xprt_names(struct svc_serv *serv, char *buf, int buflen);
 
 static inline void svc_xprt_get(struct svc_xprt *xprt)
@@ -88,29 +90,32 @@ static inline void svc_xprt_get(struct svc_xprt *xprt)
         kref_get(&xprt->xpt_ref);
 }
 static inline void svc_xprt_set_local(struct svc_xprt *xprt,
-                                      struct sockaddr *sa, int salen)
+                                      const struct sockaddr *sa,
+                                      const size_t salen)
 {
         memcpy(&xprt->xpt_local, sa, salen);
         xprt->xpt_locallen = salen;
 }
 static inline void svc_xprt_set_remote(struct svc_xprt *xprt,
-                                       struct sockaddr *sa, int salen)
+                                       const struct sockaddr *sa,
+                                       const size_t salen)
 {
         memcpy(&xprt->xpt_remote, sa, salen);
         xprt->xpt_remotelen = salen;
 }
-static inline unsigned short svc_addr_port(struct sockaddr *sa)
+static inline unsigned short svc_addr_port(const struct sockaddr *sa)
 {
-        unsigned short ret = 0;
+        const struct sockaddr_in *sin = (const struct sockaddr_in *)sa;
+        const struct sockaddr_in6 *sin6 = (const struct sockaddr_in6 *)sa;
+
         switch (sa->sa_family) {
         case AF_INET:
-                ret = ntohs(((struct sockaddr_in *)sa)->sin_port);
-                break;
+                return ntohs(sin->sin_port);
         case AF_INET6:
-                ret = ntohs(((struct sockaddr_in6 *)sa)->sin6_port);
-                break;
+                return ntohs(sin6->sin6_port);
         }
-        return ret;
+
+        return 0;
 }
 
 static inline size_t svc_addr_len(struct sockaddr *sa)
@@ -124,36 +129,39 @@ static inline size_t svc_addr_len(struct sockaddr *sa)
         return -EAFNOSUPPORT;
 }
 
-static inline unsigned short svc_xprt_local_port(struct svc_xprt *xprt)
+static inline unsigned short svc_xprt_local_port(const struct svc_xprt *xprt)
 {
-        return svc_addr_port((struct sockaddr *)&xprt->xpt_local);
+        return svc_addr_port((const struct sockaddr *)&xprt->xpt_local);
 }
 
-static inline unsigned short svc_xprt_remote_port(struct svc_xprt *xprt)
+static inline unsigned short svc_xprt_remote_port(const struct svc_xprt *xprt)
 {
-        return svc_addr_port((struct sockaddr *)&xprt->xpt_remote);
+        return svc_addr_port((const struct sockaddr *)&xprt->xpt_remote);
 }
 
-static inline char *__svc_print_addr(struct sockaddr *addr,
-                                     char *buf, size_t len)
+static inline char *__svc_print_addr(const struct sockaddr *addr,
+                                     char *buf, const size_t len)
 {
+        const struct sockaddr_in *sin = (const struct sockaddr_in *)addr;
+        const struct sockaddr_in6 *sin6 = (const struct sockaddr_in6 *)addr;
+
         switch (addr->sa_family) {
         case AF_INET:
-                snprintf(buf, len, "%pI4, port=%u",
-                        &((struct sockaddr_in *)addr)->sin_addr,
-                        ntohs(((struct sockaddr_in *) addr)->sin_port));
+                snprintf(buf, len, "%pI4, port=%u", &sin->sin_addr,
+                        ntohs(sin->sin_port));
                 break;
 
         case AF_INET6:
                 snprintf(buf, len, "%pI6, port=%u",
-                         &((struct sockaddr_in6 *)addr)->sin6_addr,
-                        ntohs(((struct sockaddr_in6 *) addr)->sin6_port));
+                         &sin6->sin6_addr,
+                        ntohs(sin6->sin6_port));
                 break;
 
         default:
                 snprintf(buf, len, "unknown address type: %d", addr->sa_family);
                 break;
         }
+
         return buf;
 }
 #endif /* SUNRPC_SVC_XPRT_H */
diff --git a/include/linux/sunrpc/xdr.h b/include/linux/sunrpc/xdr.h
index 49e1eb454465..d8910b68e1bd 100644
--- a/include/linux/sunrpc/xdr.h
+++ b/include/linux/sunrpc/xdr.h
@@ -69,27 +69,27 @@ struct xdr_buf {
  * pre-xdr'ed macros.
  */
 
-#define xdr_zero        __constant_htonl(0)
-#define xdr_one         __constant_htonl(1)
-#define xdr_two         __constant_htonl(2)
-
-#define rpc_success             __constant_htonl(RPC_SUCCESS)
-#define rpc_prog_unavail        __constant_htonl(RPC_PROG_UNAVAIL)
-#define rpc_prog_mismatch       __constant_htonl(RPC_PROG_MISMATCH)
-#define rpc_proc_unavail        __constant_htonl(RPC_PROC_UNAVAIL)
-#define rpc_garbage_args        __constant_htonl(RPC_GARBAGE_ARGS)
-#define rpc_system_err          __constant_htonl(RPC_SYSTEM_ERR)
-#define rpc_drop_reply          __constant_htonl(RPC_DROP_REPLY)
-
-#define rpc_auth_ok             __constant_htonl(RPC_AUTH_OK)
-#define rpc_autherr_badcred     __constant_htonl(RPC_AUTH_BADCRED)
-#define rpc_autherr_rejectedcred __constant_htonl(RPC_AUTH_REJECTEDCRED)
-#define rpc_autherr_badverf     __constant_htonl(RPC_AUTH_BADVERF)
-#define rpc_autherr_rejectedverf __constant_htonl(RPC_AUTH_REJECTEDVERF)
-#define rpc_autherr_tooweak     __constant_htonl(RPC_AUTH_TOOWEAK)
-#define rpcsec_gsserr_credproblem       __constant_htonl(RPCSEC_GSS_CREDPROBLEM)
-#define rpcsec_gsserr_ctxproblem        __constant_htonl(RPCSEC_GSS_CTXPROBLEM)
-#define rpc_autherr_oldseqnum   __constant_htonl(101)
+#define xdr_zero        cpu_to_be32(0)
+#define xdr_one         cpu_to_be32(1)
+#define xdr_two         cpu_to_be32(2)
+
+#define rpc_success             cpu_to_be32(RPC_SUCCESS)
+#define rpc_prog_unavail        cpu_to_be32(RPC_PROG_UNAVAIL)
+#define rpc_prog_mismatch       cpu_to_be32(RPC_PROG_MISMATCH)
+#define rpc_proc_unavail        cpu_to_be32(RPC_PROC_UNAVAIL)
+#define rpc_garbage_args        cpu_to_be32(RPC_GARBAGE_ARGS)
+#define rpc_system_err          cpu_to_be32(RPC_SYSTEM_ERR)
+#define rpc_drop_reply          cpu_to_be32(RPC_DROP_REPLY)
+
+#define rpc_auth_ok             cpu_to_be32(RPC_AUTH_OK)
+#define rpc_autherr_badcred     cpu_to_be32(RPC_AUTH_BADCRED)
+#define rpc_autherr_rejectedcred cpu_to_be32(RPC_AUTH_REJECTEDCRED)
+#define rpc_autherr_badverf     cpu_to_be32(RPC_AUTH_BADVERF)
+#define rpc_autherr_rejectedverf cpu_to_be32(RPC_AUTH_REJECTEDVERF)
+#define rpc_autherr_tooweak     cpu_to_be32(RPC_AUTH_TOOWEAK)
+#define rpcsec_gsserr_credproblem       cpu_to_be32(RPCSEC_GSS_CREDPROBLEM)
+#define rpcsec_gsserr_ctxproblem        cpu_to_be32(RPCSEC_GSS_CTXPROBLEM)
+#define rpc_autherr_oldseqnum   cpu_to_be32(101)
 
 /*
  * Miscellaneous XDR helper functions
diff --git a/include/linux/sunrpc/xprt.h b/include/linux/sunrpc/xprt.h
index 11fc71d50c1e..08afe43118f4 100644
--- a/include/linux/sunrpc/xprt.h
+++ b/include/linux/sunrpc/xprt.h
@@ -235,6 +235,7 @@ static inline __be32 *xprt_skip_transport_header(struct rpc_xprt *xprt, __be32 *
  */
 int                     xprt_register_transport(struct xprt_class *type);
 int                     xprt_unregister_transport(struct xprt_class *type);
+int                     xprt_load_transport(const char *);
 void                    xprt_set_retrans_timeout_def(struct rpc_task *task);
 void                    xprt_set_retrans_timeout_rtt(struct rpc_task *task);
 void                    xprt_wake_pending_tasks(struct rpc_xprt *xprt, int status);
@@ -259,6 +260,8 @@ void			xprt_conditional_disconnect(struct rpc_xprt *xprt, unsigned int cookie);
 #define XPRT_BOUND              (4)
 #define XPRT_BINDING            (5)
 #define XPRT_CLOSING            (6)
+#define XPRT_CONNECTION_ABORT   (7)
+#define XPRT_CONNECTION_CLOSE   (8)
 
 static inline void xprt_set_connected(struct rpc_xprt *xprt)
 {
diff --git a/include/linux/suspend.h b/include/linux/suspend.h
index c7d9bb1832ba..795032edfc46 100644
--- a/include/linux/suspend.h
+++ b/include/linux/suspend.h
@@ -1,9 +1,6 @@
 #ifndef _LINUX_SUSPEND_H
 #define _LINUX_SUSPEND_H
 
-#if defined(CONFIG_X86) || defined(CONFIG_FRV) || defined(CONFIG_PPC32) || defined(CONFIG_PPC64)
-#include <asm/suspend.h>
-#endif
 #include <linux/swap.h>
 #include <linux/notifier.h>
 #include <linux/init.h>
@@ -61,10 +58,17 @@ typedef int __bitwise suspend_state_t;
  *      by @begin().
  *      @prepare() is called right after devices have been suspended (ie. the
  *      appropriate .suspend() method has been executed for each device) and
- *      before the nonboot CPUs are disabled (it is executed with IRQs enabled).
- *      This callback is optional.  It returns 0 on success or a negative
- *      error code otherwise, in which case the system cannot enter the desired
- *      sleep state (@enter() and @finish() will not be called in that case).
+ *      before device drivers' late suspend callbacks are executed.  It returns
+ *      0 on success or a negative error code otherwise, in which case the
+ *      system cannot enter the desired sleep state (@prepare_late(), @enter(),
+ *      @wake(), and @finish() will not be called in that case).
+ *
+ * @prepare_late: Finish preparing the platform for entering the system sleep
+ *      state indicated by @begin().
+ *      @prepare_late is called before disabling nonboot CPUs and after
+ *      device drivers' late suspend callbacks have been executed.  It returns
+ *      0 on success or a negative error code otherwise, in which case the
+ *      system cannot enter the desired sleep state (@enter() and @wake()).
  *
  * @enter: Enter the system sleep state indicated by @begin() or represented by
  *      the argument if @begin() is not implemented.
@@ -72,19 +76,26 @@ typedef int __bitwise suspend_state_t;
  *      error code otherwise, in which case the system cannot enter the desired
  *      sleep state.
  *
- * @finish: Called when the system has just left a sleep state, right after
- *      the nonboot CPUs have been enabled and before devices are resumed (it is
- *      executed with IRQs enabled).
+ * @wake: Called when the system has just left a sleep state, right after
+ *      the nonboot CPUs have been enabled and before device drivers' early
+ *      resume callbacks are executed.
+ *      This callback is optional, but should be implemented by the platforms
+ *      that implement @prepare_late().  If implemented, it is always called
+ *      after @enter(), even if @enter() fails.
+ *
+ * @finish: Finish wake-up of the platform.
+ *      @finish is called right prior to calling device drivers' regular suspend
+ *      callbacks.
  *      This callback is optional, but should be implemented by the platforms
  *      that implement @prepare().  If implemented, it is always called after
- *      @enter() (even if @enter() fails).
+ *      @enter() and @wake(), if implemented, even if any of them fails.
  *
  * @end: Called by the PM core right after resuming devices, to indicate to
  *      the platform that the system has returned to the working state or
  *      the transition to the sleep state has been aborted.
  *      This callback is optional, but should be implemented by the platforms
- *      that implement @begin(), but platforms implementing @begin() should
- *      also provide a @end() which cleans up transitions aborted before
+ *      that implement @begin().  Accordingly, platforms implementing @begin()
+ *      should also provide a @end() which cleans up transitions aborted before
  *      @enter().
  *
  * @recover: Recover the platform from a suspend failure.
@@ -96,7 +107,9 @@ struct platform_suspend_ops {
         int (*valid)(suspend_state_t state);
         int (*begin)(suspend_state_t state);
         int (*prepare)(void);
+        int (*prepare_late)(void);
         int (*enter)(suspend_state_t state);
+        void (*wake)(void);
         void (*finish)(void);
         void (*end)(void);
         void (*recover)(void);
diff --git a/include/linux/swap.h b/include/linux/swap.h
index d30215578877..62d81435347a 100644
--- a/include/linux/swap.h
+++ b/include/linux/swap.h
@@ -212,7 +212,7 @@ static inline void lru_cache_add_active_file(struct page *page)
 
 /* linux/mm/vmscan.c */
 extern unsigned long try_to_free_pages(struct zonelist *zonelist, int order,
-                                        gfp_t gfp_mask);
+                                        gfp_t gfp_mask, nodemask_t *mask);
 extern unsigned long try_to_free_mem_cgroup_pages(struct mem_cgroup *mem,
                                                   gfp_t gfp_mask, bool noswap,
                                                   unsigned int swappiness);
@@ -382,6 +382,11 @@ static inline struct page *swapin_readahead(swp_entry_t swp, gfp_t gfp_mask,
         return NULL;
 }
 
+static inline int swap_writepage(struct page *p, struct writeback_control *wbc)
+{
+        return 0;
+}
+
 static inline struct page *lookup_swap_cache(swp_entry_t swp)
 {
         return NULL;
diff --git a/include/linux/swiotlb.h b/include/linux/swiotlb.h
index dedd3c0cfe30..ac9ff54f7cb3 100644
--- a/include/linux/swiotlb.h
+++ b/include/linux/swiotlb.h
@@ -31,7 +31,7 @@ extern dma_addr_t swiotlb_phys_to_bus(struct device *hwdev,
                                       phys_addr_t address);
 extern phys_addr_t swiotlb_bus_to_phys(dma_addr_t address);
 
-extern int swiotlb_arch_range_needs_mapping(void *ptr, size_t size);
+extern int swiotlb_arch_range_needs_mapping(phys_addr_t paddr, size_t size);
 
 extern void
 *swiotlb_alloc_coherent(struct device *hwdev, size_t size,
@@ -41,20 +41,13 @@ extern void
 swiotlb_free_coherent(struct device *hwdev, size_t size,
                       void *vaddr, dma_addr_t dma_handle);
 
-extern dma_addr_t
-swiotlb_map_single(struct device *hwdev, void *ptr, size_t size, int dir);
-
-extern void
-swiotlb_unmap_single(struct device *hwdev, dma_addr_t dev_addr,
-                     size_t size, int dir);
-
-extern dma_addr_t
-swiotlb_map_single_attrs(struct device *hwdev, void *ptr, size_t size,
-                         int dir, struct dma_attrs *attrs);
-
-extern void
-swiotlb_unmap_single_attrs(struct device *hwdev, dma_addr_t dev_addr,
-                           size_t size, int dir, struct dma_attrs *attrs);
+extern dma_addr_t swiotlb_map_page(struct device *dev, struct page *page,
+                                   unsigned long offset, size_t size,
+                                   enum dma_data_direction dir,
+                                   struct dma_attrs *attrs);
+extern void swiotlb_unmap_page(struct device *hwdev, dma_addr_t dev_addr,
+                               size_t size, enum dma_data_direction dir,
+                               struct dma_attrs *attrs);
 
 extern int
 swiotlb_map_sg(struct device *hwdev, struct scatterlist *sg, int nents,
@@ -66,36 +59,38 @@ swiotlb_unmap_sg(struct device *hwdev, struct scatterlist *sg, int nents,
 
 extern int
 swiotlb_map_sg_attrs(struct device *hwdev, struct scatterlist *sgl, int nelems,
-                     int dir, struct dma_attrs *attrs);
+                     enum dma_data_direction dir, struct dma_attrs *attrs);
 
 extern void
 swiotlb_unmap_sg_attrs(struct device *hwdev, struct scatterlist *sgl,
-                       int nelems, int dir, struct dma_attrs *attrs);
+                       int nelems, enum dma_data_direction dir,
+                       struct dma_attrs *attrs);
 
 extern void
 swiotlb_sync_single_for_cpu(struct device *hwdev, dma_addr_t dev_addr,
-                            size_t size, int dir);
+                            size_t size, enum dma_data_direction dir);
 
 extern void
 swiotlb_sync_sg_for_cpu(struct device *hwdev, struct scatterlist *sg,
-                        int nelems, int dir);
+                        int nelems, enum dma_data_direction dir);
 
 extern void
 swiotlb_sync_single_for_device(struct device *hwdev, dma_addr_t dev_addr,
-                               size_t size, int dir);
+                               size_t size, enum dma_data_direction dir);
 
 extern void
 swiotlb_sync_sg_for_device(struct device *hwdev, struct scatterlist *sg,
-                           int nelems, int dir);
+                           int nelems, enum dma_data_direction dir);
 
 extern void
 swiotlb_sync_single_range_for_cpu(struct device *hwdev, dma_addr_t dev_addr,
-                                  unsigned long offset, size_t size, int dir);
+                                  unsigned long offset, size_t size,
+                                  enum dma_data_direction dir);
 
 extern void
 swiotlb_sync_single_range_for_device(struct device *hwdev, dma_addr_t dev_addr,
                                      unsigned long offset, size_t size,
-                                     int dir);
+                                     enum dma_data_direction dir);
 
 extern int
 swiotlb_dma_mapping_error(struct device *hwdev, dma_addr_t dma_addr);
diff --git a/include/linux/synclink.h b/include/linux/synclink.h
index 99b8bdb17b2b..0ff2779c44d0 100644
--- a/include/linux/synclink.h
+++ b/include/linux/synclink.h
@@ -125,6 +125,7 @@
 #define MGSL_MODE_MONOSYNC      3
 #define MGSL_MODE_BISYNC        4
 #define MGSL_MODE_RAW           6
+#define MGSL_MODE_BASE_CLOCK    7
 
 #define MGSL_BUS_TYPE_ISA       1
 #define MGSL_BUS_TYPE_EISA      2
diff --git a/include/linux/syscalls.h b/include/linux/syscalls.h
index f9f900cfd066..40617c1d8976 100644
--- a/include/linux/syscalls.h
+++ b/include/linux/syscalls.h
@@ -65,6 +65,7 @@ struct old_linux_dirent;
 #include <asm/signal.h>
 #include <linux/quota.h>
 #include <linux/key.h>
+#include <trace/syscall.h>
 
 #define __SC_DECL1(t1, a1)      t1 a1
 #define __SC_DECL2(t2, a2, ...) t2 a2, __SC_DECL1(__VA_ARGS__)
@@ -95,7 +96,46 @@ struct old_linux_dirent;
 #define __SC_TEST5(t5, a5, ...) __SC_TEST(t5); __SC_TEST4(__VA_ARGS__)
 #define __SC_TEST6(t6, a6, ...) __SC_TEST(t6); __SC_TEST5(__VA_ARGS__)
 
+#ifdef CONFIG_FTRACE_SYSCALLS
+#define __SC_STR_ADECL1(t, a)           #a
+#define __SC_STR_ADECL2(t, a, ...)      #a, __SC_STR_ADECL1(__VA_ARGS__)
+#define __SC_STR_ADECL3(t, a, ...)      #a, __SC_STR_ADECL2(__VA_ARGS__)
+#define __SC_STR_ADECL4(t, a, ...)      #a, __SC_STR_ADECL3(__VA_ARGS__)
+#define __SC_STR_ADECL5(t, a, ...)      #a, __SC_STR_ADECL4(__VA_ARGS__)
+#define __SC_STR_ADECL6(t, a, ...)      #a, __SC_STR_ADECL5(__VA_ARGS__)
+
+#define __SC_STR_TDECL1(t, a)           #t
+#define __SC_STR_TDECL2(t, a, ...)      #t, __SC_STR_TDECL1(__VA_ARGS__)
+#define __SC_STR_TDECL3(t, a, ...)      #t, __SC_STR_TDECL2(__VA_ARGS__)
+#define __SC_STR_TDECL4(t, a, ...)      #t, __SC_STR_TDECL3(__VA_ARGS__)
+#define __SC_STR_TDECL5(t, a, ...)      #t, __SC_STR_TDECL4(__VA_ARGS__)
+#define __SC_STR_TDECL6(t, a, ...)      #t, __SC_STR_TDECL5(__VA_ARGS__)
+
+#define SYSCALL_METADATA(sname, nb)                             \
+        static const struct syscall_metadata __used             \
+          __attribute__((__aligned__(4)))                       \
+          __attribute__((section("__syscalls_metadata")))       \
+          __syscall_meta_##sname = {                            \
+                .name           = "sys"#sname,                  \
+                .nb_args        = nb,                           \
+                .types          = types_##sname,                \
+                .args           = args_##sname,                 \
+        }
+
+#define SYSCALL_DEFINE0(sname)                                  \
+        static const struct syscall_metadata __used             \
+          __attribute__((__aligned__(4)))                       \
+          __attribute__((section("__syscalls_metadata")))       \
+          __syscall_meta_##sname = {                            \
+                .name           = "sys_"#sname,                 \
+                .nb_args        = 0,                            \
+        };                                                      \
+        asmlinkage long sys_##sname(void)
+
+#else
 #define SYSCALL_DEFINE0(name)      asmlinkage long sys_##name(void)
+#endif
+
 #define SYSCALL_DEFINE1(name, ...) SYSCALL_DEFINEx(1, _##name, __VA_ARGS__)
 #define SYSCALL_DEFINE2(name, ...) SYSCALL_DEFINEx(2, _##name, __VA_ARGS__)
 #define SYSCALL_DEFINE3(name, ...) SYSCALL_DEFINEx(3, _##name, __VA_ARGS__)
@@ -108,7 +148,7 @@ struct old_linux_dirent;
         asm ("\t.globl " #alias "\n\t.set " #alias ", " #name "\n"      \
              "\t.globl ." #alias "\n\t.set ." #alias ", ." #name)
 #else
-#ifdef CONFIG_ALPHA
+#if defined(CONFIG_ALPHA) || defined(CONFIG_MIPS)
 #define SYSCALL_ALIAS(alias, name)                                      \
         asm ( #alias " = " #name "\n\t.globl " #alias)
 #else
@@ -117,10 +157,26 @@ struct old_linux_dirent;
 #endif
 #endif
 
+#ifdef CONFIG_FTRACE_SYSCALLS
+#define SYSCALL_DEFINEx(x, sname, ...)                          \
+        static const char *types_##sname[] = {                  \
+                __SC_STR_TDECL##x(__VA_ARGS__)                  \
+        };                                                      \
+        static const char *args_##sname[] = {                   \
+                __SC_STR_ADECL##x(__VA_ARGS__)                  \
+        };                                                      \
+        SYSCALL_METADATA(sname, x);                             \
+        __SYSCALL_DEFINEx(x, sname, __VA_ARGS__)
+#else
+#define SYSCALL_DEFINEx(x, sname, ...)                          \
+        __SYSCALL_DEFINEx(x, sname, __VA_ARGS__)
+#endif
+
 #ifdef CONFIG_HAVE_SYSCALL_WRAPPERS
 
 #define SYSCALL_DEFINE(name) static inline long SYSC_##name
-#define SYSCALL_DEFINEx(x, name, ...)                                   \
+
+#define __SYSCALL_DEFINEx(x, name, ...)                                 \
         asmlinkage long sys##name(__SC_DECL##x(__VA_ARGS__));           \
         static inline long SYSC##name(__SC_DECL##x(__VA_ARGS__));       \
         asmlinkage long SyS##name(__SC_LONG##x(__VA_ARGS__))            \
@@ -134,7 +190,7 @@ struct old_linux_dirent;
 #else /* CONFIG_HAVE_SYSCALL_WRAPPERS */
 
 #define SYSCALL_DEFINE(name) asmlinkage long sys_##name
-#define SYSCALL_DEFINEx(x, name, ...)                                   \
+#define __SYSCALL_DEFINEx(x, name, ...)                                 \
         asmlinkage long sys##name(__SC_DECL##x(__VA_ARGS__))
 
 #endif /* CONFIG_HAVE_SYSCALL_WRAPPERS */
@@ -461,6 +517,10 @@ asmlinkage long sys_pread64(unsigned int fd, char __user *buf,
                             size_t count, loff_t pos);
 asmlinkage long sys_pwrite64(unsigned int fd, const char __user *buf,
                              size_t count, loff_t pos);
+asmlinkage long sys_preadv(unsigned long fd, const struct iovec __user *vec,
+                           unsigned long vlen, unsigned long pos_l, unsigned long pos_h);
+asmlinkage long sys_pwritev(unsigned long fd, const struct iovec __user *vec,
+                            unsigned long vlen, unsigned long pos_l, unsigned long pos_h);
 asmlinkage long sys_getcwd(char __user *buf, unsigned long size);
 asmlinkage long sys_mkdir(const char __user *pathname, int mode);
 asmlinkage long sys_chdir(const char __user *filename);
diff --git a/include/linux/thermal.h b/include/linux/thermal.h
index 917707e6151d..1de8b9eb841b 100644
--- a/include/linux/thermal.h
+++ b/include/linux/thermal.h
@@ -27,27 +27,46 @@
 
 #include <linux/idr.h>
 #include <linux/device.h>
+#include <linux/workqueue.h>
 
 struct thermal_zone_device;
 struct thermal_cooling_device;
 
+enum thermal_device_mode {
+        THERMAL_DEVICE_DISABLED = 0,
+        THERMAL_DEVICE_ENABLED,
+};
+
+enum thermal_trip_type {
+        THERMAL_TRIP_ACTIVE = 0,
+        THERMAL_TRIP_PASSIVE,
+        THERMAL_TRIP_HOT,
+        THERMAL_TRIP_CRITICAL,
+};
+
 struct thermal_zone_device_ops {
         int (*bind) (struct thermal_zone_device *,
                      struct thermal_cooling_device *);
         int (*unbind) (struct thermal_zone_device *,
                        struct thermal_cooling_device *);
-        int (*get_temp) (struct thermal_zone_device *, char *);
-        int (*get_mode) (struct thermal_zone_device *, char *);
-        int (*set_mode) (struct thermal_zone_device *, const char *);
-        int (*get_trip_type) (struct thermal_zone_device *, int, char *);
-        int (*get_trip_temp) (struct thermal_zone_device *, int, char *);
+        int (*get_temp) (struct thermal_zone_device *, unsigned long *);
+        int (*get_mode) (struct thermal_zone_device *,
+                         enum thermal_device_mode *);
+        int (*set_mode) (struct thermal_zone_device *,
+                enum thermal_device_mode);
+        int (*get_trip_type) (struct thermal_zone_device *, int,
+                enum thermal_trip_type *);
+        int (*get_trip_temp) (struct thermal_zone_device *, int,
+                              unsigned long *);
         int (*get_crit_temp) (struct thermal_zone_device *, unsigned long *);
+        int (*notify) (struct thermal_zone_device *, int,
+                       enum thermal_trip_type);
 };
 
 struct thermal_cooling_device_ops {
-        int (*get_max_state) (struct thermal_cooling_device *, char *);
-        int (*get_cur_state) (struct thermal_cooling_device *, char *);
-        int (*set_cur_state) (struct thermal_cooling_device *, unsigned int);
+        int (*get_max_state) (struct thermal_cooling_device *, unsigned long *);
+        int (*get_cur_state) (struct thermal_cooling_device *, unsigned long *);
+        int (*set_cur_state) (struct thermal_cooling_device *, unsigned long);
 };
 
 #define THERMAL_TRIPS_NONE -1
@@ -88,11 +107,19 @@ struct thermal_zone_device {
         struct device device;
         void *devdata;
         int trips;
+        int tc1;
+        int tc2;
+        int passive_delay;
+        int polling_delay;
+        int last_temperature;
+        bool passive;
+        unsigned int forced_passive;
         struct thermal_zone_device_ops *ops;
         struct list_head cooling_devices;
         struct idr idr;
         struct mutex lock;      /* protect cooling devices list */
         struct list_head node;
+        struct delayed_work poll_queue;
 #if defined(CONFIG_THERMAL_HWMON)
         struct list_head hwmon_node;
         struct thermal_hwmon_device *hwmon;
@@ -104,13 +131,16 @@ struct thermal_zone_device {
 struct thermal_zone_device *thermal_zone_device_register(char *, int, void *,
                                                          struct
                                                          thermal_zone_device_ops
-                                                         *);
+                                                         *, int tc1, int tc2,
+                                                         int passive_freq,
+                                                         int polling_freq);
 void thermal_zone_device_unregister(struct thermal_zone_device *);
 
 int thermal_zone_bind_cooling_device(struct thermal_zone_device *, int,
                                      struct thermal_cooling_device *);
 int thermal_zone_unbind_cooling_device(struct thermal_zone_device *, int,
                                        struct thermal_cooling_device *);
+void thermal_zone_device_update(struct thermal_zone_device *);
 struct thermal_cooling_device *thermal_cooling_device_register(char *, void *,
                                                                struct
                                                                thermal_cooling_device_ops
diff --git a/include/linux/timer.h b/include/linux/timer.h
index e2d662e3416e..6cdb6f3331f1 100644
--- a/include/linux/timer.h
+++ b/include/linux/timer.h
@@ -5,6 +5,7 @@
 #include <linux/ktime.h>
 #include <linux/stddef.h>
 #include <linux/debugobjects.h>
+#include <linux/stringify.h>
 
 struct tvec_base;
 
@@ -21,52 +22,126 @@ struct timer_list {
         char start_comm[16];
         int start_pid;
 #endif
+#ifdef CONFIG_LOCKDEP
+        struct lockdep_map lockdep_map;
+#endif
 };
 
 extern struct tvec_base boot_tvec_bases;
 
+#ifdef CONFIG_LOCKDEP
+/*
+ * NB: because we have to copy the lockdep_map, setting the lockdep_map key
+ * (second argument) here is required, otherwise it could be initialised to
+ * the copy of the lockdep_map later! We use the pointer to and the string
+ * "<file>:<line>" as the key resp. the name of the lockdep_map.
+ */
+#define __TIMER_LOCKDEP_MAP_INITIALIZER(_kn)                            \
+        .lockdep_map = STATIC_LOCKDEP_MAP_INIT(_kn, &_kn),
+#else
+#define __TIMER_LOCKDEP_MAP_INITIALIZER(_kn)
+#endif
+
 #define TIMER_INITIALIZER(_function, _expires, _data) {         \
                 .entry = { .prev = TIMER_ENTRY_STATIC },        \
                 .function = (_function),                        \
                 .expires = (_expires),                          \
                 .data = (_data),                                \
                 .base = &boot_tvec_bases,                       \
+                __TIMER_LOCKDEP_MAP_INITIALIZER(                \
+                        __FILE__ ":" __stringify(__LINE__))     \
         }
 
 #define DEFINE_TIMER(_name, _function, _expires, _data)         \
         struct timer_list _name =                               \
                 TIMER_INITIALIZER(_function, _expires, _data)
 
-void init_timer(struct timer_list *timer);
-void init_timer_deferrable(struct timer_list *timer);
+void init_timer_key(struct timer_list *timer,
+                    const char *name,
+                    struct lock_class_key *key);
+void init_timer_deferrable_key(struct timer_list *timer,
+                               const char *name,
+                               struct lock_class_key *key);
+
+#ifdef CONFIG_LOCKDEP
+#define init_timer(timer)                                               \
+        do {                                                            \
+                static struct lock_class_key __key;                     \
+                init_timer_key((timer), #timer, &__key);                \
+        } while (0)
+
+#define init_timer_deferrable(timer)                                    \
+        do {                                                            \
+                static struct lock_class_key __key;                     \
+                init_timer_deferrable_key((timer), #timer, &__key);     \
+        } while (0)
+
+#define init_timer_on_stack(timer)                                      \
+        do {                                                            \
+                static struct lock_class_key __key;                     \
+                init_timer_on_stack_key((timer), #timer, &__key);       \
+        } while (0)
+
+#define setup_timer(timer, fn, data)                                    \
+        do {                                                            \
+                static struct lock_class_key __key;                     \
+                setup_timer_key((timer), #timer, &__key, (fn), (data));\
+        } while (0)
+
+#define setup_timer_on_stack(timer, fn, data)                           \
+        do {                                                            \
+                static struct lock_class_key __key;                     \
+                setup_timer_on_stack_key((timer), #timer, &__key,       \
+                                         (fn), (data));                 \
+        } while (0)
+#else
+#define init_timer(timer)\
+        init_timer_key((timer), NULL, NULL)
+#define init_timer_deferrable(timer)\
+        init_timer_deferrable_key((timer), NULL, NULL)
+#define init_timer_on_stack(timer)\
+        init_timer_on_stack_key((timer), NULL, NULL)
+#define setup_timer(timer, fn, data)\
+        setup_timer_key((timer), NULL, NULL, (fn), (data))
+#define setup_timer_on_stack(timer, fn, data)\
+        setup_timer_on_stack_key((timer), NULL, NULL, (fn), (data))
+#endif
 
 #ifdef CONFIG_DEBUG_OBJECTS_TIMERS
-extern void init_timer_on_stack(struct timer_list *timer);
+extern void init_timer_on_stack_key(struct timer_list *timer,
+                                    const char *name,
+                                    struct lock_class_key *key);
 extern void destroy_timer_on_stack(struct timer_list *timer);
 #else
 static inline void destroy_timer_on_stack(struct timer_list *timer) { }
-static inline void init_timer_on_stack(struct timer_list *timer)
+static inline void init_timer_on_stack_key(struct timer_list *timer,
+                                           const char *name,
+                                           struct lock_class_key *key)
 {
-        init_timer(timer);
+        init_timer_key(timer, name, key);
 }
 #endif
 
-static inline void setup_timer(struct timer_list * timer,
+static inline void setup_timer_key(struct timer_list * timer,
+                                const char *name,
+                                struct lock_class_key *key,
                                 void (*function)(unsigned long),
                                 unsigned long data)
 {
         timer->function = function;
         timer->data = data;
-        init_timer(timer);
+        init_timer_key(timer, name, key);
 }
 
-static inline void setup_timer_on_stack(struct timer_list *timer,
+static inline void setup_timer_on_stack_key(struct timer_list *timer,
+                                        const char *name,
+                                        struct lock_class_key *key,
                                         void (*function)(unsigned long),
                                         unsigned long data)
 {
         timer->function = function;
         timer->data = data;
-        init_timer_on_stack(timer);
+        init_timer_on_stack_key(timer, name, key);
 }
 
 /**
diff --git a/include/linux/timeriomem-rng.h b/include/linux/timeriomem-rng.h
index dd253177f65f..3e08a1c86830 100644
--- a/include/linux/timeriomem-rng.h
+++ b/include/linux/timeriomem-rng.h
@@ -14,7 +14,7 @@ struct timeriomem_rng_data {
         struct completion       completion;
         unsigned int            present:1;
 
-        u32 __iomem             *address;
+        void __iomem            *address;
 
         /* measures in usecs */
         unsigned int            period;
diff --git a/include/linux/topology.h b/include/linux/topology.h
index a16b9e06f2e5..7402c1a27c4f 100644
--- a/include/linux/topology.h
+++ b/include/linux/topology.h
@@ -38,11 +38,7 @@
 #endif
 
 #ifndef nr_cpus_node
-#define nr_cpus_node(node)                              \
-        ({                                              \
-                node_to_cpumask_ptr(__tmp__, node);     \
-                cpus_weight(*__tmp__);                  \
-        })
+#define nr_cpus_node(node) cpumask_weight(cpumask_of_node(node))
 #endif
 
 #define for_each_node_with_cpus(node)                   \
@@ -200,4 +196,9 @@ int arch_update_cpu_topology(void);
 #define topology_core_cpumask(cpu)              cpumask_of(cpu)
 #endif
 
+/* Returns the number of the current Node. */
+#ifndef numa_node_id
+#define numa_node_id()          (cpu_to_node(raw_smp_processor_id()))
+#endif
+
 #endif /* _LINUX_TOPOLOGY_H */
diff --git a/include/linux/trace_clock.h b/include/linux/trace_clock.h
new file mode 100644
index 000000000000..7a8130384087
--- /dev/null
+++ b/include/linux/trace_clock.h
@@ -0,0 +1,19 @@
+#ifndef _LINUX_TRACE_CLOCK_H
+#define _LINUX_TRACE_CLOCK_H
+
+/*
+ * 3 trace clock variants, with differing scalability/precision
+ * tradeoffs:
+ *
+ *  -   local: CPU-local trace clock
+ *  -  medium: scalable global clock with some jitter
+ *  -  global: globally monotonic, serialized clock
+ */
+#include <linux/compiler.h>
+#include <linux/types.h>
+
+extern u64 notrace trace_clock_local(void);
+extern u64 notrace trace_clock(void);
+extern u64 notrace trace_clock_global(void);
+
+#endif /* _LINUX_TRACE_CLOCK_H */
diff --git a/include/linux/tracehook.h b/include/linux/tracehook.h
index 6186a789d6c7..c7aa154f4bfc 100644
--- a/include/linux/tracehook.h
+++ b/include/linux/tracehook.h
@@ -388,17 +388,14 @@ static inline void tracehook_signal_handler(int sig, siginfo_t *info,
  * tracehook_consider_ignored_signal - suppress short-circuit of ignored signal
  * @task:               task receiving the signal
  * @sig:                signal number being sent
- * @handler:            %SIG_IGN or %SIG_DFL
  *
  * Return zero iff tracing doesn't care to examine this ignored signal,
  * so it can short-circuit normal delivery and never even get queued.
- * Either @handler is %SIG_DFL and @sig's default is ignore, or it's %SIG_IGN.
  *
  * Called with @task->sighand->siglock held.
  */
 static inline int tracehook_consider_ignored_signal(struct task_struct *task,
-                                                    int sig,
-                                                    void __user *handler)
+                                                    int sig)
 {
         return (task_ptrace(task) & PT_PTRACED) != 0;
 }
@@ -407,19 +404,17 @@ static inline int tracehook_consider_ignored_signal(struct task_struct *task,
  * tracehook_consider_fatal_signal - suppress special handling of fatal signal
  * @task:               task receiving the signal
  * @sig:                signal number being sent
- * @handler:            %SIG_DFL or %SIG_IGN
  *
  * Return nonzero to prevent special handling of this termination signal.
- * Normally @handler is %SIG_DFL.  It can be %SIG_IGN if @sig is ignored,
- * in which case force_sig() is about to reset it to %SIG_DFL.
+ * Normally handler for signal is %SIG_DFL.  It can be %SIG_IGN if @sig is
+ * ignored, in which case force_sig() is about to reset it to %SIG_DFL.
  * When this returns zero, this signal might cause a quick termination
  * that does not give the debugger a chance to intercept the signal.
  *
  * Called with or without @task->sighand->siglock held.
  */
 static inline int tracehook_consider_fatal_signal(struct task_struct *task,
-                                                  int sig,
-                                                  void __user *handler)
+                                                  int sig)
 {
         return (task_ptrace(task) & PT_PTRACED) != 0;
 }
@@ -507,7 +502,7 @@ static inline int tracehook_notify_jctl(int notify, int why)
 static inline int tracehook_notify_death(struct task_struct *task,
                                          void **death_cookie, int group_dead)
 {
-        if (task->exit_signal == -1)
+        if (task_detached(task))
                 return task->ptrace ? SIGCHLD : DEATH_REAP;
 
         /*
diff --git a/include/linux/tracepoint.h b/include/linux/tracepoint.h
index 757005458366..d35a7ee7611f 100644
--- a/include/linux/tracepoint.h
+++ b/include/linux/tracepoint.h
@@ -31,8 +31,8 @@ struct tracepoint {
                                          * Keep in sync with vmlinux.lds.h.
                                          */
 
-#define TPPROTO(args...)        args
-#define TPARGS(args...)         args
+#define TP_PROTO(args...)       args
+#define TP_ARGS(args...)                args
 
 #ifdef CONFIG_TRACEPOINTS
 
@@ -65,7 +65,7 @@ struct tracepoint {
         {                                                               \
                 if (unlikely(__tracepoint_##name.state))                \
                         __DO_TRACE(&__tracepoint_##name,                \
-                                TPPROTO(proto), TPARGS(args));          \
+                                TP_PROTO(proto), TP_ARGS(args));        \
         }                                                               \
         static inline int register_trace_##name(void (*probe)(proto))   \
         {                                                               \
@@ -153,4 +153,114 @@ static inline void tracepoint_synchronize_unregister(void)
         synchronize_sched();
 }
 
+#define PARAMS(args...) args
+#define TRACE_FORMAT(name, proto, args, fmt)            \
+        DECLARE_TRACE(name, PARAMS(proto), PARAMS(args))
+
+
+/*
+ * For use with the TRACE_EVENT macro:
+ *
+ * We define a tracepoint, its arguments, its printk format
+ * and its 'fast binay record' layout.
+ *
+ * Firstly, name your tracepoint via TRACE_EVENT(name : the
+ * 'subsystem_event' notation is fine.
+ *
+ * Think about this whole construct as the
+ * 'trace_sched_switch() function' from now on.
+ *
+ *
+ *  TRACE_EVENT(sched_switch,
+ *
+ *      *
+ *      * A function has a regular function arguments
+ *      * prototype, declare it via TP_PROTO():
+ *      *
+ *
+ *      TP_PROTO(struct rq *rq, struct task_struct *prev,
+ *               struct task_struct *next),
+ *
+ *      *
+ *      * Define the call signature of the 'function'.
+ *      * (Design sidenote: we use this instead of a
+ *      *  TP_PROTO1/TP_PROTO2/TP_PROTO3 ugliness.)
+ *      *
+ *
+ *      TP_ARGS(rq, prev, next),
+ *
+ *      *
+ *      * Fast binary tracing: define the trace record via
+ *      * TP_STRUCT__entry(). You can think about it like a
+ *      * regular C structure local variable definition.
+ *      *
+ *      * This is how the trace record is structured and will
+ *      * be saved into the ring buffer. These are the fields
+ *      * that will be exposed to user-space in
+ *      * /debug/tracing/events/<*>/format.
+ *      *
+ *      * The declared 'local variable' is called '__entry'
+ *      *
+ *      * __field(pid_t, prev_prid) is equivalent to a standard declariton:
+ *      *
+ *      *       pid_t   prev_pid;
+ *      *
+ *      * __array(char, prev_comm, TASK_COMM_LEN) is equivalent to:
+ *      *
+ *      *       char    prev_comm[TASK_COMM_LEN];
+ *      *
+ *
+ *      TP_STRUCT__entry(
+ *              __array(        char,   prev_comm,      TASK_COMM_LEN   )
+ *              __field(        pid_t,  prev_pid                        )
+ *              __field(        int,    prev_prio                       )
+ *              __array(        char,   next_comm,      TASK_COMM_LEN   )
+ *              __field(        pid_t,  next_pid                        )
+ *              __field(        int,    next_prio                       )
+ *      ),
+ *
+ *      *
+ *      * Assign the entry into the trace record, by embedding
+ *      * a full C statement block into TP_fast_assign(). You
+ *      * can refer to the trace record as '__entry' -
+ *      * otherwise you can put arbitrary C code in here.
+ *      *
+ *      * Note: this C code will execute every time a trace event
+ *      * happens, on an active tracepoint.
+ *      *
+ *
+ *      TP_fast_assign(
+ *              memcpy(__entry->next_comm, next->comm, TASK_COMM_LEN);
+ *              __entry->prev_pid       = prev->pid;
+ *              __entry->prev_prio      = prev->prio;
+ *              memcpy(__entry->prev_comm, prev->comm, TASK_COMM_LEN);
+ *              __entry->next_pid       = next->pid;
+ *              __entry->next_prio      = next->prio;
+ *      )
+ *
+ *      *
+ *      * Formatted output of a trace record via TP_printk().
+ *      * This is how the tracepoint will appear under ftrace
+ *      * plugins that make use of this tracepoint.
+ *      *
+ *      * (raw-binary tracing wont actually perform this step.)
+ *      *
+ *
+ *      TP_printk("task %s:%d [%d] ==> %s:%d [%d]",
+ *              __entry->prev_comm, __entry->prev_pid, __entry->prev_prio,
+ *              __entry->next_comm, __entry->next_pid, __entry->next_prio),
+ *
+ * );
+ *
+ * This macro construct is thus used for the regular printk format
+ * tracing setup, it is used to construct a function pointer based
+ * tracepoint callback (this is used by programmatic plugins and
+ * can also by used by generic instrumentation like SystemTap), and
+ * it is also used to expose a structured trace record in
+ * /debug/tracing/events/.
+ */
+
+#define TRACE_EVENT(name, proto, args, struct, assign, print)   \
+        DECLARE_TRACE(name, PARAMS(proto), PARAMS(args))
+
 #endif
diff --git a/include/linux/tty_driver.h b/include/linux/tty_driver.h
index 08e088334dba..bcba84ea2d86 100644
--- a/include/linux/tty_driver.h
+++ b/include/linux/tty_driver.h
@@ -252,8 +252,6 @@ struct tty_operations {
         void (*set_ldisc)(struct tty_struct *tty);
         void (*wait_until_sent)(struct tty_struct *tty, int timeout);
         void (*send_xchar)(struct tty_struct *tty, char ch);
-        int (*read_proc)(char *page, char **start, off_t off,
-                          int count, int *eof, void *data);
         int (*tiocmget)(struct tty_struct *tty, struct file *file);
         int (*tiocmset)(struct tty_struct *tty, struct file *file,
                         unsigned int set, unsigned int clear);
@@ -264,6 +262,7 @@ struct tty_operations {
         int (*poll_get_char)(struct tty_driver *driver, int line);
         void (*poll_put_char)(struct tty_driver *driver, int line, char ch);
 #endif
+        const struct file_operations *proc_fops;
 };
 
 struct tty_driver {
@@ -310,7 +309,8 @@ extern void tty_set_operations(struct tty_driver *driver,
 extern struct tty_driver *tty_find_polling_driver(char *name, int *line);
 
 extern void tty_driver_kref_put(struct tty_driver *driver);
-extern inline struct tty_driver *tty_driver_kref_get(struct tty_driver *d)
+
+static inline struct tty_driver *tty_driver_kref_get(struct tty_driver *d)
 {
         kref_get(&d->kref);
         return d;
diff --git a/include/linux/usb.h b/include/linux/usb.h
index c6b2ab41b908..3aa2cd1f8d08 100644
--- a/include/linux/usb.h
+++ b/include/linux/usb.h
@@ -1387,6 +1387,7 @@ extern int usb_string(struct usb_device *dev, int index,
 extern int usb_clear_halt(struct usb_device *dev, int pipe);
 extern int usb_reset_configuration(struct usb_device *dev);
 extern int usb_set_interface(struct usb_device *dev, int ifnum, int alternate);
+extern void usb_reset_endpoint(struct usb_device *dev, unsigned int epaddr);
 
 /* this request isn't really synchronous, but it belongs with the others */
 extern int usb_driver_set_configuration(struct usb_device *udev, int config);
@@ -1491,14 +1492,6 @@ void usb_sg_wait(struct usb_sg_request *io);
 #define usb_pipecontrol(pipe)   (usb_pipetype((pipe)) == PIPE_CONTROL)
 #define usb_pipebulk(pipe)      (usb_pipetype((pipe)) == PIPE_BULK)
 
-/* The D0/D1 toggle bits ... USE WITH CAUTION (they're almost hcd-internal) */
-#define usb_gettoggle(dev, ep, out) (((dev)->toggle[out] >> (ep)) & 1)
-#define usb_dotoggle(dev, ep, out)  ((dev)->toggle[out] ^= (1 << (ep)))
-#define usb_settoggle(dev, ep, out, bit) \
-                ((dev)->toggle[out] = ((dev)->toggle[out] & ~(1 << (ep))) | \
-                 ((bit) << (ep)))
-
-
 static inline unsigned int __create_pipe(struct usb_device *dev,
                 unsigned int endpoint)
 {
diff --git a/include/linux/usb/cdc.h b/include/linux/usb/cdc.h
index 3c86ed25a04c..c24124a42ce5 100644
--- a/include/linux/usb/cdc.h
+++ b/include/linux/usb/cdc.h
@@ -17,6 +17,7 @@
 #define USB_CDC_SUBCLASS_DMM                    0x09
 #define USB_CDC_SUBCLASS_MDLM                   0x0a
 #define USB_CDC_SUBCLASS_OBEX                   0x0b
+#define USB_CDC_SUBCLASS_EEM                    0x0c
 
 #define USB_CDC_PROTO_NONE                      0
 
@@ -28,6 +29,8 @@
 #define USB_CDC_ACM_PROTO_AT_CDMA               6
 #define USB_CDC_ACM_PROTO_VENDOR                0xff
 
+#define USB_CDC_PROTO_EEM                       7
+
 /*-------------------------------------------------------------------------*/
 
 /*
diff --git a/include/linux/usb/musb.h b/include/linux/usb/musb.h
index d6aad0ea6033..d43755669261 100644
--- a/include/linux/usb/musb.h
+++ b/include/linux/usb/musb.h
@@ -7,6 +7,9 @@
  * key configuration differences between boards.
  */
 
+#ifndef __LINUX_USB_MUSB_H
+#define __LINUX_USB_MUSB_H
+
 /* The USB role is defined by the connector used on the board, so long as
  * standards are being followed.  (Developer boards sometimes won't.)
  */
@@ -101,3 +104,5 @@ extern int __init tusb6010_setup_interface(
 extern int tusb6010_platform_retime(unsigned is_refclk);
 
 #endif  /* OMAP2 */
+
+#endif /* __LINUX_USB_MUSB_H */
diff --git a/include/linux/usb/serial.h b/include/linux/usb/serial.h
index b95842542590..625e9e4639c6 100644
--- a/include/linux/usb/serial.h
+++ b/include/linux/usb/serial.h
@@ -29,7 +29,7 @@
 /**
  * usb_serial_port: structure for the specific ports of a device.
  * @serial: pointer back to the struct usb_serial owner of this port.
- * @tty: pointer to the corresponding tty for this port.
+ * @port: pointer to the corresponding tty_port for this port.
  * @lock: spinlock to grab when updating portions of this structure.
  * @mutex: mutex used to synchronize serial_open() and serial_close()
  *      access for this port.
@@ -44,19 +44,22 @@
  * @interrupt_out_endpointAddress: endpoint address for the interrupt out pipe
  *      for this port.
  * @bulk_in_buffer: pointer to the bulk in buffer for this port.
+ * @bulk_in_size: the size of the bulk_in_buffer, in bytes.
  * @read_urb: pointer to the bulk in struct urb for this port.
  * @bulk_in_endpointAddress: endpoint address for the bulk in pipe for this
  *      port.
  * @bulk_out_buffer: pointer to the bulk out buffer for this port.
  * @bulk_out_size: the size of the bulk_out_buffer, in bytes.
  * @write_urb: pointer to the bulk out struct urb for this port.
+ * @write_urb_busy: port`s writing status
  * @bulk_out_endpointAddress: endpoint address for the bulk out pipe for this
  *      port.
  * @write_wait: a wait_queue_head_t used by the port.
  * @work: work queue entry for the line discipline waking up.
- * @open_count: number of times this port has been opened.
  * @throttled: nonzero if the read urb is inactive to throttle the device
  * @throttle_req: nonzero if the tty wants to throttle us
+ * @console: attached usb serial console
+ * @dev: pointer to the serial device
  *
  * This structure is used by the usb-serial core and drivers for the specific
  * ports of a device.
diff --git a/include/linux/usb/wusb.h b/include/linux/usb/wusb.h
index 5f401b644ed5..429c631d2aad 100644
--- a/include/linux/usb/wusb.h
+++ b/include/linux/usb/wusb.h
@@ -80,8 +80,7 @@ struct wusb_ckhdid {
         u8 data[16];
 } __attribute__((packed));
 
-const static
-struct wusb_ckhdid wusb_ckhdid_zero = { .data = { 0 } };
+static const struct wusb_ckhdid wusb_ckhdid_zero = { .data = { 0 } };
 
 #define WUSB_CKHDID_STRSIZE (3 * sizeof(struct wusb_ckhdid) + 1)
 
diff --git a/include/linux/video_decoder.h b/include/linux/video_decoder.h
deleted file mode 100644
index e26c0c86a6ea..000000000000
--- a/include/linux/video_decoder.h
+++ /dev/null
@@ -1,48 +0,0 @@
-#ifndef _LINUX_VIDEO_DECODER_H
-#define _LINUX_VIDEO_DECODER_H
-
-#include <linux/types.h>
-
-#define HAVE_VIDEO_DECODER 1
-
-struct video_decoder_capability { /* this name is too long */
-        __u32   flags;
-#define VIDEO_DECODER_PAL       1       /* can decode PAL signal */
-#define VIDEO_DECODER_NTSC      2       /* can decode NTSC */
-#define VIDEO_DECODER_SECAM     4       /* can decode SECAM */
-#define VIDEO_DECODER_AUTO      8       /* can autosense norm */
-#define VIDEO_DECODER_CCIR      16      /* CCIR-601 pixel rate (720 pixels per line) instead of square pixel rate */
-        int     inputs;                 /* number of inputs */
-        int     outputs;                /* number of outputs */
-};
-
-/*
-DECODER_GET_STATUS returns the following flags.  The only one you need is
-DECODER_STATUS_GOOD, the others are just nice things to know.
-*/
-#define DECODER_STATUS_GOOD     1       /* receiving acceptable input */
-#define DECODER_STATUS_COLOR    2       /* receiving color information */
-#define DECODER_STATUS_PAL      4       /* auto detected */
-#define DECODER_STATUS_NTSC     8       /* auto detected */
-#define DECODER_STATUS_SECAM    16      /* auto detected */
-
-struct video_decoder_init {
-        unsigned char len;
-        const unsigned char *data;
-};
-
-#define DECODER_GET_CAPABILITIES _IOR('d', 1, struct video_decoder_capability)
-#define DECODER_GET_STATUS      _IOR('d', 2, int)
-#define DECODER_SET_NORM        _IOW('d', 3, int)
-#define DECODER_SET_INPUT       _IOW('d', 4, int)       /* 0 <= input < #inputs */
-#define DECODER_SET_OUTPUT      _IOW('d', 5, int)       /* 0 <= output < #outputs */
-#define DECODER_ENABLE_OUTPUT   _IOW('d', 6, int)       /* boolean output enable control */
-#define DECODER_SET_PICTURE     _IOW('d', 7, struct video_picture)
-#define DECODER_SET_GPIO        _IOW('d', 8, int)       /* switch general purpose pin */
-#define DECODER_INIT            _IOW('d', 9, struct video_decoder_init) /* init internal registers at once */
-#define DECODER_SET_VBI_BYPASS  _IOW('d', 10, int)      /* switch vbi bypass */
-
-#define DECODER_DUMP            _IO('d', 192)           /* debug hook */
-
-
-#endif
diff --git a/include/linux/video_encoder.h b/include/linux/video_encoder.h
deleted file mode 100644
index b7b6423bbb8a..000000000000
--- a/include/linux/video_encoder.h
+++ /dev/null
@@ -1,23 +0,0 @@
-#ifndef _LINUX_VIDEO_ENCODER_H
-#define _LINUX_VIDEO_ENCODER_H
-
-#include <linux/types.h>
-
-struct video_encoder_capability { /* this name is too long */
-        __u32   flags;
-#define VIDEO_ENCODER_PAL       1       /* can encode PAL signal */
-#define VIDEO_ENCODER_NTSC      2       /* can encode NTSC */
-#define VIDEO_ENCODER_SECAM     4       /* can encode SECAM */
-#define VIDEO_ENCODER_CCIR      16      /* CCIR-601 pixel rate (720 pixels per line) instead of square pixel rate */
-        int     inputs;                 /* number of inputs */
-        int     outputs;                /* number of outputs */
-};
-
-#define ENCODER_GET_CAPABILITIES _IOR('e', 1, struct video_encoder_capability)
-#define ENCODER_SET_NORM        _IOW('e', 2, int)
-#define ENCODER_SET_INPUT       _IOW('e', 3, int)       /* 0 <= input < #inputs */
-#define ENCODER_SET_OUTPUT      _IOW('e', 4, int)       /* 0 <= output < #outputs */
-#define ENCODER_ENABLE_OUTPUT   _IOW('e', 5, int)       /* boolean output enable control */
-
-
-#endif
diff --git a/include/linux/videodev.h b/include/linux/videodev.h
index 837f392fbe97..b19eab140977 100644
--- a/include/linux/videodev.h
+++ b/include/linux/videodev.h
@@ -16,6 +16,23 @@
 #include <linux/ioctl.h>
 #include <linux/videodev2.h>
 
+#if defined(__MIN_V4L1) && defined (__KERNEL__)
+
+/*
+ * Used by those V4L2 core functions that need a minimum V4L1 support,
+ * in order to allow V4L1 Compatibilty code compilation.
+ */
+
+struct video_mbuf
+{
+        int     size;           /* Total memory to map */
+        int     frames;         /* Frames */
+        int     offsets[VIDEO_MAX_FRAME];
+};
+
+#define VIDIOCGMBUF             _IOR('v',20, struct video_mbuf)         /* Memory map buffer info */
+
+#else
 #if defined(CONFIG_VIDEO_V4L1_COMPAT) || !defined (__KERNEL__)
 
 #define VID_TYPE_CAPTURE        1       /* Can capture */
@@ -312,6 +329,7 @@ struct video_code
 #define VID_PLAY_END_MARK               14
 
 #endif /* CONFIG_VIDEO_V4L1_COMPAT */
+#endif /* __MIN_V4L1 */
 
 #endif /* __LINUX_VIDEODEV_H */
 
diff --git a/include/linux/videodev2.h b/include/linux/videodev2.h
index 5571dbe1c0ad..ebb2ea6b4995 100644
--- a/include/linux/videodev2.h
+++ b/include/linux/videodev2.h
@@ -344,6 +344,8 @@ struct v4l2_pix_format {
 #define V4L2_PIX_FMT_SPCA508  v4l2_fourcc('S', '5', '0', '8') /* YUVY per line */
 #define V4L2_PIX_FMT_SPCA561  v4l2_fourcc('S', '5', '6', '1') /* compressed GBRG bayer */
 #define V4L2_PIX_FMT_PAC207   v4l2_fourcc('P', '2', '0', '7') /* compressed BGGR bayer */
+#define V4L2_PIX_FMT_MR97310A v4l2_fourcc('M', '3', '1', '0') /* compressed BGGR bayer */
+#define V4L2_PIX_FMT_SQ905C   v4l2_fourcc('9', '0', '5', 'C') /* compressed RGGB bayer */
 #define V4L2_PIX_FMT_PJPG     v4l2_fourcc('P', 'J', 'P', 'G') /* Pixart 73xx JPEG */
 #define V4L2_PIX_FMT_YVYU    v4l2_fourcc('Y', 'V', 'Y', 'U') /* 16  YVU 4:2:2     */
 
@@ -735,6 +737,11 @@ struct v4l2_input {
 #define V4L2_IN_ST_NO_SIGNAL   0x00000002
 #define V4L2_IN_ST_NO_COLOR    0x00000004
 
+/* field 'status' - sensor orientation */
+/* If sensor is mounted upside down set both bits */
+#define V4L2_IN_ST_HFLIP       0x00000010 /* Frames are flipped horizontally */
+#define V4L2_IN_ST_VFLIP       0x00000020 /* Frames are flipped vertically */
+
 /* field 'status' - analog */
 #define V4L2_IN_ST_NO_H_LOCK   0x00000100  /* No horizontal sync lock */
 #define V4L2_IN_ST_COLOR_KILL  0x00000200  /* Color killer is active */
@@ -829,6 +836,7 @@ struct v4l2_querymenu {
 #define V4L2_CTRL_FLAG_UPDATE           0x0008
 #define V4L2_CTRL_FLAG_INACTIVE         0x0010
 #define V4L2_CTRL_FLAG_SLIDER           0x0020
+#define V4L2_CTRL_FLAG_WRITE_ONLY       0x0040
 
 /*  Query flag, to be ORed with the control ID */
 #define V4L2_CTRL_FLAG_NEXT_CTRL        0x80000000
@@ -879,8 +887,15 @@ enum v4l2_power_line_frequency {
 #define V4L2_CID_BACKLIGHT_COMPENSATION         (V4L2_CID_BASE+28)
 #define V4L2_CID_CHROMA_AGC                     (V4L2_CID_BASE+29)
 #define V4L2_CID_COLOR_KILLER                   (V4L2_CID_BASE+30)
+#define V4L2_CID_COLORFX                        (V4L2_CID_BASE+31)
+enum v4l2_colorfx {
+        V4L2_COLORFX_NONE       = 0,
+        V4L2_COLORFX_BW         = 1,
+        V4L2_COLORFX_SEPIA      = 2,
+};
+
 /* last CID + 1 */
-#define V4L2_CID_LASTP1                         (V4L2_CID_BASE+31)
+#define V4L2_CID_LASTP1                         (V4L2_CID_BASE+32)
 
 /*  MPEG-class control IDs defined by V4L2 */
 #define V4L2_CID_MPEG_BASE                      (V4L2_CTRL_CLASS_MPEG | 0x900)
@@ -1339,6 +1354,53 @@ struct v4l2_sliced_vbi_data {
 };
 
 /*
+ * Sliced VBI data inserted into MPEG Streams
+ */
+
+/*
+ * V4L2_MPEG_STREAM_VBI_FMT_IVTV:
+ *
+ * Structure of payload contained in an MPEG 2 Private Stream 1 PES Packet in an
+ * MPEG-2 Program Pack that contains V4L2_MPEG_STREAM_VBI_FMT_IVTV Sliced VBI
+ * data
+ *
+ * Note, the MPEG-2 Program Pack and Private Stream 1 PES packet header
+ * definitions are not included here.  See the MPEG-2 specifications for details
+ * on these headers.
+ */
+
+/* Line type IDs */
+#define V4L2_MPEG_VBI_IVTV_TELETEXT_B     (1)
+#define V4L2_MPEG_VBI_IVTV_CAPTION_525    (4)
+#define V4L2_MPEG_VBI_IVTV_WSS_625        (5)
+#define V4L2_MPEG_VBI_IVTV_VPS            (7)
+
+struct v4l2_mpeg_vbi_itv0_line {
+        __u8 id;        /* One of V4L2_MPEG_VBI_IVTV_* above */
+        __u8 data[42];  /* Sliced VBI data for the line */
+} __attribute__ ((packed));
+
+struct v4l2_mpeg_vbi_itv0 {
+        __le32 linemask[2]; /* Bitmasks of VBI service lines present */
+        struct v4l2_mpeg_vbi_itv0_line line[35];
+} __attribute__ ((packed));
+
+struct v4l2_mpeg_vbi_ITV0 {
+        struct v4l2_mpeg_vbi_itv0_line line[36];
+} __attribute__ ((packed));
+
+#define V4L2_MPEG_VBI_IVTV_MAGIC0       "itv0"
+#define V4L2_MPEG_VBI_IVTV_MAGIC1       "ITV0"
+
+struct v4l2_mpeg_vbi_fmt_ivtv {
+        __u8 magic[4];
+        union {
+                struct v4l2_mpeg_vbi_itv0 itv0;
+                struct v4l2_mpeg_vbi_ITV0 ITV0;
+        };
+} __attribute__ ((packed));
+
+/*
  *      A G G R E G A T E   S T R U C T U R E S
  */
 
@@ -1403,14 +1465,6 @@ struct v4l2_dbg_chip_ident {
         __u32 revision;    /* chip revision, chip specific */
 } __attribute__ ((packed));
 
-/* VIDIOC_G_CHIP_IDENT_OLD: Deprecated, do not use */
-struct v4l2_chip_ident_old {
-        __u32 match_type;  /* Match type */
-        __u32 match_chip;  /* Match this chip, meaning determined by match_type */
-        __u32 ident;       /* chip identifier as specified in <media/v4l2-chip-ident.h> */
-        __u32 revision;    /* chip revision, chip specific */
-};
-
 /*
  *      I O C T L   C O D E S   F O R   V I D E O   D E V I C E S
  *
@@ -1488,8 +1542,6 @@ struct v4l2_chip_ident_old {
 /* Experimental, meant for debugging, testing and internal use.
    Never use this ioctl in applications! */
 #define VIDIOC_DBG_G_CHIP_IDENT _IOWR('V', 81, struct v4l2_dbg_chip_ident)
-/* This is deprecated and will go away in 2.6.30 */
-#define VIDIOC_G_CHIP_IDENT_OLD _IOWR('V', 81, struct v4l2_chip_ident_old)
 #endif
 
 #define VIDIOC_S_HW_FREQ_SEEK    _IOW('V', 82, struct v4l2_hw_freq_seek)
diff --git a/include/linux/virtio_net.h b/include/linux/virtio_net.h
index 242348bb3766..cec79adbe3ea 100644
--- a/include/linux/virtio_net.h
+++ b/include/linux/virtio_net.h
@@ -4,6 +4,7 @@
  * compatible drivers/servers. */
 #include <linux/types.h>
 #include <linux/virtio_config.h>
+#include <linux/if_ether.h>
 
 /* The ID for virtio_net */
 #define VIRTIO_ID_NET   1
diff --git a/include/linux/wait.h b/include/linux/wait.h
index a210ede73b56..bc024632f365 100644
--- a/include/linux/wait.h
+++ b/include/linux/wait.h
@@ -135,8 +135,11 @@ static inline void __remove_wait_queue(wait_queue_head_t *head,
 void __wake_up_common(wait_queue_head_t *q, unsigned int mode,
                         int nr_exclusive, int sync, void *key);
 void __wake_up(wait_queue_head_t *q, unsigned int mode, int nr, void *key);
-extern void __wake_up_locked(wait_queue_head_t *q, unsigned int mode);
-extern void __wake_up_sync(wait_queue_head_t *q, unsigned int mode, int nr);
+void __wake_up_locked_key(wait_queue_head_t *q, unsigned int mode, void *key);
+void __wake_up_sync_key(wait_queue_head_t *q, unsigned int mode, int nr,
+                        void *key);
+void __wake_up_locked(wait_queue_head_t *q, unsigned int mode);
+void __wake_up_sync(wait_queue_head_t *q, unsigned int mode, int nr);
 void __wake_up_bit(wait_queue_head_t *, void *, int);
 int __wait_on_bit(wait_queue_head_t *, struct wait_bit_queue *, int (*)(void *), unsigned);
 int __wait_on_bit_lock(wait_queue_head_t *, struct wait_bit_queue *, int (*)(void *), unsigned);
@@ -155,21 +158,17 @@ wait_queue_head_t *bit_waitqueue(void *, int);
 #define wake_up_interruptible_all(x)    __wake_up(x, TASK_INTERRUPTIBLE, 0, NULL)
 #define wake_up_interruptible_sync(x)   __wake_up_sync((x), TASK_INTERRUPTIBLE, 1)
 
-#ifdef CONFIG_DEBUG_LOCK_ALLOC
 /*
- * macro to avoid include hell
+ * Wakeup macros to be used to report events to the targets.
  */
-#define wake_up_nested(x, s)                                            \
-do {                                                                    \
-        unsigned long flags;                                            \
-                                                                        \
-        spin_lock_irqsave_nested(&(x)->lock, flags, (s));               \
-        wake_up_locked(x);                                              \
-        spin_unlock_irqrestore(&(x)->lock, flags);                      \
-} while (0)
-#else
-#define wake_up_nested(x, s)            wake_up(x)
-#endif
+#define wake_up_poll(x, m)                              \
+        __wake_up(x, TASK_NORMAL, 1, (void *) (m))
+#define wake_up_locked_poll(x, m)                               \
+        __wake_up_locked_key((x), TASK_NORMAL, (void *) (m))
+#define wake_up_interruptible_poll(x, m)                        \
+        __wake_up(x, TASK_INTERRUPTIBLE, 1, (void *) (m))
+#define wake_up_interruptible_sync_poll(x, m)                           \
+        __wake_up_sync_key((x), TASK_INTERRUPTIBLE, 1, (void *) (m))
 
 #define __wait_event(wq, condition)                                     \
 do {                                                                    \
@@ -441,13 +440,15 @@ void abort_exclusive_wait(wait_queue_head_t *q, wait_queue_t *wait,
 int autoremove_wake_function(wait_queue_t *wait, unsigned mode, int sync, void *key);
 int wake_bit_function(wait_queue_t *wait, unsigned mode, int sync, void *key);
 
-#define DEFINE_WAIT(name)                                               \
+#define DEFINE_WAIT_FUNC(name, function)                                \
         wait_queue_t name = {                                           \
                 .private        = current,                              \
-                .func           = autoremove_wake_function,             \
+                .func           = function,                             \
                 .task_list      = LIST_HEAD_INIT((name).task_list),     \
         }
 
+#define DEFINE_WAIT(name) DEFINE_WAIT_FUNC(name, autoremove_wake_function)
+
 #define DEFINE_WAIT_BIT(name, word, bit)                                \
         struct wait_bit_queue name = {                                  \
                 .key = __WAIT_BIT_KEY_INITIALIZER(word, bit),           \
diff --git a/include/linux/workqueue.h b/include/linux/workqueue.h
index 3cd51e579ab1..13e1adf55c4c 100644
--- a/include/linux/workqueue.h
+++ b/include/linux/workqueue.h
@@ -41,6 +41,11 @@ struct delayed_work {
         struct timer_list timer;
 };
 
+static inline struct delayed_work *to_delayed_work(struct work_struct *work)
+{
+        return container_of(work, struct delayed_work, work);
+}
+
 struct execute_work {
         struct work_struct work;
 };
diff --git a/include/linux/writeback.h b/include/linux/writeback.h
index 7300ecdc480c..9c1ed1fb6ddb 100644
--- a/include/linux/writeback.h
+++ b/include/linux/writeback.h
@@ -109,8 +109,8 @@ extern int dirty_background_ratio;
 extern unsigned long dirty_background_bytes;
 extern int vm_dirty_ratio;
 extern unsigned long vm_dirty_bytes;
-extern int dirty_writeback_interval;
-extern int dirty_expire_interval;
+extern unsigned int dirty_writeback_interval;
+extern unsigned int dirty_expire_interval;
 extern int vm_highmem_is_dirtyable;
 extern int block_dump;
 extern int laptop_mode;
@@ -168,6 +168,8 @@ void writeback_set_ratelimit(void);
 /* pdflush.c */
 extern int nr_pdflush_threads;  /* Global so it can be exported to sysctl
                                    read-only. */
+extern int nr_pdflush_threads_max; /* Global so it can be exported to sysctl */
+extern int nr_pdflush_threads_min; /* Global so it can be exported to sysctl */
 
 
 #endif          /* WRITEBACK_H */