Merge commit 'v2.6.30-rc1' into perfcounters/core

Conflicts:
	arch/powerpc/include/asm/systbl.h
	arch/powerpc/include/asm/unistd.h
	include/linux/init_task.h

Merge reason: the conflicts are non-trivial: PowerPC placement
              of sys_perf_counter_open has to be mixed with the
	      new preadv/pwrite syscalls.

Signed-off-by: Ingo Molnar <mingo@elte.hu>

27 files changed, 1301 insertions, 66 deletions

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/blkdev.h b/include/linux/blkdev.h
index e03660964e02..ba54c834a590 100644
--- a/include/linux/blkdev.h
+++ b/include/linux/blkdev.h
@@ -117,7 +117,6 @@ enum rq_flag_bits {
         __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_NR_BITS,          /* stops here */
 };
@@ -145,7 +144,6 @@ 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 BLK_MAX_CDB     16
diff --git a/include/linux/compiler.h b/include/linux/compiler.h
index 6faa7e549de4..37bcb50a4d7c 100644
--- a/include/linux/compiler.h
+++ b/include/linux/compiler.h
@@ -76,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)
@@ -114,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                        \
diff --git a/include/linux/dma-mapping.h b/include/linux/dma-mapping.h
index d7d090d21031..8083b6a36a38 100644
--- a/include/linux/dma-mapping.h
+++ b/include/linux/dma-mapping.h
@@ -115,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/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/fs.h b/include/linux/fs.h
index bce40a2207ee..562d2855cf30 100644
--- a/include/linux/fs.h
+++ b/include/linux/fs.h
@@ -1699,6 +1699,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),
diff --git a/include/linux/fsl_devices.h b/include/linux/fsl_devices.h
index 7ef1caf50269..f2a78b5e8b55 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,27 +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
diff --git a/include/linux/ftrace.h b/include/linux/ftrace.h
index 015a3d22cf74..da5405dce347 100644
--- a/include/linux/ftrace.h
+++ b/include/linux/ftrace.h
@@ -356,6 +356,9 @@ 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.
@@ -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>
diff --git a/include/linux/hardirq.h b/include/linux/hardirq.h
index faa1cf848bcd..45257475623c 100644
--- a/include/linux/hardirq.h
+++ b/include/linux/hardirq.h
@@ -116,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()
diff --git a/include/linux/i2c-id.h b/include/linux/i2c-id.h
index ee9fbc172405..c9087de5c6c6 100644
--- a/include/linux/i2c-id.h
+++ b/include/linux/i2c-id.h
@@ -51,6 +51,7 @@
 #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                                                     */
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/init_task.h b/include/linux/init_task.h
index ca226a91abee..c98866102817 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>
@@ -195,9 +196,10 @@ extern struct cred init_cred;
         },                                                              \
         .dirties = INIT_PROP_LOCAL_SINGLE(dirties),                     \
         INIT_IDS                                                        \
+        INIT_PERF_COUNTERS(tsk)                                         \
         INIT_TRACE_IRQFLAGS                                             \
         INIT_LOCKDEP                                                    \
-        INIT_PERF_COUNTERS(tsk)                                         \
+        INIT_FTRACE_GRAPH                                               \
 }
 
 
diff --git a/include/linux/interrupt.h b/include/linux/interrupt.h
index 8a9613d0c674..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);
 
 /*
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/irq.h b/include/linux/irq.h
index 974890b3c52f..ca507c9426b0 100644
--- a/include/linux/irq.h
+++ b/include/linux/irq.h
@@ -22,6 +22,7 @@
 #include <linux/irqnr.h>
 #include <linux/errno.h>
 #include <linux/topology.h>
+#include <linux/wait.h>
 
 #include <asm/irq.h>
 #include <asm/ptrace.h>
@@ -158,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
  */
@@ -189,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
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/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/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/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/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.h b/include/linux/pci.h
index a7fe4bbd7ff1..72698d89e767 100644
--- a/include/linux/pci.h
+++ b/include/linux/pci.h
@@ -674,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;
diff --git a/include/linux/sched.h b/include/linux/sched.h
index 7ed41f7c5ace..8a8b84390813 100644
--- a/include/linux/sched.h
+++ b/include/linux/sched.h
@@ -302,17 +302,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)
 {
 }
@@ -321,6 +315,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")))
@@ -1258,9 +1261,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 */
@@ -1297,6 +1299,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;
 
diff --git a/include/linux/serial_core.h b/include/linux/serial_core.h
index 83e4b3ff9cda..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>
diff --git a/include/linux/spi/spi.h b/include/linux/spi/spi.h
index 68bb1c501d0d..2cc43fa380cb 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,6 +240,11 @@ struct spi_master {
          */
         u16                     num_chipselect;
 
+        /* 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) */
         int                     (*setup)(struct spi_device *spi);
 
diff --git a/include/linux/tty_driver.h b/include/linux/tty_driver.h
index 8615d661ab60..bcba84ea2d86 100644
--- a/include/linux/tty_driver.h
+++ b/include/linux/tty_driver.h
@@ -309,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/videodev2.h b/include/linux/videodev2.h
index 139d234923cd..ebb2ea6b4995 100644
--- a/include/linux/videodev2.h
+++ b/include/linux/videodev2.h
@@ -737,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 */
diff --git a/include/linux/writeback.h b/include/linux/writeback.h
index 93445477f86a..9c1ed1fb6ddb 100644
--- a/include/linux/writeback.h
+++ b/include/linux/writeback.h
@@ -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 */