102 files changed, 1768 insertions, 669 deletions
diff --git a/include/asm-generic/atomic.h b/include/asm-generic/atomic.h
index 058129e9b04c..e53347fbf1da 100644
--- a/include/asm-generic/atomic.h
+++ b/include/asm-generic/atomic.h
@@ -57,11 +57,11 @@ static inline int atomic_add_return(int i, atomic_t *v)
        unsigned long flags;
        int temp;
-        local_irq_save(flags);
+        raw_local_irq_save(flags); /* Don't trace it in a irqsoff handler */
        temp = v->counter;
        temp += i;
        v->counter = temp;
-        local_irq_restore(flags);
+        raw_local_irq_restore(flags);
        return temp;
 }
@@ -78,11 +78,11 @@ static inline int atomic_sub_return(int i, atomic_t *v)
        unsigned long flags;
        int temp;
-        local_irq_save(flags);
+        raw_local_irq_save(flags); /* Don't trace it in a irqsoff handler */
        temp = v->counter;
        temp -= i;
        v->counter = temp;
-        local_irq_restore(flags);
+        raw_local_irq_restore(flags);
        return temp;
 }
@@ -135,9 +135,9 @@ static inline void atomic_clear_mask(unsigned long mask, unsigned long *addr)
        unsigned long flags;
        mask = ~mask;
-        local_irq_save(flags);
+        raw_local_irq_save(flags); /* Don't trace it in a irqsoff handler */
        *addr &= mask;
-        local_irq_restore(flags);
+        raw_local_irq_restore(flags);
 }
 #define atomic_xchg(ptr, v)             (xchg(&(ptr)->counter, (v)))
diff --git a/include/asm-generic/fcntl.h b/include/asm-generic/fcntl.h
index fcd268ce0674..e3cbc38bdcc2 100644
--- a/include/asm-generic/fcntl.h
+++ b/include/asm-generic/fcntl.h
@@ -3,6 +3,14 @@
 #include <linux/types.h>
+/*
+ * FMODE_EXEC is 0x20
+ * FMODE_NONOTIFY is 0x1000000
+ * These cannot be used by userspace O_* until internal and external open
+ * flags are split.
+ * -Eric Paris
+ */
 #define O_ACCMODE       00000003
 #define O_RDONLY        00000000
 #define O_WRONLY        00000001
diff --git a/include/asm-generic/io.h b/include/asm-generic/io.h
index bcee6365dca0..118601fce92d 100644
--- a/include/asm-generic/io.h
+++ b/include/asm-generic/io.h
@@ -188,11 +188,15 @@ static inline void outsl(unsigned long addr, const void *buffer, int count)
 #ifndef CONFIG_GENERIC_IOMAP
 #define ioread8(addr)           readb(addr)
 #define ioread16(addr)          readw(addr)
+#define ioread16be(addr)        be16_to_cpu(ioread16(addr))
 #define ioread32(addr)          readl(addr)
+#define ioread32be(addr)        be32_to_cpu(ioread32(addr))
 #define iowrite8(v, addr)       writeb((v), (addr))
 #define iowrite16(v, addr)      writew((v), (addr))
+#define iowrite16be(v, addr)    iowrite16(be16_to_cpu(v), (addr))
 #define iowrite32(v, addr)      writel((v), (addr))
+#define iowrite32be(v, addr)    iowrite32(be32_to_cpu(v), (addr))
 #define ioread8_rep(p, dst, count) \
        insb((unsigned long) (p), (dst), (count))
diff --git a/include/asm-generic/ioctls.h b/include/asm-generic/ioctls.h
index a799e20a769e..8554cb6a81b9 100644
--- a/include/asm-generic/ioctls.h
+++ b/include/asm-generic/ioctls.h
@@ -69,6 +69,7 @@
 #define TCSETX          0x5433
 #define TCSETXF         0x5434
 #define TCSETXW         0x5435
+#define TIOCSIG         _IOW('T', 0x36, int)  /* pty: generate signal */
 #define FIONCLEX        0x5450
 #define FIOCLEX         0x5451
@@ -87,12 +88,10 @@
 #define TIOCGICOUNT     0x545D  /* read serial port inline interrupt counts */
 /*
- * some architectures define FIOQSIZE as 0x545E, which is used for
+ * Some arches already define FIOQSIZE due to a historical
- * TIOCGHAYESESP on others
+ * conflict with a Hayes modem-specific ioctl value.
 */
 #ifndef FIOQSIZE
-# define TIOCGHAYESESP  0x545E  /* Get Hayes ESP configuration */
-# define TIOCSHAYESESP  0x545F  /* Set Hayes ESP configuration */
 # define FIOQSIZE       0x5460
 #endif
@@ -104,6 +103,7 @@
 #define TIOCPKT_START            8
 #define TIOCPKT_NOSTOP          16
 #define TIOCPKT_DOSTOP          32
+#define TIOCPKT_IOCTL           64
 #define TIOCSER_TEMT    0x01    /* Transmitter physically empty */
diff --git a/include/asm-generic/statfs.h b/include/asm-generic/statfs.h
index 3b4fb3e52f0d..0fd28e028de1 100644
--- a/include/asm-generic/statfs.h
+++ b/include/asm-generic/statfs.h
@@ -33,7 +33,8 @@ struct statfs {
        __kernel_fsid_t f_fsid;
        __statfs_word f_namelen;
        __statfs_word f_frsize;
-        __statfs_word f_spare[5];
+        __statfs_word f_flags;
+        __statfs_word f_spare[4];
 };
 /*
@@ -55,7 +56,8 @@ struct statfs64 {
        __kernel_fsid_t f_fsid;
        __statfs_word f_namelen;
        __statfs_word f_frsize;
-        __statfs_word f_spare[5];
+        __statfs_word f_flags;
+        __statfs_word f_spare[4];
 } ARCH_PACK_STATFS64;
 /* 
@@ -77,7 +79,8 @@ struct compat_statfs64 {
        __kernel_fsid_t f_fsid;
        __u32 f_namelen;
        __u32 f_frsize;
-        __u32 f_spare[5];
+        __u32 f_flags;
+        __u32 f_spare[4];
 } ARCH_PACK_COMPAT_STATFS64;
 #endif
diff --git a/include/asm-generic/termbits.h b/include/asm-generic/termbits.h
index 1c9773d48cb0..232b4781aef3 100644
--- a/include/asm-generic/termbits.h
+++ b/include/asm-generic/termbits.h
@@ -178,6 +178,7 @@ struct ktermios {
 #define FLUSHO  0010000
 #define PENDIN  0040000
 #define IEXTEN  0100000
+#define EXTPROC 0200000
 /* tcflow() and TCXONC use these */
 #define TCOOFF          0
diff --git a/include/asm-generic/topology.h b/include/asm-generic/topology.h
index fd60700503c8..fc824e2828f3 100644
--- a/include/asm-generic/topology.h
+++ b/include/asm-generic/topology.h
@@ -5,7 +5,7 @@
 *
 * Copyright (C) 2002, IBM Corp.
 *
- * All rights reserved.          
+ * 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
@@ -34,9 +34,16 @@
 #ifndef cpu_to_node
 #define cpu_to_node(cpu)        ((void)(cpu),0)
 #endif
+#ifndef set_numa_node
+#define set_numa_node(node)
+#endif
+#ifndef set_cpu_numa_node
+#define set_cpu_numa_node(cpu, node)
+#endif
 #ifndef cpu_to_mem
 #define cpu_to_mem(cpu)         ((void)(cpu),0)
 #endif
 #ifndef parent_node
 #define parent_node(node)       ((void)(node),0)
 #endif
@@ -55,4 +62,15 @@
 #endif  /* CONFIG_NUMA */
+#if !defined(CONFIG_NUMA) || !defined(CONFIG_HAVE_MEMORYLESS_NODES)
+#ifndef set_numa_mem
+#define set_numa_mem(node)
+#endif
+#ifndef set_cpu_numa_mem
+#define set_cpu_numa_mem(cpu, node)
+#endif
+#endif  /* !CONFIG_NUMA || !CONFIG_HAVE_MEMORYLESS_NODES */
 #endif /* _ASM_GENERIC_TOPOLOGY_H */
diff --git a/include/asm-generic/unistd.h b/include/asm-generic/unistd.h
index 6a0b30f78a62..e1898090f22c 100644
--- a/include/asm-generic/unistd.h
+++ b/include/asm-generic/unistd.h
@@ -18,7 +18,7 @@
 #define __SYSCALL(x, y)
 #endif
-#if __BITS_PER_LONG == 32
+#if __BITS_PER_LONG == 32 || defined(__SYSCALL_COMPAT)
 #define __SC_3264(_nr, _32, _64) __SYSCALL(_nr, _32)
 #else
 #define __SC_3264(_nr, _32, _64) __SYSCALL(_nr, _64)
@@ -241,8 +241,13 @@ __SYSCALL(__NR_sync, sys_sync)
 __SYSCALL(__NR_fsync, sys_fsync)
 #define __NR_fdatasync 83
 __SYSCALL(__NR_fdatasync, sys_fdatasync)
+#ifdef __ARCH_WANT_SYNC_FILE_RANGE2
+#define __NR_sync_file_range2 84
+__SYSCALL(__NR_sync_file_range2, sys_sync_file_range2)
+#else
 #define __NR_sync_file_range 84
-__SYSCALL(__NR_sync_file_range, sys_sync_file_range) /* .long sys_sync_file_range2, */
+__SYSCALL(__NR_sync_file_range, sys_sync_file_range)
+#endif
 /* fs/timerfd.c */
 #define __NR_timerfd_create 85
@@ -580,7 +585,7 @@ __SYSCALL(__NR_execve, sys_execve)	/* .long sys_execve_wrapper */
 __SC_3264(__NR3264_mmap, sys_mmap2, sys_mmap)
 /* mm/fadvise.c */
 #define __NR3264_fadvise64 223
-__SC_3264(__NR3264_fadvise64, sys_fadvise64_64, sys_fadvise64)
+__SYSCALL(__NR3264_fadvise64, sys_fadvise64_64)
 /* mm/, CONFIG_MMU only */
 #ifndef __ARCH_NOMMU
@@ -627,8 +632,19 @@ __SYSCALL(__NR_accept4, sys_accept4)
 #define __NR_recvmmsg 243
 __SYSCALL(__NR_recvmmsg, sys_recvmmsg)
+/*
+ * Architectures may provide up to 16 syscalls of their own
+ * starting with this value.
+ */
+#define __NR_arch_specific_syscall 244
+#define __NR_wait4 260
+__SYSCALL(__NR_wait4, sys_wait4)
+#define __NR_prlimit64 261
+__SYSCALL(__NR_prlimit64, sys_prlimit64)
 #undef __NR_syscalls
-#define __NR_syscalls 244
+#define __NR_syscalls 262
 /*
 * All syscalls below here should go away really,
@@ -694,7 +710,8 @@ __SYSCALL(__NR_signalfd, sys_signalfd)
 #define __NR_syscalls (__NR_signalfd+1)
 #endif /* __ARCH_WANT_SYSCALL_NO_FLAGS */
-#if __BITS_PER_LONG == 32 && defined(__ARCH_WANT_SYSCALL_OFF_T)
+#if (__BITS_PER_LONG == 32 || defined(__SYSCALL_COMPAT)) && \
+     defined(__ARCH_WANT_SYSCALL_OFF_T)
 #define __NR_sendfile 1046
 __SYSCALL(__NR_sendfile, sys_sendfile)
 #define __NR_ftruncate 1047
@@ -740,6 +757,7 @@ __SYSCALL(__NR_getpgrp, sys_getpgrp)
 __SYSCALL(__NR_pause, sys_pause)
 #define __NR_time 1062
 #define __ARCH_WANT_SYS_TIME
+#define __ARCH_WANT_COMPAT_SYS_TIME
 __SYSCALL(__NR_time, sys_time)
 #define __NR_utime 1063
 #define __ARCH_WANT_SYS_UTIME
@@ -763,8 +781,8 @@ __SYSCALL(__NR_epoll_wait, sys_epoll_wait)
 __SYSCALL(__NR_ustat, sys_ustat)
 #define __NR_vfork 1071
 __SYSCALL(__NR_vfork, sys_vfork)
-#define __NR_wait4 1072
+#define __NR_oldwait4 1072
-__SYSCALL(__NR_wait4, sys_wait4)
+__SYSCALL(__NR_oldwait4, sys_wait4)
 #define __NR_recv 1073
 __SYSCALL(__NR_recv, sys_recv)
 #define __NR_send 1074
@@ -801,7 +819,7 @@ __SYSCALL(__NR_fork, sys_ni_syscall)
 * Here we map the numbers so that both versions
 * use the same syscall table layout.
 */
-#if __BITS_PER_LONG == 64
+#if __BITS_PER_LONG == 64 && !defined(__SYSCALL_COMPAT)
 #define __NR_fcntl __NR3264_fcntl
 #define __NR_statfs __NR3264_statfs
 #define __NR_fstatfs __NR3264_fstatfs
@@ -848,6 +866,7 @@ __SYSCALL(__NR_fork, sys_ni_syscall)
 #endif
 #define __ARCH_WANT_SYS_RT_SIGACTION
 #define __ARCH_WANT_SYS_RT_SIGSUSPEND
+#define __ARCH_WANT_COMPAT_SYS_RT_SIGSUSPEND
 /*
 * "Conditional" syscalls
diff --git a/include/linux/Kbuild b/include/linux/Kbuild
index 9aa9bcadf869..2547daf2aef2 100644
--- a/include/linux/Kbuild
+++ b/include/linux/Kbuild
@@ -210,6 +210,7 @@ unifdef-y += ethtool.h
 unifdef-y += eventpoll.h
 unifdef-y += signalfd.h
 unifdef-y += ext2_fs.h
+unifdef-y += fanotify.h
 unifdef-y += fb.h
 unifdef-y += fcntl.h
 unifdef-y += filter.h
diff --git a/include/linux/auto_fs.h b/include/linux/auto_fs.h
index 7b09c8348fd3..da64e15004b6 100644
--- a/include/linux/auto_fs.h
+++ b/include/linux/auto_fs.h
@@ -79,6 +79,7 @@ struct autofs_packet_expire {
 #define AUTOFS_IOC_FAIL       _IO(0x93,0x61)
 #define AUTOFS_IOC_CATATONIC  _IO(0x93,0x62)
 #define AUTOFS_IOC_PROTOVER   _IOR(0x93,0x63,int)
+#define AUTOFS_IOC_SETTIMEOUT32 _IOWR(0x93,0x64,compat_ulong_t)
 #define AUTOFS_IOC_SETTIMEOUT _IOWR(0x93,0x64,unsigned long)
 #define AUTOFS_IOC_EXPIRE     _IOR(0x93,0x65,struct autofs_packet_expire)
diff --git a/include/linux/buffer_head.h b/include/linux/buffer_head.h
index 1b9ba193b789..43e649a72529 100644
--- a/include/linux/buffer_head.h
+++ b/include/linux/buffer_head.h
@@ -203,12 +203,10 @@ int block_write_full_page_endio(struct page *page, get_block_t *get_block,
 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);
-int block_write_begin_newtrunc(struct file *, struct address_space *,
+int block_write_begin(struct address_space *mapping, loff_t pos, unsigned len,
-                                loff_t, unsigned, unsigned,
+                unsigned flags, struct page **pagep, get_block_t *get_block);
-                                struct page **, void **, get_block_t*);
+int __block_write_begin(struct page *page, loff_t pos, unsigned len,
-int block_write_begin(struct file *, struct address_space *,
+                get_block_t *get_block);
-                                loff_t, unsigned, unsigned,
-                                struct page **, void **, get_block_t*);
 int block_write_end(struct file *, struct address_space *,
                                loff_t, unsigned, unsigned,
                                struct page *, void *);
@@ -217,9 +215,6 @@ int generic_write_end(struct file *, struct address_space *,
                                struct page *, void *);
 void page_zero_new_buffers(struct page *page, unsigned from, unsigned to);
 int block_prepare_write(struct page*, unsigned, unsigned, get_block_t*);
-int cont_write_begin_newtrunc(struct file *, struct address_space *, loff_t,
-                        unsigned, unsigned, struct page **, void **,
-                        get_block_t *, loff_t *);
 int cont_write_begin(struct file *, struct address_space *, loff_t,
                        unsigned, unsigned, struct page **, void **,
                        get_block_t *, loff_t *);
@@ -230,12 +225,7 @@ int block_page_mkwrite(struct vm_area_struct *vma, struct vm_fault *vmf,
 void block_sync_page(struct page *);
 sector_t generic_block_bmap(struct address_space *, sector_t, get_block_t *);
 int block_truncate_page(struct address_space *, loff_t, get_block_t *);
-int file_fsync(struct file *, int);
+int nobh_write_begin(struct address_space *, loff_t, unsigned, unsigned,
-int nobh_write_begin_newtrunc(struct file *, struct address_space *,
-                                loff_t, unsigned, unsigned,
-                                struct page **, void **, get_block_t*);
-int nobh_write_begin(struct file *, struct address_space *,
-                                loff_t, unsigned, unsigned,
                                struct page **, void **, get_block_t*);
 int nobh_write_end(struct file *, struct address_space *,
                                loff_t, unsigned, unsigned,
@@ -314,15 +304,10 @@ map_bh(struct buffer_head *bh, struct super_block *sb, sector_t block)
        bh->b_size = sb->s_blocksize;
 }
-/*
- * Calling wait_on_buffer() for a zero-ref buffer is illegal, so we call into
- * __wait_on_buffer() just to trip a debug check.  Because debug code in inline
- * functions is bloaty.
- */
 static inline void wait_on_buffer(struct buffer_head *bh)
 {
        might_sleep();
-        if (buffer_locked(bh) || atomic_read(&bh->b_count) == 0)
+        if (buffer_locked(bh))
                __wait_on_buffer(bh);
 }
diff --git a/include/linux/compiler-gcc.h b/include/linux/compiler-gcc.h
index 0da5b187f124..16508bcddacc 100644
--- a/include/linux/compiler-gcc.h
+++ b/include/linux/compiler-gcc.h
@@ -35,8 +35,7 @@
    (typeof(ptr)) (__ptr + (off)); })
 /* &a[0] degrades to a pointer: a different type from an array */
-#define __must_be_array(a) \
+#define __must_be_array(a) BUILD_BUG_ON_ZERO(__same_type((a), &(a)[0]))
-  BUILD_BUG_ON_ZERO(__builtin_types_compatible_p(typeof(a), typeof(&a[0])))
 /*
 * Force always-inline if the user requests it so via the .config,
diff --git a/include/linux/console_struct.h b/include/linux/console_struct.h
index 38fe59dc89ae..7f0c32908568 100644
--- a/include/linux/console_struct.h
+++ b/include/linux/console_struct.h
@@ -21,6 +21,8 @@ struct vt_struct;
 #define NPAR 16
 struct vc_data {
+        struct tty_port port;                   /* Upper level data */
        unsigned short  vc_num;                 /* Console number */
        unsigned int    vc_cols;                /* [#] Console size */
        unsigned int    vc_rows;
@@ -56,7 +58,6 @@ struct vc_data {
        /* VT terminal data */
        unsigned int    vc_state;               /* Escape sequence parser state */
        unsigned int    vc_npar,vc_par[NPAR];   /* Parameters of current escape sequence */
-        struct tty_struct *vc_tty;              /* TTY we are attached to */
        /* data for manual vt switching */
        struct vt_mode  vt_mode;
        struct pid      *vt_pid;
@@ -105,6 +106,7 @@ struct vc_data {
        struct vc_data **vc_display_fg;         /* [!] Ptr to var holding fg console for this display */
        unsigned long   vc_uni_pagedir;
        unsigned long   *vc_uni_pagedir_loc;  /* [!] Location of uni_pagedir variable for this console */
+        bool vc_panic_force_write; /* when oops/panic this VC can accept forced output/blanking */
        /* additional information is in vt_kern.h */
 };
diff --git a/include/linux/cpuidle.h b/include/linux/cpuidle.h
index 55215cce5005..36ca9721a0c2 100644
--- a/include/linux/cpuidle.h
+++ b/include/linux/cpuidle.h
@@ -52,6 +52,7 @@ struct cpuidle_state {
 #define CPUIDLE_FLAG_SHALLOW    (0x20) /* low latency, minimal savings */
 #define CPUIDLE_FLAG_BALANCED   (0x40) /* medium latency, moderate savings */
 #define CPUIDLE_FLAG_DEEP       (0x80) /* high latency, large savings */
+#define CPUIDLE_FLAG_IGNORE     (0x100) /* ignore during this idle period */
 #define CPUIDLE_DRIVER_FLAGS_MASK (0xFFFF0000)
@@ -84,6 +85,7 @@ struct cpuidle_state_kobj {
 struct cpuidle_device {
        unsigned int            registered:1;
        unsigned int            enabled:1;
+        unsigned int            power_specified:1;
        unsigned int            cpu;
        int                     last_residency;
@@ -97,6 +99,8 @@ struct cpuidle_device {
        struct completion       kobj_unregister;
        void                    *governor_data;
        struct cpuidle_state    *safe_state;
+        int (*prepare)          (struct cpuidle_device *dev);
 };
 DECLARE_PER_CPU(struct cpuidle_device *, cpuidle_devices);
diff --git a/include/linux/dcache.h b/include/linux/dcache.h
index eebb617c17d8..d23be0386e2d 100644
--- a/include/linux/dcache.h
+++ b/include/linux/dcache.h
@@ -315,6 +315,7 @@ extern char *dynamic_dname(struct dentry *, char *, int, const char *, ...);
 extern char *__d_path(const struct path *path, struct path *root, char *, int);
 extern char *d_path(const struct path *, char *, int);
+extern char *__dentry_path(struct dentry *, char *, int);
 extern char *dentry_path(struct dentry *, char *, int);
 /* Allocation counts.. */
diff --git a/include/linux/dmaengine.h b/include/linux/dmaengine.h
index 5204f018931b..c61d4ca27bcc 100644
--- a/include/linux/dmaengine.h
+++ b/include/linux/dmaengine.h
@@ -114,11 +114,17 @@ enum dma_ctrl_flags {
 * @DMA_TERMINATE_ALL: terminate all ongoing transfers
 * @DMA_PAUSE: pause ongoing transfers
 * @DMA_RESUME: resume paused transfer
+ * @DMA_SLAVE_CONFIG: this command is only implemented by DMA controllers
+ * that need to runtime reconfigure the slave channels (as opposed to passing
+ * configuration data in statically from the platform). An additional
+ * argument of struct dma_slave_config must be passed in with this
+ * command.
 */
 enum dma_ctrl_cmd {
        DMA_TERMINATE_ALL,
        DMA_PAUSE,
        DMA_RESUME,
+        DMA_SLAVE_CONFIG,
 };
 /**
@@ -199,6 +205,71 @@ struct dma_chan_dev {
        atomic_t *idr_ref;
 };
+/**
+ * enum dma_slave_buswidth - defines bus with of the DMA slave
+ * device, source or target buses
+ */
+enum dma_slave_buswidth {
+        DMA_SLAVE_BUSWIDTH_UNDEFINED = 0,
+        DMA_SLAVE_BUSWIDTH_1_BYTE = 1,
+        DMA_SLAVE_BUSWIDTH_2_BYTES = 2,
+        DMA_SLAVE_BUSWIDTH_4_BYTES = 4,
+        DMA_SLAVE_BUSWIDTH_8_BYTES = 8,
+};
+/**
+ * struct dma_slave_config - dma slave channel runtime config
+ * @direction: whether the data shall go in or out on this slave
+ * channel, right now. DMA_TO_DEVICE and DMA_FROM_DEVICE are
+ * legal values, DMA_BIDIRECTIONAL is not acceptable since we
+ * need to differentiate source and target addresses.
+ * @src_addr: this is the physical address where DMA slave data
+ * should be read (RX), if the source is memory this argument is
+ * ignored.
+ * @dst_addr: this is the physical address where DMA slave data
+ * should be written (TX), if the source is memory this argument
+ * is ignored.
+ * @src_addr_width: this is the width in bytes of the source (RX)
+ * register where DMA data shall be read. If the source
+ * is memory this may be ignored depending on architecture.
+ * Legal values: 1, 2, 4, 8.
+ * @dst_addr_width: same as src_addr_width but for destination
+ * target (TX) mutatis mutandis.
+ * @src_maxburst: the maximum number of words (note: words, as in
+ * units of the src_addr_width member, not bytes) that can be sent
+ * in one burst to the device. Typically something like half the
+ * FIFO depth on I/O peripherals so you don't overflow it. This
+ * may or may not be applicable on memory sources.
+ * @dst_maxburst: same as src_maxburst but for destination target
+ * mutatis mutandis.
+ *
+ * This struct is passed in as configuration data to a DMA engine
+ * in order to set up a certain channel for DMA transport at runtime.
+ * The DMA device/engine has to provide support for an additional
+ * command in the channel config interface, DMA_SLAVE_CONFIG
+ * and this struct will then be passed in as an argument to the
+ * DMA engine device_control() function.
+ *
+ * The rationale for adding configuration information to this struct
+ * is as follows: if it is likely that most DMA slave controllers in
+ * the world will support the configuration option, then make it
+ * generic. If not: if it is fixed so that it be sent in static from
+ * the platform data, then prefer to do that. Else, if it is neither
+ * fixed at runtime, nor generic enough (such as bus mastership on
+ * some CPU family and whatnot) then create a custom slave config
+ * struct and pass that, then make this config a member of that
+ * struct, if applicable.
+ */
+struct dma_slave_config {
+        enum dma_data_direction direction;
+        dma_addr_t src_addr;
+        dma_addr_t dst_addr;
+        enum dma_slave_buswidth src_addr_width;
+        enum dma_slave_buswidth dst_addr_width;
+        u32 src_maxburst;
+        u32 dst_maxburst;
+};
 static inline const char *dma_chan_name(struct dma_chan *chan)
 {
        return dev_name(&chan->dev->device);
diff --git a/include/linux/dnotify.h b/include/linux/dnotify.h
index ecc06286226d..3290555a52ee 100644
--- a/include/linux/dnotify.h
+++ b/include/linux/dnotify.h
@@ -28,6 +28,7 @@ struct dnotify_struct {
                            FS_CREATE | FS_DN_RENAME |\
                            FS_MOVED_FROM | FS_MOVED_TO)
+extern int dir_notify_enable;
 extern void dnotify_flush(struct file *, fl_owner_t);
 extern int fcntl_dirnotify(int, struct file *, unsigned long);
diff --git a/include/linux/ext3_fs.h b/include/linux/ext3_fs.h
index 3d3a9915dde2..6ce1bca01724 100644
--- a/include/linux/ext3_fs.h
+++ b/include/linux/ext3_fs.h
@@ -895,7 +895,7 @@ int ext3_get_blocks_handle(handle_t *handle, struct inode *inode,
 extern struct inode *ext3_iget(struct super_block *, unsigned long);
 extern int  ext3_write_inode (struct inode *, struct writeback_control *);
 extern int  ext3_setattr (struct dentry *, struct iattr *);
-extern void ext3_delete_inode (struct inode *);
+extern void ext3_evict_inode (struct inode *);
 extern int  ext3_sync_inode (handle_t *, struct inode *);
 extern void ext3_discard_reservation (struct inode *);
 extern void ext3_dirty_inode(struct inode *);
diff --git a/include/linux/fanotify.h b/include/linux/fanotify.h
new file mode 100644
index 000000000000..f0949a57ca9d
--- /dev/null
+++ b/include/linux/fanotify.h
@@ -0,0 +1,105 @@
+#ifndef _LINUX_FANOTIFY_H
+#define _LINUX_FANOTIFY_H
+#include <linux/types.h>
+/* the following events that user-space can register for */
+#define FAN_ACCESS              0x00000001      /* File was accessed */
+#define FAN_MODIFY              0x00000002      /* File was modified */
+#define FAN_CLOSE_WRITE         0x00000008      /* Unwrittable file closed */
+#define FAN_CLOSE_NOWRITE       0x00000010      /* Writtable file closed */
+#define FAN_OPEN                0x00000020      /* File was opened */
+#define FAN_EVENT_ON_CHILD      0x08000000      /* interested in child events */
+/* FIXME currently Q's have no limit.... */
+#define FAN_Q_OVERFLOW          0x00004000      /* Event queued overflowed */
+#define FAN_OPEN_PERM           0x00010000      /* File open in perm check */
+#define FAN_ACCESS_PERM         0x00020000      /* File accessed in perm check */
+/* helper events */
+#define FAN_CLOSE               (FAN_CLOSE_WRITE | FAN_CLOSE_NOWRITE) /* close */
+/* flags used for fanotify_init() */
+#define FAN_CLOEXEC             0x00000001
+#define FAN_NONBLOCK            0x00000002
+#define FAN_ALL_INIT_FLAGS      (FAN_CLOEXEC | FAN_NONBLOCK)
+/* flags used for fanotify_modify_mark() */
+#define FAN_MARK_ADD            0x00000001
+#define FAN_MARK_REMOVE         0x00000002
+#define FAN_MARK_DONT_FOLLOW    0x00000004
+#define FAN_MARK_ONLYDIR        0x00000008
+#define FAN_MARK_MOUNT          0x00000010
+#define FAN_MARK_IGNORED_MASK   0x00000020
+#define FAN_MARK_IGNORED_SURV_MODIFY    0x00000040
+#define FAN_MARK_FLUSH          0x00000080
+#define FAN_ALL_MARK_FLAGS      (FAN_MARK_ADD |\
+                                 FAN_MARK_REMOVE |\
+                                 FAN_MARK_DONT_FOLLOW |\
+                                 FAN_MARK_ONLYDIR |\
+                                 FAN_MARK_MOUNT |\
+                                 FAN_MARK_IGNORED_MASK |\
+                                 FAN_MARK_IGNORED_SURV_MODIFY)
+/*
+ * All of the events - we build the list by hand so that we can add flags in
+ * the future and not break backward compatibility.  Apps will get only the
+ * events that they originally wanted.  Be sure to add new events here!
+ */
+#define FAN_ALL_EVENTS (FAN_ACCESS |\
+                        FAN_MODIFY |\
+                        FAN_CLOSE |\
+                        FAN_OPEN)
+/*
+ * All events which require a permission response from userspace
+ */
+#define FAN_ALL_PERM_EVENTS (FAN_OPEN_PERM |\
+                             FAN_ACCESS_PERM)
+#define FAN_ALL_OUTGOING_EVENTS (FAN_ALL_EVENTS |\
+                                 FAN_ALL_PERM_EVENTS |\
+                                 FAN_Q_OVERFLOW)
+#define FANOTIFY_METADATA_VERSION       1
+struct fanotify_event_metadata {
+        __u32 event_len;
+        __u32 vers;
+        __s32 fd;
+        __u64 mask;
+        __s64 pid;
+} __attribute__ ((packed));
+struct fanotify_response {
+        __s32 fd;
+        __u32 response;
+} __attribute__ ((packed));
+/* Legit userspace responses to a _PERM event */
+#define FAN_ALLOW       0x01
+#define FAN_DENY        0x02
+/* Helper functions to deal with fanotify_event_metadata buffers */
+#define FAN_EVENT_METADATA_LEN (sizeof(struct fanotify_event_metadata))
+#define FAN_EVENT_NEXT(meta, len) ((len) -= (meta)->event_len, \
+                                   (struct fanotify_event_metadata*)(((char *)(meta)) + \
+                                   (meta)->event_len))
+#define FAN_EVENT_OK(meta, len) ((long)(len) >= (long)FAN_EVENT_METADATA_LEN && \
+                                (long)(meta)->event_len >= (long)FAN_EVENT_METADATA_LEN && \
+                                (long)(meta)->event_len <= (long)(len))
+#ifdef __KERNEL__
+struct fanotify_wait {
+        struct fsnotify_event *event;
+        __s32 fd;
+};
+#endif /* __KERNEL__ */
+#endif /* _LINUX_FANOTIFY_H */
diff --git a/include/linux/fb.h b/include/linux/fb.h
index 0c5659c41b01..f0268deca658 100644
--- a/include/linux/fb.h
+++ b/include/linux/fb.h
@@ -825,6 +825,10 @@ struct fb_tile_ops {
 */
 #define FBINFO_BE_MATH  0x100000
+/* report to the VT layer that this fb driver can accept forced console
+   output like oopses */
+#define FBINFO_CAN_FORCE_OUTPUT     0x200000
 struct fb_info {
        int node;
        int flags;
diff --git a/include/linux/flex_array.h b/include/linux/flex_array.h
index 1d747f72298b..631b77f2ac70 100644
--- a/include/linux/flex_array.h
+++ b/include/linux/flex_array.h
@@ -70,4 +70,9 @@ int flex_array_clear(struct flex_array *fa, unsigned int element_nr);
 void *flex_array_get(struct flex_array *fa, unsigned int element_nr);
 int flex_array_shrink(struct flex_array *fa);
+#define flex_array_put_ptr(fa, nr, src, gfp) \
+        flex_array_put(fa, nr, &(void *)(src), gfp)
+void *flex_array_get_ptr(struct flex_array *fa, unsigned int element_nr);
 #endif /* _FLEX_ARRAY_H */
diff --git a/include/linux/fs.h b/include/linux/fs.h
index e5106e49bd2c..a8ccf85b8691 100644
--- a/include/linux/fs.h
+++ b/include/linux/fs.h
@@ -91,6 +91,9 @@ struct inodes_stat_t {
 /* Expect random access pattern */
 #define FMODE_RANDOM            ((__force fmode_t)0x1000)
+/* File was opened by fanotify and shouldn't generate fanotify events */
+#define FMODE_NONOTIFY          ((__force fmode_t)16777216) /* 0x1000000 */
 /*
 * The below are the various read and write types that we support. Some of
 * them include behavioral modifiers that send information down to the
@@ -210,6 +213,7 @@ struct inodes_stat_t {
 #define MS_KERNMOUNT    (1<<22) /* this is a kern_mount call */
 #define MS_I_VERSION    (1<<23) /* Update inode I_version field */
 #define MS_STRICTATIME  (1<<24) /* Always perform atime updates */
+#define MS_BORN         (1<<29)
 #define MS_ACTIVE       (1<<30)
 #define MS_NOUSER       (1<<31)
@@ -408,9 +412,6 @@ extern int get_max_files(void);
 extern int sysctl_nr_open;
 extern struct inodes_stat_t inodes_stat;
 extern int leases_enable, lease_break_time;
-#ifdef CONFIG_DNOTIFY
-extern int dir_notify_enable;
-#endif
 struct buffer_head;
 typedef int (get_block_t)(struct inode *inode, sector_t iblock,
@@ -687,6 +688,7 @@ struct block_device {
 */
 #define PAGECACHE_TAG_DIRTY     0
 #define PAGECACHE_TAG_WRITEBACK 1
+#define PAGECACHE_TAG_TOWRITE   2
 int mapping_tagged(struct address_space *mapping, int tag);
@@ -770,12 +772,7 @@ struct inode {
 #ifdef CONFIG_FSNOTIFY
        __u32                   i_fsnotify_mask; /* all events this inode cares about */
-        struct hlist_head       i_fsnotify_mark_entries; /* fsnotify mark entries */
+        struct hlist_head       i_fsnotify_marks;
-#endif
-#ifdef CONFIG_INOTIFY
-        struct list_head        inotify_watches; /* watches on this inode */
-        struct mutex            inotify_mutex;  /* protects the watches list */
 #endif
        unsigned long           i_state;
@@ -1563,8 +1560,8 @@ struct super_operations {
        void (*dirty_inode) (struct inode *);
        int (*write_inode) (struct inode *, struct writeback_control *wbc);
-        void (*drop_inode) (struct inode *);
+        int (*drop_inode) (struct inode *);
-        void (*delete_inode) (struct inode *);
+        void (*evict_inode) (struct inode *);
        void (*put_super) (struct super_block *);
        void (*write_super) (struct super_block *);
        int (*sync_fs)(struct super_block *sb, int wait);
@@ -1572,7 +1569,6 @@ struct super_operations {
        int (*unfreeze_fs) (struct super_block *);
        int (*statfs) (struct dentry *, struct kstatfs *);
        int (*remount_fs) (struct super_block *, int *, char *);
-        void (*clear_inode) (struct inode *);
        void (*umount_begin) (struct super_block *);
        int (*show_options)(struct seq_file *, struct vfsmount *);
@@ -1617,8 +1613,8 @@ struct super_operations {
 * I_FREEING            Set when inode is about to be freed but still has dirty
 *                      pages or buffers attached or the inode itself is still
 *                      dirty.
- * I_CLEAR              Set by clear_inode().  In this state the inode is clean
+ * I_CLEAR              Added by end_writeback().  In this state the inode is clean
- *                      and can be destroyed.
+ *                      and can be destroyed.  Inode keeps I_FREEING.
 *
 *                      Inodes that are I_WILL_FREE, I_FREEING or I_CLEAR are
 *                      prohibited for many purposes.  iget() must wait for
@@ -1815,7 +1811,8 @@ extern struct vfsmount *collect_mounts(struct path *);
 extern void drop_collected_mounts(struct vfsmount *);
 extern int iterate_mounts(int (*)(struct vfsmount *, void *), void *,
                          struct vfsmount *);
-extern int vfs_statfs(struct dentry *, struct kstatfs *);
+extern int vfs_statfs(struct path *, struct kstatfs *);
+extern int statfs_by_dentry(struct dentry *, struct kstatfs *);
 extern int freeze_super(struct super_block *super);
 extern int thaw_super(struct super_block *super);
@@ -2165,9 +2162,8 @@ extern void iput(struct inode *);
 extern struct inode * igrab(struct inode *);
 extern ino_t iunique(struct super_block *, ino_t);
 extern int inode_needs_sync(struct inode *inode);
-extern void generic_delete_inode(struct inode *inode);
+extern int generic_delete_inode(struct inode *inode);
-extern void generic_drop_inode(struct inode *inode);
+extern int generic_drop_inode(struct inode *inode);
-extern int generic_detach_inode(struct inode *inode);
 extern struct inode *ilookup5_nowait(struct super_block *sb,
                unsigned long hashval, int (*test)(struct inode *, void *),
@@ -2184,7 +2180,7 @@ extern void unlock_new_inode(struct inode *);
 extern void __iget(struct inode * inode);
 extern void iget_failed(struct inode *);
-extern void clear_inode(struct inode *);
+extern void end_writeback(struct inode *);
 extern void destroy_inode(struct inode *);
 extern void __destroy_inode(struct inode *);
 extern struct inode *new_inode(struct super_block *);
@@ -2270,16 +2266,6 @@ static inline int xip_truncate_page(struct address_space *mapping, loff_t from)
 struct bio;
 typedef void (dio_submit_t)(int rw, struct bio *bio, struct inode *inode,
                            loff_t file_offset);
-void dio_end_io(struct bio *bio, int error);
-ssize_t __blockdev_direct_IO_newtrunc(int rw, struct kiocb *iocb, struct inode *inode,
-        struct block_device *bdev, const struct iovec *iov, loff_t offset,
-        unsigned long nr_segs, get_block_t get_block, dio_iodone_t end_io,
-        dio_submit_t submit_io, int lock_type);
-ssize_t __blockdev_direct_IO(int rw, struct kiocb *iocb, struct inode *inode,
-        struct block_device *bdev, const struct iovec *iov, loff_t offset,
-        unsigned long nr_segs, get_block_t get_block, dio_iodone_t end_io,
-        dio_submit_t submit_io, int lock_type);
 enum {
        /* need locking between buffered and direct access */
@@ -2289,24 +2275,13 @@ enum {
        DIO_SKIP_HOLES  = 0x02,
 };
-static inline ssize_t blockdev_direct_IO_newtrunc(int rw, struct kiocb *iocb,
+void dio_end_io(struct bio *bio, int error);
-        struct inode *inode, struct block_device *bdev, const struct iovec *iov,
-        loff_t offset, unsigned long nr_segs, get_block_t get_block,
+ssize_t __blockdev_direct_IO(int rw, struct kiocb *iocb, struct inode *inode,
-        dio_iodone_t end_io)
+        struct block_device *bdev, const struct iovec *iov, loff_t offset,
-{
+        unsigned long nr_segs, get_block_t get_block, dio_iodone_t end_io,
-        return __blockdev_direct_IO_newtrunc(rw, iocb, inode, bdev, iov, offset,
+        dio_submit_t submit_io, int flags);
-                                    nr_segs, get_block, end_io, NULL,
-                                    DIO_LOCKING | DIO_SKIP_HOLES);
-}
-static inline ssize_t blockdev_direct_IO_no_locking_newtrunc(int rw, struct kiocb *iocb,
-        struct inode *inode, struct block_device *bdev, const struct iovec *iov,
-        loff_t offset, unsigned long nr_segs, get_block_t get_block,
-        dio_iodone_t end_io)
-{
-        return __blockdev_direct_IO_newtrunc(rw, iocb, inode, bdev, iov, offset,
-                                nr_segs, get_block, end_io, NULL, 0);
-}
 static inline ssize_t blockdev_direct_IO(int rw, struct kiocb *iocb,
        struct inode *inode, struct block_device *bdev, const struct iovec *iov,
        loff_t offset, unsigned long nr_segs, get_block_t get_block,
@@ -2316,15 +2291,6 @@ static inline ssize_t blockdev_direct_IO(int rw, struct kiocb *iocb,
                                    nr_segs, get_block, end_io, NULL,
                                    DIO_LOCKING | DIO_SKIP_HOLES);
 }
-static inline ssize_t blockdev_direct_IO_no_locking(int rw, struct kiocb *iocb,
-        struct inode *inode, struct block_device *bdev, const struct iovec *iov,
-        loff_t offset, unsigned long nr_segs, get_block_t get_block,
-        dio_iodone_t end_io)
-{
-        return __blockdev_direct_IO(rw, iocb, inode, bdev, iov, offset,
-                                    nr_segs, get_block, end_io, NULL, 0);
-}
 #endif
 extern const struct file_operations generic_ro_fops;
@@ -2386,7 +2352,6 @@ extern int simple_link(struct dentry *, struct inode *, struct dentry *);
 extern int simple_unlink(struct inode *, struct dentry *);
 extern int simple_rmdir(struct inode *, struct dentry *);
 extern int simple_rename(struct inode *, struct dentry *, struct inode *, struct dentry *);
-extern int simple_setsize(struct inode *, loff_t);
 extern int noop_fsync(struct file *, int);
 extern int simple_empty(struct dentry *);
 extern int simple_readpage(struct file *file, struct page *page);
@@ -2423,8 +2388,7 @@ extern int buffer_migrate_page(struct address_space *,
 extern int inode_change_ok(const struct inode *, struct iattr *);
 extern int inode_newsize_ok(const struct inode *, loff_t offset);
-extern int __must_check inode_setattr(struct inode *, const struct iattr *);
+extern void setattr_copy(struct inode *inode, const struct iattr *attr);
-extern void generic_setattr(struct inode *inode, const struct iattr *attr);
 extern void file_update_time(struct file *file);
@@ -2515,7 +2479,8 @@ int proc_nr_files(struct ctl_table *table, int write,
 int __init get_filesystem_list(char *buf);
 #define ACC_MODE(x) ("\004\002\006\006"[(x)&O_ACCMODE])
-#define OPEN_FMODE(flag) ((__force fmode_t)((flag + 1) & O_ACCMODE))
+#define OPEN_FMODE(flag) ((__force fmode_t)(((flag + 1) & O_ACCMODE) | \
+                                            (flag & FMODE_NONOTIFY)))
 #endif /* __KERNEL__ */
 #endif /* _LINUX_FS_H */
diff --git a/include/linux/fsnotify.h b/include/linux/fsnotify.h
index 01755909ce81..e4e2204187ee 100644
--- a/include/linux/fsnotify.h
+++ b/include/linux/fsnotify.h
@@ -11,8 +11,6 @@
 * (C) Copyright 2005 Robert Love
 */
-#include <linux/dnotify.h>
-#include <linux/inotify.h>
 #include <linux/fsnotify_backend.h>
 #include <linux/audit.h>
 #include <linux/slab.h>
@@ -21,35 +19,52 @@
 * fsnotify_d_instantiate - instantiate a dentry for inode
 * Called with dcache_lock held.
 */
-static inline void fsnotify_d_instantiate(struct dentry *entry,
+static inline void fsnotify_d_instantiate(struct dentry *dentry,
-                                                struct inode *inode)
+                                          struct inode *inode)
 {
-        __fsnotify_d_instantiate(entry, inode);
+        __fsnotify_d_instantiate(dentry, inode);
-        inotify_d_instantiate(entry, inode);
 }
 /* Notify this dentry's parent about a child's events. */
-static inline void fsnotify_parent(struct dentry *dentry, __u32 mask)
+static inline void fsnotify_parent(struct file *file, struct dentry *dentry, __u32 mask)
 {
-        __fsnotify_parent(dentry, mask);
+        if (!dentry)
+                dentry = file->f_path.dentry;
+        __fsnotify_parent(file, dentry, mask);
+}
-        inotify_dentry_parent_queue_event(dentry, mask, 0, dentry->d_name.name);
+/* simple call site for access decisions */
+static inline int fsnotify_perm(struct file *file, int mask)
+{
+        struct inode *inode = file->f_path.dentry->d_inode;
+        __u32 fsnotify_mask = 0;
+        if (file->f_mode & FMODE_NONOTIFY)
+                return 0;
+        if (!(mask & (MAY_READ | MAY_OPEN)))
+                return 0;
+        if (mask & MAY_OPEN)
+                fsnotify_mask = FS_OPEN_PERM;
+        else if (mask & MAY_READ)
+                fsnotify_mask = FS_ACCESS_PERM;
+        else
+                BUG();
+        return fsnotify(inode, fsnotify_mask, file, FSNOTIFY_EVENT_FILE, NULL, 0);
 }
 /*
- * fsnotify_d_move - entry has been moved
+ * fsnotify_d_move - dentry has been moved
- * Called with dcache_lock and entry->d_lock held.
+ * Called with dcache_lock and dentry->d_lock held.
 */
-static inline void fsnotify_d_move(struct dentry *entry)
+static inline void fsnotify_d_move(struct dentry *dentry)
 {
        /*
-         * On move we need to update entry->d_flags to indicate if the new parent
+         * On move we need to update dentry->d_flags to indicate if the new parent
-         * cares about events from this entry.
+         * cares about events from this dentry.
         */
-        __fsnotify_update_dcache_flags(entry);
+        __fsnotify_update_dcache_flags(dentry);
-        inotify_d_move(entry);
 }
 /*
@@ -57,8 +72,6 @@ static inline void fsnotify_d_move(struct dentry *entry)
 */
 static inline void fsnotify_link_count(struct inode *inode)
 {
-        inotify_inode_queue_event(inode, IN_ATTRIB, 0, NULL, NULL);
        fsnotify(inode, FS_ATTRIB, inode, FSNOTIFY_EVENT_INODE, NULL, 0);
 }
@@ -66,45 +79,31 @@ static inline void fsnotify_link_count(struct inode *inode)
 * fsnotify_move - file old_name at old_dir was moved to new_name at new_dir
 */
 static inline void fsnotify_move(struct inode *old_dir, struct inode *new_dir,
-                                 const char *old_name,
+                                 const unsigned char *old_name,
                                 int isdir, struct inode *target, struct dentry *moved)
 {
        struct inode *source = moved->d_inode;
-        u32 in_cookie = inotify_get_cookie();
        u32 fs_cookie = fsnotify_get_cookie();
        __u32 old_dir_mask = (FS_EVENT_ON_CHILD | FS_MOVED_FROM);
        __u32 new_dir_mask = (FS_EVENT_ON_CHILD | FS_MOVED_TO);
-        const char *new_name = moved->d_name.name;
+        const unsigned char *new_name = moved->d_name.name;
        if (old_dir == new_dir)
                old_dir_mask |= FS_DN_RENAME;
        if (isdir) {
-                isdir = IN_ISDIR;
                old_dir_mask |= FS_IN_ISDIR;
                new_dir_mask |= FS_IN_ISDIR;
        }
-        inotify_inode_queue_event(old_dir, IN_MOVED_FROM|isdir, in_cookie, old_name,
-                                  source);
-        inotify_inode_queue_event(new_dir, IN_MOVED_TO|isdir, in_cookie, new_name,
-                                  source);
        fsnotify(old_dir, old_dir_mask, old_dir, FSNOTIFY_EVENT_INODE, old_name, fs_cookie);
        fsnotify(new_dir, new_dir_mask, new_dir, FSNOTIFY_EVENT_INODE, new_name, fs_cookie);
-        if (target) {
+        if (target)
-                inotify_inode_queue_event(target, IN_DELETE_SELF, 0, NULL, NULL);
-                inotify_inode_is_dead(target);
-                /* this is really a link_count change not a removal */
                fsnotify_link_count(target);
-        }
-        if (source) {
+        if (source)
-                inotify_inode_queue_event(source, IN_MOVE_SELF, 0, NULL, NULL);
                fsnotify(source, FS_MOVE_SELF, moved->d_inode, FSNOTIFY_EVENT_INODE, NULL, 0);
-        }
        audit_inode_child(moved, new_dir);
 }
@@ -117,6 +116,14 @@ static inline void fsnotify_inode_delete(struct inode *inode)
 }
 /*
+ * fsnotify_vfsmount_delete - a vfsmount is being destroyed, clean up is needed
+ */
+static inline void fsnotify_vfsmount_delete(struct vfsmount *mnt)
+{
+        __fsnotify_vfsmount_delete(mnt);
+}
+/*
 * fsnotify_nameremove - a filename was removed from a directory
 */
 static inline void fsnotify_nameremove(struct dentry *dentry, int isdir)
@@ -126,7 +133,7 @@ static inline void fsnotify_nameremove(struct dentry *dentry, int isdir)
        if (isdir)
                mask |= FS_IN_ISDIR;
-        fsnotify_parent(dentry, mask);
+        fsnotify_parent(NULL, dentry, mask);
 }
 /*
@@ -134,9 +141,6 @@ static inline void fsnotify_nameremove(struct dentry *dentry, int isdir)
 */
 static inline void fsnotify_inoderemove(struct inode *inode)
 {
-        inotify_inode_queue_event(inode, IN_DELETE_SELF, 0, NULL, NULL);
-        inotify_inode_is_dead(inode);
        fsnotify(inode, FS_DELETE_SELF, inode, FSNOTIFY_EVENT_INODE, NULL, 0);
        __fsnotify_inode_delete(inode);
 }
@@ -146,8 +150,6 @@ static inline void fsnotify_inoderemove(struct inode *inode)
 */
 static inline void fsnotify_create(struct inode *inode, struct dentry *dentry)
 {
-        inotify_inode_queue_event(inode, IN_CREATE, 0, dentry->d_name.name,
-                                  dentry->d_inode);
        audit_inode_child(dentry, inode);
        fsnotify(inode, FS_CREATE, dentry->d_inode, FSNOTIFY_EVENT_INODE, dentry->d_name.name, 0);
@@ -160,8 +162,6 @@ static inline void fsnotify_create(struct inode *inode, struct dentry *dentry)
 */
 static inline void fsnotify_link(struct inode *dir, struct inode *inode, struct dentry *new_dentry)
 {
-        inotify_inode_queue_event(dir, IN_CREATE, 0, new_dentry->d_name.name,
-                                  inode);
        fsnotify_link_count(inode);
        audit_inode_child(new_dentry, dir);
@@ -176,7 +176,6 @@ static inline void fsnotify_mkdir(struct inode *inode, struct dentry *dentry)
        __u32 mask = (FS_CREATE | FS_IN_ISDIR);
        struct inode *d_inode = dentry->d_inode;
-        inotify_inode_queue_event(inode, mask, 0, dentry->d_name.name, d_inode);
        audit_inode_child(dentry, inode);
        fsnotify(inode, mask, d_inode, FSNOTIFY_EVENT_INODE, dentry->d_name.name, 0);
@@ -185,52 +184,52 @@ static inline void fsnotify_mkdir(struct inode *inode, struct dentry *dentry)
 /*
 * fsnotify_access - file was read
 */
-static inline void fsnotify_access(struct dentry *dentry)
+static inline void fsnotify_access(struct file *file)
 {
-        struct inode *inode = dentry->d_inode;
+        struct inode *inode = file->f_path.dentry->d_inode;
        __u32 mask = FS_ACCESS;
        if (S_ISDIR(inode->i_mode))
                mask |= FS_IN_ISDIR;
-        inotify_inode_queue_event(inode, mask, 0, NULL, NULL);
+        if (!(file->f_mode & FMODE_NONOTIFY)) {
+                fsnotify_parent(file, NULL, mask);
-        fsnotify_parent(dentry, mask);
+                fsnotify(inode, mask, file, FSNOTIFY_EVENT_FILE, NULL, 0);
-        fsnotify(inode, mask, inode, FSNOTIFY_EVENT_INODE, NULL, 0);
+        }
 }
 /*
 * fsnotify_modify - file was modified
 */
-static inline void fsnotify_modify(struct dentry *dentry)
+static inline void fsnotify_modify(struct file *file)
 {
-        struct inode *inode = dentry->d_inode;
+        struct inode *inode = file->f_path.dentry->d_inode;
        __u32 mask = FS_MODIFY;
        if (S_ISDIR(inode->i_mode))
                mask |= FS_IN_ISDIR;
-        inotify_inode_queue_event(inode, mask, 0, NULL, NULL);
+        if (!(file->f_mode & FMODE_NONOTIFY)) {
+                fsnotify_parent(file, NULL, mask);
-        fsnotify_parent(dentry, mask);
+                fsnotify(inode, mask, file, FSNOTIFY_EVENT_FILE, NULL, 0);
-        fsnotify(inode, mask, inode, FSNOTIFY_EVENT_INODE, NULL, 0);
+        }
 }
 /*
 * fsnotify_open - file was opened
 */
-static inline void fsnotify_open(struct dentry *dentry)
+static inline void fsnotify_open(struct file *file)
 {
-        struct inode *inode = dentry->d_inode;
+        struct inode *inode = file->f_path.dentry->d_inode;
        __u32 mask = FS_OPEN;
        if (S_ISDIR(inode->i_mode))
                mask |= FS_IN_ISDIR;
-        inotify_inode_queue_event(inode, mask, 0, NULL, NULL);
+        if (!(file->f_mode & FMODE_NONOTIFY)) {
+                fsnotify_parent(file, NULL, mask);
-        fsnotify_parent(dentry, mask);
+                fsnotify(inode, mask, file, FSNOTIFY_EVENT_FILE, NULL, 0);
-        fsnotify(inode, mask, inode, FSNOTIFY_EVENT_INODE, NULL, 0);
+        }
 }
 /*
@@ -238,18 +237,17 @@ static inline void fsnotify_open(struct dentry *dentry)
 */
 static inline void fsnotify_close(struct file *file)
 {
-        struct dentry *dentry = file->f_path.dentry;
+        struct inode *inode = file->f_path.dentry->d_inode;
-        struct inode *inode = dentry->d_inode;
        fmode_t mode = file->f_mode;
        __u32 mask = (mode & FMODE_WRITE) ? FS_CLOSE_WRITE : FS_CLOSE_NOWRITE;
        if (S_ISDIR(inode->i_mode))
                mask |= FS_IN_ISDIR;
-        inotify_inode_queue_event(inode, mask, 0, NULL, NULL);
+        if (!(file->f_mode & FMODE_NONOTIFY)) {
+                fsnotify_parent(file, NULL, mask);
-        fsnotify_parent(dentry, mask);
+                fsnotify(inode, mask, file, FSNOTIFY_EVENT_FILE, NULL, 0);
-        fsnotify(inode, mask, file, FSNOTIFY_EVENT_FILE, NULL, 0);
+        }
 }
 /*
@@ -263,9 +261,7 @@ static inline void fsnotify_xattr(struct dentry *dentry)
        if (S_ISDIR(inode->i_mode))
                mask |= FS_IN_ISDIR;
-        inotify_inode_queue_event(inode, mask, 0, NULL, NULL);
+        fsnotify_parent(NULL, dentry, mask);
-        fsnotify_parent(dentry, mask);
        fsnotify(inode, mask, inode, FSNOTIFY_EVENT_INODE, NULL, 0);
 }
@@ -299,19 +295,18 @@ static inline void fsnotify_change(struct dentry *dentry, unsigned int ia_valid)
        if (mask) {
                if (S_ISDIR(inode->i_mode))
                        mask |= FS_IN_ISDIR;
-                inotify_inode_queue_event(inode, mask, 0, NULL, NULL);
-                fsnotify_parent(dentry, mask);
+                fsnotify_parent(NULL, dentry, mask);
                fsnotify(inode, mask, inode, FSNOTIFY_EVENT_INODE, NULL, 0);
        }
 }
-#if defined(CONFIG_INOTIFY) || defined(CONFIG_FSNOTIFY) /* notify helpers */
+#if defined(CONFIG_FSNOTIFY)    /* notify helpers */
 /*
 * fsnotify_oldname_init - save off the old filename before we change it
 */
-static inline const char *fsnotify_oldname_init(const char *name)
+static inline const unsigned char *fsnotify_oldname_init(const unsigned char *name)
 {
        return kstrdup(name, GFP_KERNEL);
 }
@@ -319,22 +314,22 @@ static inline const char *fsnotify_oldname_init(const char *name)
 /*
 * fsnotify_oldname_free - free the name we got from fsnotify_oldname_init
 */
-static inline void fsnotify_oldname_free(const char *old_name)
+static inline void fsnotify_oldname_free(const unsigned char *old_name)
 {
        kfree(old_name);
 }
-#else   /* CONFIG_INOTIFY || CONFIG_FSNOTIFY */
+#else   /* CONFIG_FSNOTIFY */
-static inline const char *fsnotify_oldname_init(const char *name)
+static inline const char *fsnotify_oldname_init(const unsigned char *name)
 {
        return NULL;
 }
-static inline void fsnotify_oldname_free(const char *old_name)
+static inline void fsnotify_oldname_free(const unsigned char *old_name)
 {
 }
-#endif  /* ! CONFIG_INOTIFY */
+#endif  /*  CONFIG_FSNOTIFY */
 #endif  /* _LINUX_FS_NOTIFY_H */
diff --git a/include/linux/fsnotify_backend.h b/include/linux/fsnotify_backend.h
index 4d6f47b51189..9bbfd7204b04 100644
--- a/include/linux/fsnotify_backend.h
+++ b/include/linux/fsnotify_backend.h
@@ -41,6 +41,10 @@
 #define FS_Q_OVERFLOW           0x00004000      /* Event queued overflowed */
 #define FS_IN_IGNORED           0x00008000      /* last inotify event here */
+#define FS_OPEN_PERM            0x00010000      /* open event in an permission hook */
+#define FS_ACCESS_PERM          0x00020000      /* access event in a permissions hook */
+#define FS_EXCL_UNLINK          0x04000000      /* do not send events if object is unlinked */
 #define FS_IN_ISDIR             0x40000000      /* event occurred against dir */
 #define FS_IN_ONESHOT           0x80000000      /* only send event once */
@@ -58,13 +62,20 @@
                                   FS_MOVED_FROM | FS_MOVED_TO | FS_CREATE |\
                                   FS_DELETE)
-/* listeners that hard code group numbers near the top */
+#define FS_MOVE                 (FS_MOVED_FROM | FS_MOVED_TO)
-#define DNOTIFY_GROUP_NUM       UINT_MAX
-#define INOTIFY_GROUP_NUM       (DNOTIFY_GROUP_NUM-1)
+#define ALL_FSNOTIFY_EVENTS (FS_ACCESS | FS_MODIFY | FS_ATTRIB | \
+                             FS_CLOSE_WRITE | FS_CLOSE_NOWRITE | FS_OPEN | \
+                             FS_MOVED_FROM | FS_MOVED_TO | FS_CREATE | \
+                             FS_DELETE | FS_DELETE_SELF | FS_MOVE_SELF | \
+                             FS_UNMOUNT | FS_Q_OVERFLOW | FS_IN_IGNORED | \
+                             FS_OPEN_PERM | FS_ACCESS_PERM | FS_EXCL_UNLINK | \
+                             FS_IN_ISDIR | FS_IN_ONESHOT | FS_DN_RENAME | \
+                             FS_DN_MULTISHOT | FS_EVENT_ON_CHILD)
 struct fsnotify_group;
 struct fsnotify_event;
-struct fsnotify_mark_entry;
+struct fsnotify_mark;
 struct fsnotify_event_private_data;
 /*
@@ -80,10 +91,16 @@ struct fsnotify_event_private_data;
 *              valid group and inode to use to clean up.
 */
 struct fsnotify_ops {
-        bool (*should_send_event)(struct fsnotify_group *group, struct inode *inode, __u32 mask);
+        bool (*should_send_event)(struct fsnotify_group *group, struct inode *inode,
-        int (*handle_event)(struct fsnotify_group *group, struct fsnotify_event *event);
+                                  struct fsnotify_mark *inode_mark,
+                                  struct fsnotify_mark *vfsmount_mark,
+                                  __u32 mask, void *data, int data_type);
+        int (*handle_event)(struct fsnotify_group *group,
+                            struct fsnotify_mark *inode_mark,
+                            struct fsnotify_mark *vfsmount_mark,
+                            struct fsnotify_event *event);
        void (*free_group_priv)(struct fsnotify_group *group);
-        void (*freeing_mark)(struct fsnotify_mark_entry *entry, struct fsnotify_group *group);
+        void (*freeing_mark)(struct fsnotify_mark *mark, struct fsnotify_group *group);
        void (*free_event_priv)(struct fsnotify_event_private_data *priv);
 };
@@ -95,22 +112,6 @@ struct fsnotify_ops {
 */
 struct fsnotify_group {
        /*
-         * global list of all groups receiving events from fsnotify.
-         * anchored by fsnotify_groups and protected by either fsnotify_grp_mutex
-         * or fsnotify_grp_srcu depending on write vs read.
-         */
-        struct list_head group_list;
-        /*
-         * Defines all of the event types in which this group is interested.
-         * This mask is a bitwise OR of the FS_* events from above.  Each time
-         * this mask changes for a group (if it changes) the correct functions
-         * must be called to update the global structures which indicate global
-         * interest in event types.
-         */
-        __u32 mask;
-        /*
         * How the refcnt is used is up to each group.  When the refcnt hits 0
         * fsnotify will clean up all of the resources associated with this group.
         * As an example, the dnotify group will always have a refcnt=1 and that
@@ -119,7 +120,6 @@ struct fsnotify_group {
         * closed.
         */
        atomic_t refcnt;                /* things with interest in this group */
-        unsigned int group_num;         /* simply prevents accidental group collision */
        const struct fsnotify_ops *ops; /* how this group handles things */
@@ -130,15 +130,12 @@ struct fsnotify_group {
        unsigned int q_len;                     /* events on the queue */
        unsigned int max_events;                /* maximum events allowed on the list */
-        /* stores all fastapth entries assoc with this group so they can be cleaned on unregister */
+        /* stores all fastpath marks assoc with this group so they can be cleaned on unregister */
-        spinlock_t mark_lock;           /* protect mark_entries list */
+        spinlock_t mark_lock;           /* protect marks_list */
-        atomic_t num_marks;             /* 1 for each mark entry and 1 for not being
+        atomic_t num_marks;             /* 1 for each mark and 1 for not being
                                         * past the point of no return when freeing
                                         * a group */
-        struct list_head mark_entries;  /* all inode mark entries for this group */
+        struct list_head marks_list;    /* all inode marks for this group */
-        /* prevents double list_del of group_list.  protected by global fsnotify_grp_mutex */
-        bool on_group_list;
        /* groups can define private fields here or use the void *private */
        union {
@@ -152,6 +149,17 @@ struct fsnotify_group {
                        struct user_struct      *user;
                } inotify_data;
 #endif
+#ifdef CONFIG_FANOTIFY
+                struct fanotify_group_private_data {
+#ifdef CONFIG_FANOTIFY_ACCESS_PERMISSIONS
+                        /* allows a group to block waiting for a userspace response */
+                        struct mutex access_mutex;
+                        struct list_head access_list;
+                        wait_queue_head_t access_waitq;
+#endif /* CONFIG_FANOTIFY_ACCESS_PERMISSIONS */
+                        int f_flags;
+                } fanotify_data;
+#endif /* CONFIG_FANOTIFY */
        };
 };
@@ -195,35 +203,57 @@ struct fsnotify_event {
        /* to_tell may ONLY be dereferenced during handle_event(). */
        struct inode *to_tell;  /* either the inode the event happened to or its parent */
        /*
-         * depending on the event type we should have either a path or inode
+         * depending on the event type we should have either a file or inode
-         * We hold a reference on path, but NOT on inode.  Since we have the ref on
+         * We hold a reference on file, but NOT on inode.  Since we have the ref on
-         * the path, it may be dereferenced at any point during this object's
+         * the file, it may be dereferenced at any point during this object's
         * lifetime.  That reference is dropped when this object's refcnt hits
-         * 0.  If this event contains an inode instead of a path, the inode may
+         * 0.  If this event contains an inode instead of a file, the inode may
         * ONLY be used during handle_event().
         */
        union {
-                struct path path;
+                struct file *file;
                struct inode *inode;
        };
 /* when calling fsnotify tell it if the data is a path or inode */
 #define FSNOTIFY_EVENT_NONE     0
-#define FSNOTIFY_EVENT_PATH     1
+#define FSNOTIFY_EVENT_FILE     1
 #define FSNOTIFY_EVENT_INODE    2
-#define FSNOTIFY_EVENT_FILE     3
        int data_type;          /* which of the above union we have */
        atomic_t refcnt;        /* how many groups still are using/need to send this event */
        __u32 mask;             /* the type of access, bitwise OR for FS_* event types */
        u32 sync_cookie;        /* used to corrolate events, namely inotify mv events */
-        char *file_name;
+        const unsigned char *file_name;
        size_t name_len;
+        struct pid *tgid;
+#ifdef CONFIG_FANOTIFY_ACCESS_PERMISSIONS
+        __u32 response; /* userspace answer to question */
+#endif /* CONFIG_FANOTIFY_ACCESS_PERMISSIONS */
        struct list_head private_data_list;     /* groups can store private data here */
 };
 /*
- * a mark is simply an entry attached to an in core inode which allows an
+ * Inode specific fields in an fsnotify_mark
+ */
+struct fsnotify_inode_mark {
+        struct inode *inode;            /* inode this mark is associated with */
+        struct hlist_node i_list;       /* list of marks by inode->i_fsnotify_marks */
+        struct list_head free_i_list;   /* tmp list used when freeing this mark */
+};
+/*
+ * Mount point specific fields in an fsnotify_mark
+ */
+struct fsnotify_vfsmount_mark {
+        struct vfsmount *mnt;           /* vfsmount this mark is associated with */
+        struct hlist_node m_list;       /* list of marks by inode->i_fsnotify_marks */
+        struct list_head free_m_list;   /* tmp list used when freeing this mark */
+};
+/*
+ * a mark is simply an object attached to an in core inode which allows an
 * fsnotify listener to indicate they are either no longer interested in events
 * of a type matching mask or only interested in those events.
 *
@@ -232,19 +262,28 @@ struct fsnotify_event {
 * (such as dnotify) will flush these when the open fd is closed and not at
 * inode eviction or modification.
 */
-struct fsnotify_mark_entry {
+struct fsnotify_mark {
-        __u32 mask;                     /* mask this mark entry is for */
+        __u32 mask;                     /* mask this mark is for */
        /* we hold ref for each i_list and g_list.  also one ref for each 'thing'
         * in kernel that found and may be using this mark. */
        atomic_t refcnt;                /* active things looking at this mark */
-        struct inode *inode;            /* inode this entry is associated with */
+        struct fsnotify_group *group;   /* group this mark is for */
-        struct fsnotify_group *group;   /* group this mark entry is for */
+        struct list_head g_list;        /* list of marks by group->i_fsnotify_marks */
-        struct hlist_node i_list;       /* list of mark_entries by inode->i_fsnotify_mark_entries */
+        spinlock_t lock;                /* protect group and inode */
-        struct list_head g_list;        /* list of mark_entries by group->i_fsnotify_mark_entries */
+        union {
-        spinlock_t lock;                /* protect group, inode, and killme */
+                struct fsnotify_inode_mark i;
-        struct list_head free_i_list;   /* tmp list used when freeing this mark */
+                struct fsnotify_vfsmount_mark m;
+        };
+        __u32 ignored_mask;             /* events types to ignore */
        struct list_head free_g_list;   /* tmp list used when freeing this mark */
-        void (*free_mark)(struct fsnotify_mark_entry *entry); /* called on final put+free */
+#define FSNOTIFY_MARK_FLAG_INODE                0x01
+#define FSNOTIFY_MARK_FLAG_VFSMOUNT             0x02
+#define FSNOTIFY_MARK_FLAG_OBJECT_PINNED        0x04
+#define FSNOTIFY_MARK_FLAG_IGNORED_SURV_MODIFY  0x08
+#define FSNOTIFY_MARK_FLAG_ALIVE                0x10
+        unsigned int flags;             /* vfsmount or inode mark? */
+        struct list_head destroy_list;
+        void (*free_mark)(struct fsnotify_mark *mark); /* called on final put+free */
 };
 #ifdef CONFIG_FSNOTIFY
@@ -252,10 +291,11 @@ struct fsnotify_mark_entry {
 /* called from the vfs helpers */
 /* main fsnotify call to send events */
-extern void fsnotify(struct inode *to_tell, __u32 mask, void *data, int data_is,
+extern int fsnotify(struct inode *to_tell, __u32 mask, void *data, int data_is,
-                     const char *name, u32 cookie);
+                    const unsigned char *name, u32 cookie);
-extern void __fsnotify_parent(struct dentry *dentry, __u32 mask);
+extern void __fsnotify_parent(struct file *file, struct dentry *dentry, __u32 mask);
 extern void __fsnotify_inode_delete(struct inode *inode);
+extern void __fsnotify_vfsmount_delete(struct vfsmount *mnt);
 extern u32 fsnotify_get_cookie(void);
 static inline int fsnotify_inode_watches_children(struct inode *inode)
@@ -304,15 +344,9 @@ static inline void __fsnotify_d_instantiate(struct dentry *dentry, struct inode
 /* called from fsnotify listeners, such as fanotify or dnotify */
-/* must call when a group changes its ->mask */
-extern void fsnotify_recalc_global_mask(void);
 /* get a reference to an existing or create a new group */
-extern struct fsnotify_group *fsnotify_obtain_group(unsigned int group_num,
+extern struct fsnotify_group *fsnotify_alloc_group(const struct fsnotify_ops *ops);
-                                                    __u32 mask,
+/* drop reference on a group from fsnotify_alloc_group */
-                                                    const struct fsnotify_ops *ops);
-/* run all marks associated with this group and update group->mask */
-extern void fsnotify_recalc_group_mask(struct fsnotify_group *group);
-/* drop reference on a group from fsnotify_obtain_group */
 extern void fsnotify_put_group(struct fsnotify_group *group);
 /* take a reference to an event */
@@ -323,8 +357,11 @@ extern struct fsnotify_event_private_data *fsnotify_remove_priv_from_event(struc
                                                                           struct fsnotify_event *event);
 /* attach the event to the group notification queue */
-extern int fsnotify_add_notify_event(struct fsnotify_group *group, struct fsnotify_event *event,
+extern struct fsnotify_event *fsnotify_add_notify_event(struct fsnotify_group *group,
-                                     struct fsnotify_event_private_data *priv);
+                                                        struct fsnotify_event *event,
+                                                        struct fsnotify_event_private_data *priv,
+                                                        struct fsnotify_event *(*merge)(struct list_head *,
+                                                                                        struct fsnotify_event *));
 /* true if the group notification queue is empty */
 extern bool fsnotify_notify_queue_is_empty(struct fsnotify_group *group);
 /* return, but do not dequeue the first event on the notification queue */
@@ -334,38 +371,66 @@ extern struct fsnotify_event *fsnotify_remove_notify_event(struct fsnotify_group
 /* functions used to manipulate the marks attached to inodes */
+/* run all marks associated with a vfsmount and update mnt->mnt_fsnotify_mask */
+extern void fsnotify_recalc_vfsmount_mask(struct vfsmount *mnt);
 /* run all marks associated with an inode and update inode->i_fsnotify_mask */
 extern void fsnotify_recalc_inode_mask(struct inode *inode);
-extern void fsnotify_init_mark(struct fsnotify_mark_entry *entry, void (*free_mark)(struct fsnotify_mark_entry *entry));
+extern void fsnotify_init_mark(struct fsnotify_mark *mark, void (*free_mark)(struct fsnotify_mark *mark));
 /* find (and take a reference) to a mark associated with group and inode */
-extern struct fsnotify_mark_entry *fsnotify_find_mark_entry(struct fsnotify_group *group, struct inode *inode);
+extern struct fsnotify_mark *fsnotify_find_inode_mark(struct fsnotify_group *group, struct inode *inode);
+/* find (and take a reference) to a mark associated with group and vfsmount */
+extern struct fsnotify_mark *fsnotify_find_vfsmount_mark(struct fsnotify_group *group, struct vfsmount *mnt);
+/* copy the values from old into new */
+extern void fsnotify_duplicate_mark(struct fsnotify_mark *new, struct fsnotify_mark *old);
+/* set the ignored_mask of a mark */
+extern void fsnotify_set_mark_ignored_mask_locked(struct fsnotify_mark *mark, __u32 mask);
+/* set the mask of a mark (might pin the object into memory */
+extern void fsnotify_set_mark_mask_locked(struct fsnotify_mark *mark, __u32 mask);
 /* attach the mark to both the group and the inode */
-extern int fsnotify_add_mark(struct fsnotify_mark_entry *entry, struct fsnotify_group *group, struct inode *inode);
+extern int fsnotify_add_mark(struct fsnotify_mark *mark, struct fsnotify_group *group,
+                             struct inode *inode, struct vfsmount *mnt, int allow_dups);
 /* given a mark, flag it to be freed when all references are dropped */
-extern void fsnotify_destroy_mark_by_entry(struct fsnotify_mark_entry *entry);
+extern void fsnotify_destroy_mark(struct fsnotify_mark *mark);
+/* run all the marks in a group, and clear all of the vfsmount marks */
+extern void fsnotify_clear_vfsmount_marks_by_group(struct fsnotify_group *group);
+/* run all the marks in a group, and clear all of the inode marks */
+extern void fsnotify_clear_inode_marks_by_group(struct fsnotify_group *group);
+/* run all the marks in a group, and clear all of the marks where mark->flags & flags is true*/
+extern void fsnotify_clear_marks_by_group_flags(struct fsnotify_group *group, unsigned int flags);
 /* run all the marks in a group, and flag them to be freed */
 extern void fsnotify_clear_marks_by_group(struct fsnotify_group *group);
-extern void fsnotify_get_mark(struct fsnotify_mark_entry *entry);
+extern void fsnotify_get_mark(struct fsnotify_mark *mark);
-extern void fsnotify_put_mark(struct fsnotify_mark_entry *entry);
+extern void fsnotify_put_mark(struct fsnotify_mark *mark);
 extern void fsnotify_unmount_inodes(struct list_head *list);
 /* put here because inotify does some weird stuff when destroying watches */
 extern struct fsnotify_event *fsnotify_create_event(struct inode *to_tell, __u32 mask,
-                                                    void *data, int data_is, const char *name,
+                                                    void *data, int data_is,
+                                                    const unsigned char *name,
                                                    u32 cookie, gfp_t gfp);
+/* fanotify likes to change events after they are on lists... */
+extern struct fsnotify_event *fsnotify_clone_event(struct fsnotify_event *old_event);
+extern int fsnotify_replace_event(struct fsnotify_event_holder *old_holder,
+                                  struct fsnotify_event *new_event);
 #else
-static inline void fsnotify(struct inode *to_tell, __u32 mask, void *data, int data_is,
+static inline int fsnotify(struct inode *to_tell, __u32 mask, void *data, int data_is,
-                            const char *name, u32 cookie)
+                           const unsigned char *name, u32 cookie)
-{}
+{
+        return 0;
+}
-static inline void __fsnotify_parent(struct dentry *dentry, __u32 mask)
+static inline void __fsnotify_parent(struct file *file, struct dentry *dentry, __u32 mask)
 {}
 static inline void __fsnotify_inode_delete(struct inode *inode)
 {}
+static inline void __fsnotify_vfsmount_delete(struct vfsmount *mnt)
+{}
 static inline void __fsnotify_update_dcache_flags(struct dentry *dentry)
 {}
diff --git a/include/linux/gpio_keys.h b/include/linux/gpio_keys.h
index cd0b3f30f48e..ce73a30113b4 100644
--- a/include/linux/gpio_keys.h
+++ b/include/linux/gpio_keys.h
@@ -17,6 +17,8 @@ struct gpio_keys_platform_data {
        struct gpio_keys_button *buttons;
        int nbuttons;
        unsigned int rep:1;             /* enable input subsystem auto repeat */
+        int (*enable)(struct device *dev);
+        void (*disable)(struct device *dev);
 };
 #endif
diff --git a/include/linux/highmem.h b/include/linux/highmem.h
index caafd0561aa1..e3060ef85b6d 100644
--- a/include/linux/highmem.h
+++ b/include/linux/highmem.h
@@ -2,6 +2,7 @@
 #define _LINUX_HIGHMEM_H
 #include <linux/fs.h>
+#include <linux/kernel.h>
 #include <linux/mm.h>
 #include <linux/uaccess.h>
@@ -72,7 +73,11 @@ static inline void *kmap_atomic(struct page *page, enum km_type idx)
 }
 #define kmap_atomic_prot(page, idx, prot)       kmap_atomic(page, idx)
-#define kunmap_atomic(addr, idx)        do { pagefault_enable(); } while (0)
+static inline void kunmap_atomic_notypecheck(void *addr, enum km_type idx)
+{
+        pagefault_enable();
+}
 #define kmap_atomic_pfn(pfn, idx)       kmap_atomic(pfn_to_page(pfn), (idx))
 #define kmap_atomic_to_page(ptr)        virt_to_page(ptr)
@@ -81,6 +86,13 @@ static inline void *kmap_atomic(struct page *page, enum km_type idx)
 #endif /* CONFIG_HIGHMEM */
+/* Prevent people trying to call kunmap_atomic() as if it were kunmap() */
+/* kunmap_atomic() should get the return value of kmap_atomic, not the page. */
+#define kunmap_atomic(addr, idx) do { \
+                BUILD_BUG_ON(__same_type((addr), struct page *)); \
+                kunmap_atomic_notypecheck((addr), (idx)); \
+        } while (0)
 /* when CONFIG_HIGHMEM is not set these will be plain clear/copy_page */
 #ifndef clear_user_highpage
 static inline void clear_user_highpage(struct page *page, unsigned long vaddr)
diff --git a/include/linux/inotify.h b/include/linux/inotify.h
index 37ea2894b3c0..d33041e2a42a 100644
--- a/include/linux/inotify.h
+++ b/include/linux/inotify.h
@@ -51,6 +51,7 @@ struct inotify_event {
 /* special flags */
 #define IN_ONLYDIR              0x01000000      /* only watch the path if it is a directory */
 #define IN_DONT_FOLLOW          0x02000000      /* don't follow a sym link */
+#define IN_EXCL_UNLINK          0x04000000      /* exclude events on unlinked objects */
 #define IN_MASK_ADD             0x20000000      /* add to the mask of an already existing watch */
 #define IN_ISDIR                0x40000000      /* event occurred against dir */
 #define IN_ONESHOT              0x80000000      /* only send event once */
@@ -70,177 +71,17 @@ struct inotify_event {
 #define IN_NONBLOCK O_NONBLOCK
 #ifdef __KERNEL__
+#include <linux/sysctl.h>
-#include <linux/dcache.h>
+extern struct ctl_table inotify_table[]; /* for sysctl */
-#include <linux/fs.h>
+#define ALL_INOTIFY_BITS (IN_ACCESS | IN_MODIFY | IN_ATTRIB | IN_CLOSE_WRITE | \
-/*
+                          IN_CLOSE_NOWRITE | IN_OPEN | IN_MOVED_FROM | \
- * struct inotify_watch - represents a watch request on a specific inode
+                          IN_MOVED_TO | IN_CREATE | IN_DELETE | \
- *
+                          IN_DELETE_SELF | IN_MOVE_SELF | IN_UNMOUNT | \
- * h_list is protected by ih->mutex of the associated inotify_handle.
+                          IN_Q_OVERFLOW | IN_IGNORED | IN_ONLYDIR | \
- * i_list, mask are protected by inode->inotify_mutex of the associated inode.
+                          IN_DONT_FOLLOW | IN_EXCL_UNLINK | IN_MASK_ADD | \
- * ih, inode, and wd are never written to once the watch is created.
+                          IN_ISDIR | IN_ONESHOT)
- *
- * Callers must use the established inotify interfaces to access inotify_watch
+#endif
- * contents.  The content of this structure is private to the inotify
- * implementation.
- */
-struct inotify_watch {
-        struct list_head        h_list; /* entry in inotify_handle's list */
-        struct list_head        i_list; /* entry in inode's list */
-        atomic_t                count;  /* reference count */
-        struct inotify_handle   *ih;    /* associated inotify handle */
-        struct inode            *inode; /* associated inode */
-        __s32                   wd;     /* watch descriptor */
-        __u32                   mask;   /* event mask for this watch */
-};
-struct inotify_operations {
-        void (*handle_event)(struct inotify_watch *, u32, u32, u32,
-                             const char *, struct inode *);
-        void (*destroy_watch)(struct inotify_watch *);
-};
-#ifdef CONFIG_INOTIFY
-/* Kernel API for producing events */
-extern void inotify_d_instantiate(struct dentry *, struct inode *);
-extern void inotify_d_move(struct dentry *);
-extern void inotify_inode_queue_event(struct inode *, __u32, __u32,
-                                      const char *, struct inode *);
-extern void inotify_dentry_parent_queue_event(struct dentry *, __u32, __u32,
-                                              const char *);
-extern void inotify_unmount_inodes(struct list_head *);
-extern void inotify_inode_is_dead(struct inode *);
-extern u32 inotify_get_cookie(void);
-/* Kernel Consumer API */
-extern struct inotify_handle *inotify_init(const struct inotify_operations *);
-extern void inotify_init_watch(struct inotify_watch *);
-extern void inotify_destroy(struct inotify_handle *);
-extern __s32 inotify_find_watch(struct inotify_handle *, struct inode *,
-                                struct inotify_watch **);
-extern __s32 inotify_find_update_watch(struct inotify_handle *, struct inode *,
-                                       u32);
-extern __s32 inotify_add_watch(struct inotify_handle *, struct inotify_watch *,
-                               struct inode *, __u32);
-extern __s32 inotify_clone_watch(struct inotify_watch *, struct inotify_watch *);
-extern void inotify_evict_watch(struct inotify_watch *);
-extern int inotify_rm_watch(struct inotify_handle *, struct inotify_watch *);
-extern int inotify_rm_wd(struct inotify_handle *, __u32);
-extern void inotify_remove_watch_locked(struct inotify_handle *,
-                                        struct inotify_watch *);
-extern void get_inotify_watch(struct inotify_watch *);
-extern void put_inotify_watch(struct inotify_watch *);
-extern int pin_inotify_watch(struct inotify_watch *);
-extern void unpin_inotify_watch(struct inotify_watch *);
-#else
-static inline void inotify_d_instantiate(struct dentry *dentry,
-                                        struct inode *inode)
-{
-}
-static inline void inotify_d_move(struct dentry *dentry)
-{
-}
-static inline void inotify_inode_queue_event(struct inode *inode,
-                                             __u32 mask, __u32 cookie,
-                                             const char *filename,
-                                             struct inode *n_inode)
-{
-}
-static inline void inotify_dentry_parent_queue_event(struct dentry *dentry,
-                                                     __u32 mask, __u32 cookie,
-                                                     const char *filename)
-{
-}
-static inline void inotify_unmount_inodes(struct list_head *list)
-{
-}
-static inline void inotify_inode_is_dead(struct inode *inode)
-{
-}
-static inline u32 inotify_get_cookie(void)
-{
-        return 0;
-}
-static inline struct inotify_handle *inotify_init(const struct inotify_operations *ops)
-{
-        return ERR_PTR(-EOPNOTSUPP);
-}
-static inline void inotify_init_watch(struct inotify_watch *watch)
-{
-}
-static inline void inotify_destroy(struct inotify_handle *ih)
-{
-}
-static inline __s32 inotify_find_watch(struct inotify_handle *ih, struct inode *inode,
-                                       struct inotify_watch **watchp)
-{
-        return -EOPNOTSUPP;
-}
-static inline __s32 inotify_find_update_watch(struct inotify_handle *ih,
-                                              struct inode *inode, u32 mask)
-{
-        return -EOPNOTSUPP;
-}
-static inline __s32 inotify_add_watch(struct inotify_handle *ih,
-                                      struct inotify_watch *watch,
-                                      struct inode *inode, __u32 mask)
-{
-        return -EOPNOTSUPP;
-}
-static inline int inotify_rm_watch(struct inotify_handle *ih,
-                                   struct inotify_watch *watch)
-{
-        return -EOPNOTSUPP;
-}
-static inline int inotify_rm_wd(struct inotify_handle *ih, __u32 wd)
-{
-        return -EOPNOTSUPP;
-}
-static inline void inotify_remove_watch_locked(struct inotify_handle *ih,
-                                               struct inotify_watch *watch)
-{
-}
-static inline void get_inotify_watch(struct inotify_watch *watch)
-{
-}
-static inline void put_inotify_watch(struct inotify_watch *watch)
-{
-}
-extern inline int pin_inotify_watch(struct inotify_watch *watch)
-{
-        return 0;
-}
-extern inline void unpin_inotify_watch(struct inotify_watch *watch)
-{
-}
-#endif  /* CONFIG_INOTIFY */
-#endif  /* __KERNEL __ */
 #endif  /* _LINUX_INOTIFY_H */
diff --git a/include/linux/input.h b/include/linux/input.h
index 339d043ccb53..896a92227bc4 100644
--- a/include/linux/input.h
+++ b/include/linux/input.h
@@ -776,6 +776,7 @@ struct input_absinfo {
 #define REP_DELAY               0x00
 #define REP_PERIOD              0x01
 #define REP_MAX                 0x01
+#define REP_CNT                 (REP_MAX+1)
 /*
 * Sounds
@@ -1099,21 +1100,18 @@ struct input_mt_slot {
 * @repeat_key: stores key code of the last key pressed; used to implement
 *      software autorepeat
 * @timer: timer for software autorepeat
- * @abs: current values for reports from absolute axes
 * @rep: current values for autorepeat parameters (delay, rate)
 * @mt: pointer to array of struct input_mt_slot holding current values
 *      of tracked contacts
 * @mtsize: number of MT slots the device uses
 * @slot: MT slot currently being transmitted
+ * @absinfo: array of &struct absinfo elements holding information
+ *      about absolute axes (current value, min, max, flat, fuzz,
+ *      resolution)
 * @key: reflects current state of device's keys/buttons
 * @led: reflects current state of device's LEDs
 * @snd: reflects current state of sound effects
 * @sw: reflects current state of device's switches
- * @absmax: maximum values for events coming from absolute axes
- * @absmin: minimum values for events coming from absolute axes
- * @absfuzz: describes noisiness for axes
- * @absflat: size of the center flat position (used by joydev)
- * @absres: resolution used for events coming form absolute axes
 * @open: this method is called when the very first user calls
 *      input_open_device(). The driver must prepare the device
 *      to start generating events (start polling thread,
@@ -1180,24 +1178,19 @@ struct input_dev {
        unsigned int repeat_key;
        struct timer_list timer;
-        int abs[ABS_CNT];
+        int rep[REP_CNT];
-        int rep[REP_MAX + 1];
        struct input_mt_slot *mt;
        int mtsize;
        int slot;
+        struct input_absinfo *absinfo;
        unsigned long key[BITS_TO_LONGS(KEY_CNT)];
        unsigned long led[BITS_TO_LONGS(LED_CNT)];
        unsigned long snd[BITS_TO_LONGS(SND_CNT)];
        unsigned long sw[BITS_TO_LONGS(SW_CNT)];
-        int absmax[ABS_CNT];
-        int absmin[ABS_CNT];
-        int absfuzz[ABS_CNT];
-        int absflat[ABS_CNT];
-        int absres[ABS_CNT];
        int (*open)(struct input_dev *dev);
        void (*close)(struct input_dev *dev);
        int (*flush)(struct input_dev *dev, struct file *file);
@@ -1459,16 +1452,32 @@ static inline void input_set_events_per_packet(struct input_dev *dev, int n_even
        dev->hint_events_per_packet = n_events;
 }
-static inline void input_set_abs_params(struct input_dev *dev, int axis, int min, int max, int fuzz, int flat)
+void input_alloc_absinfo(struct input_dev *dev);
-{
+void input_set_abs_params(struct input_dev *dev, unsigned int axis,
-        dev->absmin[axis] = min;
+                          int min, int max, int fuzz, int flat);
-        dev->absmax[axis] = max;
-        dev->absfuzz[axis] = fuzz;
+#define INPUT_GENERATE_ABS_ACCESSORS(_suffix, _item)                    \
-        dev->absflat[axis] = flat;
+static inline int input_abs_get_##_suffix(struct input_dev *dev,        \
+                                          unsigned int axis)            \
-        dev->absbit[BIT_WORD(axis)] |= BIT_MASK(axis);
+{                                                                       \
+        return dev->absinfo ? dev->absinfo[axis]._item : 0;             \
+}                                                                       \
+                                                                        \
+static inline void input_abs_set_##_suffix(struct input_dev *dev,       \
+                                           unsigned int axis, int val)  \
+{                                                                       \
+        input_alloc_absinfo(dev);                                       \
+        if (dev->absinfo)                                               \
+                dev->absinfo[axis]._item = val;                         \
 }
+INPUT_GENERATE_ABS_ACCESSORS(val, value)
+INPUT_GENERATE_ABS_ACCESSORS(min, minimum)
+INPUT_GENERATE_ABS_ACCESSORS(max, maximum)
+INPUT_GENERATE_ABS_ACCESSORS(fuzz, fuzz)
+INPUT_GENERATE_ABS_ACCESSORS(flat, flat)
+INPUT_GENERATE_ABS_ACCESSORS(res, resolution)
 int input_get_keycode(struct input_dev *dev,
                      unsigned int scancode, unsigned int *keycode);
 int input_set_keycode(struct input_dev *dev,
diff --git a/include/linux/intel_mid_dma.h b/include/linux/intel_mid_dma.h
new file mode 100644
index 000000000000..d9d08b6269b6
--- /dev/null
+++ b/include/linux/intel_mid_dma.h
@@ -0,0 +1,86 @@
+/*
+ *  intel_mid_dma.h - Intel MID DMA Drivers
+ *
+ *  Copyright (C) 2008-10 Intel Corp
+ *  Author: Vinod Koul <vinod.koul@intel.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; version 2 of the License.
+ *
+ *  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 __INTEL_MID_DMA_H__
+#define __INTEL_MID_DMA_H__
+#include <linux/dmaengine.h>
+/*DMA transaction width, src and dstn width would be same
+The DMA length must be width aligned,
+for 32 bit width the length must be 32 bit (4bytes) aligned only*/
+enum intel_mid_dma_width {
+        LNW_DMA_WIDTH_8BIT = 0x0,
+        LNW_DMA_WIDTH_16BIT = 0x1,
+        LNW_DMA_WIDTH_32BIT = 0x2,
+};
+/*DMA mode configurations*/
+enum intel_mid_dma_mode {
+        LNW_DMA_PER_TO_MEM = 0, /*periphral to memory configuration*/
+        LNW_DMA_MEM_TO_PER,     /*memory to periphral configuration*/
+        LNW_DMA_MEM_TO_MEM,     /*mem to mem confg (testing only)*/
+};
+/*DMA handshaking*/
+enum intel_mid_dma_hs_mode {
+        LNW_DMA_HW_HS = 0,      /*HW Handshaking only*/
+        LNW_DMA_SW_HS = 1,      /*SW Handshaking not recommended*/
+};
+/*Burst size configuration*/
+enum intel_mid_dma_msize {
+        LNW_DMA_MSIZE_1 = 0x0,
+        LNW_DMA_MSIZE_4 = 0x1,
+        LNW_DMA_MSIZE_8 = 0x2,
+        LNW_DMA_MSIZE_16 = 0x3,
+        LNW_DMA_MSIZE_32 = 0x4,
+        LNW_DMA_MSIZE_64 = 0x5,
+};
+/**
+ * struct intel_mid_dma_slave - DMA slave structure
+ *
+ * @dirn: DMA trf direction
+ * @src_width: tx register width
+ * @dst_width: rx register width
+ * @hs_mode: HW/SW handshaking mode
+ * @cfg_mode: DMA data transfer mode (per-per/mem-per/mem-mem)
+ * @src_msize: Source DMA burst size
+ * @dst_msize: Dst DMA burst size
+ * @device_instance: DMA peripheral device instance, we can have multiple
+ *              peripheral device connected to single DMAC
+ */
+struct intel_mid_dma_slave {
+        enum dma_data_direction         dirn;
+        enum intel_mid_dma_width        src_width; /*width of DMA src txn*/
+        enum intel_mid_dma_width        dst_width; /*width of DMA dst txn*/
+        enum intel_mid_dma_hs_mode      hs_mode;  /*handshaking*/
+        enum intel_mid_dma_mode         cfg_mode; /*mode configuration*/
+        enum intel_mid_dma_msize        src_msize; /*size if src burst*/
+        enum intel_mid_dma_msize        dst_msize; /*size of dst burst*/
+        unsigned int            device_instance; /*0, 1 for periphral instance*/
+};
+#endif /*__INTEL_MID_DMA_H__*/
diff --git a/include/linux/iommu-helper.h b/include/linux/iommu-helper.h
index 64d1b638745d..86bdeffe43ad 100644
--- a/include/linux/iommu-helper.h
+++ b/include/linux/iommu-helper.h
@@ -1,6 +1,8 @@
 #ifndef _LINUX_IOMMU_HELPER_H
 #define _LINUX_IOMMU_HELPER_H
+#include <linux/kernel.h>
 static inline unsigned long iommu_device_max_index(unsigned long size,
                                                   unsigned long offset,
                                                   u64 dma_mask)
@@ -20,7 +22,13 @@ extern unsigned long iommu_area_alloc(unsigned long *map, unsigned long size,
                                      unsigned long boundary_size,
                                      unsigned long align_mask);
-extern unsigned long iommu_num_pages(unsigned long addr, unsigned long len,
+static inline unsigned long iommu_num_pages(unsigned long addr,
-                                     unsigned long io_page_size);
+                                            unsigned long len,
+                                            unsigned long io_page_size)
+{
+        unsigned long size = (addr & (io_page_size - 1)) + len;
+        return DIV_ROUND_UP(size, io_page_size);
+}
 #endif
diff --git a/include/linux/istallion.h b/include/linux/istallion.h
index 7faca98c7d14..ad700a60c158 100644
--- a/include/linux/istallion.h
+++ b/include/linux/istallion.h
@@ -86,7 +86,7 @@ struct stlibrd {
        unsigned long   magic;
        unsigned int    brdnr;
        unsigned int    brdtype;
-        unsigned int    state;
+        unsigned long   state;
        unsigned int    nrpanels;
        unsigned int    nrports;
        unsigned int    nrdevs;
diff --git a/include/linux/jffs2.h b/include/linux/jffs2.h
index edb9231f1898..a18b719f49d4 100644
--- a/include/linux/jffs2.h
+++ b/include/linux/jffs2.h
@@ -1,7 +1,8 @@
 /*
 * JFFS2 -- Journalling Flash File System, Version 2.
 *
- * Copyright (C) 2001-2003 Red Hat, Inc.
+ * Copyright © 2001-2007 Red Hat, Inc.
+ * Copyright © 2004-2010 David Woodhouse <dwmw2@infradead.org>
 *
 * Created by David Woodhouse <dwmw2@infradead.org>
 *
diff --git a/include/linux/kernel.h b/include/linux/kernel.h
index 7d5b10ff63e0..5b57236dfbd0 100644
--- a/include/linux/kernel.h
+++ b/include/linux/kernel.h
@@ -616,17 +616,6 @@ static inline void ftrace_dump(enum ftrace_dump_mode oops_dump_mode) { }
 #endif /* CONFIG_TRACING */
 /*
- *      Display an IP address in readable format.
- */
-#define NIPQUAD(addr) \
-        ((unsigned char *)&addr)[0], \
-        ((unsigned char *)&addr)[1], \
-        ((unsigned char *)&addr)[2], \
-        ((unsigned char *)&addr)[3]
-#define NIPQUAD_FMT "%u.%u.%u.%u"
-/*
 * min()/max()/clamp() macros that also do
 * strict type-checking.. See the
 * "unnecessary" pointer comparison.
diff --git a/include/linux/ksm.h b/include/linux/ksm.h
index 43bdab769fc3..74d691ee9121 100644
--- a/include/linux/ksm.h
+++ b/include/linux/ksm.h
@@ -78,7 +78,7 @@ static inline struct page *ksm_might_need_to_copy(struct page *page,
        struct anon_vma *anon_vma = page_anon_vma(page);
        if (!anon_vma ||
-            (anon_vma == vma->anon_vma &&
+            (anon_vma->root == vma->anon_vma->root &&
             page->index == linear_page_index(vma, address)))
                return page;
diff --git a/include/linux/list.h b/include/linux/list.h
index 5d57a3a1fa1b..d167b5d7c0ac 100644
--- a/include/linux/list.h
+++ b/include/linux/list.h
@@ -1,6 +1,7 @@
 #ifndef _LINUX_LIST_H
 #define _LINUX_LIST_H
+#include <linux/types.h>
 #include <linux/stddef.h>
 #include <linux/poison.h>
 #include <linux/prefetch.h>
@@ -16,10 +17,6 @@
 * using the generic single-entry routines.
 */
-struct list_head {
-        struct list_head *next, *prev;
-};
 #define LIST_HEAD_INIT(name) { &(name), &(name) }
 #define LIST_HEAD(name) \
@@ -566,14 +563,6 @@ static inline void list_splice_tail_init(struct list_head *list,
 * You lose the ability to access the tail in O(1).
 */
-struct hlist_head {
-        struct hlist_node *first;
-};
-struct hlist_node {
-        struct hlist_node *next, **pprev;
-};
 #define HLIST_HEAD_INIT { .first = NULL }
 #define HLIST_HEAD(name) struct hlist_head name = {  .first = NULL }
 #define INIT_HLIST_HEAD(ptr) ((ptr)->first = NULL)
diff --git a/include/linux/mbcache.h b/include/linux/mbcache.h
index a09b84e4fdb4..54cbbac1e71d 100644
--- a/include/linux/mbcache.h
+++ b/include/linux/mbcache.h
@@ -4,9 +4,6 @@
  (C) 2001 by Andreas Gruenbacher, <a.gruenbacher@computer.org>
 */
-/* Hardwire the number of additional indexes */
-#define MB_CACHE_INDEXES_COUNT 1
 struct mb_cache_entry {
        struct list_head                e_lru_list;
        struct mb_cache                 *e_cache;
@@ -18,17 +15,12 @@ struct mb_cache_entry {
        struct {
                struct list_head        o_list;
                unsigned int            o_key;
-        } e_indexes[0];
+        } e_index;
-};
-struct mb_cache_op {
-        int (*free)(struct mb_cache_entry *, gfp_t);
 };
 /* Functions on caches */
-struct mb_cache * mb_cache_create(const char *, struct mb_cache_op *, size_t,
+struct mb_cache *mb_cache_create(const char *, int);
-                                  int, int);
 void mb_cache_shrink(struct block_device *);
 void mb_cache_destroy(struct mb_cache *);
@@ -36,17 +28,15 @@ void mb_cache_destroy(struct mb_cache *);
 struct mb_cache_entry *mb_cache_entry_alloc(struct mb_cache *, gfp_t);
 int mb_cache_entry_insert(struct mb_cache_entry *, struct block_device *,
-                          sector_t, unsigned int[]);
+                          sector_t, unsigned int);
 void mb_cache_entry_release(struct mb_cache_entry *);
 void mb_cache_entry_free(struct mb_cache_entry *);
 struct mb_cache_entry *mb_cache_entry_get(struct mb_cache *,
                                          struct block_device *,
                                          sector_t);
-#if !defined(MB_CACHE_INDEXES_COUNT) || (MB_CACHE_INDEXES_COUNT > 0)
+struct mb_cache_entry *mb_cache_entry_find_first(struct mb_cache *cache,
-struct mb_cache_entry *mb_cache_entry_find_first(struct mb_cache *cache, int,
                                                 struct block_device *, 
                                                 unsigned int);
-struct mb_cache_entry *mb_cache_entry_find_next(struct mb_cache_entry *, int,
+struct mb_cache_entry *mb_cache_entry_find_next(struct mb_cache_entry *,
                                                struct block_device *, 
                                                unsigned int);
-#endif
diff --git a/include/linux/memcontrol.h b/include/linux/memcontrol.h
index 9411d32840b0..73564cac38c7 100644
--- a/include/linux/memcontrol.h
+++ b/include/linux/memcontrol.h
@@ -98,11 +98,6 @@ extern void mem_cgroup_end_migration(struct mem_cgroup *mem,
 /*
 * For memory reclaim.
 */
-extern int mem_cgroup_get_reclaim_priority(struct mem_cgroup *mem);
-extern void mem_cgroup_note_reclaim_priority(struct mem_cgroup *mem,
-                                                        int priority);
-extern void mem_cgroup_record_reclaim_priority(struct mem_cgroup *mem,
-                                                        int priority);
 int mem_cgroup_inactive_anon_is_low(struct mem_cgroup *memcg);
 int mem_cgroup_inactive_file_is_low(struct mem_cgroup *memcg);
 unsigned long mem_cgroup_zone_nr_pages(struct mem_cgroup *memcg,
@@ -130,6 +125,8 @@ void mem_cgroup_update_file_mapped(struct page *page, int val);
 unsigned long mem_cgroup_soft_limit_reclaim(struct zone *zone, int order,
                                                gfp_t gfp_mask, int nid,
                                                int zid);
+u64 mem_cgroup_get_limit(struct mem_cgroup *mem);
 #else /* CONFIG_CGROUP_MEM_RES_CTLR */
 struct mem_cgroup;
@@ -309,6 +306,12 @@ unsigned long mem_cgroup_soft_limit_reclaim(struct zone *zone, int order,
        return 0;
 }
+static inline
+u64 mem_cgroup_get_limit(struct mem_cgroup *mem)
+{
+        return 0;
+}
 #endif /* CONFIG_CGROUP_MEM_CONT */
 #endif /* _LINUX_MEMCONTROL_H */
diff --git a/include/linux/mempolicy.h b/include/linux/mempolicy.h
index 7b9ef6bf45aa..31ac26ca4acf 100644
--- a/include/linux/mempolicy.h
+++ b/include/linux/mempolicy.h
@@ -210,6 +210,8 @@ extern struct zonelist *huge_zonelist(struct vm_area_struct *vma,
                                unsigned long addr, gfp_t gfp_flags,
                                struct mempolicy **mpol, nodemask_t **nodemask);
 extern bool init_nodemask_of_mempolicy(nodemask_t *mask);
+extern bool mempolicy_nodemask_intersects(struct task_struct *tsk,
+                                const nodemask_t *mask);
 extern unsigned slab_node(struct mempolicy *policy);
 extern enum zone_type policy_zone;
@@ -338,7 +340,16 @@ static inline struct zonelist *huge_zonelist(struct vm_area_struct *vma,
        return node_zonelist(0, gfp_flags);
 }
-static inline bool init_nodemask_of_mempolicy(nodemask_t *m) { return false; }
+static inline bool init_nodemask_of_mempolicy(nodemask_t *m)
+{
+        return false;
+}
+static inline bool mempolicy_nodemask_intersects(struct task_struct *tsk,
+                        const nodemask_t *mask)
+{
+        return false;
+}
 static inline int do_migrate_pages(struct mm_struct *mm,
                        const nodemask_t *from_nodes,
diff --git a/include/linux/mm.h b/include/linux/mm.h
index 7a9ab7db1975..709f6728fc90 100644
--- a/include/linux/mm.h
+++ b/include/linux/mm.h
@@ -815,6 +815,7 @@ static inline void unmap_shared_mapping_range(struct address_space *mapping,
 }
 extern void truncate_pagecache(struct inode *inode, loff_t old, loff_t new);
+extern void truncate_setsize(struct inode *inode, loff_t newsize);
 extern int vmtruncate(struct inode *inode, loff_t offset);
 extern int vmtruncate_range(struct inode *inode, loff_t offset, loff_t end);
diff --git a/include/linux/mmdebug.h b/include/linux/mmdebug.h
index ee24ef8ab616..c04ecfe03f7f 100644
--- a/include/linux/mmdebug.h
+++ b/include/linux/mmdebug.h
@@ -4,7 +4,7 @@
 #ifdef CONFIG_DEBUG_VM
 #define VM_BUG_ON(cond) BUG_ON(cond)
 #else
-#define VM_BUG_ON(cond) do { } while (0)
+#define VM_BUG_ON(cond) do { (void)(cond); } while (0)
 #endif
 #ifdef CONFIG_DEBUG_VIRTUAL
diff --git a/include/linux/mmzone.h b/include/linux/mmzone.h
index b4d109e389b8..6e6e62648a4d 100644
--- a/include/linux/mmzone.h
+++ b/include/linux/mmzone.h
@@ -348,21 +348,6 @@ struct zone {
        atomic_long_t           vm_stat[NR_VM_ZONE_STAT_ITEMS];
        /*
-         * prev_priority holds the scanning priority for this zone.  It is
-         * defined as the scanning priority at which we achieved our reclaim
-         * target at the previous try_to_free_pages() or balance_pgdat()
-         * invocation.
-         *
-         * We use prev_priority as a measure of how much stress page reclaim is
-         * under - it drives the swappiness decision: whether to unmap mapped
-         * pages.
-         *
-         * Access to both this field is quite racy even on uniprocessor.  But
-         * it is expected to average out OK.
-         */
-        int prev_priority;
-        /*
         * The target ratio of ACTIVE_ANON to INACTIVE_ANON pages on
         * this zone's LRU.  Maintained by the pageout code.
         */
@@ -651,8 +636,6 @@ typedef struct pglist_data {
 #include <linux/memory_hotplug.h>
 extern struct mutex zonelists_mutex;
-void get_zone_counts(unsigned long *active, unsigned long *inactive,
-                        unsigned long *free);
 void build_all_zonelists(void *data);
 void wakeup_kswapd(struct zone *zone, int order);
 int zone_watermark_ok(struct zone *z, int order, unsigned long mark,
diff --git a/include/linux/mount.h b/include/linux/mount.h
index 4bd05474d11d..907210bd9f9c 100644
--- a/include/linux/mount.h
+++ b/include/linux/mount.h
@@ -56,7 +56,11 @@ struct vfsmount {
        struct list_head mnt_mounts;    /* list of children, anchored here */
        struct list_head mnt_child;     /* and going through their mnt_child */
        int mnt_flags;
-        /* 4 bytes hole on 64bits arches */
+        /* 4 bytes hole on 64bits arches without fsnotify */
+#ifdef CONFIG_FSNOTIFY
+        __u32 mnt_fsnotify_mask;
+        struct hlist_head mnt_fsnotify_marks;
+#endif
        const char *mnt_devname;        /* Name of device e.g. /dev/dsk/hda1 */
        struct list_head mnt_list;
        struct list_head mnt_expire;    /* link in fs-specific expiry list */
diff --git a/include/linux/mtd/bbm.h b/include/linux/mtd/bbm.h
index 9c3757c5759d..7fa20beb2ab9 100644
--- a/include/linux/mtd/bbm.h
+++ b/include/linux/mtd/bbm.h
@@ -4,12 +4,26 @@
 *  NAND family Bad Block Management (BBM) header file
 *    - Bad Block Table (BBT) implementation
 *
- *  Copyright (c) 2005 Samsung Electronics
+ *  Copyright © 2005 Samsung Electronics
 *  Kyungmin Park <kyungmin.park@samsung.com>
 *
- *  Copyright (c) 2000-2005
+ *  Copyright © 2000-2005
 *  Thomas Gleixner <tglx@linuxtronix.de>
 *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; either version 2 of the License, or
+ * (at your option) any later version.
+ *
+ * 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
+ *
 */
 #ifndef __LINUX_MTD_BBM_H
 #define __LINUX_MTD_BBM_H
@@ -82,6 +96,12 @@ struct nand_bbt_descr {
 #define NAND_BBT_SAVECONTENT    0x00002000
 /* Search good / bad pattern on the first and the second page */
 #define NAND_BBT_SCAN2NDPAGE    0x00004000
+/* Search good / bad pattern on the last page of the eraseblock */
+#define NAND_BBT_SCANLASTPAGE   0x00008000
+/* Chip stores bad block marker on BOTH 1st and 6th bytes of OOB */
+#define NAND_BBT_SCANBYTE1AND6 0x00100000
+/* The nand_bbt_descr was created dynamicaly and must be freed */
+#define NAND_BBT_DYNAMICSTRUCT 0x00200000
 /* The maximum number of blocks to scan for a bbt */
 #define NAND_BBT_SCAN_MAXBLOCKS 4
diff --git a/include/linux/mtd/blktrans.h b/include/linux/mtd/blktrans.h
index b481ccd7ff3c..26529ebd59cc 100644
--- a/include/linux/mtd/blktrans.h
+++ b/include/linux/mtd/blktrans.h
@@ -1,7 +1,19 @@
 /*
- * (C) 2003 David Woodhouse <dwmw2@infradead.org>
+ * Copyright © 2003-2010 David Woodhouse <dwmw2@infradead.org>
 *
- * Interface to Linux block layer for MTD 'translation layers'.
+ * 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
 *
 */
diff --git a/include/linux/mtd/cfi.h b/include/linux/mtd/cfi.h
index 574d9ee066f1..d2118b0eac9a 100644
--- a/include/linux/mtd/cfi.h
+++ b/include/linux/mtd/cfi.h
@@ -1,6 +1,20 @@
+/*
-/* Common Flash Interface structures
+ * Copyright © 2000-2010 David Woodhouse <dwmw2@infradead.org> et al.
- * See http://support.intel.com/design/flash/technote/index.htm
+ *
+ * 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
+ *
 */
 #ifndef __MTD_CFI_H__
diff --git a/include/linux/mtd/cfi_endian.h b/include/linux/mtd/cfi_endian.h
index d802f7736be3..51cc3f5917a8 100644
--- a/include/linux/mtd/cfi_endian.h
+++ b/include/linux/mtd/cfi_endian.h
@@ -1,3 +1,22 @@
+/*
+ * Copyright © 2001-2010 David Woodhouse <dwmw2@infradead.org>
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; either version 2 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
+ *
+ */
 #include <asm/byteorder.h>
 #ifndef CONFIG_MTD_CFI_ADV_OPTIONS
diff --git a/include/linux/mtd/compatmac.h b/include/linux/mtd/compatmac.h
deleted file mode 100644
index 7d1300d9bd51..000000000000
--- a/include/linux/mtd/compatmac.h
+++ /dev/null
@@ -1,10 +0,0 @@
-#ifndef __LINUX_MTD_COMPATMAC_H__
-#define __LINUX_MTD_COMPATMAC_H__
-/* Nothing to see here. We write 2.5-compatible code and this
-   file makes it all OK in older kernels, but it's empty in _current_
-   kernels. Include guard just to make GCC ignore it in future inclusions
-   anyway... */
-#endif /* __LINUX_MTD_COMPATMAC_H__ */
diff --git a/include/linux/mtd/concat.h b/include/linux/mtd/concat.h
index e80c674daeb3..ccdbe93a909c 100644
--- a/include/linux/mtd/concat.h
+++ b/include/linux/mtd/concat.h
@@ -1,9 +1,22 @@
 /*
 * MTD device concatenation layer definitions
 *
- * (C) 2002 Robert Kaiser <rkaiser@sysgo.de>
+ * Copyright © 2002      Robert Kaiser <rkaiser@sysgo.de>
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; either version 2 of the License, or
+ * (at your option) any later version.
+ *
+ * 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
 *
- * This code is GPL
 */
 #ifndef MTD_CONCAT_H
diff --git a/include/linux/mtd/doc2000.h b/include/linux/mtd/doc2000.h
index 0a6d516ab71d..0f6fea73a1f6 100644
--- a/include/linux/mtd/doc2000.h
+++ b/include/linux/mtd/doc2000.h
@@ -1,12 +1,25 @@
 /*
 * Linux driver for Disk-On-Chip devices
 *
- * Copyright (C) 1999 Machine Vision Holdings, Inc.
+ * Copyright © 1999 Machine Vision Holdings, Inc.
- * Copyright (C) 2001-2003 David Woodhouse <dwmw2@infradead.org>
+ * Copyright © 1999-2010 David Woodhouse <dwmw2@infradead.org>
- * Copyright (C) 2002-2003 Greg Ungerer <gerg@snapgear.com>
+ * Copyright © 2002-2003 Greg Ungerer <gerg@snapgear.com>
- * Copyright (C) 2002-2003 SnapGear Inc
+ * Copyright © 2002-2003 SnapGear Inc
+ *
+ * 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
 *
- * Released under GPL
 */
 #ifndef __MTD_DOC2000_H__
diff --git a/include/linux/mtd/flashchip.h b/include/linux/mtd/flashchip.h
index f43e9b49b751..b63fa457febd 100644
--- a/include/linux/mtd/flashchip.h
+++ b/include/linux/mtd/flashchip.h
@@ -1,10 +1,21 @@
 /*
- * struct flchip definition
+ * Copyright © 2000      Red Hat UK Limited
+ * Copyright © 2000-2010 David Woodhouse <dwmw2@infradead.org>
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; either version 2 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
 *
- * Contains information about the location and state of a given flash device
+ * 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
 *
- * (C) 2000 Red Hat. GPLd.
 */
 #ifndef __MTD_FLASHCHIP_H__
@@ -92,7 +103,7 @@ struct flchip {
 /* This is used to handle contention on write/erase operations
   between partitions of the same physical chip. */
 struct flchip_shared {
-        spinlock_t lock;
+        struct mutex lock;
        struct flchip *writing;
        struct flchip *erasing;
 };
diff --git a/include/linux/mtd/gen_probe.h b/include/linux/mtd/gen_probe.h
index df362ddf2949..2c456054fded 100644
--- a/include/linux/mtd/gen_probe.h
+++ b/include/linux/mtd/gen_probe.h
@@ -1,6 +1,21 @@
 /*
- * (C) 2001, 2001 Red Hat, Inc.
+ * Copyright © 2001      Red Hat UK Limited
- * GPL'd
+ * Copyright © 2001-2010 David Woodhouse <dwmw2@infradead.org>
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; either version 2 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
+ *
 */
 #ifndef __LINUX_MTD_GEN_PROBE_H__
diff --git a/include/linux/mtd/map.h b/include/linux/mtd/map.h
index de89eca864ce..a9e6ba46865e 100644
--- a/include/linux/mtd/map.h
+++ b/include/linux/mtd/map.h
@@ -1,3 +1,21 @@
+/*
+ * Copyright © 2000-2010 David Woodhouse <dwmw2@infradead.org> et al.
+ *
+ * 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
+ *
+ */
 /* Overhauled routines for dealing with different mmap regions of flash */
@@ -9,7 +27,6 @@
 #include <linux/string.h>
 #include <linux/bug.h>
-#include <linux/mtd/compatmac.h>
 #include <asm/unaligned.h>
 #include <asm/system.h>
diff --git a/include/linux/mtd/mtd.h b/include/linux/mtd/mtd.h
index 5326435a7571..8485e42a9b09 100644
--- a/include/linux/mtd/mtd.h
+++ b/include/linux/mtd/mtd.h
@@ -1,7 +1,20 @@
 /*
- * Copyright (C) 1999-2003 David Woodhouse <dwmw2@infradead.org> et al.
+ * Copyright © 1999-2010 David Woodhouse <dwmw2@infradead.org> et al.
+ *
+ * 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
 *
- * Released under GPL
 */
 #ifndef __MTD_MTD_H__
@@ -13,7 +26,6 @@
 #include <linux/notifier.h>
 #include <linux/device.h>
-#include <linux/mtd/compatmac.h>
 #include <mtd/mtd-abi.h>
 #include <asm/div64.h>
@@ -216,6 +228,7 @@ struct mtd_info {
        /* Chip-supported device locking */
        int (*lock) (struct mtd_info *mtd, loff_t ofs, uint64_t len);
        int (*unlock) (struct mtd_info *mtd, loff_t ofs, uint64_t len);
+        int (*is_locked) (struct mtd_info *mtd, loff_t ofs, uint64_t len);
        /* Power Management functions */
        int (*suspend) (struct mtd_info *mtd);
diff --git a/include/linux/mtd/nand.h b/include/linux/mtd/nand.h
index a81b185e23a7..102e12c58cb3 100644
--- a/include/linux/mtd/nand.h
+++ b/include/linux/mtd/nand.h
@@ -1,9 +1,9 @@
 /*
 *  linux/include/linux/mtd/nand.h
 *
- *  Copyright (c) 2000 David Woodhouse <dwmw2@infradead.org>
+ *  Copyright © 2000-2010 David Woodhouse <dwmw2@infradead.org>
- *                     Steven J. Hill <sjhill@realitydiluted.com>
+ *                        Steven J. Hill <sjhill@realitydiluted.com>
- *                     Thomas Gleixner <tglx@linutronix.de>
+ *                        Thomas Gleixner <tglx@linutronix.de>
 *
 * 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
@@ -181,8 +181,6 @@ typedef enum {
 #define NAND_NO_READRDY         0x00000100
 /* Chip does not allow subpage writes */
 #define NAND_NO_SUBPAGE_WRITE   0x00000200
-/* Chip stores bad block marker on the last page of the eraseblock */
-#define NAND_BB_LAST_PAGE       0x00000400
 /* Device is one of 'new' xD cards that expose fake nand command set */
 #define NAND_BROKEN_XD          0x00000400
diff --git a/include/linux/mtd/nand_ecc.h b/include/linux/mtd/nand_ecc.h
index 41bc013571d0..4d8406c81652 100644
--- a/include/linux/mtd/nand_ecc.h
+++ b/include/linux/mtd/nand_ecc.h
@@ -1,7 +1,9 @@
 /*
 *  drivers/mtd/nand_ecc.h
 *
- *  Copyright (C) 2000 Steven J. Hill (sjhill@realitydiluted.com)
+ *  Copyright (C) 2000-2010 Steven J. Hill <sjhill@realitydiluted.com>
+ *                          David Woodhouse <dwmw2@infradead.org>
+ *                          Thomas Gleixner <tglx@linutronix.de>
 *
 * 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
diff --git a/include/linux/mtd/nftl.h b/include/linux/mtd/nftl.h
index dcaf611ed748..b059629e22bc 100644
--- a/include/linux/mtd/nftl.h
+++ b/include/linux/mtd/nftl.h
@@ -1,5 +1,20 @@
 /*
- * (C) 1999-2003 David Woodhouse <dwmw2@infradead.org>
+ * Copyright © 1999-2010 David Woodhouse <dwmw2@infradead.org>
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; either version 2 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
+ *
 */
 #ifndef __MTD_NFTL_H__
diff --git a/include/linux/mtd/onenand.h b/include/linux/mtd/onenand.h
index c26ff86ad08a..0c8815bfae1c 100644
--- a/include/linux/mtd/onenand.h
+++ b/include/linux/mtd/onenand.h
@@ -68,6 +68,7 @@ struct onenand_bufferram {
 * @write_word:         [REPLACEABLE] hardware specific function for write
 *                      register of OneNAND
 * @mmcontrol:          sync burst read function
+ * @chip_probe:         [REPLACEABLE] hardware specific function for chip probe
 * @block_markbad:      function to mark a block as bad
 * @scan_bbt:           [REPLACEALBE] hardware specific function for scanning
 *                      Bad block Table
@@ -114,6 +115,7 @@ struct onenand_chip {
        unsigned short (*read_word)(void __iomem *addr);
        void (*write_word)(unsigned short value, void __iomem *addr);
        void (*mmcontrol)(struct mtd_info *mtd, int sync_read);
+        int (*chip_probe)(struct mtd_info *mtd);
        int (*block_markbad)(struct mtd_info *mtd, loff_t ofs);
        int (*scan_bbt)(struct mtd_info *mtd);
diff --git a/include/linux/mtd/physmap.h b/include/linux/mtd/physmap.h
index 76f7cabf07d3..bcfd9f777454 100644
--- a/include/linux/mtd/physmap.h
+++ b/include/linux/mtd/physmap.h
@@ -25,6 +25,7 @@ struct physmap_flash_data {
        void                    (*set_vpp)(struct map_info *, int);
        unsigned int            nr_parts;
        unsigned int            pfow_base;
+        char                    *probe_type;
        struct mtd_partition    *parts;
 };
diff --git a/include/linux/omapfb.h b/include/linux/omapfb.h
index 7e4cd616bcb5..c0b018790f07 100644
--- a/include/linux/omapfb.h
+++ b/include/linux/omapfb.h
@@ -85,6 +85,9 @@
 #define OMAPFB_MEMTYPE_SRAM             1
 #define OMAPFB_MEMTYPE_MAX              1
+#define OMAPFB_MEM_IDX_ENABLED  0x80
+#define OMAPFB_MEM_IDX_MASK     0x7f
 enum omapfb_color_format {
        OMAPFB_COLOR_RGB565 = 0,
        OMAPFB_COLOR_YUV422,
@@ -136,7 +139,7 @@ struct omapfb_plane_info {
        __u8  enabled;
        __u8  channel_out;
        __u8  mirror;
-        __u8  reserved1;
+        __u8  mem_idx;
        __u32 out_width;
        __u32 out_height;
        __u32 reserved2[12];
diff --git a/include/linux/oom.h b/include/linux/oom.h
index 537662315627..f209b683e118 100644
--- a/include/linux/oom.h
+++ b/include/linux/oom.h
@@ -1,19 +1,34 @@
 #ifndef __INCLUDE_LINUX_OOM_H
 #define __INCLUDE_LINUX_OOM_H
-/* /proc/<pid>/oom_adj set to -17 protects from the oom-killer */
+/*
+ * /proc/<pid>/oom_adj is deprecated, see
+ * Documentation/feature-removal-schedule.txt.
+ *
+ * /proc/<pid>/oom_adj set to -17 protects from the oom-killer
+ */
 #define OOM_DISABLE (-17)
 /* inclusive */
 #define OOM_ADJUST_MIN (-16)
 #define OOM_ADJUST_MAX 15
+/*
+ * /proc/<pid>/oom_score_adj set to OOM_SCORE_ADJ_MIN disables oom killing for
+ * pid.
+ */
+#define OOM_SCORE_ADJ_MIN       (-1000)
+#define OOM_SCORE_ADJ_MAX       1000
 #ifdef __KERNEL__
+#include <linux/sched.h>
 #include <linux/types.h>
 #include <linux/nodemask.h>
 struct zonelist;
 struct notifier_block;
+struct mem_cgroup;
+struct task_struct;
 /*
 * Types of limitations to the nodes from which allocations may occur
@@ -22,9 +37,12 @@ enum oom_constraint {
        CONSTRAINT_NONE,
        CONSTRAINT_CPUSET,
        CONSTRAINT_MEMORY_POLICY,
+        CONSTRAINT_MEMCG,
 };
-extern int try_set_zone_oom(struct zonelist *zonelist, gfp_t gfp_flags);
+extern unsigned int oom_badness(struct task_struct *p, struct mem_cgroup *mem,
+                        const nodemask_t *nodemask, unsigned long totalpages);
+extern int try_set_zonelist_oom(struct zonelist *zonelist, gfp_t gfp_flags);
 extern void clear_zonelist_oom(struct zonelist *zonelist, gfp_t gfp_flags);
 extern void out_of_memory(struct zonelist *zonelist, gfp_t gfp_mask,
@@ -43,5 +61,14 @@ static inline void oom_killer_enable(void)
 {
        oom_killer_disabled = false;
 }
+/* The badness from the OOM killer */
+extern unsigned long badness(struct task_struct *p, struct mem_cgroup *mem,
+                      const nodemask_t *nodemask, unsigned long uptime);
+/* sysctls */
+extern int sysctl_oom_dump_tasks;
+extern int sysctl_oom_kill_allocating_task;
+extern int sysctl_panic_on_oom;
 #endif /* __KERNEL__*/
 #endif /* _INCLUDE_LINUX_OOM_H */
diff --git a/include/linux/pagemap.h b/include/linux/pagemap.h
index 3c62ed408492..78a702ce4fcb 100644
--- a/include/linux/pagemap.h
+++ b/include/linux/pagemap.h
@@ -423,8 +423,10 @@ static inline int fault_in_pages_readable(const char __user *uaddr, int size)
                const char __user *end = uaddr + size - 1;
                if (((unsigned long)uaddr & PAGE_MASK) !=
-                                ((unsigned long)end & PAGE_MASK))
+                                ((unsigned long)end & PAGE_MASK)) {
                        ret = __get_user(c, end);
+                        (void)c;
+                }
        }
        return ret;
 }
diff --git a/include/linux/pch_dma.h b/include/linux/pch_dma.h
new file mode 100644
index 000000000000..fdafe529ef8a
--- /dev/null
+++ b/include/linux/pch_dma.h
@@ -0,0 +1,37 @@
+/*
+ * Copyright (c) 2010 Intel Corporation
+ *
+ * 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., 675 Mass Ave, Cambridge, MA 02139, USA.
+ */
+#ifndef PCH_DMA_H
+#define PCH_DMA_H
+#include <linux/dmaengine.h>
+enum pch_dma_width {
+        PCH_DMA_WIDTH_1_BYTE,
+        PCH_DMA_WIDTH_2_BYTES,
+        PCH_DMA_WIDTH_4_BYTES,
+};
+struct pch_dma_slave {
+        struct device           *dma_dev;
+        unsigned int            chan_id;
+        dma_addr_t              tx_reg;
+        dma_addr_t              rx_reg;
+        enum pch_dma_width      width;
+};
+#endif
diff --git a/include/linux/percpu_counter.h b/include/linux/percpu_counter.h
index c88d67b59394..8a7d510ffa9c 100644
--- a/include/linux/percpu_counter.h
+++ b/include/linux/percpu_counter.h
@@ -40,6 +40,7 @@ void percpu_counter_destroy(struct percpu_counter *fbc);
 void percpu_counter_set(struct percpu_counter *fbc, s64 amount);
 void __percpu_counter_add(struct percpu_counter *fbc, s64 amount, s32 batch);
 s64 __percpu_counter_sum(struct percpu_counter *fbc);
+int percpu_counter_compare(struct percpu_counter *fbc, s64 rhs);
 static inline void percpu_counter_add(struct percpu_counter *fbc, s64 amount)
 {
@@ -98,6 +99,16 @@ static inline void percpu_counter_set(struct percpu_counter *fbc, s64 amount)
        fbc->count = amount;
 }
+static inline int percpu_counter_compare(struct percpu_counter *fbc, s64 rhs)
+{
+        if (fbc->count > rhs)
+                return 1;
+        else if (fbc->count < rhs)
+                return -1;
+        else
+                return 0;
+}
 static inline void
 percpu_counter_add(struct percpu_counter *fbc, s64 amount)
 {
diff --git a/include/linux/posix-timers.h b/include/linux/posix-timers.h
index 4f71bf4e628c..3e23844a6990 100644
--- a/include/linux/posix-timers.h
+++ b/include/linux/posix-timers.h
@@ -117,6 +117,6 @@ void set_process_cpu_timer(struct task_struct *task, unsigned int clock_idx,
 long clock_nanosleep_restart(struct restart_block *restart_block);
-void update_rlimit_cpu(unsigned long rlim_new);
+void update_rlimit_cpu(struct task_struct *task, unsigned long rlim_new);
 #endif
diff --git a/include/linux/ppp_channel.h b/include/linux/ppp_channel.h
index bff98ec1bfed..5d87f810a3b7 100644
--- a/include/linux/ppp_channel.h
+++ b/include/linux/ppp_channel.h
@@ -36,7 +36,7 @@ struct ppp_channel_ops {
 struct ppp_channel {
        void            *private;       /* channel private data */
-        struct ppp_channel_ops *ops;    /* operations for this channel */
+        const struct ppp_channel_ops *ops; /* operations for this channel */
        int             mtu;            /* max transmit packet size */
        int             hdrlen;         /* amount of headroom channel needs */
        void            *ppp;           /* opaque to channel */
diff --git a/include/linux/radix-tree.h b/include/linux/radix-tree.h
index 55ca73cf25e5..634b8e674ac5 100644
--- a/include/linux/radix-tree.h
+++ b/include/linux/radix-tree.h
@@ -55,7 +55,7 @@ static inline int radix_tree_is_indirect_ptr(void *ptr)
 /*** radix-tree API starts here ***/
-#define RADIX_TREE_MAX_TAGS 2
+#define RADIX_TREE_MAX_TAGS 3
 /* root tags are stored in gfp_mask, shifted by __GFP_BITS_SHIFT */
 struct radix_tree_root {
@@ -192,6 +192,10 @@ unsigned int
 radix_tree_gang_lookup_tag_slot(struct radix_tree_root *root, void ***results,
                unsigned long first_index, unsigned int max_items,
                unsigned int tag);
+unsigned long radix_tree_range_tag_if_tagged(struct radix_tree_root *root,
+                unsigned long *first_indexp, unsigned long last_index,
+                unsigned long nr_to_tag,
+                unsigned int fromtag, unsigned int totag);
 int radix_tree_tagged(struct radix_tree_root *root, unsigned int tag);
 static inline void radix_tree_preload_end(void)
diff --git a/include/linux/reiserfs_fs.h b/include/linux/reiserfs_fs.h
index ba394163dea1..91a4177e60ce 100644
--- a/include/linux/reiserfs_fs.h
+++ b/include/linux/reiserfs_fs.h
@@ -2033,7 +2033,7 @@ void reiserfs_read_locked_inode(struct inode *inode,
                                struct reiserfs_iget_args *args);
 int reiserfs_find_actor(struct inode *inode, void *p);
 int reiserfs_init_locked_inode(struct inode *inode, void *p);
-void reiserfs_delete_inode(struct inode *inode);
+void reiserfs_evict_inode(struct inode *inode);
 int reiserfs_write_inode(struct inode *inode, struct writeback_control *wbc);
 int reiserfs_get_block(struct inode *inode, sector_t block,
                       struct buffer_head *bh_result, int create);
diff --git a/include/linux/reiserfs_fs_i.h b/include/linux/reiserfs_fs_i.h
index 89f4d3abbf5a..97959bdfe214 100644
--- a/include/linux/reiserfs_fs_i.h
+++ b/include/linux/reiserfs_fs_i.h
@@ -25,7 +25,6 @@ typedef enum {
        i_link_saved_truncate_mask = 0x0020,
        i_has_xattr_dir = 0x0040,
        i_data_log = 0x0080,
-        i_ever_mapped = 0x0100
 } reiserfs_inode_flags;
 struct reiserfs_inode_info {
@@ -53,7 +52,8 @@ struct reiserfs_inode_info {
         ** flushed */
        unsigned int i_trans_id;
        struct reiserfs_journal_list *i_jl;
-        struct mutex i_mmap;
+        atomic_t openers;
+        struct mutex tailpack;
 #ifdef CONFIG_REISERFS_FS_XATTR
        struct rw_semaphore i_xattr_sem;
 #endif
diff --git a/include/linux/resource.h b/include/linux/resource.h
index f1e914eefeab..88d36f9145ba 100644
--- a/include/linux/resource.h
+++ b/include/linux/resource.h
@@ -43,6 +43,13 @@ struct rlimit {
        unsigned long   rlim_max;
 };
+#define RLIM64_INFINITY         (~0ULL)
+struct rlimit64 {
+        __u64 rlim_cur;
+        __u64 rlim_max;
+};
 #define PRIO_MIN        (-20)
 #define PRIO_MAX        20
@@ -73,6 +80,8 @@ struct rlimit {
 struct task_struct;
 int getrusage(struct task_struct *p, int who, struct rusage __user *ru);
+int do_prlimit(struct task_struct *tsk, unsigned int resource,
+                struct rlimit *new_rlim, struct rlimit *old_rlim);
 #endif /* __KERNEL__ */
diff --git a/include/linux/rmap.h b/include/linux/rmap.h
index 77216742c178..d6661de56f30 100644
--- a/include/linux/rmap.h
+++ b/include/linux/rmap.h
@@ -26,6 +26,7 @@
 */
 struct anon_vma {
        spinlock_t lock;        /* Serialize access to vma list */
+        struct anon_vma *root;  /* Root of this anon_vma tree */
 #if defined(CONFIG_KSM) || defined(CONFIG_MIGRATION)
        /*
@@ -80,6 +81,13 @@ static inline int anonvma_external_refcount(struct anon_vma *anon_vma)
 {
        return atomic_read(&anon_vma->external_refcount);
 }
+static inline void get_anon_vma(struct anon_vma *anon_vma)
+{
+        atomic_inc(&anon_vma->external_refcount);
+}
+void drop_anon_vma(struct anon_vma *);
 #else
 static inline void anonvma_external_refcount_init(struct anon_vma *anon_vma)
 {
@@ -89,6 +97,14 @@ static inline int anonvma_external_refcount(struct anon_vma *anon_vma)
 {
        return 0;
 }
+static inline void get_anon_vma(struct anon_vma *anon_vma)
+{
+}
+static inline void drop_anon_vma(struct anon_vma *anon_vma)
+{
+}
 #endif /* CONFIG_KSM */
 static inline struct anon_vma *page_anon_vma(struct page *page)
@@ -99,18 +115,28 @@ static inline struct anon_vma *page_anon_vma(struct page *page)
        return page_rmapping(page);
 }
-static inline void anon_vma_lock(struct vm_area_struct *vma)
+static inline void vma_lock_anon_vma(struct vm_area_struct *vma)
 {
        struct anon_vma *anon_vma = vma->anon_vma;
        if (anon_vma)
-                spin_lock(&anon_vma->lock);
+                spin_lock(&anon_vma->root->lock);
 }
-static inline void anon_vma_unlock(struct vm_area_struct *vma)
+static inline void vma_unlock_anon_vma(struct vm_area_struct *vma)
 {
        struct anon_vma *anon_vma = vma->anon_vma;
        if (anon_vma)
-                spin_unlock(&anon_vma->lock);
+                spin_unlock(&anon_vma->root->lock);
+}
+static inline void anon_vma_lock(struct anon_vma *anon_vma)
+{
+        spin_lock(&anon_vma->root->lock);
+}
+static inline void anon_vma_unlock(struct anon_vma *anon_vma)
+{
+        spin_unlock(&anon_vma->root->lock);
 }
 /*
@@ -136,6 +162,8 @@ static inline void anon_vma_merge(struct vm_area_struct *vma,
 */
 void page_move_anon_rmap(struct page *, struct vm_area_struct *, unsigned long);
 void page_add_anon_rmap(struct page *, struct vm_area_struct *, unsigned long);
+void do_page_add_anon_rmap(struct page *, struct vm_area_struct *,
+                           unsigned long, int);
 void page_add_new_anon_rmap(struct page *, struct vm_area_struct *, unsigned long);
 void page_add_file_rmap(struct page *);
 void page_remove_rmap(struct page *);
diff --git a/include/linux/sched.h b/include/linux/sched.h
index 9591907c4f79..ce160d68f5e7 100644
--- a/include/linux/sched.h
+++ b/include/linux/sched.h
@@ -621,7 +621,8 @@ struct signal_struct {
        struct tty_audit_buf *tty_audit_buf;
 #endif
-        int oom_adj;    /* OOM kill score adjustment (bit shift) */
+        int oom_adj;            /* OOM kill score adjustment (bit shift) */
+        int oom_score_adj;      /* OOM kill score adjustment */
 };
 /* Context switch must be unlocked if interrupts are to be enabled */
diff --git a/include/linux/security.h b/include/linux/security.h
index 723a93df756a..a22219afff09 100644
--- a/include/linux/security.h
+++ b/include/linux/security.h
@@ -23,6 +23,7 @@
 #define __LINUX_SECURITY_H
 #include <linux/fs.h>
+#include <linux/fsnotify.h>
 #include <linux/binfmts.h>
 #include <linux/signal.h>
 #include <linux/resource.h>
@@ -1498,7 +1499,8 @@ struct security_operations {
        int (*task_setnice) (struct task_struct *p, int nice);
        int (*task_setioprio) (struct task_struct *p, int ioprio);
        int (*task_getioprio) (struct task_struct *p);
-        int (*task_setrlimit) (unsigned int resource, struct rlimit *new_rlim);
+        int (*task_setrlimit) (struct task_struct *p, unsigned int resource,
+                        struct rlimit *new_rlim);
        int (*task_setscheduler) (struct task_struct *p, int policy,
                                  struct sched_param *lp);
        int (*task_getscheduler) (struct task_struct *p);
@@ -1748,7 +1750,8 @@ void security_task_getsecid(struct task_struct *p, u32 *secid);
 int security_task_setnice(struct task_struct *p, int nice);
 int security_task_setioprio(struct task_struct *p, int ioprio);
 int security_task_getioprio(struct task_struct *p);
-int security_task_setrlimit(unsigned int resource, struct rlimit *new_rlim);
+int security_task_setrlimit(struct task_struct *p, unsigned int resource,
+                struct rlimit *new_rlim);
 int security_task_setscheduler(struct task_struct *p,
                                int policy, struct sched_param *lp);
 int security_task_getscheduler(struct task_struct *p);
@@ -2310,7 +2313,8 @@ static inline int security_task_getioprio(struct task_struct *p)
        return 0;
 }
-static inline int security_task_setrlimit(unsigned int resource,
+static inline int security_task_setrlimit(struct task_struct *p,
+                                          unsigned int resource,
                                          struct rlimit *new_rlim)
 {
        return 0;
diff --git a/include/linux/serial.h b/include/linux/serial.h
index c8613c3ff9d3..1ebc694a6d52 100644
--- a/include/linux/serial.h
+++ b/include/linux/serial.h
@@ -77,7 +77,8 @@ struct serial_struct {
 #define PORT_16654      11
 #define PORT_16850      12
 #define PORT_RSA        13      /* RSA-DV II/S card */
-#define PORT_MAX        13
+#define PORT_U6_16550A  14
+#define PORT_MAX        14
 #define SERIAL_IO_PORT  0
 #define SERIAL_IO_HUB6  1
@@ -151,7 +152,7 @@ struct serial_uart_config {
 #define ASYNC_BUGGY_UART        (1U << ASYNCB_BUGGY_UART)
 #define ASYNC_AUTOPROBE         (1U << ASYNCB_AUTOPROBE)
-#define ASYNC_FLAGS             ((1U << ASYNCB_LAST_USER) - 1)
+#define ASYNC_FLAGS             ((1U << (ASYNCB_LAST_USER + 1)) - 1)
 #define ASYNC_USR_MASK          (ASYNC_SPD_HI|ASYNC_SPD_VHI| \
                ASYNC_CALLOUT_NOHUP|ASYNC_SPD_SHI|ASYNC_LOW_LATENCY)
 #define ASYNC_SPD_CUST          (ASYNC_SPD_HI|ASYNC_SPD_VHI)
@@ -210,8 +211,10 @@ struct serial_rs485 {
 #define SER_RS485_ENABLED               (1 << 0)
 #define SER_RS485_RTS_ON_SEND           (1 << 1)
 #define SER_RS485_RTS_AFTER_SEND        (1 << 2)
+#define SER_RS485_RTS_BEFORE_SEND       (1 << 3)
        __u32   delay_rts_before_send;  /* Milliseconds */
-        __u32   padding[6];             /* Memory is cheap, new structs
+        __u32   delay_rts_after_send;   /* Milliseconds */
+        __u32   padding[5];             /* Memory is cheap, new structs
                                           are a royal PITA .. */
 };
diff --git a/include/linux/serial_8250.h b/include/linux/serial_8250.h
index fb46aba11fb5..7638deaaba65 100644
--- a/include/linux/serial_8250.h
+++ b/include/linux/serial_8250.h
@@ -32,6 +32,9 @@ struct plat_serial8250_port {
        unsigned int    type;           /* If UPF_FIXED_TYPE */
        unsigned int    (*serial_in)(struct uart_port *, int);
        void            (*serial_out)(struct uart_port *, int, int);
+        void            (*set_termios)(struct uart_port *,
+                                       struct ktermios *new,
+                                       struct ktermios *old);
 };
 /*
@@ -71,5 +74,7 @@ extern int early_serial_setup(struct uart_port *port);
 extern int serial8250_find_port(struct uart_port *p);
 extern int serial8250_find_port_for_earlycon(void);
 extern int setup_early_serial8250_console(char *cmdline);
+extern void serial8250_do_set_termios(struct uart_port *port,
+                struct ktermios *termios, struct ktermios *old);
 #endif
diff --git a/include/linux/serial_core.h b/include/linux/serial_core.h
index f10db6e5f3b5..8129ca2d57e3 100644
--- a/include/linux/serial_core.h
+++ b/include/linux/serial_core.h
@@ -186,6 +186,12 @@
 #define PORT_ALTERA_JTAGUART    91
 #define PORT_ALTERA_UART        92
+/* MAX3107 */
+#define PORT_MAX3107    94
+/* High Speed UART for Medfield */
+#define PORT_MFD        95
 #ifdef __KERNEL__
 #include <linux/compiler.h>
@@ -220,7 +226,7 @@ struct uart_ops {
        void            (*flush_buffer)(struct uart_port *);
        void            (*set_termios)(struct uart_port *, struct ktermios *new,
                                       struct ktermios *old);
-        void            (*set_ldisc)(struct uart_port *);
+        void            (*set_ldisc)(struct uart_port *, int new);
        void            (*pm)(struct uart_port *, unsigned int state,
                              unsigned int oldstate);
        int             (*set_wake)(struct uart_port *, unsigned int state);
@@ -276,6 +282,9 @@ struct uart_port {
        unsigned char __iomem   *membase;               /* read/write[bwl] */
        unsigned int            (*serial_in)(struct uart_port *, int);
        void                    (*serial_out)(struct uart_port *, int, int);
+        void                    (*set_termios)(struct uart_port *,
+                                               struct ktermios *new,
+                                               struct ktermios *old);
        unsigned int            irq;                    /* irq number */
        unsigned long           irqflags;               /* irq flags  */
        unsigned int            uartclk;                /* base uart clock */
diff --git a/include/linux/serial_mfd.h b/include/linux/serial_mfd.h
new file mode 100644
index 000000000000..2b071e0b034d
--- /dev/null
+++ b/include/linux/serial_mfd.h
@@ -0,0 +1,47 @@
+#ifndef _SERIAL_MFD_H_
+#define _SERIAL_MFD_H_
+/* HW register offset definition */
+#define UART_FOR        0x08
+#define UART_PS         0x0C
+#define UART_MUL        0x0D
+#define UART_DIV        0x0E
+#define HSU_GBL_IEN     0x0
+#define HSU_GBL_IST     0x4
+#define HSU_GBL_INT_BIT_PORT0   0x0
+#define HSU_GBL_INT_BIT_PORT1   0x1
+#define HSU_GBL_INT_BIT_PORT2   0x2
+#define HSU_GBL_INT_BIT_IRI     0x3
+#define HSU_GBL_INT_BIT_HDLC    0x4
+#define HSU_GBL_INT_BIT_DMA     0x5
+#define HSU_GBL_ISR     0x8
+#define HSU_GBL_DMASR   0x400
+#define HSU_GBL_DMAISR  0x404
+#define HSU_PORT_REG_OFFSET     0x80
+#define HSU_PORT0_REG_OFFSET    0x80
+#define HSU_PORT1_REG_OFFSET    0x100
+#define HSU_PORT2_REG_OFFSET    0x180
+#define HSU_PORT_REG_LENGTH     0x80
+#define HSU_DMA_CHANS_REG_OFFSET        0x500
+#define HSU_DMA_CHANS_REG_LENGTH        0x40
+#define HSU_CH_SR               0x0     /* channel status reg */
+#define HSU_CH_CR               0x4     /* control reg */
+#define HSU_CH_DCR              0x8     /* descriptor control reg */
+#define HSU_CH_BSR              0x10    /* max fifo buffer size reg */
+#define HSU_CH_MOTSR            0x14    /* minimum ocp transfer size */
+#define HSU_CH_D0SAR            0x20    /* desc 0 start addr */
+#define HSU_CH_D0TSR            0x24    /* desc 0 transfer size */
+#define HSU_CH_D1SAR            0x28
+#define HSU_CH_D1TSR            0x2C
+#define HSU_CH_D2SAR            0x30
+#define HSU_CH_D2TSR            0x34
+#define HSU_CH_D3SAR            0x38
+#define HSU_CH_D3TSR            0x3C
+#endif
diff --git a/include/linux/serial_reg.h b/include/linux/serial_reg.h
index cf9327c051ad..c7a0ce11cd47 100644
--- a/include/linux/serial_reg.h
+++ b/include/linux/serial_reg.h
@@ -221,8 +221,24 @@
 #define UART_FCR_PXAR16 0x80    /* receive FIFO threshold = 16 */
 #define UART_FCR_PXAR32 0xc0    /* receive FIFO threshold = 32 */
+/*
+ * Intel MID on-chip HSU (High Speed UART) defined bits
+ */
+#define UART_FCR_HSU_64_1B      0x00    /* receive FIFO treshold = 1 */
+#define UART_FCR_HSU_64_16B     0x40    /* receive FIFO treshold = 16 */
+#define UART_FCR_HSU_64_32B     0x80    /* receive FIFO treshold = 32 */
+#define UART_FCR_HSU_64_56B     0xc0    /* receive FIFO treshold = 56 */
+#define UART_FCR_HSU_16_1B      0x00    /* receive FIFO treshold = 1 */
+#define UART_FCR_HSU_16_4B      0x40    /* receive FIFO treshold = 4 */
+#define UART_FCR_HSU_16_8B      0x80    /* receive FIFO treshold = 8 */
+#define UART_FCR_HSU_16_14B     0xc0    /* receive FIFO treshold = 14 */
+#define UART_FCR_HSU_64B_FIFO   0x20    /* chose 64 bytes FIFO */
+#define UART_FCR_HSU_16B_FIFO   0x00    /* chose 16 bytes FIFO */
+#define UART_FCR_HALF_EMPT_TXI  0x00    /* trigger TX_EMPT IRQ for half empty */
+#define UART_FCR_FULL_EMPT_TXI  0x08    /* trigger TX_EMPT IRQ for full empty */
 /*
 * These register definitions are for the 16C950
diff --git a/include/linux/shmem_fs.h b/include/linux/shmem_fs.h
index e164291fb3e7..399be5ad2f99 100644
--- a/include/linux/shmem_fs.h
+++ b/include/linux/shmem_fs.h
@@ -3,6 +3,7 @@
 #include <linux/swap.h>
 #include <linux/mempolicy.h>
+#include <linux/percpu_counter.h>
 /* inode in-kernel data */
@@ -23,7 +24,7 @@ struct shmem_inode_info {
 struct shmem_sb_info {
        unsigned long max_blocks;   /* How many blocks are allowed */
-        unsigned long free_blocks;  /* How many are left for allocation */
+        struct percpu_counter used_blocks;  /* How many are allocated */
        unsigned long max_inodes;   /* How many inodes are allowed */
        unsigned long free_inodes;  /* How many are left for allocation */
        spinlock_t stat_lock;       /* Serialize shmem_sb_info changes */
diff --git a/include/linux/skbuff.h b/include/linux/skbuff.h
index d20d9e7a9bbd..77eb60d2b496 100644
--- a/include/linux/skbuff.h
+++ b/include/linux/skbuff.h
@@ -1379,6 +1379,11 @@ static inline int skb_network_offset(const struct sk_buff *skb)
        return skb_network_header(skb) - skb->data;
 }
+static inline int pskb_network_may_pull(struct sk_buff *skb, unsigned int len)
+{
+        return pskb_may_pull(skb, skb_network_offset(skb) + len);
+}
 /*
 * CPUs often take a performance hit when accessing unaligned memory
 * locations. The actual performance hit varies, it can be small if the
diff --git a/include/linux/statfs.h b/include/linux/statfs.h
index b34cc829f98d..0166d320a75d 100644
--- a/include/linux/statfs.h
+++ b/include/linux/statfs.h
@@ -2,7 +2,6 @@
 #define _LINUX_STATFS_H
 #include <linux/types.h>
 #include <asm/statfs.h>
 struct kstatfs {
@@ -16,7 +15,29 @@ struct kstatfs {
        __kernel_fsid_t f_fsid;
        long f_namelen;
        long f_frsize;
-        long f_spare[5];
+        long f_flags;
+        long f_spare[4];
 };
+/*
+ * Definitions for the flag in f_flag.
+ *
+ * Generally these flags are equivalent to the MS_ flags used in the mount
+ * ABI.  The exception is ST_VALID which has the same value as MS_REMOUNT
+ * which doesn't make any sense for statfs.
+ */
+#define ST_RDONLY       0x0001  /* mount read-only */
+#define ST_NOSUID       0x0002  /* ignore suid and sgid bits */
+#define ST_NODEV        0x0004  /* disallow access to device special files */
+#define ST_NOEXEC       0x0008  /* disallow program execution */
+#define ST_SYNCHRONOUS  0x0010  /* writes are synced at once */
+#define ST_VALID        0x0020  /* f_flags support is implemented */
+#define ST_MANDLOCK     0x0040  /* allow mandatory locks on an FS */
+/* 0x0080 used for ST_WRITE in glibc */
+/* 0x0100 used for ST_APPEND in glibc */
+/* 0x0200 used for ST_IMMUTABLE in glibc */
+#define ST_NOATIME      0x0400  /* do not update access times */
+#define ST_NODIRATIME   0x0800  /* do not update directory access times */
+#define ST_RELATIME     0x1000  /* update atime relative to mtime/ctime */
 #endif
diff --git a/include/linux/swap.h b/include/linux/swap.h
index ff4acea9bbdb..91c9d3fc8513 100644
--- a/include/linux/swap.h
+++ b/include/linux/swap.h
@@ -316,7 +316,6 @@ extern long nr_swap_pages;
 extern long total_swap_pages;
 extern void si_swapinfo(struct sysinfo *);
 extern swp_entry_t get_swap_page(void);
-extern swp_entry_t get_swap_page_of_type(int);
 extern int valid_swaphandles(swp_entry_t, unsigned long *);
 extern int add_swap_count_continuation(swp_entry_t, gfp_t);
 extern void swap_shmem_alloc(swp_entry_t);
@@ -333,6 +332,13 @@ extern int reuse_swap_page(struct page *);
 extern int try_to_free_swap(struct page *);
 struct backing_dev_info;
+#ifdef CONFIG_HIBERNATION
+void hibernation_freeze_swap(void);
+void hibernation_thaw_swap(void);
+swp_entry_t get_swap_for_hibernation(int type);
+void swap_free_for_hibernation(swp_entry_t val);
+#endif
 /* linux/mm/thrash.c */
 extern struct mm_struct *swap_token_mm;
 extern void grab_swap_token(struct mm_struct *);
diff --git a/include/linux/syscalls.h b/include/linux/syscalls.h
index a6bfd1367d2a..1b67bd333b5e 100644
--- a/include/linux/syscalls.h
+++ b/include/linux/syscalls.h
@@ -35,6 +35,7 @@ struct oldold_utsname;
 struct old_utsname;
 struct pollfd;
 struct rlimit;
+struct rlimit64;
 struct rusage;
 struct sched_param;
 struct sel_arg_struct;
@@ -644,6 +645,9 @@ asmlinkage long sys_old_getrlimit(unsigned int resource, struct rlimit __user *r
 #endif
 asmlinkage long sys_setrlimit(unsigned int resource,
                                struct rlimit __user *rlim);
+asmlinkage long sys_prlimit64(pid_t pid, unsigned int resource,
+                                const struct rlimit64 __user *new_rlim,
+                                struct rlimit64 __user *old_rlim);
 asmlinkage long sys_getrusage(int who, struct rusage __user *ru);
 asmlinkage long sys_umask(int mask);
@@ -811,6 +815,10 @@ asmlinkage long sys_pselect6(int, fd_set __user *, fd_set __user *,
 asmlinkage long sys_ppoll(struct pollfd __user *, unsigned int,
                          struct timespec __user *, const sigset_t __user *,
                          size_t);
+asmlinkage long sys_fanotify_init(unsigned int flags, unsigned int event_f_flags);
+asmlinkage long sys_fanotify_mark(int fanotify_fd, unsigned int flags,
+                                  u64 mask, int fd,
+                                  const char  __user *pathname);
 int kernel_execve(const char *filename, char *const argv[], char *const envp[]);
diff --git a/include/linux/topology.h b/include/linux/topology.h
index b572e432d2f3..64e084ff5e5c 100644
--- a/include/linux/topology.h
+++ b/include/linux/topology.h
@@ -292,10 +292,6 @@ static inline void set_cpu_numa_mem(int cpu, int node)
 #else   /* !CONFIG_HAVE_MEMORYLESS_NODES */
-static inline void set_numa_mem(int node) {}
-static inline void set_cpu_numa_mem(int cpu, int node) {}
 #ifndef numa_mem_id
 /* Returns the number of the nearest Node with memory */
 static inline int numa_mem_id(void)
diff --git a/include/linux/tty.h b/include/linux/tty.h
index 7802a243ee13..1437da3ddc62 100644
--- a/include/linux/tty.h
+++ b/include/linux/tty.h
@@ -13,6 +13,7 @@
 #include <linux/tty_driver.h>
 #include <linux/tty_ldisc.h>
 #include <linux/mutex.h>
+#include <linux/smp_lock.h>
 #include <asm/system.h>
@@ -179,6 +180,7 @@ struct tty_bufhead {
 #define L_FLUSHO(tty)   _L_FLAG((tty), FLUSHO)
 #define L_PENDIN(tty)   _L_FLAG((tty), PENDIN)
 #define L_IEXTEN(tty)   _L_FLAG((tty), IEXTEN)
+#define L_EXTPROC(tty)  _L_FLAG((tty), EXTPROC)
 struct device;
 struct signal_struct;
@@ -415,6 +417,7 @@ extern int is_ignored(int sig);
 extern int tty_signal(int sig, struct tty_struct *tty);
 extern void tty_hangup(struct tty_struct *tty);
 extern void tty_vhangup(struct tty_struct *tty);
+extern void tty_vhangup_locked(struct tty_struct *tty);
 extern void tty_vhangup_self(void);
 extern void tty_unhangup(struct file *filp);
 extern int tty_hung_up_p(struct file *filp);
@@ -575,5 +578,54 @@ extern int vt_ioctl(struct tty_struct *tty, struct file *file,
 extern long vt_compat_ioctl(struct tty_struct *tty, struct file * file,
                     unsigned int cmd, unsigned long arg);
+/* tty_mutex.c */
+/* functions for preparation of BKL removal */
+extern void __lockfunc tty_lock(void) __acquires(tty_lock);
+extern void __lockfunc tty_unlock(void) __releases(tty_lock);
+extern struct task_struct *__big_tty_mutex_owner;
+#define tty_locked()            (current == __big_tty_mutex_owner)
+/*
+ * wait_event_interruptible_tty -- wait for a condition with the tty lock held
+ *
+ * The condition we are waiting for might take a long time to
+ * become true, or might depend on another thread taking the
+ * BTM. In either case, we need to drop the BTM to guarantee
+ * forward progress. This is a leftover from the conversion
+ * from the BKL and should eventually get removed as the BTM
+ * falls out of use.
+ *
+ * Do not use in new code.
+ */
+#define wait_event_interruptible_tty(wq, condition)                     \
+({                                                                      \
+        int __ret = 0;                                                  \
+        if (!(condition)) {                                             \
+                __wait_event_interruptible_tty(wq, condition, __ret);   \
+        }                                                               \
+        __ret;                                                          \
+})
+#define __wait_event_interruptible_tty(wq, condition, ret)              \
+do {                                                                    \
+        DEFINE_WAIT(__wait);                                            \
+                                                                        \
+        for (;;) {                                                      \
+                prepare_to_wait(&wq, &__wait, TASK_INTERRUPTIBLE);      \
+                if (condition)                                          \
+                        break;                                          \
+                if (!signal_pending(current)) {                         \
+                        tty_unlock();                                   \
+                        schedule();                                     \
+                        tty_lock();                                     \
+                        continue;                                       \
+                }                                                       \
+                ret = -ERESTARTSYS;                                     \
+                break;                                                  \
+        }                                                               \
+        finish_wait(&wq, &__wait);                                      \
+} while (0)
 #endif /* __KERNEL__ */
 #endif
diff --git a/include/linux/types.h b/include/linux/types.h
index 331d8baabcf2..01a082f56ef4 100644
--- a/include/linux/types.h
+++ b/include/linux/types.h
@@ -200,6 +200,18 @@ typedef struct {
 } atomic64_t;
 #endif
+struct list_head {
+        struct list_head *next, *prev;
+};
+struct hlist_head {
+        struct hlist_node *first;
+};
+struct hlist_node {
+        struct hlist_node *next, **pprev;
+};
 struct ustat {
        __kernel_daddr_t        f_tfree;
        __kernel_ino_t          f_tinode;
diff --git a/include/linux/usb.h b/include/linux/usb.h
index d5922a877994..35fe6ab222bb 100644
--- a/include/linux/usb.h
+++ b/include/linux/usb.h
@@ -127,6 +127,8 @@ enum usb_interface_condition {
 *      queued reset so that usb_cancel_queued_reset() doesn't try to
 *      remove from the workqueue when running inside the worker
 *      thread. See __usb_queue_reset_device().
+ * @resetting_device: USB core reset the device, so use alt setting 0 as
+ *      current; needs bandwidth alloc after reset.
 *
 * USB device drivers attach to interfaces on a physical device.  Each
 * interface encapsulates a single high level function, such as feeding
@@ -843,7 +845,7 @@ struct usb_driver {
        void (*disconnect) (struct usb_interface *intf);
-        int (*ioctl) (struct usb_interface *intf, unsigned int code,
+        int (*unlocked_ioctl) (struct usb_interface *intf, unsigned int code,
                        void *buf);
        int (*suspend) (struct usb_interface *intf, pm_message_t message);
@@ -1015,6 +1017,7 @@ typedef void (*usb_complete_t)(struct urb *);
 *      is a different endpoint (and pipe) from "out" endpoint two.
 *      The current configuration controls the existence, type, and
 *      maximum packet size of any given endpoint.
+ * @stream_id: the endpoint's stream ID for bulk streams
 * @dev: Identifies the USB device to perform the request.
 * @status: This is read in non-iso completion functions to get the
 *      status of the particular request.  ISO requests only use it
diff --git a/include/linux/usb/composite.h b/include/linux/usb/composite.h
index 139353efad34..890bc1472190 100644
--- a/include/linux/usb/composite.h
+++ b/include/linux/usb/composite.h
@@ -276,6 +276,8 @@ struct usb_composite_driver {
        int                     (*bind)(struct usb_composite_dev *);
        int                     (*unbind)(struct usb_composite_dev *);
+        void                    (*disconnect)(struct usb_composite_dev *);
        /* global suspend hooks */
        void                    (*suspend)(struct usb_composite_dev *);
        void                    (*resume)(struct usb_composite_dev *);
@@ -342,6 +344,10 @@ struct usb_composite_dev {
 };
 extern int usb_string_id(struct usb_composite_dev *c);
+extern int usb_string_ids_tab(struct usb_composite_dev *c,
+                              struct usb_string *str);
+extern int usb_string_ids_n(struct usb_composite_dev *c, unsigned n);
 /* messaging utils */
 #define DBG(d, fmt, args...) \
diff --git a/include/linux/usb/ehci_def.h b/include/linux/usb/ehci_def.h
index 80287af2a738..2e262cb15425 100644
--- a/include/linux/usb/ehci_def.h
+++ b/include/linux/usb/ehci_def.h
@@ -39,6 +39,12 @@ struct ehci_caps {
 #define HCS_N_PORTS(p)          (((p)>>0)&0xf)  /* bits 3:0, ports on HC */
        u32             hcc_params;      /* HCCPARAMS - offset 0x8 */
+/* EHCI 1.1 addendum */
+#define HCC_32FRAME_PERIODIC_LIST(p)    ((p)&(1 << 19))
+#define HCC_PER_PORT_CHANGE_EVENT(p)    ((p)&(1 << 18))
+#define HCC_LPM(p)                      ((p)&(1 << 17))
+#define HCC_HW_PREFETCH(p)              ((p)&(1 << 16))
 #define HCC_EXT_CAPS(p)         (((p)>>8)&0xff) /* for pci extended caps */
 #define HCC_ISOC_CACHE(p)       ((p)&(1 << 7))  /* true: can cache isoc frame */
 #define HCC_ISOC_THRES(p)       (((p)>>4)&0x7)  /* bits 6:4, uframes cached */
@@ -54,6 +60,13 @@ struct ehci_regs {
        /* USBCMD: offset 0x00 */
        u32             command;
+/* EHCI 1.1 addendum */
+#define CMD_HIRD        (0xf<<24)       /* host initiated resume duration */
+#define CMD_PPCEE       (1<<15)         /* per port change event enable */
+#define CMD_FSP         (1<<14)         /* fully synchronized prefetch */
+#define CMD_ASPE        (1<<13)         /* async schedule prefetch enable */
+#define CMD_PSPE        (1<<12)         /* periodic schedule prefetch enable */
 /* 23:16 is r/w intr rate, in microframes; default "8" == 1/msec */
 #define CMD_PARK        (1<<11)         /* enable "park" on async qh */
 #define CMD_PARK_CNT(c) (((c)>>8)&3)    /* how many transfers to park for */
@@ -67,6 +80,7 @@ struct ehci_regs {
        /* USBSTS: offset 0x04 */
        u32             status;
+#define STS_PPCE_MASK   (0xff<<16)      /* Per-Port change event 1-16 */
 #define STS_ASS         (1<<15)         /* Async Schedule Status */
 #define STS_PSS         (1<<14)         /* Periodic Schedule Status */
 #define STS_RECL        (1<<13)         /* Reclamation */
@@ -100,6 +114,14 @@ struct ehci_regs {
        /* PORTSC: offset 0x44 */
        u32             port_status[0]; /* up to N_PORTS */
+/* EHCI 1.1 addendum */
+#define PORTSC_SUSPEND_STS_ACK 0
+#define PORTSC_SUSPEND_STS_NYET 1
+#define PORTSC_SUSPEND_STS_STALL 2
+#define PORTSC_SUSPEND_STS_ERR 3
+#define PORT_DEV_ADDR   (0x7f<<25)              /* device address */
+#define PORT_SSTS       (0x3<<23)               /* suspend status */
 /* 31:23 reserved */
 #define PORT_WKOC_E     (1<<22)         /* wake on overcurrent (enable) */
 #define PORT_WKDISC_E   (1<<21)         /* wake on disconnect (enable) */
@@ -115,6 +137,7 @@ struct ehci_regs {
 #define PORT_USB11(x) (((x)&(3<<10)) == (1<<10))        /* USB 1.1 device */
 /* 11:10 for detecting lowspeed devices (reset vs release ownership) */
 /* 9 reserved */
+#define PORT_LPM        (1<<9)          /* LPM transaction */
 #define PORT_RESET      (1<<8)          /* reset port */
 #define PORT_SUSPEND    (1<<7)          /* suspend port */
 #define PORT_RESUME     (1<<6)          /* resume it */
diff --git a/include/linux/usb/functionfs.h b/include/linux/usb/functionfs.h
index a34a2a043b21..6f649c13193b 100644
--- a/include/linux/usb/functionfs.h
+++ b/include/linux/usb/functionfs.h
@@ -180,9 +180,9 @@ static int functionfs_bind(struct ffs_data *ffs, struct usb_composite_dev *cdev)
 static void functionfs_unbind(struct ffs_data *ffs)
        __attribute__((nonnull));
-static int functionfs_add(struct usb_composite_dev *cdev,
+static int functionfs_bind_config(struct usb_composite_dev *cdev,
-                          struct usb_configuration *c,
+                                  struct usb_configuration *c,
-                          struct ffs_data *ffs)
+                                  struct ffs_data *ffs)
        __attribute__((warn_unused_result, nonnull));
diff --git a/include/linux/usb/hcd.h b/include/linux/usb/hcd.h
index 2e3a4ea1a3da..3b571f1ffbb3 100644
--- a/include/linux/usb/hcd.h
+++ b/include/linux/usb/hcd.h
@@ -89,18 +89,33 @@ struct usb_hcd {
         */
        const struct hc_driver  *driver;        /* hw-specific hooks */
-        /* Flags that need to be manipulated atomically */
+        /* Flags that need to be manipulated atomically because they can
+         * change while the host controller is running.  Always use
+         * set_bit() or clear_bit() to change their values.
+         */
        unsigned long           flags;
-#define HCD_FLAG_HW_ACCESSIBLE  0x00000001
+#define HCD_FLAG_HW_ACCESSIBLE          0       /* at full power */
-#define HCD_FLAG_SAW_IRQ        0x00000002
+#define HCD_FLAG_SAW_IRQ                1
+#define HCD_FLAG_POLL_RH                2       /* poll for rh status? */
+#define HCD_FLAG_POLL_PENDING           3       /* status has changed? */
+#define HCD_FLAG_WAKEUP_PENDING         4       /* root hub is resuming? */
+        /* The flags can be tested using these macros; they are likely to
+         * be slightly faster than test_bit().
+         */
+#define HCD_HW_ACCESSIBLE(hcd)  ((hcd)->flags & (1U << HCD_FLAG_HW_ACCESSIBLE))
+#define HCD_SAW_IRQ(hcd)        ((hcd)->flags & (1U << HCD_FLAG_SAW_IRQ))
+#define HCD_POLL_RH(hcd)        ((hcd)->flags & (1U << HCD_FLAG_POLL_RH))
+#define HCD_POLL_PENDING(hcd)   ((hcd)->flags & (1U << HCD_FLAG_POLL_PENDING))
+#define HCD_WAKEUP_PENDING(hcd) ((hcd)->flags & (1U << HCD_FLAG_WAKEUP_PENDING))
+        /* Flags that get set only during HCD registration or removal. */
        unsigned                rh_registered:1;/* is root hub registered? */
+        unsigned                rh_pollable:1;  /* may we poll the root hub? */
        /* The next flag is a stopgap, to be removed when all the HCDs
         * support the new root-hub polling mechanism. */
        unsigned                uses_new_polling:1;
-        unsigned                poll_rh:1;      /* poll for rh status? */
-        unsigned                poll_pending:1; /* status has changed? */
        unsigned                wireless:1;     /* Wireless USB HCD */
        unsigned                authorized_default:1;
        unsigned                has_tt:1;       /* Integrated TT in root hub */
@@ -198,7 +213,7 @@ struct hc_driver {
         * a whole, not just the root hub; they're for PCI bus glue.
         */
        /* called after suspending the hub, before entering D3 etc */
-        int     (*pci_suspend)(struct usb_hcd *hcd);
+        int     (*pci_suspend)(struct usb_hcd *hcd, bool do_wakeup);
        /* called after entering D0 (etc), before resuming the hub */
        int     (*pci_resume)(struct usb_hcd *hcd, bool hibernated);
@@ -299,6 +314,10 @@ struct hc_driver {
        int     (*update_hub_device)(struct usb_hcd *, struct usb_device *hdev,
                        struct usb_tt *tt, gfp_t mem_flags);
        int     (*reset_device)(struct usb_hcd *, struct usb_device *);
+                /* Notifies the HCD after a device is connected and its
+                 * address is set
+                 */
+        int     (*update_device)(struct usb_hcd *, struct usb_device *);
 };
 extern int usb_hcd_link_urb_to_ep(struct usb_hcd *hcd, struct urb *urb);
diff --git a/include/linux/usb/otg.h b/include/linux/usb/otg.h
index f8302d036a76..545cba73ccaf 100644
--- a/include/linux/usb/otg.h
+++ b/include/linux/usb/otg.h
@@ -43,13 +43,6 @@ enum usb_xceiv_events {
        USB_EVENT_ENUMERATED,   /* gadget driver enumerated */
 };
-#define USB_OTG_PULLUP_ID               (1 << 0)
-#define USB_OTG_PULLDOWN_DP             (1 << 1)
-#define USB_OTG_PULLDOWN_DM             (1 << 2)
-#define USB_OTG_EXT_VBUS_INDICATOR      (1 << 3)
-#define USB_OTG_DRV_VBUS                (1 << 4)
-#define USB_OTG_DRV_VBUS_EXT            (1 << 5)
 struct otg_transceiver;
 /* for transceivers connected thru an ULPI interface, the user must
@@ -146,10 +139,10 @@ static inline int otg_io_read(struct otg_transceiver *otg, u32 reg)
        return -EINVAL;
 }
-static inline int otg_io_write(struct otg_transceiver *otg, u32 reg, u32 val)
+static inline int otg_io_write(struct otg_transceiver *otg, u32 val, u32 reg)
 {
        if (otg->io_ops && otg->io_ops->write)
-                return otg->io_ops->write(otg, reg, val);
+                return otg->io_ops->write(otg, val, reg);
        return -EINVAL;
 }
diff --git a/include/linux/usb/quirks.h b/include/linux/usb/quirks.h
index 16b7f3347545..3e93de7ecbc3 100644
--- a/include/linux/usb/quirks.h
+++ b/include/linux/usb/quirks.h
@@ -26,4 +26,8 @@
   and can't handle talking to these interfaces */
 #define USB_QUIRK_HONOR_BNUMINTERFACES  0x00000020
+/* device needs a pause during initialization, after we read the device
+   descriptor */
+#define USB_QUIRK_DELAY_INIT            0x00000040
 #endif /* __LINUX_USB_QUIRKS_H */
diff --git a/include/linux/usb/ulpi.h b/include/linux/usb/ulpi.h
index 2369d07c3c87..82b1507f4735 100644
--- a/include/linux/usb/ulpi.h
+++ b/include/linux/usb/ulpi.h
@@ -11,6 +11,42 @@
 #ifndef __LINUX_USB_ULPI_H
 #define __LINUX_USB_ULPI_H
+#include <linux/usb/otg.h>
+/*-------------------------------------------------------------------------*/
+/*
+ * ULPI Flags
+ */
+#define ULPI_OTG_ID_PULLUP              (1 << 0)
+#define ULPI_OTG_DP_PULLDOWN_DIS        (1 << 1)
+#define ULPI_OTG_DM_PULLDOWN_DIS        (1 << 2)
+#define ULPI_OTG_DISCHRGVBUS            (1 << 3)
+#define ULPI_OTG_CHRGVBUS               (1 << 4)
+#define ULPI_OTG_DRVVBUS                (1 << 5)
+#define ULPI_OTG_DRVVBUS_EXT            (1 << 6)
+#define ULPI_OTG_EXTVBUSIND             (1 << 7)
+#define ULPI_IC_6PIN_SERIAL             (1 << 8)
+#define ULPI_IC_3PIN_SERIAL             (1 << 9)
+#define ULPI_IC_CARKIT                  (1 << 10)
+#define ULPI_IC_CLKSUSPM                (1 << 11)
+#define ULPI_IC_AUTORESUME              (1 << 12)
+#define ULPI_IC_EXTVBUS_INDINV          (1 << 13)
+#define ULPI_IC_IND_PASSTHRU            (1 << 14)
+#define ULPI_IC_PROTECT_DIS             (1 << 15)
+#define ULPI_FC_HS                      (1 << 16)
+#define ULPI_FC_FS                      (1 << 17)
+#define ULPI_FC_LS                      (1 << 18)
+#define ULPI_FC_FS4LS                   (1 << 19)
+#define ULPI_FC_TERMSEL                 (1 << 20)
+#define ULPI_FC_OP_NORM                 (1 << 21)
+#define ULPI_FC_OP_NODRV                (1 << 22)
+#define ULPI_FC_OP_DIS_NRZI             (1 << 23)
+#define ULPI_FC_OP_NSYNC_NEOP           (1 << 24)
+#define ULPI_FC_RST                     (1 << 25)
+#define ULPI_FC_SUSPM                   (1 << 26)
 /*-------------------------------------------------------------------------*/
 /*
@@ -58,6 +94,10 @@
 /*-------------------------------------------------------------------------*/
+/*
+ * Register Bits
+ */
 /* Function Control */
 #define ULPI_FUNC_CTRL_XCVRSEL                  (1 << 0)
 #define  ULPI_FUNC_CTRL_XCVRSEL_MASK            (3 << 0)
diff --git a/include/linux/vt_kern.h b/include/linux/vt_kern.h
index 7f56db4a79f0..6625cc1ab758 100644
--- a/include/linux/vt_kern.h
+++ b/include/linux/vt_kern.h
@@ -76,17 +76,52 @@ int con_copy_unimap(struct vc_data *dst_vc, struct vc_data *src_vc);
 #define vc_translate(vc, c) ((vc)->vc_translate[(c) |                   \
                                        ((vc)->vc_toggle_meta ? 0x80 : 0)])
 #else
-#define con_set_trans_old(arg) (0)
+static inline int con_set_trans_old(unsigned char __user *table)
-#define con_get_trans_old(arg) (-EINVAL)
+{
-#define con_set_trans_new(arg) (0)
+        return 0;
-#define con_get_trans_new(arg) (-EINVAL)
+}
-#define con_clear_unimap(vc, ui) (0)
+static inline int con_get_trans_old(unsigned char __user *table)
-#define con_set_unimap(vc, ct, list) (0)
+{
-#define con_set_default_unimap(vc) (0)
+        return -EINVAL;
-#define con_copy_unimap(d, s) (0)
+}
-#define con_get_unimap(vc, ct, uct, list) (-EINVAL)
+static inline int con_set_trans_new(unsigned short __user *table)
-#define con_free_unimap(vc) do { ; } while (0)
+{
-#define con_protect_unimap(vc, rdonly) do { ; } while (0)
+        return 0;
+}
+static inline int con_get_trans_new(unsigned short __user *table)
+{
+        return -EINVAL;
+}
+static inline int con_clear_unimap(struct vc_data *vc, struct unimapinit *ui)
+{
+        return 0;
+}
+static inline
+int con_set_unimap(struct vc_data *vc, ushort ct, struct unipair __user *list)
+{
+        return 0;
+}
+static inline
+int con_get_unimap(struct vc_data *vc, ushort ct, ushort __user *uct,
+                   struct unipair __user *list)
+{
+        return -EINVAL;
+}
+static inline int con_set_default_unimap(struct vc_data *vc)
+{
+        return 0;
+}
+static inline void con_free_unimap(struct vc_data *vc)
+{
+}
+static inline void con_protect_unimap(struct vc_data *vc, int rdonly)
+{
+}
+static inline
+int con_copy_unimap(struct vc_data *dst_vc, struct vc_data *src_vc)
+{
+        return 0;
+}
 #define vc_translate(vc, c) (c)
 #endif
@@ -100,6 +135,13 @@ extern int unbind_con_driver(const struct consw *csw, int first, int last,
                             int deflt);
 int vty_init(const struct file_operations *console_fops);
+static inline bool vt_force_oops_output(struct vc_data *vc)
+{
+        if (oops_in_progress && vc->vc_panic_force_write)
+                return true;
+        return false;
+}
 /*
 * vc_screen.c shares this temporary buffer with the console write code so that
 * we can easily avoid touching user space while holding the console spinlock.
diff --git a/include/mtd/mtd-abi.h b/include/mtd/mtd-abi.h
index be51ae2bd0ff..4debb4514634 100644
--- a/include/mtd/mtd-abi.h
+++ b/include/mtd/mtd-abi.h
@@ -1,5 +1,20 @@
 /*
- * Portions of MTD ABI definition which are shared by kernel and user space
+ * Copyright © 1999-2010 David Woodhouse <dwmw2@infradead.org> et al.
+ *
+ * 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
+ *
 */
 #ifndef __MTD_ABI_H__
@@ -110,6 +125,7 @@ struct otp_info {
 #define MEMERASE64              _IOW('M', 20, struct erase_info_user64)
 #define MEMWRITEOOB64           _IOWR('M', 21, struct mtd_oob_buf64)
 #define MEMREADOOB64            _IOWR('M', 22, struct mtd_oob_buf64)
+#define MEMISLOCKED             _IOR('M', 23, struct erase_info_user)
 /*
 * Obsolete legacy interface. Keep it in order not to break userspace
diff --git a/include/mtd/mtd-user.h b/include/mtd/mtd-user.h
index 170ceca3b2d0..aa3c2f86a913 100644
--- a/include/mtd/mtd-user.h
+++ b/include/mtd/mtd-user.h
@@ -1,5 +1,20 @@
 /*
- * MTD ABI header for use by user space only.
+ * Copyright © 1999-2010 David Woodhouse <dwmw2@infradead.org>
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; either version 2 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
+ *
 */
 #ifndef __MTD_USER_H__
diff --git a/include/mtd/nftl-user.h b/include/mtd/nftl-user.h
index 98e9e57f22de..bdeabd86ad99 100644
--- a/include/mtd/nftl-user.h
+++ b/include/mtd/nftl-user.h
@@ -1,5 +1,19 @@
 /*
- * Parts of NFTL headers shared with userspace
+ * Copyright © 1999-2010 David Woodhouse <dwmw2@infradead.org>
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; either version 2 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
 *
 */
diff --git a/include/mtd/ubi-user.h b/include/mtd/ubi-user.h
index 466a8320f1e6..c0d47ad4b103 100644
--- a/include/mtd/ubi-user.h
+++ b/include/mtd/ubi-user.h
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) International Business Machines Corp., 2006
+ * Copyright © International Business Machines Corp., 2006
 *
 * 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
diff --git a/include/net/bluetooth/hci_core.h b/include/net/bluetooth/hci_core.h
index 8b28962e737e..4568b938ca35 100644
--- a/include/net/bluetooth/hci_core.h
+++ b/include/net/bluetooth/hci_core.h
@@ -132,7 +132,7 @@ struct hci_dev {
        struct inquiry_cache    inq_cache;
        struct hci_conn_hash    conn_hash;
-        struct bdaddr_list      blacklist;
+        struct list_head        blacklist;
        struct hci_dev_stats    stat;
diff --git a/include/trace/events/gfpflags.h b/include/trace/events/gfpflags.h
new file mode 100644
index 000000000000..e3615c093741
--- /dev/null
+++ b/include/trace/events/gfpflags.h
@@ -0,0 +1,37 @@
+/*
+ * The order of these masks is important. Matching masks will be seen
+ * first and the left over flags will end up showing by themselves.
+ *
+ * For example, if we have GFP_KERNEL before GFP_USER we wil get:
+ *
+ *  GFP_KERNEL|GFP_HARDWALL
+ *
+ * Thus most bits set go first.
+ */
+#define show_gfp_flags(flags)                                           \
+        (flags) ? __print_flags(flags, "|",                             \
+        {(unsigned long)GFP_HIGHUSER_MOVABLE,   "GFP_HIGHUSER_MOVABLE"}, \
+        {(unsigned long)GFP_HIGHUSER,           "GFP_HIGHUSER"},        \
+        {(unsigned long)GFP_USER,               "GFP_USER"},            \
+        {(unsigned long)GFP_TEMPORARY,          "GFP_TEMPORARY"},       \
+        {(unsigned long)GFP_KERNEL,             "GFP_KERNEL"},          \
+        {(unsigned long)GFP_NOFS,               "GFP_NOFS"},            \
+        {(unsigned long)GFP_ATOMIC,             "GFP_ATOMIC"},          \
+        {(unsigned long)GFP_NOIO,               "GFP_NOIO"},            \
+        {(unsigned long)__GFP_HIGH,             "GFP_HIGH"},            \
+        {(unsigned long)__GFP_WAIT,             "GFP_WAIT"},            \
+        {(unsigned long)__GFP_IO,               "GFP_IO"},              \
+        {(unsigned long)__GFP_COLD,             "GFP_COLD"},            \
+        {(unsigned long)__GFP_NOWARN,           "GFP_NOWARN"},          \
+        {(unsigned long)__GFP_REPEAT,           "GFP_REPEAT"},          \
+        {(unsigned long)__GFP_NOFAIL,           "GFP_NOFAIL"},          \
+        {(unsigned long)__GFP_NORETRY,          "GFP_NORETRY"},         \
+        {(unsigned long)__GFP_COMP,             "GFP_COMP"},            \
+        {(unsigned long)__GFP_ZERO,             "GFP_ZERO"},            \
+        {(unsigned long)__GFP_NOMEMALLOC,       "GFP_NOMEMALLOC"},      \
+        {(unsigned long)__GFP_HARDWALL,         "GFP_HARDWALL"},        \
+        {(unsigned long)__GFP_THISNODE,         "GFP_THISNODE"},        \
+        {(unsigned long)__GFP_RECLAIMABLE,      "GFP_RECLAIMABLE"},     \
+        {(unsigned long)__GFP_MOVABLE,          "GFP_MOVABLE"}          \
+        ) : "GFP_NOWAIT"
diff --git a/include/trace/events/kmem.h b/include/trace/events/kmem.h
index 3adca0ca9dbe..a9c87ad8331c 100644
--- a/include/trace/events/kmem.h
+++ b/include/trace/events/kmem.h
@@ -6,43 +6,7 @@
 #include <linux/types.h>
 #include <linux/tracepoint.h>
+#include "gfpflags.h"
-/*
- * The order of these masks is important. Matching masks will be seen
- * first and the left over flags will end up showing by themselves.
- *
- * For example, if we have GFP_KERNEL before GFP_USER we wil get:
- *
- *  GFP_KERNEL|GFP_HARDWALL
- *
- * Thus most bits set go first.
- */
-#define show_gfp_flags(flags)                                           \
-        (flags) ? __print_flags(flags, "|",                             \
-        {(unsigned long)GFP_HIGHUSER_MOVABLE,   "GFP_HIGHUSER_MOVABLE"}, \
-        {(unsigned long)GFP_HIGHUSER,           "GFP_HIGHUSER"},        \
-        {(unsigned long)GFP_USER,               "GFP_USER"},            \
-        {(unsigned long)GFP_TEMPORARY,          "GFP_TEMPORARY"},       \
-        {(unsigned long)GFP_KERNEL,             "GFP_KERNEL"},          \
-        {(unsigned long)GFP_NOFS,               "GFP_NOFS"},            \
-        {(unsigned long)GFP_ATOMIC,             "GFP_ATOMIC"},          \
-        {(unsigned long)GFP_NOIO,               "GFP_NOIO"},            \
-        {(unsigned long)__GFP_HIGH,             "GFP_HIGH"},            \
-        {(unsigned long)__GFP_WAIT,             "GFP_WAIT"},            \
-        {(unsigned long)__GFP_IO,               "GFP_IO"},              \
-        {(unsigned long)__GFP_COLD,             "GFP_COLD"},            \
-        {(unsigned long)__GFP_NOWARN,           "GFP_NOWARN"},          \
-        {(unsigned long)__GFP_REPEAT,           "GFP_REPEAT"},          \
-        {(unsigned long)__GFP_NOFAIL,           "GFP_NOFAIL"},          \
-        {(unsigned long)__GFP_NORETRY,          "GFP_NORETRY"},         \
-        {(unsigned long)__GFP_COMP,             "GFP_COMP"},            \
-        {(unsigned long)__GFP_ZERO,             "GFP_ZERO"},            \
-        {(unsigned long)__GFP_NOMEMALLOC,       "GFP_NOMEMALLOC"},      \
-        {(unsigned long)__GFP_HARDWALL,         "GFP_HARDWALL"},        \
-        {(unsigned long)__GFP_THISNODE,         "GFP_THISNODE"},        \
-        {(unsigned long)__GFP_RECLAIMABLE,      "GFP_RECLAIMABLE"},     \
-        {(unsigned long)__GFP_MOVABLE,          "GFP_MOVABLE"}          \
-        ) : "GFP_NOWAIT"
 DECLARE_EVENT_CLASS(kmem_alloc,
diff --git a/include/trace/events/vmscan.h b/include/trace/events/vmscan.h
new file mode 100644
index 000000000000..370aa5a87322
--- /dev/null
+++ b/include/trace/events/vmscan.h
@@ -0,0 +1,275 @@
+#undef TRACE_SYSTEM
+#define TRACE_SYSTEM vmscan
+#if !defined(_TRACE_VMSCAN_H) || defined(TRACE_HEADER_MULTI_READ)
+#define _TRACE_VMSCAN_H
+#include <linux/types.h>
+#include <linux/tracepoint.h>
+#include "gfpflags.h"
+#define RECLAIM_WB_ANON         0x0001u
+#define RECLAIM_WB_FILE         0x0002u
+#define RECLAIM_WB_SYNC         0x0004u
+#define RECLAIM_WB_ASYNC        0x0008u
+#define show_reclaim_flags(flags)                               \
+        (flags) ? __print_flags(flags, "|",                     \
+                {RECLAIM_WB_ANON,       "RECLAIM_WB_ANON"},     \
+                {RECLAIM_WB_FILE,       "RECLAIM_WB_FILE"},     \
+                {RECLAIM_WB_SYNC,       "RECLAIM_WB_SYNC"},     \
+                {RECLAIM_WB_ASYNC,      "RECLAIM_WB_ASYNC"}     \
+                ) : "RECLAIM_WB_NONE"
+#define trace_reclaim_flags(page, sync) ( \
+        (page_is_file_cache(page) ? RECLAIM_WB_FILE : RECLAIM_WB_ANON) | \
+        (sync == PAGEOUT_IO_SYNC ? RECLAIM_WB_SYNC : RECLAIM_WB_ASYNC)   \
+        )
+TRACE_EVENT(mm_vmscan_kswapd_sleep,
+        TP_PROTO(int nid),
+        TP_ARGS(nid),
+        TP_STRUCT__entry(
+                __field(        int,    nid     )
+        ),
+        TP_fast_assign(
+                __entry->nid    = nid;
+        ),
+        TP_printk("nid=%d", __entry->nid)
+);
+TRACE_EVENT(mm_vmscan_kswapd_wake,
+        TP_PROTO(int nid, int order),
+        TP_ARGS(nid, order),
+        TP_STRUCT__entry(
+                __field(        int,    nid     )
+                __field(        int,    order   )
+        ),
+        TP_fast_assign(
+                __entry->nid    = nid;
+                __entry->order  = order;
+        ),
+        TP_printk("nid=%d order=%d", __entry->nid, __entry->order)
+);
+TRACE_EVENT(mm_vmscan_wakeup_kswapd,
+        TP_PROTO(int nid, int zid, int order),
+        TP_ARGS(nid, zid, order),
+        TP_STRUCT__entry(
+                __field(        int,            nid     )
+                __field(        int,            zid     )
+                __field(        int,            order   )
+        ),
+        TP_fast_assign(
+                __entry->nid            = nid;
+                __entry->zid            = zid;
+                __entry->order          = order;
+        ),
+        TP_printk("nid=%d zid=%d order=%d",
+                __entry->nid,
+                __entry->zid,
+                __entry->order)
+);
+DECLARE_EVENT_CLASS(mm_vmscan_direct_reclaim_begin_template,
+        TP_PROTO(int order, int may_writepage, gfp_t gfp_flags),
+        TP_ARGS(order, may_writepage, gfp_flags),
+        TP_STRUCT__entry(
+                __field(        int,    order           )
+                __field(        int,    may_writepage   )
+                __field(        gfp_t,  gfp_flags       )
+        ),
+        TP_fast_assign(
+                __entry->order          = order;
+                __entry->may_writepage  = may_writepage;
+                __entry->gfp_flags      = gfp_flags;
+        ),
+        TP_printk("order=%d may_writepage=%d gfp_flags=%s",
+                __entry->order,
+                __entry->may_writepage,
+                show_gfp_flags(__entry->gfp_flags))
+);
+DEFINE_EVENT(mm_vmscan_direct_reclaim_begin_template, mm_vmscan_direct_reclaim_begin,
+        TP_PROTO(int order, int may_writepage, gfp_t gfp_flags),
+        TP_ARGS(order, may_writepage, gfp_flags)
+);
+DEFINE_EVENT(mm_vmscan_direct_reclaim_begin_template, mm_vmscan_memcg_reclaim_begin,
+        TP_PROTO(int order, int may_writepage, gfp_t gfp_flags),
+        TP_ARGS(order, may_writepage, gfp_flags)
+);
+DEFINE_EVENT(mm_vmscan_direct_reclaim_begin_template, mm_vmscan_memcg_softlimit_reclaim_begin,
+        TP_PROTO(int order, int may_writepage, gfp_t gfp_flags),
+        TP_ARGS(order, may_writepage, gfp_flags)
+);
+DECLARE_EVENT_CLASS(mm_vmscan_direct_reclaim_end_template,
+        TP_PROTO(unsigned long nr_reclaimed),
+        TP_ARGS(nr_reclaimed),
+        TP_STRUCT__entry(
+                __field(        unsigned long,  nr_reclaimed    )
+        ),
+        TP_fast_assign(
+                __entry->nr_reclaimed   = nr_reclaimed;
+        ),
+        TP_printk("nr_reclaimed=%lu", __entry->nr_reclaimed)
+);
+DEFINE_EVENT(mm_vmscan_direct_reclaim_end_template, mm_vmscan_direct_reclaim_end,
+        TP_PROTO(unsigned long nr_reclaimed),
+        TP_ARGS(nr_reclaimed)
+);
+DEFINE_EVENT(mm_vmscan_direct_reclaim_end_template, mm_vmscan_memcg_reclaim_end,
+        TP_PROTO(unsigned long nr_reclaimed),
+        TP_ARGS(nr_reclaimed)
+);
+DEFINE_EVENT(mm_vmscan_direct_reclaim_end_template, mm_vmscan_memcg_softlimit_reclaim_end,
+        TP_PROTO(unsigned long nr_reclaimed),
+        TP_ARGS(nr_reclaimed)
+);
+DECLARE_EVENT_CLASS(mm_vmscan_lru_isolate_template,
+        TP_PROTO(int order,
+                unsigned long nr_requested,
+                unsigned long nr_scanned,
+                unsigned long nr_taken,
+                unsigned long nr_lumpy_taken,
+                unsigned long nr_lumpy_dirty,
+                unsigned long nr_lumpy_failed,
+                int isolate_mode),
+        TP_ARGS(order, nr_requested, nr_scanned, nr_taken, nr_lumpy_taken, nr_lumpy_dirty, nr_lumpy_failed, isolate_mode),
+        TP_STRUCT__entry(
+                __field(int, order)
+                __field(unsigned long, nr_requested)
+                __field(unsigned long, nr_scanned)
+                __field(unsigned long, nr_taken)
+                __field(unsigned long, nr_lumpy_taken)
+                __field(unsigned long, nr_lumpy_dirty)
+                __field(unsigned long, nr_lumpy_failed)
+                __field(int, isolate_mode)
+        ),
+        TP_fast_assign(
+                __entry->order = order;
+                __entry->nr_requested = nr_requested;
+                __entry->nr_scanned = nr_scanned;
+                __entry->nr_taken = nr_taken;
+                __entry->nr_lumpy_taken = nr_lumpy_taken;
+                __entry->nr_lumpy_dirty = nr_lumpy_dirty;
+                __entry->nr_lumpy_failed = nr_lumpy_failed;
+                __entry->isolate_mode = isolate_mode;
+        ),
+        TP_printk("isolate_mode=%d order=%d nr_requested=%lu nr_scanned=%lu nr_taken=%lu contig_taken=%lu contig_dirty=%lu contig_failed=%lu",
+                __entry->isolate_mode,
+                __entry->order,
+                __entry->nr_requested,
+                __entry->nr_scanned,
+                __entry->nr_taken,
+                __entry->nr_lumpy_taken,
+                __entry->nr_lumpy_dirty,
+                __entry->nr_lumpy_failed)
+);
+DEFINE_EVENT(mm_vmscan_lru_isolate_template, mm_vmscan_lru_isolate,
+        TP_PROTO(int order,
+                unsigned long nr_requested,
+                unsigned long nr_scanned,
+                unsigned long nr_taken,
+                unsigned long nr_lumpy_taken,
+                unsigned long nr_lumpy_dirty,
+                unsigned long nr_lumpy_failed,
+                int isolate_mode),
+        TP_ARGS(order, nr_requested, nr_scanned, nr_taken, nr_lumpy_taken, nr_lumpy_dirty, nr_lumpy_failed, isolate_mode)
+);
+DEFINE_EVENT(mm_vmscan_lru_isolate_template, mm_vmscan_memcg_isolate,
+        TP_PROTO(int order,
+                unsigned long nr_requested,
+                unsigned long nr_scanned,
+                unsigned long nr_taken,
+                unsigned long nr_lumpy_taken,
+                unsigned long nr_lumpy_dirty,
+                unsigned long nr_lumpy_failed,
+                int isolate_mode),
+        TP_ARGS(order, nr_requested, nr_scanned, nr_taken, nr_lumpy_taken, nr_lumpy_dirty, nr_lumpy_failed, isolate_mode)
+);
+TRACE_EVENT(mm_vmscan_writepage,
+        TP_PROTO(struct page *page,
+                int reclaim_flags),
+        TP_ARGS(page, reclaim_flags),
+        TP_STRUCT__entry(
+                __field(struct page *, page)
+                __field(int, reclaim_flags)
+        ),
+        TP_fast_assign(
+                __entry->page = page;
+                __entry->reclaim_flags = reclaim_flags;
+        ),
+        TP_printk("page=%p pfn=%lu flags=%s",
+                __entry->page,
+                page_to_pfn(__entry->page),
+                show_reclaim_flags(__entry->reclaim_flags))
+);
+#endif /* _TRACE_VMSCAN_H */
+/* This part must be outside protection */
+#include <trace/define_trace.h>