112 files changed, 2524 insertions, 1325 deletions
diff --git a/include/linux/Kbuild b/include/linux/Kbuild
index bda6f04791d4..78fade0a1e35 100644
--- a/include/linux/Kbuild
+++ b/include/linux/Kbuild
@@ -20,6 +20,7 @@ header-y += affs_hardblocks.h
 header-y += aio_abi.h
 header-y += arcfb.h
 header-y += atmapi.h
+header-y += atmarp.h
 header-y += atmbr2684.h
 header-y += atmclip.h
 header-y += atm_eni.h
@@ -48,6 +49,7 @@ header-y += coff.h
 header-y += comstats.h
 header-y += const.h
 header-y += cgroupstats.h
+header-y += cramfs_fs.h
 header-y += cycx_cfm.h
 header-y += dlmconstants.h
 header-y += dlm_device.h
@@ -70,10 +72,12 @@ header-y += firewire-constants.h
 header-y += fuse.h
 header-y += genetlink.h
 header-y += gen_stats.h
+header-y += gfs2_ondisk.h
 header-y += gigaset_dev.h
 header-y += hysdn_if.h
 header-y += i2o-dev.h
 header-y += i8k.h
+header-y += if_addrlabel.h
 header-y += if_arcnet.h
 header-y += if_bonding.h
 header-y += if_cablemodem.h
@@ -91,6 +95,7 @@ header-y += if_tunnel.h
 header-y += in6.h
 header-y += in_route.h
 header-y += ioctl.h
+header-y += ip6_tunnel.h
 header-y += ipmi_msgdefs.h
 header-y += ipsec.h
 header-y += ipx.h
@@ -117,7 +122,6 @@ header-y += nfs2.h
 header-y += nfs4_mount.h
 header-y += nfs_mount.h
 header-y += nl80211.h
-header-y += oom.h
 header-y += param.h
 header-y += pci_regs.h
 header-y += pfkeyv2.h
@@ -166,7 +170,6 @@ unifdef-y += adfs_fs.h
 unifdef-y += agpgart.h
 unifdef-y += apm_bios.h
 unifdef-y += atalk.h
-unifdef-y += atmarp.h
 unifdef-y += atmdev.h
 unifdef-y += atm.h
 unifdef-y += atm_tcp.h
@@ -182,7 +185,6 @@ unifdef-y += cm4000_cs.h
 unifdef-y += cn_proc.h
 unifdef-y += coda.h
 unifdef-y += connector.h
-unifdef-y += cramfs_fs.h
 unifdef-y += cuda.h
 unifdef-y += cyclades.h
 unifdef-y += dccp.h
@@ -205,7 +207,6 @@ unifdef-y += futex.h
 unifdef-y += fs.h
 unifdef-y += gameport.h
 unifdef-y += generic_serial.h
-unifdef-y += gfs2_ondisk.h
 unifdef-y += hayesesp.h
 unifdef-y += hdlcdrv.h
 unifdef-y += hdlc.h
@@ -219,7 +220,6 @@ unifdef-y += i2c-dev.h
 unifdef-y += icmp.h
 unifdef-y += icmpv6.h
 unifdef-y += if_addr.h
-unifdef-y += if_addrlabel.h
 unifdef-y += if_arp.h
 unifdef-y += if_bridge.h
 unifdef-y += if_ec.h
@@ -243,7 +243,6 @@ unifdef-y += ipc.h
 unifdef-y += ipmi.h
 unifdef-y += ipv6.h
 unifdef-y += ipv6_route.h
-unifdef-y += ip6_tunnel.h
 unifdef-y += isdn.h
 unifdef-y += isdnif.h
 unifdef-y += isdn_divertif.h
diff --git a/include/linux/acpi.h b/include/linux/acpi.h
index 2c7e003356ac..41f7ce7edd7a 100644
--- a/include/linux/acpi.h
+++ b/include/linux/acpi.h
@@ -79,6 +79,7 @@ typedef int (*acpi_table_handler) (struct acpi_table_header *table);
 typedef int (*acpi_table_entry_handler) (struct acpi_subtable_header *header, const unsigned long end);
 char * __acpi_map_table (unsigned long phys_addr, unsigned long size);
+int early_acpi_boot_init(void);
 int acpi_boot_init (void);
 int acpi_boot_table_init (void);
 int acpi_numa_init (void);
@@ -235,6 +236,10 @@ int acpi_check_mem_region(resource_size_t start, resource_size_t n,
 #else   /* CONFIG_ACPI */
+static inline int early_acpi_boot_init(void)
+{
+        return 0;
+}
 static inline int acpi_boot_init(void)
 {
        return 0;
diff --git a/include/linux/aio.h b/include/linux/aio.h
index 0d0b7f629bd3..b51ddd28444e 100644
--- a/include/linux/aio.h
+++ b/include/linux/aio.h
@@ -209,27 +209,8 @@ extern ssize_t wait_on_sync_kiocb(struct kiocb *iocb);
 extern int aio_put_req(struct kiocb *iocb);
 extern void kick_iocb(struct kiocb *iocb);
 extern int aio_complete(struct kiocb *iocb, long res, long res2);
-extern void __put_ioctx(struct kioctx *ctx);
 struct mm_struct;
 extern void exit_aio(struct mm_struct *mm);
-extern struct kioctx *lookup_ioctx(unsigned long ctx_id);
-extern int io_submit_one(struct kioctx *ctx, struct iocb __user *user_iocb,
-                         struct iocb *iocb);
-/* semi private, but used by the 32bit emulations: */
-struct kioctx *lookup_ioctx(unsigned long ctx_id);
-int io_submit_one(struct kioctx *ctx, struct iocb __user *user_iocb,
-                  struct iocb *iocb);
-#define get_ioctx(kioctx) do {                                          \
-        BUG_ON(atomic_read(&(kioctx)->users) <= 0);                     \
-        atomic_inc(&(kioctx)->users);                                   \
-} while (0)
-#define put_ioctx(kioctx) do {                                          \
-        BUG_ON(atomic_read(&(kioctx)->users) <= 0);                     \
-        if (unlikely(atomic_dec_and_test(&(kioctx)->users)))            \
-                __put_ioctx(kioctx);                                    \
-} while (0)
 #define io_wait_to_kiocb(wait) container_of(wait, struct kiocb, ki_wait)
diff --git a/include/linux/audit.h b/include/linux/audit.h
index 4ccb048cae1d..63c3bb98558f 100644
--- a/include/linux/audit.h
+++ b/include/linux/audit.h
@@ -146,7 +146,7 @@
 /* Rule structure sizes -- if these change, different AUDIT_ADD and
 * AUDIT_LIST commands must be implemented. */
 #define AUDIT_MAX_FIELDS   64
-#define AUDIT_MAX_KEY_LEN  32
+#define AUDIT_MAX_KEY_LEN  256
 #define AUDIT_BITMASK_SIZE 64
 #define AUDIT_WORD(nr) ((__u32)((nr)/32))
 #define AUDIT_BIT(nr)  (1 << ((nr) - AUDIT_WORD(nr)*32))
@@ -209,6 +209,7 @@
 #define AUDIT_WATCH     105
 #define AUDIT_PERM      106
 #define AUDIT_DIR       107
+#define AUDIT_FILETYPE  108
 #define AUDIT_ARG0      200
 #define AUDIT_ARG1      (AUDIT_ARG0+1)
@@ -549,16 +550,20 @@ extern void		    audit_log_format(struct audit_buffer *ab,
                                             const char *fmt, ...)
                            __attribute__((format(printf,2,3)));
 extern void                 audit_log_end(struct audit_buffer *ab);
-extern void                 audit_log_hex(struct audit_buffer *ab,
-                                          const unsigned char *buf,
-                                          size_t len);
 extern int                  audit_string_contains_control(const char *string,
                                                          size_t len);
+extern void                 audit_log_n_hex(struct audit_buffer *ab,
+                                          const unsigned char *buf,
+                                          size_t len);
+extern void                 audit_log_n_string(struct audit_buffer *ab,
+                                               const char *buf,
+                                               size_t n);
+#define audit_log_string(a,b) audit_log_n_string(a, b, strlen(b));
+extern void                 audit_log_n_untrustedstring(struct audit_buffer *ab,
+                                                        const char *string,
+                                                        size_t n);
 extern void                 audit_log_untrustedstring(struct audit_buffer *ab,
                                                      const char *string);
-extern void                 audit_log_n_untrustedstring(struct audit_buffer *ab,
-                                                        size_t n,
-                                                        const char *string);
 extern void                 audit_log_d_path(struct audit_buffer *ab,
                                             const char *prefix,
                                             struct path *path);
@@ -569,7 +574,8 @@ extern int		    audit_update_lsm_rules(void);
 extern int audit_filter_user(struct netlink_skb_parms *cb, int type);
 extern int audit_filter_type(int type);
 extern int  audit_receive_filter(int type, int pid, int uid, int seq,
-                         void *data, size_t datasz, uid_t loginuid, u32 sid);
+                                void *data, size_t datasz, uid_t loginuid,
+                                u32 sessionid, u32 sid);
 extern int audit_enabled;
 #else
 #define audit_log(c,g,t,f,...) do { ; } while (0)
@@ -577,9 +583,11 @@ extern int audit_enabled;
 #define audit_log_vformat(b,f,a) do { ; } while (0)
 #define audit_log_format(b,f,...) do { ; } while (0)
 #define audit_log_end(b) do { ; } while (0)
-#define audit_log_hex(a,b,l) do { ; } while (0)
+#define audit_log_n_hex(a,b,l) do { ; } while (0)
-#define audit_log_untrustedstring(a,s) do { ; } while (0)
+#define audit_log_n_string(a,c,l) do { ; } while (0)
+#define audit_log_string(a,c) do { ; } while (0)
 #define audit_log_n_untrustedstring(a,n,s) do { ; } while (0)
+#define audit_log_untrustedstring(a,s) do { ; } while (0)
 #define audit_log_d_path(b, p, d) do { ; } while (0)
 #define audit_enabled 0
 #endif
diff --git a/include/linux/backing-dev.h b/include/linux/backing-dev.h
index 48a62baace58..b66fa2bdfd9c 100644
--- a/include/linux/backing-dev.h
+++ b/include/linux/backing-dev.h
@@ -156,9 +156,7 @@ static inline unsigned long bdi_stat_error(struct backing_dev_info *bdi)
 extern struct backing_dev_info default_backing_dev_info;
 void default_unplug_io_fn(struct backing_dev_info *bdi, struct page *page);
-int writeback_acquire(struct backing_dev_info *bdi);
 int writeback_in_progress(struct backing_dev_info *bdi);
-void writeback_release(struct backing_dev_info *bdi);
 static inline int bdi_congested(struct backing_dev_info *bdi, int bdi_bits)
 {
diff --git a/include/linux/binfmts.h b/include/linux/binfmts.h
index b7fc55ec8d48..b512e48f6d8e 100644
--- a/include/linux/binfmts.h
+++ b/include/linux/binfmts.h
@@ -34,7 +34,8 @@ struct linux_binprm{
 #endif
        struct mm_struct *mm;
        unsigned long p; /* current top of mem */
-        int sh_bang;
+        unsigned int sh_bang:1,
+                     misc_bang:1;
        struct file * file;
        int e_uid, e_gid;
        kernel_cap_t cap_inheritable, cap_permitted;
@@ -48,7 +49,6 @@ struct linux_binprm{
        unsigned interp_flags;
        unsigned interp_data;
        unsigned long loader, exec;
-        unsigned long argv_len;
 };
 #define BINPRM_FLAGS_ENFORCE_NONDUMP_BIT 0
diff --git a/include/linux/bio.h b/include/linux/bio.h
index d259690863fb..61c15eaf3fb3 100644
--- a/include/linux/bio.h
+++ b/include/linux/bio.h
@@ -324,6 +324,8 @@ extern struct bio *bio_map_user_iov(struct request_queue *,
 extern void bio_unmap_user(struct bio *);
 extern struct bio *bio_map_kern(struct request_queue *, void *, unsigned int,
                                gfp_t);
+extern struct bio *bio_copy_kern(struct request_queue *, void *, unsigned int,
+                                 gfp_t, int);
 extern void bio_set_pages_dirty(struct bio *bio);
 extern void bio_check_pages_dirty(struct bio *bio);
 extern struct bio *bio_copy_user(struct request_queue *, unsigned long, unsigned int, int);
diff --git a/include/linux/bitmap.h b/include/linux/bitmap.h
index 1dbe074f1c64..43b406def35f 100644
--- a/include/linux/bitmap.h
+++ b/include/linux/bitmap.h
@@ -46,6 +46,8 @@
 * bitmap_shift_left(dst, src, n, nbits)        *dst = *src << n
 * bitmap_remap(dst, src, old, new, nbits)      *dst = map(old, new)(src)
 * bitmap_bitremap(oldbit, old, new, nbits)     newbit = map(old, new)(oldbit)
+ * bitmap_onto(dst, orig, relmap, nbits)        *dst = orig relative to relmap
+ * bitmap_fold(dst, orig, sz, nbits)            dst bits = orig bits mod sz
 * bitmap_scnprintf(buf, len, src, nbits)       Print bitmap src to buf
 * bitmap_parse(buf, buflen, dst, nbits)        Parse bitmap dst from kernel buf
 * bitmap_parse_user(ubuf, ulen, dst, nbits)    Parse bitmap dst from user buf
@@ -121,6 +123,10 @@ extern void bitmap_remap(unsigned long *dst, const unsigned long *src,
                const unsigned long *old, const unsigned long *new, int bits);
 extern int bitmap_bitremap(int oldbit,
                const unsigned long *old, const unsigned long *new, int bits);
+extern void bitmap_onto(unsigned long *dst, const unsigned long *orig,
+                const unsigned long *relmap, int bits);
+extern void bitmap_fold(unsigned long *dst, const unsigned long *orig,
+                int sz, int bits);
 extern int bitmap_find_free_region(unsigned long *bitmap, int bits, int order);
 extern void bitmap_release_region(unsigned long *bitmap, int pos, int order);
 extern int bitmap_allocate_region(unsigned long *bitmap, int pos, int order);
diff --git a/include/linux/bitops.h b/include/linux/bitops.h
index 48bde600a2db..024f2b027244 100644
--- a/include/linux/bitops.h
+++ b/include/linux/bitops.h
@@ -6,8 +6,8 @@
 #define BIT(nr)                 (1UL << (nr))
 #define BIT_MASK(nr)            (1UL << ((nr) % BITS_PER_LONG))
 #define BIT_WORD(nr)            ((nr) / BITS_PER_LONG)
-#define BITS_TO_LONGS(nr)       DIV_ROUND_UP(nr, BITS_PER_LONG)
 #define BITS_PER_BYTE           8
+#define BITS_TO_LONGS(nr)       DIV_ROUND_UP(nr, BITS_PER_BYTE * sizeof(long))
 #endif
 /*
@@ -114,8 +114,6 @@ static inline unsigned fls_long(unsigned long l)
 #ifdef __KERNEL__
 #ifdef CONFIG_GENERIC_FIND_FIRST_BIT
-extern unsigned long __find_first_bit(const unsigned long *addr,
-                unsigned long size);
 /**
 * find_first_bit - find the first set bit in a memory region
@@ -124,28 +122,8 @@ extern unsigned long __find_first_bit(const unsigned long *addr,
 *
 * Returns the bit number of the first set bit.
 */
-static __always_inline unsigned long
+extern unsigned long find_first_bit(const unsigned long *addr,
-find_first_bit(const unsigned long *addr, unsigned long size)
+                                    unsigned long size);
-{
-        /* Avoid a function call if the bitmap size is a constant */
-        /* and not bigger than BITS_PER_LONG. */
-        /* insert a sentinel so that __ffs returns size if there */
-        /* are no set bits in the bitmap */
-        if (__builtin_constant_p(size) && (size < BITS_PER_LONG))
-                return __ffs((*addr) | (1ul << size));
-        /* the result of __ffs(0) is undefined, so it needs to be */
-        /* handled separately */
-        if (__builtin_constant_p(size) && (size == BITS_PER_LONG))
-                return ((*addr) == 0) ? BITS_PER_LONG : __ffs(*addr);
-        /* size is not constant or too big */
-        return __find_first_bit(addr, size);
-}
-extern unsigned long __find_first_zero_bit(const unsigned long *addr,
-                unsigned long size);
 /**
 * find_first_zero_bit - find the first cleared bit in a memory region
@@ -154,31 +132,12 @@ extern unsigned long __find_first_zero_bit(const unsigned long *addr,
 *
 * Returns the bit number of the first cleared bit.
 */
-static __always_inline unsigned long
+extern unsigned long find_first_zero_bit(const unsigned long *addr,
-find_first_zero_bit(const unsigned long *addr, unsigned long size)
+                                         unsigned long size);
-{
-        /* Avoid a function call if the bitmap size is a constant */
-        /* and not bigger than BITS_PER_LONG. */
-        /* insert a sentinel so that __ffs returns size if there */
-        /* are no set bits in the bitmap */
-        if (__builtin_constant_p(size) && (size < BITS_PER_LONG)) {
-                return __ffs(~(*addr) | (1ul << size));
-        }
-        /* the result of __ffs(0) is undefined, so it needs to be */
-        /* handled separately */
-        if (__builtin_constant_p(size) && (size == BITS_PER_LONG))
-                return (~(*addr) == 0) ? BITS_PER_LONG : __ffs(~(*addr));
-        /* size is not constant or too big */
-        return __find_first_zero_bit(addr, size);
-}
 #endif /* CONFIG_GENERIC_FIND_FIRST_BIT */
 #ifdef CONFIG_GENERIC_FIND_NEXT_BIT
-extern unsigned long __find_next_bit(const unsigned long *addr,
-                unsigned long size, unsigned long offset);
 /**
 * find_next_bit - find the next set bit in a memory region
@@ -186,36 +145,8 @@ extern unsigned long __find_next_bit(const unsigned long *addr,
 * @offset: The bitnumber to start searching at
 * @size: The bitmap size in bits
 */
-static __always_inline unsigned long
+extern unsigned long find_next_bit(const unsigned long *addr,
-find_next_bit(const unsigned long *addr, unsigned long size,
+                                   unsigned long size, unsigned long offset);
-                unsigned long offset)
-{
-        unsigned long value;
-        /* Avoid a function call if the bitmap size is a constant */
-        /* and not bigger than BITS_PER_LONG. */
-        /* insert a sentinel so that __ffs returns size if there */
-        /* are no set bits in the bitmap */
-        if (__builtin_constant_p(size) && (size < BITS_PER_LONG)) {
-                value = (*addr) & ((~0ul) << offset);
-                value |= (1ul << size);
-                return __ffs(value);
-        }
-        /* the result of __ffs(0) is undefined, so it needs to be */
-        /* handled separately */
-        if (__builtin_constant_p(size) && (size == BITS_PER_LONG)) {
-                value = (*addr) & ((~0ul) << offset);
-                return (value == 0) ? BITS_PER_LONG : __ffs(value);
-        }
-        /* size is not constant or too big */
-        return __find_next_bit(addr, size, offset);
-}
-extern unsigned long __find_next_zero_bit(const unsigned long *addr,
-                unsigned long size, unsigned long offset);
 /**
 * find_next_zero_bit - find the next cleared bit in a memory region
@@ -223,33 +154,11 @@ extern unsigned long __find_next_zero_bit(const unsigned long *addr,
 * @offset: The bitnumber to start searching at
 * @size: The bitmap size in bits
 */
-static __always_inline unsigned long
-find_next_zero_bit(const unsigned long *addr, unsigned long size,
+extern unsigned long find_next_zero_bit(const unsigned long *addr,
-                unsigned long offset)
+                                        unsigned long size,
-{
+                                        unsigned long offset);
-        unsigned long value;
-        /* Avoid a function call if the bitmap size is a constant */
-        /* and not bigger than BITS_PER_LONG. */
-        /* insert a sentinel so that __ffs returns size if there */
-        /* are no set bits in the bitmap */
-        if (__builtin_constant_p(size) && (size < BITS_PER_LONG)) {
-                value = (~(*addr)) & ((~0ul) << offset);
-                value |= (1ul << size);
-                return __ffs(value);
-        }
-        /* the result of __ffs(0) is undefined, so it needs to be */
-        /* handled separately */
-        if (__builtin_constant_p(size) && (size == BITS_PER_LONG)) {
-                value = (~(*addr)) & ((~0ul) << offset);
-                return (value == 0) ? BITS_PER_LONG : __ffs(value);
-        }
-        /* size is not constant or too big */
-        return __find_next_zero_bit(addr, size, offset);
-}
 #endif /* CONFIG_GENERIC_FIND_NEXT_BIT */
 #endif /* __KERNEL__ */
 #endif
diff --git a/include/linux/blkdev.h b/include/linux/blkdev.h
index c5065e3d2ca9..d2a1b71e93c3 100644
--- a/include/linux/blkdev.h
+++ b/include/linux/blkdev.h
@@ -215,8 +215,9 @@ struct request {
        /*
         * when request is used as a packet command carrier
         */
-        unsigned int cmd_len;
+        unsigned short cmd_len;
-        unsigned char cmd[BLK_MAX_CDB];
+        unsigned char __cmd[BLK_MAX_CDB];
+        unsigned char *cmd;
        unsigned int data_len;
        unsigned int extra_len; /* length of alignment and padding */
@@ -407,6 +408,41 @@ struct request_queue
 #define QUEUE_FLAG_PLUGGED      7       /* queue is plugged */
 #define QUEUE_FLAG_ELVSWITCH    8       /* don't use elevator, just do FIFO */
 #define QUEUE_FLAG_BIDI         9       /* queue supports bidi requests */
+#define QUEUE_FLAG_NOMERGES    10       /* disable merge attempts */
+static inline int queue_is_locked(struct request_queue *q)
+{
+#ifdef CONFIG_SMP
+        spinlock_t *lock = q->queue_lock;
+        return lock && spin_is_locked(lock);
+#else
+        return 1;
+#endif
+}
+static inline void queue_flag_set_unlocked(unsigned int flag,
+                                           struct request_queue *q)
+{
+        __set_bit(flag, &q->queue_flags);
+}
+static inline void queue_flag_set(unsigned int flag, struct request_queue *q)
+{
+        WARN_ON_ONCE(!queue_is_locked(q));
+        __set_bit(flag, &q->queue_flags);
+}
+static inline void queue_flag_clear_unlocked(unsigned int flag,
+                                             struct request_queue *q)
+{
+        __clear_bit(flag, &q->queue_flags);
+}
+static inline void queue_flag_clear(unsigned int flag, struct request_queue *q)
+{
+        WARN_ON_ONCE(!queue_is_locked(q));
+        __clear_bit(flag, &q->queue_flags);
+}
 enum {
        /*
@@ -451,6 +487,7 @@ enum {
 #define blk_queue_plugged(q)    test_bit(QUEUE_FLAG_PLUGGED, &(q)->queue_flags)
 #define blk_queue_tagged(q)     test_bit(QUEUE_FLAG_QUEUED, &(q)->queue_flags)
 #define blk_queue_stopped(q)    test_bit(QUEUE_FLAG_STOPPED, &(q)->queue_flags)
+#define blk_queue_nomerges(q)   test_bit(QUEUE_FLAG_NOMERGES, &(q)->queue_flags)
 #define blk_queue_flushing(q)   ((q)->ordseq)
 #define blk_fs_request(rq)      ((rq)->cmd_type == REQ_TYPE_FS)
@@ -496,17 +533,17 @@ static inline int blk_queue_full(struct request_queue *q, int rw)
 static inline void blk_set_queue_full(struct request_queue *q, int rw)
 {
        if (rw == READ)
-                set_bit(QUEUE_FLAG_READFULL, &q->queue_flags);
+                queue_flag_set(QUEUE_FLAG_READFULL, q);
        else
-                set_bit(QUEUE_FLAG_WRITEFULL, &q->queue_flags);
+                queue_flag_set(QUEUE_FLAG_WRITEFULL, q);
 }
 static inline void blk_clear_queue_full(struct request_queue *q, int rw)
 {
        if (rw == READ)
-                clear_bit(QUEUE_FLAG_READFULL, &q->queue_flags);
+                queue_flag_clear(QUEUE_FLAG_READFULL, q);
        else
-                clear_bit(QUEUE_FLAG_WRITEFULL, &q->queue_flags);
+                queue_flag_clear(QUEUE_FLAG_WRITEFULL, q);
 }
@@ -583,6 +620,7 @@ extern int blk_register_queue(struct gendisk *disk);
 extern void blk_unregister_queue(struct gendisk *disk);
 extern void register_disk(struct gendisk *dev);
 extern void generic_make_request(struct bio *bio);
+extern void blk_rq_init(struct request_queue *q, struct request *rq);
 extern void blk_put_request(struct request *);
 extern void __blk_put_request(struct request_queue *, struct request *);
 extern void blk_end_sync_rq(struct request *rq, int error);
@@ -626,6 +664,7 @@ extern void blk_start_queue(struct request_queue *q);
 extern void blk_stop_queue(struct request_queue *q);
 extern void blk_sync_queue(struct request_queue *q);
 extern void __blk_stop_queue(struct request_queue *q);
+extern void __blk_run_queue(struct request_queue *);
 extern void blk_run_queue(struct request_queue *);
 extern void blk_start_queueing(struct request_queue *);
 extern int blk_rq_map_user(struct request_queue *, struct request *, void __user *, unsigned long);
diff --git a/include/linux/bootmem.h b/include/linux/bootmem.h
index 4e4e340592fb..6a5dbdc8a7dc 100644
--- a/include/linux/bootmem.h
+++ b/include/linux/bootmem.h
@@ -101,6 +101,8 @@ extern void reserve_bootmem_node(pg_data_t *pgdat,
 extern void free_bootmem_node(pg_data_t *pgdat,
                              unsigned long addr,
                              unsigned long size);
+extern void *alloc_bootmem_section(unsigned long size,
+                                   unsigned long section_nr);
 #ifndef CONFIG_HAVE_ARCH_BOOTMEM_NODE
 #define alloc_bootmem_node(pgdat, x) \
diff --git a/include/linux/buffer_head.h b/include/linux/buffer_head.h
index 932eb02a2753..82aa36c53ea7 100644
--- a/include/linux/buffer_head.h
+++ b/include/linux/buffer_head.h
@@ -225,7 +225,6 @@ int block_page_mkwrite(struct vm_area_struct *vma, struct page *page,
                                get_block_t get_block);
 void block_sync_page(struct page *);
 sector_t generic_block_bmap(struct address_space *, sector_t, get_block_t *);
-int generic_commit_write(struct file *, struct page *, unsigned, unsigned);
 int block_truncate_page(struct address_space *, loff_t, get_block_t *);
 int file_fsync(struct file *, struct dentry *, int);
 int nobh_write_begin(struct file *, struct address_space *,
diff --git a/include/linux/cache.h b/include/linux/cache.h
index 4552504c0228..97e24881c4c6 100644
--- a/include/linux/cache.h
+++ b/include/linux/cache.h
@@ -60,4 +60,8 @@
 #endif
 #endif
+#ifndef CONFIG_ARCH_HAS_CACHE_LINE_SIZE
+#define cache_line_size()       L1_CACHE_BYTES
+#endif
 #endif /* __LINUX_CACHE_H */
diff --git a/include/linux/capability.h b/include/linux/capability.h
index 7d50ff6d269f..f4ea0dd9a618 100644
--- a/include/linux/capability.h
+++ b/include/linux/capability.h
@@ -155,6 +155,7 @@ typedef struct kernel_cap_struct {
 *   Add any capability from current's capability bounding set
 *       to the current process' inheritable set
 *   Allow taking bits out of capability bounding set
+ *   Allow modification of the securebits for a process
 */
 #define CAP_SETPCAP          8
@@ -364,12 +365,12 @@ typedef struct kernel_cap_struct {
 # error Fix up hand-coded capability macro initializers
 #else /* HAND-CODED capability initializers */
-# define CAP_EMPTY_SET    {{ 0, 0 }}
+# define CAP_EMPTY_SET    ((kernel_cap_t){{ 0, 0 }})
-# define CAP_FULL_SET     {{ ~0, ~0 }}
+# define CAP_FULL_SET     ((kernel_cap_t){{ ~0, ~0 }})
-# define CAP_INIT_EFF_SET {{ ~CAP_TO_MASK(CAP_SETPCAP), ~0 }}
+# define CAP_INIT_EFF_SET ((kernel_cap_t){{ ~CAP_TO_MASK(CAP_SETPCAP), ~0 }})
-# define CAP_FS_SET       {{ CAP_FS_MASK_B0, CAP_FS_MASK_B1 } }
+# define CAP_FS_SET       ((kernel_cap_t){{ CAP_FS_MASK_B0, CAP_FS_MASK_B1 } })
-# define CAP_NFSD_SET     {{ CAP_FS_MASK_B0|CAP_TO_MASK(CAP_SYS_RESOURCE), \
+# define CAP_NFSD_SET     ((kernel_cap_t){{ CAP_FS_MASK_B0|CAP_TO_MASK(CAP_SYS_RESOURCE), \
-                             CAP_FS_MASK_B1 } }
+                                        CAP_FS_MASK_B1 } })
 #endif /* _LINUX_CAPABILITY_U32S != 2 */
@@ -490,8 +491,6 @@ extern const kernel_cap_t __cap_init_eff_set;
 int capable(int cap);
 int __capable(struct task_struct *t, int cap);
-extern long cap_prctl_drop(unsigned long cap);
 #endif /* __KERNEL__ */
 #endif /* !_LINUX_CAPABILITY_H */
diff --git a/include/linux/cgroup.h b/include/linux/cgroup.h
index a6a6035a4e1e..e155aa78d859 100644
--- a/include/linux/cgroup.h
+++ b/include/linux/cgroup.h
@@ -88,6 +88,17 @@ static inline void css_put(struct cgroup_subsys_state *css)
                __css_put(css);
 }
+/* bits in struct cgroup flags field */
+enum {
+        /* Control Group is dead */
+        CGRP_REMOVED,
+        /* Control Group has previously had a child cgroup or a task,
+         * but no longer (only if CGRP_NOTIFY_ON_RELEASE is set) */
+        CGRP_RELEASABLE,
+        /* Control Group requires release notifications to userspace */
+        CGRP_NOTIFY_ON_RELEASE,
+};
 struct cgroup {
        unsigned long flags;            /* "unsigned long" so bitops work */
@@ -139,10 +150,10 @@ struct css_set {
        struct kref ref;
        /*
-         * List running through all cgroup groups. Protected by
+         * List running through all cgroup groups in the same hash
-         * css_set_lock
+         * slot. Protected by css_set_lock
         */
-        struct list_head list;
+        struct hlist_node hlist;
        /*
         * List running through all tasks using this cgroup
@@ -163,7 +174,16 @@ struct css_set {
         * during subsystem registration (at boot time).
         */
        struct cgroup_subsys_state *subsys[CGROUP_SUBSYS_COUNT];
+};
+/*
+ * cgroup_map_cb is an abstract callback API for reporting map-valued
+ * control files
+ */
+struct cgroup_map_cb {
+        int (*fill)(struct cgroup_map_cb *cb, const char *key, u64 value);
+        void *state;
 };
 /* struct cftype:
@@ -190,20 +210,51 @@ struct cftype {
                         struct file *file,
                         char __user *buf, size_t nbytes, loff_t *ppos);
        /*
-         * read_uint() is a shortcut for the common case of returning a
+         * read_u64() is a shortcut for the common case of returning a
         * single integer. Use it in place of read()
         */
-        u64 (*read_uint) (struct cgroup *cgrp, struct cftype *cft);
+        u64 (*read_u64) (struct cgroup *cgrp, struct cftype *cft);
+        /*
+         * read_s64() is a signed version of read_u64()
+         */
+        s64 (*read_s64) (struct cgroup *cgrp, struct cftype *cft);
+        /*
+         * read_map() is used for defining a map of key/value
+         * pairs. It should call cb->fill(cb, key, value) for each
+         * entry. The key/value pairs (and their ordering) should not
+         * change between reboots.
+         */
+        int (*read_map) (struct cgroup *cont, struct cftype *cft,
+                         struct cgroup_map_cb *cb);
+        /*
+         * read_seq_string() is used for outputting a simple sequence
+         * using seqfile.
+         */
+        int (*read_seq_string) (struct cgroup *cont, struct cftype *cft,
+                         struct seq_file *m);
        ssize_t (*write) (struct cgroup *cgrp, struct cftype *cft,
                          struct file *file,
                          const char __user *buf, size_t nbytes, loff_t *ppos);
        /*
-         * write_uint() is a shortcut for the common case of accepting
+         * write_u64() is a shortcut for the common case of accepting
         * a single integer (as parsed by simple_strtoull) from
         * userspace. Use in place of write(); return 0 or error.
         */
-        int (*write_uint) (struct cgroup *cgrp, struct cftype *cft, u64 val);
+        int (*write_u64) (struct cgroup *cgrp, struct cftype *cft, u64 val);
+        /*
+         * write_s64() is a signed version of write_u64()
+         */
+        int (*write_s64) (struct cgroup *cgrp, struct cftype *cft, s64 val);
+        /*
+         * trigger() callback can be used to get some kick from the
+         * userspace, when the actual string written is not important
+         * at all. The private field can be used to determine the
+         * kick type for multiplexing.
+         */
+        int (*trigger)(struct cgroup *cgrp, unsigned int event);
        int (*release) (struct inode *inode, struct file *file);
 };
@@ -254,6 +305,12 @@ struct cgroup_subsys {
                        struct cgroup *cgrp);
        void (*post_clone)(struct cgroup_subsys *ss, struct cgroup *cgrp);
        void (*bind)(struct cgroup_subsys *ss, struct cgroup *root);
+        /*
+         * This routine is called with the task_lock of mm->owner held
+         */
+        void (*mm_owner_changed)(struct cgroup_subsys *ss,
+                                        struct cgroup *old,
+                                        struct cgroup *new);
        int subsys_id;
        int active;
        int disabled;
@@ -339,4 +396,13 @@ static inline int cgroupstats_build(struct cgroupstats *stats,
 #endif /* !CONFIG_CGROUPS */
+#ifdef CONFIG_MM_OWNER
+extern void
+cgroup_mm_owner_callbacks(struct task_struct *old, struct task_struct *new);
+#else /* !CONFIG_MM_OWNER */
+static inline void
+cgroup_mm_owner_callbacks(struct task_struct *old, struct task_struct *new)
+{
+}
+#endif /* CONFIG_MM_OWNER */
 #endif /* _LINUX_CGROUP_H */
diff --git a/include/linux/cgroup_subsys.h b/include/linux/cgroup_subsys.h
index 1ddebfc52565..e2877454ec82 100644
--- a/include/linux/cgroup_subsys.h
+++ b/include/linux/cgroup_subsys.h
@@ -42,3 +42,9 @@ SUBSYS(mem_cgroup)
 #endif
 /* */
+#ifdef CONFIG_CGROUP_DEVICE
+SUBSYS(devices)
+#endif
+/* */
diff --git a/include/linux/coda_linux.h b/include/linux/coda_linux.h
index 1c47a34aa794..31b75311e2ca 100644
--- a/include/linux/coda_linux.h
+++ b/include/linux/coda_linux.h
@@ -43,9 +43,6 @@ int coda_getattr(struct vfsmount *, struct dentry *, struct kstat *);
 int coda_setattr(struct dentry *, struct iattr *);
 /* this file:  heloers */
-static __inline__ struct CodaFid *coda_i2f(struct inode *);
-static __inline__ char *coda_i2s(struct inode *);
-static __inline__ void coda_flag_inode(struct inode *, int flag);
 char *coda_f2s(struct CodaFid *f);
 int coda_isroot(struct inode *i);
 int coda_iscontrol(const char *name, size_t length);
diff --git a/include/linux/console_struct.h b/include/linux/console_struct.h
index d71f7c0f931b..b03f80a078be 100644
--- a/include/linux/console_struct.h
+++ b/include/linux/console_struct.h
@@ -53,6 +53,7 @@ struct vc_data {
        unsigned short  vc_hi_font_mask;        /* [#] Attribute set for upper 256 chars of font or 0 if not supported */
        struct console_font vc_font;            /* Current VC font set */
        unsigned short  vc_video_erase_char;    /* Background erase character */
+        unsigned short  vc_scrl_erase_char;     /* Erase character for scroll */
        /* VT terminal data */
        unsigned int    vc_state;               /* Escape sequence parser state */
        unsigned int    vc_npar,vc_par[NPAR];   /* Parameters of current escape sequence */
diff --git a/include/linux/cpu.h b/include/linux/cpu.h
index f212fa98283e..7464ba3b4333 100644
--- a/include/linux/cpu.h
+++ b/include/linux/cpu.h
@@ -108,7 +108,7 @@ static inline void cpuhotplug_mutex_unlock(struct mutex *cpu_hp_mutex)
 extern void get_online_cpus(void);
 extern void put_online_cpus(void);
 #define hotcpu_notifier(fn, pri) {                              \
-        static struct notifier_block fn##_nb =                  \
+        static struct notifier_block fn##_nb __cpuinitdata =    \
                { .notifier_call = fn, .priority = pri };       \
        register_cpu_notifier(&fn##_nb);                        \
 }
diff --git a/include/linux/cpufreq.h b/include/linux/cpufreq.h
index ddd8652fc3f3..e7e91dbfde0f 100644
--- a/include/linux/cpufreq.h
+++ b/include/linux/cpufreq.h
@@ -83,7 +83,8 @@ struct cpufreq_real_policy {
 };
 struct cpufreq_policy {
-        cpumask_t               cpus;   /* affected CPUs */
+        cpumask_t               cpus;   /* CPUs requiring sw coordination */
+        cpumask_t               related_cpus; /* CPUs with any coordination */
        unsigned int            shared_type; /* ANY or ALL affected CPUs
                                                should set cpufreq */
        unsigned int            cpu;    /* cpu nr of registered CPU */
@@ -307,6 +308,9 @@ extern struct cpufreq_governor cpufreq_gov_performance;
 #endif
 #ifdef CONFIG_CPU_FREQ_DEFAULT_GOV_PERFORMANCE
 #define CPUFREQ_DEFAULT_GOVERNOR        (&cpufreq_gov_performance)
+#elif defined(CONFIG_CPU_FREQ_DEFAULT_GOV_POWERSAVE)
+extern struct cpufreq_governor cpufreq_gov_powersave;
+#define CPUFREQ_DEFAULT_GOVERNOR        (&cpufreq_gov_powersave)
 #elif defined(CONFIG_CPU_FREQ_DEFAULT_GOV_USERSPACE)
 extern struct cpufreq_governor cpufreq_gov_userspace;
 #define CPUFREQ_DEFAULT_GOVERNOR        (&cpufreq_gov_userspace)
diff --git a/include/linux/cpumask.h b/include/linux/cpumask.h
index 259c8051155d..9650806fe2ea 100644
--- a/include/linux/cpumask.h
+++ b/include/linux/cpumask.h
@@ -14,6 +14,8 @@
 * bitmap_scnlistprintf() and bitmap_parselist(), also in bitmap.c.
 * For details of cpu_remap(), see bitmap_bitremap in lib/bitmap.c
 * For details of cpus_remap(), see bitmap_remap in lib/bitmap.c.
+ * For details of cpus_onto(), see bitmap_onto in lib/bitmap.c.
+ * For details of cpus_fold(), see bitmap_fold in lib/bitmap.c.
 *
 * The available cpumask operations are:
 *
@@ -53,7 +55,9 @@
 * int cpulist_scnprintf(buf, len, mask) Format cpumask as list for printing
 * int cpulist_parse(buf, map)          Parse ascii string as cpulist
 * int cpu_remap(oldbit, old, new)      newbit = map(old, new)(oldbit)
- * int cpus_remap(dst, src, old, new)   *dst = map(old, new)(src)
+ * void cpus_remap(dst, src, old, new)  *dst = map(old, new)(src)
+ * void cpus_onto(dst, orig, relmap)    *dst = orig relative to relmap
+ * void cpus_fold(dst, orig, sz)        dst bits = orig bits mod sz
 *
 * for_each_cpu_mask(cpu, mask)         for-loop cpu over mask
 *
@@ -330,6 +334,22 @@ static inline void __cpus_remap(cpumask_t *dstp, const cpumask_t *srcp,
        bitmap_remap(dstp->bits, srcp->bits, oldp->bits, newp->bits, nbits);
 }
+#define cpus_onto(dst, orig, relmap) \
+                __cpus_onto(&(dst), &(orig), &(relmap), NR_CPUS)
+static inline void __cpus_onto(cpumask_t *dstp, const cpumask_t *origp,
+                const cpumask_t *relmapp, int nbits)
+{
+        bitmap_onto(dstp->bits, origp->bits, relmapp->bits, nbits);
+}
+#define cpus_fold(dst, orig, sz) \
+                __cpus_fold(&(dst), &(orig), sz, NR_CPUS)
+static inline void __cpus_fold(cpumask_t *dstp, const cpumask_t *origp,
+                int sz, int nbits)
+{
+        bitmap_fold(dstp->bits, origp->bits, sz, nbits);
+}
 #if NR_CPUS > 1
 #define for_each_cpu_mask(cpu, mask)            \
        for ((cpu) = first_cpu(mask);           \
diff --git a/include/linux/cpuset.h b/include/linux/cpuset.h
index 726761e24003..038578362b47 100644
--- a/include/linux/cpuset.h
+++ b/include/linux/cpuset.h
@@ -26,7 +26,7 @@ extern nodemask_t cpuset_mems_allowed(struct task_struct *p);
 #define cpuset_current_mems_allowed (current->mems_allowed)
 void cpuset_init_current_mems_allowed(void);
 void cpuset_update_task_memory_state(void);
-int cpuset_zonelist_valid_mems_allowed(struct zonelist *zl);
+int cpuset_nodemask_valid_mems_allowed(nodemask_t *nodemask);
 extern int __cpuset_zone_allowed_softwall(struct zone *z, gfp_t gfp_mask);
 extern int __cpuset_zone_allowed_hardwall(struct zone *z, gfp_t gfp_mask);
@@ -103,7 +103,7 @@ static inline nodemask_t cpuset_mems_allowed(struct task_struct *p)
 static inline void cpuset_init_current_mems_allowed(void) {}
 static inline void cpuset_update_task_memory_state(void) {}
-static inline int cpuset_zonelist_valid_mems_allowed(struct zonelist *zl)
+static inline int cpuset_nodemask_valid_mems_allowed(nodemask_t *nodemask)
 {
        return 1;
 }
diff --git a/include/linux/device_cgroup.h b/include/linux/device_cgroup.h
new file mode 100644
index 000000000000..0b0d9c39ed67
--- /dev/null
+++ b/include/linux/device_cgroup.h
@@ -0,0 +1,12 @@
+#include <linux/module.h>
+#include <linux/fs.h>
+#ifdef CONFIG_CGROUP_DEVICE
+extern int devcgroup_inode_permission(struct inode *inode, int mask);
+extern int devcgroup_inode_mknod(int mode, dev_t dev);
+#else
+static inline int devcgroup_inode_permission(struct inode *inode, int mask)
+{ return 0; }
+static inline int devcgroup_inode_mknod(int mode, dev_t dev)
+{ return 0; }
+#endif
diff --git a/include/linux/dma-attrs.h b/include/linux/dma-attrs.h
new file mode 100644
index 000000000000..1677e2bfa00c
--- /dev/null
+++ b/include/linux/dma-attrs.h
@@ -0,0 +1,74 @@
+#ifndef _DMA_ATTR_H
+#define _DMA_ATTR_H
+#include <linux/bitmap.h>
+#include <linux/bitops.h>
+#include <linux/bug.h>
+/**
+ * an enum dma_attr represents an attribute associated with a DMA
+ * mapping. The semantics of each attribute should be defined in
+ * Documentation/DMA-attributes.txt.
+ */
+enum dma_attr {
+        DMA_ATTR_WRITE_BARRIER,
+        DMA_ATTR_MAX,
+};
+#define __DMA_ATTRS_LONGS BITS_TO_LONGS(DMA_ATTR_MAX)
+/**
+ * struct dma_attrs - an opaque container for DMA attributes
+ * @flags - bitmask representing a collection of enum dma_attr
+ */
+struct dma_attrs {
+        unsigned long flags[__DMA_ATTRS_LONGS];
+};
+#define DEFINE_DMA_ATTRS(x)                                     \
+        struct dma_attrs x = {                                  \
+                .flags = { [0 ... __DMA_ATTRS_LONGS-1] = 0 },   \
+        }
+static inline void init_dma_attrs(struct dma_attrs *attrs)
+{
+        bitmap_zero(attrs->flags, __DMA_ATTRS_LONGS);
+}
+#ifdef CONFIG_HAVE_DMA_ATTRS
+/**
+ * dma_set_attr - set a specific attribute
+ * @attr: attribute to set
+ * @attrs: struct dma_attrs (may be NULL)
+ */
+static inline void dma_set_attr(enum dma_attr attr, struct dma_attrs *attrs)
+{
+        if (attrs == NULL)
+                return;
+        BUG_ON(attr >= DMA_ATTR_MAX);
+        __set_bit(attr, attrs->flags);
+}
+/**
+ * dma_get_attr - check for a specific attribute
+ * @attr: attribute to set
+ * @attrs: struct dma_attrs (may be NULL)
+ */
+static inline int dma_get_attr(enum dma_attr attr, struct dma_attrs *attrs)
+{
+        if (attrs == NULL)
+                return 0;
+        BUG_ON(attr >= DMA_ATTR_MAX);
+        return test_bit(attr, attrs->flags);
+}
+#else /* !CONFIG_HAVE_DMA_ATTRS */
+static inline void dma_set_attr(enum dma_attr attr, struct dma_attrs *attrs)
+{
+}
+static inline int dma_get_attr(enum dma_attr attr, struct dma_attrs *attrs)
+{
+        return 0;
+}
+#endif /* CONFIG_HAVE_DMA_ATTRS */
+#endif /* _DMA_ATTR_H */
diff --git a/include/linux/dma-mapping.h b/include/linux/dma-mapping.h
index 332030709623..952e0f857ac9 100644
--- a/include/linux/dma-mapping.h
+++ b/include/linux/dma-mapping.h
@@ -146,4 +146,21 @@ static inline void dmam_release_declared_memory(struct device *dev)
 }
 #endif /* ARCH_HAS_DMA_DECLARE_COHERENT_MEMORY */
+#ifndef CONFIG_HAVE_DMA_ATTRS
+struct dma_attrs;
+#define dma_map_single_attrs(dev, cpu_addr, size, dir, attrs) \
+        dma_map_single(dev, cpu_addr, size, dir)
+#define dma_unmap_single_attrs(dev, dma_addr, size, dir, attrs) \
+        dma_unmap_single(dev, dma_addr, size, dir)
+#define dma_map_sg_attrs(dev, sgl, nents, dir, attrs) \
+        dma_map_sg(dev, sgl, nents, dir)
+#define dma_unmap_sg_attrs(dev, sgl, nents, dir, attrs) \
+        dma_unmap_sg(dev, sgl, nents, dir)
+#endif /* CONFIG_HAVE_DMA_ATTRS */
 #endif
diff --git a/include/linux/dmi.h b/include/linux/dmi.h
index 325acdf5c462..2a063b64133f 100644
--- a/include/linux/dmi.h
+++ b/include/linux/dmi.h
@@ -90,6 +90,7 @@ static inline int dmi_check_system(const struct dmi_system_id *list) { return 0;
 static inline const char * dmi_get_system_info(int field) { return NULL; }
 static inline const struct dmi_device * dmi_find_device(int type, const char *name,
        const struct dmi_device *from) { return NULL; }
+static inline void dmi_scan_machine(void) { return; }
 static inline int dmi_get_year(int year) { return 0; }
 static inline int dmi_name_in_vendors(const char *s) { return 0; }
 #define dmi_available 0
diff --git a/include/linux/edac.h b/include/linux/edac.h
index eab451e69a91..7cf92e8a4196 100644
--- a/include/linux/edac.h
+++ b/include/linux/edac.h
@@ -3,7 +3,7 @@
 *
 * Author: Dave Jiang <djiang@mvista.com>
 *
- * 2006-2007 (c) MontaVista Software, Inc. This file is licensed under
+ * 2006-2008 (c) MontaVista Software, Inc. This file is licensed under
 * the terms of the GNU General Public License version 2. This program
 * is licensed "as is" without any warranty of any kind, whether express
 * or implied.
@@ -26,4 +26,16 @@ extern atomic_t edac_handlers;
 extern int edac_handler_set(void);
 extern void edac_atomic_assert_error(void);
+static inline void opstate_init(void)
+{
+        switch (edac_op_state) {
+        case EDAC_OPSTATE_POLL:
+        case EDAC_OPSTATE_NMI:
+                break;
+        default:
+                edac_op_state = EDAC_OPSTATE_POLL;
+        }
+        return;
+}
 #endif
diff --git a/include/linux/elf.h b/include/linux/elf.h
index bad1b16ec49a..ff9fbed90123 100644
--- a/include/linux/elf.h
+++ b/include/linux/elf.h
@@ -208,7 +208,7 @@ typedef struct elf32_hdr{
 } Elf32_Ehdr;
 typedef struct elf64_hdr {
-  unsigned char e_ident[16];            /* ELF "magic number" */
+  unsigned char e_ident[EI_NIDENT];     /* ELF "magic number" */
  Elf64_Half e_type;
  Elf64_Half e_machine;
  Elf64_Word e_version;
diff --git a/include/linux/fb.h b/include/linux/fb.h
index 58c57a33e5dd..72295b099228 100644
--- a/include/linux/fb.h
+++ b/include/linux/fb.h
@@ -791,6 +791,17 @@ struct fb_tile_ops {
 */
 #define FBINFO_MISC_ALWAYS_SETPAR   0x40000
+/*
+ * Host and GPU endianness differ.
+ */
+#define FBINFO_FOREIGN_ENDIAN   0x100000
+/*
+ * Big endian math. This is the same flags as above, but with different
+ * meaning, it is set by the fb subsystem depending FOREIGN_ENDIAN flag
+ * and host endianness. Drivers should not use this flag.
+ */
+#define FBINFO_BE_MATH  0x100000
 struct fb_info {
        int node;
        int flags;
@@ -899,15 +910,11 @@ struct fb_info {
 #endif
-#if defined (__BIG_ENDIAN)
+#define FB_LEFT_POS(p, bpp)          (fb_be_math(p) ? (32 - (bpp)) : 0)
-#define FB_LEFT_POS(bpp)          (32 - bpp)
+#define FB_SHIFT_HIGH(p, val, bits)  (fb_be_math(p) ? (val) >> (bits) : \
-#define FB_SHIFT_HIGH(val, bits)  ((val) >> (bits))
+                                                      (val) << (bits))
-#define FB_SHIFT_LOW(val, bits)   ((val) << (bits))
+#define FB_SHIFT_LOW(p, val, bits)   (fb_be_math(p) ? (val) << (bits) : \
-#else
+                                                      (val) >> (bits))
-#define FB_LEFT_POS(bpp)          (0)
-#define FB_SHIFT_HIGH(val, bits)  ((val) << (bits))
-#define FB_SHIFT_LOW(val, bits)   ((val) >> (bits))
-#endif
    /*
     *  `Generic' versions of the frame buffer device operations
@@ -970,6 +977,25 @@ extern void fb_deferred_io_cleanup(struct fb_info *info);
 extern int fb_deferred_io_fsync(struct file *file, struct dentry *dentry,
                                int datasync);
+static inline bool fb_be_math(struct fb_info *info)
+{
+#ifdef CONFIG_FB_FOREIGN_ENDIAN
+#if defined(CONFIG_FB_BOTH_ENDIAN)
+        return info->flags & FBINFO_BE_MATH;
+#elif defined(CONFIG_FB_BIG_ENDIAN)
+        return true;
+#elif defined(CONFIG_FB_LITTLE_ENDIAN)
+        return false;
+#endif /* CONFIG_FB_BOTH_ENDIAN */
+#else
+#ifdef __BIG_ENDIAN
+        return true;
+#else
+        return false;
+#endif /* __BIG_ENDIAN */
+#endif /* CONFIG_FB_FOREIGN_ENDIAN */
+}
 /* drivers/video/fbsysfs.c */
 extern struct fb_info *framebuffer_alloc(size_t size, struct device *dev);
 extern void framebuffer_release(struct fb_info *info);
diff --git a/include/linux/fs.h b/include/linux/fs.h
index d6d7c52055c6..a1ba005d08e7 100644
--- a/include/linux/fs.h
+++ b/include/linux/fs.h
@@ -474,8 +474,8 @@ struct address_space_operations {
        int (*releasepage) (struct page *, gfp_t);
        ssize_t (*direct_IO)(int, struct kiocb *, const struct iovec *iov,
                        loff_t offset, unsigned long nr_segs);
-        struct page* (*get_xip_page)(struct address_space *, sector_t,
+        int (*get_xip_mem)(struct address_space *, pgoff_t, int,
-                        int);
+                                                void **, unsigned long *);
        /* migrate the contents of a page to the specified target */
        int (*migratepage) (struct address_space *,
                        struct page *, struct page *);
@@ -1178,7 +1178,8 @@ struct block_device_operations {
        int (*ioctl) (struct inode *, struct file *, unsigned, unsigned long);
        long (*unlocked_ioctl) (struct file *, unsigned, unsigned long);
        long (*compat_ioctl) (struct file *, unsigned, unsigned long);
-        int (*direct_access) (struct block_device *, sector_t, unsigned long *);
+        int (*direct_access) (struct block_device *, sector_t,
+                                                void **, unsigned long *);
        int (*media_changed) (struct gendisk *);
        int (*revalidate_disk) (struct gendisk *);
        int (*getgeo)(struct block_device *, struct hd_geometry *);
@@ -1520,7 +1521,6 @@ extern int get_sb_pseudo(struct file_system_type *, char *,
        const struct super_operations *ops, unsigned long,
        struct vfsmount *mnt);
 extern int simple_set_mnt(struct vfsmount *mnt, struct super_block *sb);
-int __put_super(struct super_block *sb);
 int __put_super_and_need_restart(struct super_block *sb);
 void unnamed_dev_init(void);
@@ -1964,7 +1964,6 @@ extern int vfs_stat_fd(int dfd, char __user *, struct kstat *);
 extern int vfs_lstat_fd(int dfd, char __user *, struct kstat *);
 extern int vfs_fstat(unsigned int, struct kstat *);
-extern long vfs_ioctl(struct file *filp, unsigned int cmd, unsigned long arg);
 extern int do_vfs_ioctl(struct file *filp, unsigned int fd, unsigned int cmd,
                    unsigned long arg);
diff --git a/include/linux/gfp.h b/include/linux/gfp.h
index 164be9da3c1b..b414be387180 100644
--- a/include/linux/gfp.h
+++ b/include/linux/gfp.h
@@ -40,9 +40,9 @@ struct vm_area_struct;
 #define __GFP_FS        ((__force gfp_t)0x80u)  /* Can call down to low-level FS? */
 #define __GFP_COLD      ((__force gfp_t)0x100u) /* Cache-cold page required */
 #define __GFP_NOWARN    ((__force gfp_t)0x200u) /* Suppress page allocation failure warning */
-#define __GFP_REPEAT    ((__force gfp_t)0x400u) /* Retry the allocation.  Might fail */
+#define __GFP_REPEAT    ((__force gfp_t)0x400u) /* See above */
-#define __GFP_NOFAIL    ((__force gfp_t)0x800u) /* Retry for ever.  Cannot fail */
+#define __GFP_NOFAIL    ((__force gfp_t)0x800u) /* See above */
-#define __GFP_NORETRY   ((__force gfp_t)0x1000u)/* Do not retry.  Might fail */
+#define __GFP_NORETRY   ((__force gfp_t)0x1000u)/* See above */
 #define __GFP_COMP      ((__force gfp_t)0x4000u)/* Add compound page metadata */
 #define __GFP_ZERO      ((__force gfp_t)0x8000u)/* Return zeroed page on success */
 #define __GFP_NOMEMALLOC ((__force gfp_t)0x10000u) /* Don't use emergency reserves */
@@ -119,35 +119,22 @@ static inline int allocflags_to_migratetype(gfp_t gfp_flags)
 static inline enum zone_type gfp_zone(gfp_t flags)
 {
-        int base = 0;
-#ifdef CONFIG_NUMA
-        if (flags & __GFP_THISNODE)
-                base = MAX_NR_ZONES;
-#endif
 #ifdef CONFIG_ZONE_DMA
        if (flags & __GFP_DMA)
-                return base + ZONE_DMA;
+                return ZONE_DMA;
 #endif
 #ifdef CONFIG_ZONE_DMA32
        if (flags & __GFP_DMA32)
-                return base + ZONE_DMA32;
+                return ZONE_DMA32;
 #endif
        if ((flags & (__GFP_HIGHMEM | __GFP_MOVABLE)) ==
                        (__GFP_HIGHMEM | __GFP_MOVABLE))
-                return base + ZONE_MOVABLE;
+                return ZONE_MOVABLE;
 #ifdef CONFIG_HIGHMEM
        if (flags & __GFP_HIGHMEM)
-                return base + ZONE_HIGHMEM;
+                return ZONE_HIGHMEM;
 #endif
-        return base + ZONE_NORMAL;
+        return ZONE_NORMAL;
-}
-static inline gfp_t set_migrateflags(gfp_t gfp, gfp_t migrate_flags)
-{
-        BUG_ON((gfp & GFP_MOVABLE_MASK) == GFP_MOVABLE_MASK);
-        return (gfp & ~(GFP_MOVABLE_MASK)) | migrate_flags;
 }
 /*
@@ -157,13 +144,27 @@ static inline gfp_t set_migrateflags(gfp_t gfp, gfp_t migrate_flags)
 * virtual kernel addresses to the allocated page(s).
 */
+static inline int gfp_zonelist(gfp_t flags)
+{
+        if (NUMA_BUILD && unlikely(flags & __GFP_THISNODE))
+                return 1;
+        return 0;
+}
 /*
 * We get the zone list from the current node and the gfp_mask.
 * This zone list contains a maximum of MAXNODES*MAX_NR_ZONES zones.
+ * There are two zonelists per node, one for all zones with memory and
+ * one containing just zones from the node the zonelist belongs to.
 *
 * For the normal case of non-DISCONTIGMEM systems the NODE_DATA() gets
 * optimized to &contig_page_data at compile-time.
 */
+static inline struct zonelist *node_zonelist(int nid, gfp_t flags)
+{
+        return NODE_DATA(nid)->node_zonelists + gfp_zonelist(flags);
+}
 #ifndef HAVE_ARCH_FREE_PAGE
 static inline void arch_free_page(struct page *page, int order) { }
@@ -174,6 +175,10 @@ static inline void arch_alloc_page(struct page *page, int order) { }
 extern struct page *__alloc_pages(gfp_t, unsigned int, struct zonelist *);
+extern struct page *
+__alloc_pages_nodemask(gfp_t, unsigned int,
+                                struct zonelist *, nodemask_t *nodemask);
 static inline struct page *alloc_pages_node(int nid, gfp_t gfp_mask,
                                                unsigned int order)
 {
@@ -184,8 +189,7 @@ static inline struct page *alloc_pages_node(int nid, gfp_t gfp_mask,
        if (nid < 0)
                nid = numa_node_id();
-        return __alloc_pages(gfp_mask, order,
+        return __alloc_pages(gfp_mask, order, node_zonelist(nid, gfp_mask));
-                NODE_DATA(nid)->node_zonelists + gfp_zone(gfp_mask));
 }
 #ifdef CONFIG_NUMA
diff --git a/include/linux/hid.h b/include/linux/hid.h
index d951ec411241..4ce3b7a979ba 100644
--- a/include/linux/hid.h
+++ b/include/linux/hid.h
@@ -498,13 +498,13 @@ struct hid_parser {
 struct hid_class_descriptor {
        __u8  bDescriptorType;
-        __u16 wDescriptorLength;
+        __le16 wDescriptorLength;
 } __attribute__ ((packed));
 struct hid_descriptor {
        __u8  bLength;
        __u8  bDescriptorType;
-        __u16 bcdHID;
+        __le16 bcdHID;
        __u8  bCountryCode;
        __u8  bNumDescriptors;
diff --git a/include/linux/hugetlb.h b/include/linux/hugetlb.h
index addca4cd4f11..a79e80b689d8 100644
--- a/include/linux/hugetlb.h
+++ b/include/linux/hugetlb.h
@@ -8,6 +8,7 @@
 #include <linux/mempolicy.h>
 #include <linux/shm.h>
 #include <asm/tlbflush.h>
+#include <asm/hugetlb.h>
 struct ctl_table;
@@ -51,51 +52,6 @@ int pmd_huge(pmd_t pmd);
 void hugetlb_change_protection(struct vm_area_struct *vma,
                unsigned long address, unsigned long end, pgprot_t newprot);
-#ifndef ARCH_HAS_HUGEPAGE_ONLY_RANGE
-#define is_hugepage_only_range(mm, addr, len)   0
-#endif
-#ifndef ARCH_HAS_HUGETLB_FREE_PGD_RANGE
-#define hugetlb_free_pgd_range  free_pgd_range
-#else
-void hugetlb_free_pgd_range(struct mmu_gather **tlb, unsigned long addr,
-                            unsigned long end, unsigned long floor,
-                            unsigned long ceiling);
-#endif
-#ifndef ARCH_HAS_PREPARE_HUGEPAGE_RANGE
-/*
- * If the arch doesn't supply something else, assume that hugepage
- * size aligned regions are ok without further preparation.
- */
-static inline int prepare_hugepage_range(unsigned long addr, unsigned long len)
-{
-        if (len & ~HPAGE_MASK)
-                return -EINVAL;
-        if (addr & ~HPAGE_MASK)
-                return -EINVAL;
-        return 0;
-}
-#else
-int prepare_hugepage_range(unsigned long addr, unsigned long len);
-#endif
-#ifndef ARCH_HAS_SETCLEAR_HUGE_PTE
-#define set_huge_pte_at(mm, addr, ptep, pte)    set_pte_at(mm, addr, ptep, pte)
-#define huge_ptep_get_and_clear(mm, addr, ptep) ptep_get_and_clear(mm, addr, ptep)
-#else
-void set_huge_pte_at(struct mm_struct *mm, unsigned long addr,
-                     pte_t *ptep, pte_t pte);
-pte_t huge_ptep_get_and_clear(struct mm_struct *mm, unsigned long addr,
-                              pte_t *ptep);
-#endif
-#ifndef ARCH_HAS_HUGETLB_PREFAULT_HOOK
-#define hugetlb_prefault_arch_hook(mm)          do { } while (0)
-#else
-void hugetlb_prefault_arch_hook(struct mm_struct *mm);
-#endif
 #else /* !CONFIG_HUGETLB_PAGE */
 static inline int is_vm_hugetlb_page(struct vm_area_struct *vma)
diff --git a/include/linux/i2c-id.h b/include/linux/i2c-id.h
index 32eb8bbe4831..580acc93903e 100644
--- a/include/linux/i2c-id.h
+++ b/include/linux/i2c-id.h
@@ -79,12 +79,9 @@
 #define I2C_DRIVERID_UPD64031A  79      /* upd64031a video processor    */
 #define I2C_DRIVERID_SAA717X    80      /* saa717x video encoder        */
 #define I2C_DRIVERID_DS1672     81      /* Dallas/Maxim DS1672 RTC      */
-#define I2C_DRIVERID_X1205      82      /* Xicor/Intersil X1205 RTC     */
-#define I2C_DRIVERID_PCF8563    83      /* Philips PCF8563 RTC          */
 #define I2C_DRIVERID_BT866      85      /* Conexant bt866 video encoder */
 #define I2C_DRIVERID_KS0127     86      /* Samsung ks0127 video decoder */
 #define I2C_DRIVERID_TLV320AIC23B 87    /* TI TLV320AIC23B audio codec  */
-#define I2C_DRIVERID_ISL1208    88      /* Intersil ISL1208 RTC         */
 #define I2C_DRIVERID_WM8731     89      /* Wolfson WM8731 audio codec */
 #define I2C_DRIVERID_WM8750     90      /* Wolfson WM8750 audio codec */
 #define I2C_DRIVERID_WM8753     91      /* Wolfson WM8753 audio codec */
diff --git a/include/linux/i2c.h b/include/linux/i2c.h
index 365e0df3646b..cb63da5c2139 100644
--- a/include/linux/i2c.h
+++ b/include/linux/i2c.h
@@ -126,7 +126,7 @@ struct i2c_driver {
         * With the driver model, device enumeration is NEVER done by drivers;
         * it's done by infrastructure.  (NEW STYLE DRIVERS ONLY)
         */
-        int (*probe)(struct i2c_client *);
+        int (*probe)(struct i2c_client *, const struct i2c_device_id *);
        int (*remove)(struct i2c_client *);
        /* driver model interfaces that don't relate to enumeration  */
@@ -140,11 +140,10 @@ struct i2c_driver {
        int (*command)(struct i2c_client *client,unsigned int cmd, void *arg);
        struct device_driver driver;
+        const struct i2c_device_id *id_table;
 };
 #define to_i2c_driver(d) container_of(d, struct i2c_driver, driver)
-#define I2C_NAME_SIZE   20
 /**
 * struct i2c_client - represent an I2C slave device
 * @flags: I2C_CLIENT_TEN indicates the device uses a ten bit chip address;
@@ -230,17 +229,17 @@ struct i2c_board_info {
 };
 /**
- * I2C_BOARD_INFO - macro used to list an i2c device and its driver
+ * I2C_BOARD_INFO - macro used to list an i2c device and its address
- * @driver: identifies the driver to use with the device
+ * @dev_type: identifies the device type
 * @dev_addr: the device's address on the bus.
 *
 * This macro initializes essential fields of a struct i2c_board_info,
 * declaring what has been provided on a particular board.  Optional
- * fields (such as the chip type, its associated irq, or device-specific
+ * fields (such as associated irq, or device-specific platform_data)
- * platform_data) are provided using conventional syntax.
+ * are provided using conventional syntax.
 */
-#define I2C_BOARD_INFO(driver,dev_addr) \
+#define I2C_BOARD_INFO(dev_type,dev_addr) \
-        .driver_name = (driver), .addr = (dev_addr)
+        .type = (dev_type), .addr = (dev_addr)
 /* Add-on boards should register/unregister their devices; e.g. a board
diff --git a/include/linux/i2o.h b/include/linux/i2o.h
index e92170dda245..f65e58a1d925 100644
--- a/include/linux/i2o.h
+++ b/include/linux/i2o.h
@@ -613,14 +613,9 @@ struct i2o_sys_tbl {
 extern struct list_head i2o_controllers;
 /* Message functions */
-static inline struct i2o_message *i2o_msg_get(struct i2o_controller *);
 extern struct i2o_message *i2o_msg_get_wait(struct i2o_controller *, int);
-static inline void i2o_msg_post(struct i2o_controller *, struct i2o_message *);
-static inline int i2o_msg_post_wait(struct i2o_controller *,
-                                    struct i2o_message *, unsigned long);
 extern int i2o_msg_post_wait_mem(struct i2o_controller *, struct i2o_message *,
                                 unsigned long, struct i2o_dma *);
-static inline void i2o_flush_reply(struct i2o_controller *, u32);
 /* IOP functions */
 extern int i2o_status_get(struct i2o_controller *);
diff --git a/include/linux/ide.h b/include/linux/ide.h
index 32fd77bb4436..b0135b0c3a04 100644
--- a/include/linux/ide.h
+++ b/include/linux/ide.h
@@ -427,6 +427,8 @@ struct ide_dma_ops {
        void    (*dma_timeout)(struct ide_drive_s *);
 };
+struct ide_task_s;
 typedef struct hwif_s {
        struct hwif_s *next;            /* for linked-list in ide_hwgroup_t */
        struct hwif_s *mate;            /* other hwif from same PCI chip */
@@ -467,24 +469,18 @@ typedef struct hwif_s {
        const struct ide_port_ops       *port_ops;
        const struct ide_dma_ops        *dma_ops;
-        void (*ata_input_data)(ide_drive_t *, void *, u32);
+        void (*tf_load)(ide_drive_t *, struct ide_task_s *);
-        void (*ata_output_data)(ide_drive_t *, void *, u32);
+        void (*tf_read)(ide_drive_t *, struct ide_task_s *);
-        void (*atapi_input_bytes)(ide_drive_t *, void *, u32);
+        void (*input_data)(ide_drive_t *, struct request *, void *, unsigned);
-        void (*atapi_output_bytes)(ide_drive_t *, void *, u32);
+        void (*output_data)(ide_drive_t *, struct request *, void *, unsigned);
        void (*ide_dma_clear_irq)(ide_drive_t *drive);
        void (*OUTB)(u8 addr, unsigned long port);
        void (*OUTBSYNC)(ide_drive_t *drive, u8 addr, unsigned long port);
-        void (*OUTW)(u16 addr, unsigned long port);
-        void (*OUTSW)(unsigned long port, void *addr, u32 count);
-        void (*OUTSL)(unsigned long port, void *addr, u32 count);
        u8  (*INB)(unsigned long port);
-        u16 (*INW)(unsigned long port);
-        void (*INSW)(unsigned long port, void *addr, u32 count);
-        void (*INSL)(unsigned long port, void *addr, u32 count);
        /* dma physical region descriptor table (cpu view) */
        unsigned int    *dmatable_cpu;
@@ -509,10 +505,7 @@ typedef struct hwif_s {
        unsigned long   dma_base;       /* base addr for dma ports */
        unsigned long   dma_command;    /* dma command register */
-        unsigned long   dma_vendor1;    /* dma vendor 1 register */
        unsigned long   dma_status;     /* dma status register */
-        unsigned long   dma_vendor3;    /* dma vendor 3 register */
-        unsigned long   dma_prdtable;   /* actual prd table address */
        unsigned long   config_data;    /* for use by chipset-specific code */
        unsigned long   select_data;    /* for use by chipset-specific code */
@@ -547,7 +540,7 @@ typedef ide_startstop_t (ide_handler_t)(ide_drive_t *);
 typedef int (ide_expiry_t)(ide_drive_t *);
 /* used by ide-cd, ide-floppy, etc. */
-typedef void (xfer_func_t)(ide_drive_t *, void *, u32);
+typedef void (xfer_func_t)(ide_drive_t *, struct request *rq, void *, unsigned);
 typedef struct hwgroup_s {
                /* irq handler, if active */
@@ -829,6 +822,10 @@ extern void ide_set_handler (ide_drive_t *drive, ide_handler_t *handler, unsigne
 void ide_execute_command(ide_drive_t *, u8, ide_handler_t *, unsigned int,
                         ide_expiry_t *);
+void ide_execute_pkt_cmd(ide_drive_t *);
+void ide_pad_transfer(ide_drive_t *, int, int);
 ide_startstop_t __ide_error(ide_drive_t *, struct request *, u8, u8);
 ide_startstop_t ide_error (ide_drive_t *drive, const char *msg, byte stat);
@@ -965,8 +962,7 @@ typedef struct ide_task_s {
        void                    *special;       /* valid_t generally */
 } ide_task_t;
-void ide_tf_load(ide_drive_t *, ide_task_t *);
+void ide_tf_dump(const char *, struct ide_taskfile *);
-void ide_tf_read(ide_drive_t *, ide_task_t *);
 extern void SELECT_DRIVE(ide_drive_t *);
 extern void SELECT_MASK(ide_drive_t *, int);
@@ -1072,6 +1068,8 @@ enum {
        IDE_HFLAG_NO_DMA                = (1 << 14),
        /* check if host is PCI IDE device before allowing DMA */
        IDE_HFLAG_NO_AUTODMA            = (1 << 15),
+        /* host uses MMIO */
+        IDE_HFLAG_MMIO                  = (1 << 16),
        /* host is CS5510/CS5520 */
        IDE_HFLAG_CS5520                = IDE_HFLAG_VDMA,
        /* no LBA48 */
@@ -1360,27 +1358,4 @@ static inline u8 ide_read_error(ide_drive_t *drive)
        return hwif->INB(hwif->io_ports.error_addr);
 }
-/*
- * Too bad. The drive wants to send us data which we are not ready to accept.
- * Just throw it away.
- */
-static inline void ide_atapi_discard_data(ide_drive_t *drive, unsigned bcount)
-{
-        ide_hwif_t *hwif = drive->hwif;
-        /* FIXME: use ->atapi_input_bytes */
-        while (bcount--)
-                (void)hwif->INB(hwif->io_ports.data_addr);
-}
-static inline void ide_atapi_write_zeros(ide_drive_t *drive, unsigned bcount)
-{
-        ide_hwif_t *hwif = drive->hwif;
-        /* FIXME: use ->atapi_output_bytes */
-        while (bcount--)
-                hwif->OUTB(0, hwif->io_ports.data_addr);
-}
 #endif /* _IDE_H */
diff --git a/include/linux/idr.h b/include/linux/idr.h
index 0edda411959c..9a2d762124de 100644
--- a/include/linux/idr.h
+++ b/include/linux/idr.h
@@ -14,6 +14,7 @@
 #include <linux/types.h>
 #include <linux/bitops.h>
+#include <linux/init.h>
 #if BITS_PER_LONG == 32
 # define IDR_BITS 5
@@ -115,4 +116,6 @@ void ida_remove(struct ida *ida, int id);
 void ida_destroy(struct ida *ida);
 void ida_init(struct ida *ida);
+void __init idr_init_cache(void);
 #endif /* __IDR_H__ */
diff --git a/include/linux/init.h b/include/linux/init.h
index fb58c0493cf2..21d658cdfa27 100644
--- a/include/linux/init.h
+++ b/include/linux/init.h
@@ -147,6 +147,8 @@ extern unsigned int reset_devices;
 void setup_arch(char **);
 void prepare_namespace(void);
+extern void (*late_time_init)(void);
 #endif
  
 #ifndef MODULE
diff --git a/include/linux/init_task.h b/include/linux/init_task.h
index 37a6f5bc4a92..bf6b8a61f8db 100644
--- a/include/linux/init_task.h
+++ b/include/linux/init_task.h
@@ -9,6 +9,7 @@
 #include <linux/ipc.h>
 #include <linux/pid_namespace.h>
 #include <linux/user_namespace.h>
+#include <linux/securebits.h>
 #include <net/net_namespace.h>
 #define INIT_FDTABLE \
@@ -172,7 +173,7 @@ extern struct group_info init_groups;
        .cap_inheritable = CAP_INIT_INH_SET,                            \
        .cap_permitted  = CAP_FULL_SET,                                 \
        .cap_bset       = CAP_INIT_BSET,                                \
-        .keep_capabilities = 0,                                         \
+        .securebits     = SECUREBITS_DEFAULT,                           \
        .user           = INIT_USER,                                    \
        .comm           = "swapper",                                    \
        .thread         = INIT_THREAD,                                  \
diff --git a/include/linux/interrupt.h b/include/linux/interrupt.h
index b5fef13148bd..f1fc7470d26c 100644
--- a/include/linux/interrupt.h
+++ b/include/linux/interrupt.h
@@ -289,6 +289,7 @@ struct softirq_action
 };
 asmlinkage void do_softirq(void);
+asmlinkage void __do_softirq(void);
 extern void open_softirq(int nr, void (*action)(struct softirq_action*), void *data);
 extern void softirq_init(void);
 #define __raise_softirq_irqoff(nr) do { or_softirq_pending(1UL << (nr)); } while (0)
diff --git a/include/linux/ipc_namespace.h b/include/linux/ipc_namespace.h
index e4451d1da753..ea6c18a8b0d4 100644
--- a/include/linux/ipc_namespace.h
+++ b/include/linux/ipc_namespace.h
@@ -4,6 +4,17 @@
 #include <linux/err.h>
 #include <linux/idr.h>
 #include <linux/rwsem.h>
+#include <linux/notifier.h>
+/*
+ * ipc namespace events
+ */
+#define IPCNS_MEMCHANGED   0x00000001   /* Notify lowmem size changed */
+#define IPCNS_CREATED  0x00000002   /* Notify new ipc namespace created */
+#define IPCNS_REMOVED  0x00000003   /* Notify ipc namespace removed */
+#define IPCNS_CALLBACK_PRI 0
 struct ipc_ids {
        int in_use;
@@ -30,15 +41,24 @@ struct ipc_namespace {
        size_t          shm_ctlall;
        int             shm_ctlmni;
        int             shm_tot;
+        struct notifier_block ipcns_nb;
 };
 extern struct ipc_namespace init_ipc_ns;
+extern atomic_t nr_ipc_ns;
 #ifdef CONFIG_SYSVIPC
 #define INIT_IPC_NS(ns)         .ns             = &init_ipc_ns,
-#else
+extern int register_ipcns_notifier(struct ipc_namespace *);
+extern int cond_register_ipcns_notifier(struct ipc_namespace *);
+extern int unregister_ipcns_notifier(struct ipc_namespace *);
+extern int ipcns_notify(unsigned long);
+#else /* CONFIG_SYSVIPC */
 #define INIT_IPC_NS(ns)
-#endif
+#endif /* CONFIG_SYSVIPC */
 #if defined(CONFIG_SYSVIPC) && defined(CONFIG_IPC_NS)
 extern void free_ipc_ns(struct kref *kref);
diff --git a/include/linux/ipmi.h b/include/linux/ipmi.h
index c5bd28b69aec..7ebdb4fb4e54 100644
--- a/include/linux/ipmi.h
+++ b/include/linux/ipmi.h
@@ -64,7 +64,7 @@
 * applications and another for userland applications.  The
 * capabilities are basically the same for both interface, although
 * the interfaces are somewhat different.  The stuff in the
- * #ifdef KERNEL below is the in-kernel interface.  The userland
+ * #ifdef __KERNEL__ below is the in-kernel interface.  The userland
 * interface is defined later in the file.  */
@@ -75,8 +75,7 @@
 * work for sockets.
 */
 #define IPMI_MAX_ADDR_SIZE 32
-struct ipmi_addr
+struct ipmi_addr {
-{
         /* Try to take these from the "Channel Medium Type" table
            in section 6.5 of the IPMI 1.5 manual. */
        int   addr_type;
@@ -90,8 +89,7 @@ struct ipmi_addr
 * 0), or IPMC_BMC_CHANNEL if communicating directly with the BMC.
 */
 #define IPMI_SYSTEM_INTERFACE_ADDR_TYPE 0x0c
-struct ipmi_system_interface_addr
+struct ipmi_system_interface_addr {
-{
        int           addr_type;
        short         channel;
        unsigned char lun;
@@ -100,10 +98,9 @@ struct ipmi_system_interface_addr
 /* An IPMB Address. */
 #define IPMI_IPMB_ADDR_TYPE             0x01
 /* Used for broadcast get device id as described in section 17.9 of the
-   IPMI 1.5 manual. */ 
+   IPMI 1.5 manual. */
 #define IPMI_IPMB_BROADCAST_ADDR_TYPE   0x41
-struct ipmi_ipmb_addr
+struct ipmi_ipmb_addr {
-{
        int           addr_type;
        short         channel;
        unsigned char slave_addr;
@@ -128,8 +125,7 @@ struct ipmi_ipmb_addr
 * message is a little weird, but this is required.
 */
 #define IPMI_LAN_ADDR_TYPE              0x04
-struct ipmi_lan_addr
+struct ipmi_lan_addr {
-{
        int           addr_type;
        short         channel;
        unsigned char privilege;
@@ -162,16 +158,14 @@ struct ipmi_lan_addr
 * byte of data in the response (as the spec shows the messages laid
 * out).
 */
-struct ipmi_msg
+struct ipmi_msg {
-{
        unsigned char  netfn;
        unsigned char  cmd;
        unsigned short data_len;
        unsigned char  __user *data;
 };
-struct kernel_ipmi_msg
+struct kernel_ipmi_msg {
-{
        unsigned char  netfn;
        unsigned char  cmd;
        unsigned short data_len;
@@ -239,12 +233,11 @@ typedef struct ipmi_user *ipmi_user_t;
 * used after the message is delivered, so the upper layer may use the
 * link to build a linked list, if it likes.
 */
-struct ipmi_recv_msg
+struct ipmi_recv_msg {
-{
        struct list_head link;
        /* The type of message as defined in the "Receive Types"
-           defines above. */
+           defines above. */
        int              recv_type;
        ipmi_user_t      user;
@@ -271,9 +264,8 @@ struct ipmi_recv_msg
 /* Allocate and free the receive message. */
 void ipmi_free_recv_msg(struct ipmi_recv_msg *msg);
-struct ipmi_user_hndl
+struct ipmi_user_hndl {
-{
+        /* Routine type to call when a message needs to be routed to
-        /* Routine type to call when a message needs to be routed to
           the upper layer.  This will be called with some locks held,
           the only IPMI routines that can be called are ipmi_request
           and the alloc/free operations.  The handler_data is the
@@ -368,9 +360,8 @@ int ipmi_request_supply_msgs(ipmi_user_t          user,
 * Poll the IPMI interface for the user.  This causes the IPMI code to
 * do an immediate check for information from the driver and handle
 * anything that is immediately pending.  This will not block in any
- * way.  This is useful if you need to implement polling from the user
+ * way.  This is useful if you need to spin waiting for something to
- * for things like modifying the watchdog timeout when a panic occurs
+ * happen in the IPMI driver.
- * or disabling the watchdog timer on a reboot.
 */
 void ipmi_poll_interface(ipmi_user_t user);
@@ -422,12 +413,6 @@ int ipmi_get_maintenance_mode(ipmi_user_t user);
 int ipmi_set_maintenance_mode(ipmi_user_t user, int mode);
 /*
- * Allow run-to-completion mode to be set for the interface of
- * a specific user.
- */
-void ipmi_user_set_run_to_completion(ipmi_user_t user, int val);
-/*
 * When the user is created, it will not receive IPMI events by
 * default.  The user must set this to TRUE to get incoming events.
 * The first user that sets this to TRUE will receive all events that
@@ -440,8 +425,7 @@ int ipmi_set_gets_events(ipmi_user_t user, int val);
 * every existing interface when a new watcher is registered with
 * ipmi_smi_watcher_register().
 */
-struct ipmi_smi_watcher
+struct ipmi_smi_watcher {
-{
        struct list_head link;
        /* You must set the owner to the current module, if you are in
@@ -512,8 +496,7 @@ int ipmi_validate_addr(struct ipmi_addr *addr, int len);
 /* Messages sent to the interface are this format. */
-struct ipmi_req
+struct ipmi_req {
-{
        unsigned char __user *addr; /* Address to send the message to. */
        unsigned int  addr_len;
@@ -538,12 +521,11 @@ struct ipmi_req
 /* Messages sent to the interface with timing parameters are this
   format. */
-struct ipmi_req_settime
+struct ipmi_req_settime {
-{
        struct ipmi_req req;
        /* See ipmi_request_settime() above for details on these
-           values. */
+           values. */
        int          retries;
        unsigned int retry_time_ms;
 };
@@ -560,8 +542,7 @@ struct ipmi_req_settime
                                             struct ipmi_req_settime)
 /* Messages received from the interface are this format. */
-struct ipmi_recv
+struct ipmi_recv {
-{
        int     recv_type; /* Is this a command, response or an
                              asyncronous event. */
@@ -607,13 +588,12 @@ struct ipmi_recv
                                              struct ipmi_recv)
 /* Register to get commands from other entities on this interface. */
-struct ipmi_cmdspec
+struct ipmi_cmdspec {
-{
        unsigned char netfn;
        unsigned char cmd;
 };
-/* 
+/*
 * Register to receive a specific command.  error values:
 *   - EFAULT - an address supplied was invalid.
 *   - EBUSY - The netfn/cmd supplied was already in use.
@@ -636,8 +616,7 @@ struct ipmi_cmdspec
 * else.  The chans field is a bitmask, (1 << channel) for each channel.
 * It may be IPMI_CHAN_ALL for all channels.
 */
-struct ipmi_cmdspec_chans
+struct ipmi_cmdspec_chans {
-{
        unsigned int netfn;
        unsigned int cmd;
        unsigned int chans;
@@ -659,7 +638,7 @@ struct ipmi_cmdspec_chans
 #define IPMICTL_UNREGISTER_FOR_CMD_CHANS _IOR(IPMI_IOC_MAGIC, 29,       \
                                             struct ipmi_cmdspec_chans)
-/* 
+/*
 * Set whether this interface receives events.  Note that the first
 * user registered for events will get all pending events for the
 * interface.  error values:
@@ -675,15 +654,18 @@ struct ipmi_cmdspec_chans
 * things it takes to determine your address (if not the BMC) and set
 * it for everyone else.  You should probably leave the LUN alone.
 */
-struct ipmi_channel_lun_address_set
+struct ipmi_channel_lun_address_set {
-{
        unsigned short channel;
        unsigned char  value;
 };
-#define IPMICTL_SET_MY_CHANNEL_ADDRESS_CMD _IOR(IPMI_IOC_MAGIC, 24, struct ipmi_channel_lun_address_set)
+#define IPMICTL_SET_MY_CHANNEL_ADDRESS_CMD \
-#define IPMICTL_GET_MY_CHANNEL_ADDRESS_CMD _IOR(IPMI_IOC_MAGIC, 25, struct ipmi_channel_lun_address_set)
+        _IOR(IPMI_IOC_MAGIC, 24, struct ipmi_channel_lun_address_set)
-#define IPMICTL_SET_MY_CHANNEL_LUN_CMD     _IOR(IPMI_IOC_MAGIC, 26, struct ipmi_channel_lun_address_set)
+#define IPMICTL_GET_MY_CHANNEL_ADDRESS_CMD \
-#define IPMICTL_GET_MY_CHANNEL_LUN_CMD     _IOR(IPMI_IOC_MAGIC, 27, struct ipmi_channel_lun_address_set)
+        _IOR(IPMI_IOC_MAGIC, 25, struct ipmi_channel_lun_address_set)
+#define IPMICTL_SET_MY_CHANNEL_LUN_CMD \
+        _IOR(IPMI_IOC_MAGIC, 26, struct ipmi_channel_lun_address_set)
+#define IPMICTL_GET_MY_CHANNEL_LUN_CMD \
+        _IOR(IPMI_IOC_MAGIC, 27, struct ipmi_channel_lun_address_set)
 /* Legacy interfaces, these only set IPMB 0. */
 #define IPMICTL_SET_MY_ADDRESS_CMD      _IOR(IPMI_IOC_MAGIC, 17, unsigned int)
 #define IPMICTL_GET_MY_ADDRESS_CMD      _IOR(IPMI_IOC_MAGIC, 18, unsigned int)
@@ -694,8 +676,7 @@ struct ipmi_channel_lun_address_set
 * Get/set the default timing values for an interface.  You shouldn't
 * generally mess with these.
 */
-struct ipmi_timing_parms
+struct ipmi_timing_parms {
-{
        int          retries;
        unsigned int retry_time_ms;
 };
diff --git a/include/linux/ipmi_smi.h b/include/linux/ipmi_smi.h
index 6e8cec503380..62b73668b602 100644
--- a/include/linux/ipmi_smi.h
+++ b/include/linux/ipmi_smi.h
@@ -60,8 +60,7 @@ typedef struct ipmi_smi *ipmi_smi_t;
 * asynchronous data and messages and request them from the
 * interface.
 */
-struct ipmi_smi_msg
+struct ipmi_smi_msg {
-{
        struct list_head link;
        long    msgid;
@@ -74,12 +73,11 @@ struct ipmi_smi_msg
        unsigned char rsp[IPMI_MAX_MSG_LENGTH];
        /* Will be called when the system is done with the message
-           (presumably to free it). */
+           (presumably to free it). */
        void (*done)(struct ipmi_smi_msg *msg);
 };
-struct ipmi_smi_handlers
+struct ipmi_smi_handlers {
-{
        struct module *owner;
        /* The low-level interface cannot start sending messages to
@@ -231,7 +229,7 @@ static inline void ipmi_free_smi_msg(struct ipmi_smi_msg *msg)
   directory for this interface.  Note that the entry will
   automatically be dstroyed when the interface is destroyed. */
 int ipmi_smi_add_proc_entry(ipmi_smi_t smi, char *name,
-                            read_proc_t *read_proc, write_proc_t *write_proc,
+                            read_proc_t *read_proc,
                            void *data, struct module *owner);
 #endif /* __LINUX_IPMI_SMI_H */
diff --git a/include/linux/kbuild.h b/include/linux/kbuild.h
new file mode 100644
index 000000000000..22a72198c14b
--- /dev/null
+++ b/include/linux/kbuild.h
@@ -0,0 +1,15 @@
+#ifndef __LINUX_KBUILD_H
+#define __LINUX_KBUILD_H
+#define DEFINE(sym, val) \
+        asm volatile("\n->" #sym " %0 " #val : : "i" (val))
+#define BLANK() asm volatile("\n->" : : )
+#define OFFSET(sym, str, mem) \
+        DEFINE(sym, offsetof(struct str, mem))
+#define COMMENT(x) \
+        asm volatile("\n->#" x)
+#endif
diff --git a/include/linux/kernel.h b/include/linux/kernel.h
index cd6d02cf854d..53839ba265ec 100644
--- a/include/linux/kernel.h
+++ b/include/linux/kernel.h
@@ -20,6 +20,9 @@
 extern const char linux_banner[];
 extern const char linux_proc_banner[];
+#define USHORT_MAX      ((u16)(~0U))
+#define SHORT_MAX       ((s16)(USHORT_MAX>>1))
+#define SHORT_MIN       (-SHORT_MAX - 1)
 #define INT_MAX         ((int)(~0U>>1))
 #define INT_MIN         (-INT_MAX - 1)
 #define UINT_MAX        (~0U)
@@ -188,6 +191,7 @@ extern int log_buf_copy(char *dest, int idx, int len);
 extern int printk_ratelimit_jiffies;
 extern int printk_ratelimit_burst;
 extern int printk_ratelimit(void);
+extern int __ratelimit(int ratelimit_jiffies, int ratelimit_burst);
 extern int __printk_ratelimit(int ratelimit_jiffies, int ratelimit_burst);
 extern bool printk_timed_ratelimit(unsigned long *caller_jiffies,
                                   unsigned int interval_msec);
@@ -255,6 +259,7 @@ extern enum system_states {
 #define TAINT_USER                      (1<<6)
 #define TAINT_DIE                       (1<<7)
 #define TAINT_OVERRIDDEN_ACPI_TABLE     (1<<8)
+#define TAINT_WARN                      (1<<9)
 extern void dump_stack(void) __cold;
diff --git a/include/linux/key.h b/include/linux/key.h
index a70b8a8f2005..c45c962d1cc5 100644
--- a/include/linux/key.h
+++ b/include/linux/key.h
@@ -19,6 +19,7 @@
 #include <linux/list.h>
 #include <linux/rbtree.h>
 #include <linux/rcupdate.h>
+#include <linux/sysctl.h>
 #include <asm/atomic.h>
 #ifdef __KERNEL__
@@ -67,6 +68,8 @@ struct key;
 #define KEY_OTH_SETATTR 0x00000020
 #define KEY_OTH_ALL     0x0000003f
+#define KEY_PERM_UNDEF  0xffffffff
 struct seq_file;
 struct user_struct;
 struct signal_struct;
@@ -208,16 +211,19 @@ extern struct key *request_key(struct key_type *type,
 extern struct key *request_key_with_auxdata(struct key_type *type,
                                            const char *description,
-                                            const char *callout_info,
+                                            const void *callout_info,
+                                            size_t callout_len,
                                            void *aux);
 extern struct key *request_key_async(struct key_type *type,
                                     const char *description,
-                                     const char *callout_info);
+                                     const void *callout_info,
+                                     size_t callout_len);
 extern struct key *request_key_async_with_auxdata(struct key_type *type,
                                                  const char *description,
-                                                  const char *callout_info,
+                                                  const void *callout_info,
+                                                  size_t callout_len,
                                                  void *aux);
 extern int wait_for_key_construction(struct key *key, bool intr);
@@ -229,6 +235,7 @@ extern key_ref_t key_create_or_update(key_ref_t keyring,
                                      const char *description,
                                      const void *payload,
                                      size_t plen,
+                                      key_perm_t perm,
                                      unsigned long flags);
 extern int key_update(key_ref_t key,
@@ -257,14 +264,18 @@ extern int keyring_add_key(struct key *keyring,
 extern struct key *key_lookup(key_serial_t id);
-#define key_serial(key) ((key) ? (key)->serial : 0)
+static inline key_serial_t key_serial(struct key *key)
+{
+        return key ? key->serial : 0;
+}
+#ifdef CONFIG_SYSCTL
+extern ctl_table key_sysctls[];
+#endif
 /*
 * the userspace interface
 */
-extern struct key root_user_keyring, root_session_keyring;
-extern int alloc_uid_keyring(struct user_struct *user,
-                             struct task_struct *ctx);
 extern void switch_uid_keyring(struct user_struct *new_user);
 extern int copy_keys(unsigned long clone_flags, struct task_struct *tsk);
 extern int copy_thread_group_keys(struct task_struct *tsk);
@@ -293,7 +304,6 @@ extern void key_init(void);
 #define make_key_ref(k, p)                      ({ NULL; })
 #define key_ref_to_ptr(k)               ({ NULL; })
 #define is_key_possessed(k)             0
-#define alloc_uid_keyring(u,c)          0
 #define switch_uid_keyring(u)           do { } while(0)
 #define __install_session_keyring(t, k) ({ NULL; })
 #define copy_keys(f,t)                  0
@@ -306,10 +316,6 @@ extern void key_init(void);
 #define key_fsgid_changed(t)            do { } while(0)
 #define key_init()                      do { } while(0)
-/* Initial keyrings */
-extern struct key root_user_keyring;
-extern struct key root_session_keyring;
 #endif /* CONFIG_KEYS */
 #endif /* __KERNEL__ */
 #endif /* _LINUX_KEY_H */
diff --git a/include/linux/keyctl.h b/include/linux/keyctl.h
index 3365945640c9..656ee6b77a4a 100644
--- a/include/linux/keyctl.h
+++ b/include/linux/keyctl.h
@@ -49,5 +49,6 @@
 #define KEYCTL_SET_REQKEY_KEYRING       14      /* set default request-key keyring */
 #define KEYCTL_SET_TIMEOUT              15      /* set key timeout */
 #define KEYCTL_ASSUME_AUTHORITY         16      /* assume request_key() authorisation */
+#define KEYCTL_GET_SECURITY             17      /* get key security label */
 #endif /*  _LINUX_KEYCTL_H */
diff --git a/include/linux/kprobes.h b/include/linux/kprobes.h
index 0f28486f6360..1036631ff4fa 100644
--- a/include/linux/kprobes.h
+++ b/include/linux/kprobes.h
@@ -173,6 +173,13 @@ struct kretprobe_blackpoint {
        const char *name;
        void *addr;
 };
+struct kprobe_blackpoint {
+        const char *name;
+        unsigned long start_addr;
+        unsigned long range;
+};
 extern struct kretprobe_blackpoint kretprobe_blacklist[];
 static inline void kretprobe_assert(struct kretprobe_instance *ri,
@@ -227,15 +234,21 @@ static inline struct kprobe_ctlblk *get_kprobe_ctlblk(void)
 int register_kprobe(struct kprobe *p);
 void unregister_kprobe(struct kprobe *p);
+int register_kprobes(struct kprobe **kps, int num);
+void unregister_kprobes(struct kprobe **kps, int num);
 int setjmp_pre_handler(struct kprobe *, struct pt_regs *);
 int longjmp_break_handler(struct kprobe *, struct pt_regs *);
 int register_jprobe(struct jprobe *p);
 void unregister_jprobe(struct jprobe *p);
+int register_jprobes(struct jprobe **jps, int num);
+void unregister_jprobes(struct jprobe **jps, int num);
 void jprobe_return(void);
 unsigned long arch_deref_entry_point(void *);
 int register_kretprobe(struct kretprobe *rp);
 void unregister_kretprobe(struct kretprobe *rp);
+int register_kretprobes(struct kretprobe **rps, int num);
+void unregister_kretprobes(struct kretprobe **rps, int num);
 void kprobe_flush_task(struct task_struct *tk);
 void recycle_rp_inst(struct kretprobe_instance *ri, struct hlist_head *head);
@@ -254,16 +267,30 @@ static inline int register_kprobe(struct kprobe *p)
 {
        return -ENOSYS;
 }
+static inline int register_kprobes(struct kprobe **kps, int num)
+{
+        return -ENOSYS;
+}
 static inline void unregister_kprobe(struct kprobe *p)
 {
 }
+static inline void unregister_kprobes(struct kprobe **kps, int num)
+{
+}
 static inline int register_jprobe(struct jprobe *p)
 {
        return -ENOSYS;
 }
+static inline int register_jprobes(struct jprobe **jps, int num)
+{
+        return -ENOSYS;
+}
 static inline void unregister_jprobe(struct jprobe *p)
 {
 }
+static inline void unregister_jprobes(struct jprobe **jps, int num)
+{
+}
 static inline void jprobe_return(void)
 {
 }
@@ -271,9 +298,16 @@ static inline int register_kretprobe(struct kretprobe *rp)
 {
        return -ENOSYS;
 }
+static inline int register_kretprobes(struct kretprobe **rps, int num)
+{
+        return -ENOSYS;
+}
 static inline void unregister_kretprobe(struct kretprobe *rp)
 {
 }
+static inline void unregister_kretprobes(struct kretprobe **rps, int num)
+{
+}
 static inline void kprobe_flush_task(struct task_struct *tk)
 {
 }
diff --git a/include/linux/list.h b/include/linux/list.h
index dac16f99c701..7627508f1b74 100644
--- a/include/linux/list.h
+++ b/include/linux/list.h
@@ -319,7 +319,16 @@ static inline int list_empty_careful(const struct list_head *head)
        return (next == head) && (next == head->prev);
 }
-static inline void __list_splice(struct list_head *list,
+/**
+ * list_is_singular - tests whether a list has just one entry.
+ * @head: the list to test.
+ */
+static inline int list_is_singular(const struct list_head *head)
+{
+        return !list_empty(head) && (head->next == head->prev);
+}
+static inline void __list_splice(const struct list_head *list,
                                 struct list_head *head)
 {
        struct list_head *first = list->next;
@@ -338,7 +347,8 @@ static inline void __list_splice(struct list_head *list,
 * @list: the new list to add.
 * @head: the place to add it in the first list.
 */
-static inline void list_splice(struct list_head *list, struct list_head *head)
+static inline void list_splice(const struct list_head *list,
+                                struct list_head *head)
 {
        if (!list_empty(list))
                __list_splice(list, head);
diff --git a/include/linux/lmb.h b/include/linux/lmb.h
index 271153d27fba..c46c89505dac 100644
--- a/include/linux/lmb.h
+++ b/include/linux/lmb.h
@@ -40,7 +40,8 @@ extern struct lmb lmb;
 extern void __init lmb_init(void);
 extern void __init lmb_analyze(void);
-extern long __init lmb_add(u64 base, u64 size);
+extern long lmb_add(u64 base, u64 size);
+extern long lmb_remove(u64 base, u64 size);
 extern long __init lmb_reserve(u64 base, u64 size);
 extern u64 __init lmb_alloc_nid(u64 size, u64 align, int nid,
                                u64 (*nid_range)(u64, u64, int *));
@@ -53,6 +54,7 @@ extern u64 __init lmb_phys_mem_size(void);
 extern u64 __init lmb_end_of_DRAM(void);
 extern void __init lmb_enforce_memory_limit(u64 memory_limit);
 extern int __init lmb_is_reserved(u64 addr);
+extern int lmb_find(struct lmb_property *res);
 extern void lmb_dump_all(void);
diff --git a/include/linux/mca-legacy.h b/include/linux/mca-legacy.h
index f2bb770e530a..7a3aea845902 100644
--- a/include/linux/mca-legacy.h
+++ b/include/linux/mca-legacy.h
@@ -34,7 +34,6 @@
 extern int mca_find_adapter(int id, int start);
 extern int mca_find_unused_adapter(int id, int start);
-extern int mca_is_adapter_used(int slot);
 extern int mca_mark_as_used(int slot);
 extern void mca_mark_as_unused(int slot);
diff --git a/include/linux/memcontrol.h b/include/linux/memcontrol.h
index 8b1c4295848b..e6608776bc96 100644
--- a/include/linux/memcontrol.h
+++ b/include/linux/memcontrol.h
@@ -27,9 +27,6 @@ struct mm_struct;
 #ifdef CONFIG_CGROUP_MEM_RES_CTLR
-extern void mm_init_cgroup(struct mm_struct *mm, struct task_struct *p);
-extern void mm_free_cgroup(struct mm_struct *mm);
 #define page_reset_bad_cgroup(page)     ((page)->page_cgroup = 0)
 extern struct page_cgroup *page_get_page_cgroup(struct page *page);
@@ -48,8 +45,10 @@ extern unsigned long mem_cgroup_isolate_pages(unsigned long nr_to_scan,
 extern void mem_cgroup_out_of_memory(struct mem_cgroup *mem, gfp_t gfp_mask);
 int task_in_mem_cgroup(struct task_struct *task, const struct mem_cgroup *mem);
+extern struct mem_cgroup *mem_cgroup_from_task(struct task_struct *p);
 #define mm_match_cgroup(mm, cgroup)     \
-        ((cgroup) == rcu_dereference((mm)->mem_cgroup))
+        ((cgroup) == mem_cgroup_from_task((mm)->owner))
 extern int mem_cgroup_prepare_migration(struct page *page);
 extern void mem_cgroup_end_migration(struct page *page);
@@ -73,15 +72,6 @@ extern long mem_cgroup_calc_reclaim_inactive(struct mem_cgroup *mem,
                                struct zone *zone, int priority);
 #else /* CONFIG_CGROUP_MEM_RES_CTLR */
-static inline void mm_init_cgroup(struct mm_struct *mm,
-                                        struct task_struct *p)
-{
-}
-static inline void mm_free_cgroup(struct mm_struct *mm)
-{
-}
 static inline void page_reset_bad_cgroup(struct page *page)
 {
 }
diff --git a/include/linux/memory.h b/include/linux/memory.h
index f80e0e331cb7..2f5f8a5ef2a0 100644
--- a/include/linux/memory.h
+++ b/include/linux/memory.h
@@ -53,6 +53,13 @@ struct memory_notify {
 struct notifier_block;
 struct mem_section;
+/*
+ * Priorities for the hotplug memory callback routines (stored in decreasing
+ * order in the callback chain)
+ */
+#define SLAB_CALLBACK_PRI       1
+#define IPC_CALLBACK_PRI        10
 #ifndef CONFIG_MEMORY_HOTPLUG_SPARSE
 static inline int memory_dev_init(void)
 {
diff --git a/include/linux/memory_hotplug.h b/include/linux/memory_hotplug.h
index 8fee7a45736b..73e358612eaf 100644
--- a/include/linux/memory_hotplug.h
+++ b/include/linux/memory_hotplug.h
@@ -8,8 +8,18 @@
 struct page;
 struct zone;
 struct pglist_data;
+struct mem_section;
 #ifdef CONFIG_MEMORY_HOTPLUG
+/*
+ * Magic number for free bootmem.
+ * The normal smallest mapcount is -1. Here is smaller value than it.
+ */
+#define SECTION_INFO            0xfffffffe
+#define MIX_INFO                0xfffffffd
+#define NODE_INFO               0xfffffffc
 /*
 * pgdat resizing functions
 */
@@ -64,9 +74,11 @@ extern int offline_pages(unsigned long, unsigned long, unsigned long);
 /* reasonably generic interface to expand the physical pages in a zone  */
 extern int __add_pages(struct zone *zone, unsigned long start_pfn,
        unsigned long nr_pages);
+extern int __remove_pages(struct zone *zone, unsigned long start_pfn,
+        unsigned long nr_pages);
 /*
- * Walk thorugh all memory which is registered as resource.
+ * Walk through all memory which is registered as resource.
 * arg is (start_pfn, nr_pages, private_arg_pointer)
 */
 extern int walk_memory_resource(unsigned long start_pfn,
@@ -142,6 +154,18 @@ static inline void arch_refresh_nodedata(int nid, pg_data_t *pgdat)
 #endif /* CONFIG_NUMA */
 #endif /* CONFIG_HAVE_ARCH_NODEDATA_EXTENSION */
+#ifdef CONFIG_SPARSEMEM_VMEMMAP
+static inline void register_page_bootmem_info_node(struct pglist_data *pgdat)
+{
+}
+static inline void put_page_bootmem(struct page *page)
+{
+}
+#else
+extern void register_page_bootmem_info_node(struct pglist_data *pgdat);
+extern void put_page_bootmem(struct page *page);
+#endif
 #else /* ! CONFIG_MEMORY_HOTPLUG */
 /*
 * Stub functions for when hotplug is off
@@ -169,6 +193,10 @@ static inline int mhp_notimplemented(const char *func)
        return -ENOSYS;
 }
+static inline void register_page_bootmem_info_node(struct pglist_data *pgdat)
+{
+}
 #endif /* ! CONFIG_MEMORY_HOTPLUG */
 extern int add_memory(int nid, u64 start, u64 size);
@@ -176,5 +204,8 @@ extern int arch_add_memory(int nid, u64 start, u64 size);
 extern int remove_memory(u64 start, u64 size);
 extern int sparse_add_one_section(struct zone *zone, unsigned long start_pfn,
                                                                int nr_pages);
+extern void sparse_remove_one_section(struct zone *zone, struct mem_section *ms);
+extern struct page *sparse_decode_mem_map(unsigned long coded_mem_map,
+                                          unsigned long pnum);
 #endif /* __LINUX_MEMORY_HOTPLUG_H */
diff --git a/include/linux/mempolicy.h b/include/linux/mempolicy.h
index 59c4865bc85f..3a39570b81b8 100644
--- a/include/linux/mempolicy.h
+++ b/include/linux/mempolicy.h
@@ -8,15 +8,32 @@
 * Copyright 2003,2004 Andi Kleen SuSE Labs
 */
+/*
+ * Both the MPOL_* mempolicy mode and the MPOL_F_* optional mode flags are
+ * passed by the user to either set_mempolicy() or mbind() in an 'int' actual.
+ * The MPOL_MODE_FLAGS macro determines the legal set of optional mode flags.
+ */
 /* Policies */
-#define MPOL_DEFAULT    0
+enum {
-#define MPOL_PREFERRED  1
+        MPOL_DEFAULT,
-#define MPOL_BIND       2
+        MPOL_PREFERRED,
-#define MPOL_INTERLEAVE 3
+        MPOL_BIND,
+        MPOL_INTERLEAVE,
+        MPOL_MAX,       /* always last member of enum */
+};
-#define MPOL_MAX MPOL_INTERLEAVE
+/* Flags for set_mempolicy */
+#define MPOL_F_STATIC_NODES     (1 << 15)
+#define MPOL_F_RELATIVE_NODES   (1 << 14)
-/* Flags for get_mem_policy */
+/*
+ * MPOL_MODE_FLAGS is the union of all possible optional mode flags passed to
+ * either set_mempolicy() or mbind().
+ */
+#define MPOL_MODE_FLAGS (MPOL_F_STATIC_NODES | MPOL_F_RELATIVE_NODES)
+/* Flags for get_mempolicy */
 #define MPOL_F_NODE     (1<<0)  /* return next IL mode instead of node mask */
 #define MPOL_F_ADDR     (1<<1)  /* look up vma using address */
 #define MPOL_F_MEMS_ALLOWED (1<<2) /* return allowed memories */
@@ -27,6 +44,14 @@
 #define MPOL_MF_MOVE_ALL (1<<2) /* Move every page to conform to mapping */
 #define MPOL_MF_INTERNAL (1<<3) /* Internal flags start here */
+/*
+ * Internal flags that share the struct mempolicy flags word with
+ * "mode flags".  These flags are allocated from bit 0 up, as they
+ * are never OR'ed into the mode in mempolicy API arguments.
+ */
+#define MPOL_F_SHARED  (1 << 0) /* identify shared policies */
+#define MPOL_F_LOCAL   (1 << 1) /* preferred local allocation */
 #ifdef __KERNEL__
 #include <linux/mmzone.h>
@@ -35,7 +60,6 @@
 #include <linux/spinlock.h>
 #include <linux/nodemask.h>
-struct vm_area_struct;
 struct mm_struct;
 #ifdef CONFIG_NUMA
@@ -54,22 +78,27 @@ struct mm_struct;
 * mmap_sem.
 *
 * Freeing policy:
- * When policy is MPOL_BIND v.zonelist is kmalloc'ed and must be kfree'd.
+ * Mempolicy objects are reference counted.  A mempolicy will be freed when
- * All other policies don't have any external state. mpol_free() handles this.
+ * mpol_put() decrements the reference count to zero.
 *
- * Copying policy objects:
+ * Duplicating policy objects:
- * For MPOL_BIND the zonelist must be always duplicated. mpol_clone() does this.
+ * mpol_dup() allocates a new mempolicy and copies the specified mempolicy
+ * to the new storage.  The reference count of the new object is initialized
+ * to 1, representing the caller of mpol_dup().
 */
 struct mempolicy {
        atomic_t refcnt;
-        short policy;   /* See MPOL_* above */
+        unsigned short mode;    /* See MPOL_* above */
+        unsigned short flags;   /* See set_mempolicy() MPOL_F_* above */
        union {
-                struct zonelist  *zonelist;     /* bind */
                short            preferred_node; /* preferred */
-                nodemask_t       nodes;         /* interleave */
+                nodemask_t       nodes;         /* interleave/bind */
                /* undefined for default */
        } v;
-        nodemask_t cpuset_mems_allowed; /* mempolicy relative to these nodes */
+        union {
+                nodemask_t cpuset_mems_allowed; /* relative to these nodes */
+                nodemask_t user_nodemask;       /* nodemask passed by user */
+        } w;
 };
 /*
@@ -77,18 +106,43 @@ struct mempolicy {
 * The default fast path of a NULL MPOL_DEFAULT policy is always inlined.
 */
-extern void __mpol_free(struct mempolicy *pol);
+extern void __mpol_put(struct mempolicy *pol);
-static inline void mpol_free(struct mempolicy *pol)
+static inline void mpol_put(struct mempolicy *pol)
 {
        if (pol)
-                __mpol_free(pol);
+                __mpol_put(pol);
 }
-extern struct mempolicy *__mpol_copy(struct mempolicy *pol);
+/*
-static inline struct mempolicy *mpol_copy(struct mempolicy *pol)
+ * Does mempolicy pol need explicit unref after use?
+ * Currently only needed for shared policies.
+ */
+static inline int mpol_needs_cond_ref(struct mempolicy *pol)
+{
+        return (pol && (pol->flags & MPOL_F_SHARED));
+}
+static inline void mpol_cond_put(struct mempolicy *pol)
+{
+        if (mpol_needs_cond_ref(pol))
+                __mpol_put(pol);
+}
+extern struct mempolicy *__mpol_cond_copy(struct mempolicy *tompol,
+                                          struct mempolicy *frompol);
+static inline struct mempolicy *mpol_cond_copy(struct mempolicy *tompol,
+                                                struct mempolicy *frompol)
+{
+        if (!frompol)
+                return frompol;
+        return __mpol_cond_copy(tompol, frompol);
+}
+extern struct mempolicy *__mpol_dup(struct mempolicy *pol);
+static inline struct mempolicy *mpol_dup(struct mempolicy *pol)
 {
        if (pol)
-                pol = __mpol_copy(pol);
+                pol = __mpol_dup(pol);
        return pol;
 }
@@ -108,11 +162,6 @@ static inline int mpol_equal(struct mempolicy *a, struct mempolicy *b)
                return 1;
        return __mpol_equal(a, b);
 }
-#define vma_mpol_equal(a,b) mpol_equal(vma_policy(a), vma_policy(b))
-/* Could later add inheritance of the process policy here. */
-#define mpol_set_vma_default(vma) ((vma)->vm_policy = NULL)
 /*
 * Tree of shared policies for a shared memory region.
@@ -133,8 +182,7 @@ struct shared_policy {
        spinlock_t lock;
 };
-void mpol_shared_policy_init(struct shared_policy *info, int policy,
+void mpol_shared_policy_init(struct shared_policy *sp, struct mempolicy *mpol);
-                                nodemask_t *nodes);
 int mpol_set_shared_policy(struct shared_policy *info,
                                struct vm_area_struct *vma,
                                struct mempolicy *new);
@@ -149,9 +197,9 @@ extern void mpol_rebind_task(struct task_struct *tsk,
 extern void mpol_rebind_mm(struct mm_struct *mm, nodemask_t *new);
 extern void mpol_fix_fork_child_flag(struct task_struct *p);
-extern struct mempolicy default_policy;
 extern struct zonelist *huge_zonelist(struct vm_area_struct *vma,
-                unsigned long addr, gfp_t gfp_flags, struct mempolicy **mpol);
+                                unsigned long addr, gfp_t gfp_flags,
+                                struct mempolicy **mpol, nodemask_t **nodemask);
 extern unsigned slab_node(struct mempolicy *policy);
 extern enum zone_type policy_zone;
@@ -165,6 +213,13 @@ static inline void check_highest_zone(enum zone_type k)
 int do_migrate_pages(struct mm_struct *mm,
        const nodemask_t *from_nodes, const nodemask_t *to_nodes, int flags);
+#ifdef CONFIG_TMPFS
+extern int mpol_parse_str(char *str, struct mempolicy **mpol, int no_context);
+extern int mpol_to_str(char *buffer, int maxlen, struct mempolicy *pol,
+                        int no_context);
+#endif
 #else
 struct mempolicy {};
@@ -173,19 +228,26 @@ static inline int mpol_equal(struct mempolicy *a, struct mempolicy *b)
 {
        return 1;
 }
-#define vma_mpol_equal(a,b) 1
-#define mpol_set_vma_default(vma) do {} while(0)
+static inline void mpol_put(struct mempolicy *p)
+{
+}
+static inline void mpol_cond_put(struct mempolicy *pol)
+{
+}
-static inline void mpol_free(struct mempolicy *p)
+static inline struct mempolicy *mpol_cond_copy(struct mempolicy *to,
+                                                struct mempolicy *from)
 {
+        return from;
 }
 static inline void mpol_get(struct mempolicy *pol)
 {
 }
-static inline struct mempolicy *mpol_copy(struct mempolicy *old)
+static inline struct mempolicy *mpol_dup(struct mempolicy *old)
 {
        return NULL;
 }
@@ -199,8 +261,8 @@ static inline int mpol_set_shared_policy(struct shared_policy *info,
        return -EINVAL;
 }
-static inline void mpol_shared_policy_init(struct shared_policy *info,
+static inline void mpol_shared_policy_init(struct shared_policy *sp,
-                                        int policy, nodemask_t *nodes)
+                                                struct mempolicy *mpol)
 {
 }
@@ -239,9 +301,12 @@ static inline void mpol_fix_fork_child_flag(struct task_struct *p)
 }
 static inline struct zonelist *huge_zonelist(struct vm_area_struct *vma,
-                unsigned long addr, gfp_t gfp_flags, struct mempolicy **mpol)
+                                unsigned long addr, gfp_t gfp_flags,
+                                struct mempolicy **mpol, nodemask_t **nodemask)
 {
-        return NODE_DATA(0)->node_zonelists + gfp_zone(gfp_flags);
+        *mpol = NULL;
+        *nodemask = NULL;
+        return node_zonelist(0, gfp_flags);
 }
 static inline int do_migrate_pages(struct mm_struct *mm,
@@ -254,6 +319,21 @@ static inline int do_migrate_pages(struct mm_struct *mm,
 static inline void check_highest_zone(int k)
 {
 }
+#ifdef CONFIG_TMPFS
+static inline int mpol_parse_str(char *str, struct mempolicy **mpol,
+                                int no_context)
+{
+        return 1;       /* error */
+}
+static inline int mpol_to_str(char *buffer, int maxlen, struct mempolicy *pol,
+                                int no_context)
+{
+        return 0;
+}
+#endif
 #endif /* CONFIG_NUMA */
 #endif /* __KERNEL__ */
diff --git a/include/linux/mlx4/device.h b/include/linux/mlx4/device.h
index 9fa1a8002ce2..a744383d16e9 100644
--- a/include/linux/mlx4/device.h
+++ b/include/linux/mlx4/device.h
@@ -382,7 +382,8 @@ void mlx4_free_hwq_res(struct mlx4_dev *mdev, struct mlx4_hwq_resources *wqres,
                       int size);
 int mlx4_cq_alloc(struct mlx4_dev *dev, int nent, struct mlx4_mtt *mtt,
-                  struct mlx4_uar *uar, u64 db_rec, struct mlx4_cq *cq);
+                  struct mlx4_uar *uar, u64 db_rec, struct mlx4_cq *cq,
+                  int collapsed);
 void mlx4_cq_free(struct mlx4_dev *dev, struct mlx4_cq *cq);
 int mlx4_qp_alloc(struct mlx4_dev *dev, int sqpn, struct mlx4_qp *qp);
diff --git a/include/linux/mm.h b/include/linux/mm.h
index 286d31521605..c31a9cd2a30e 100644
--- a/include/linux/mm.h
+++ b/include/linux/mm.h
@@ -107,6 +107,7 @@ extern unsigned int kobjsize(const void *objp);
 #define VM_ALWAYSDUMP   0x04000000      /* Always include in core dumps */
 #define VM_CAN_NONLINEAR 0x08000000     /* Has ->fault & does nonlinear pages */
+#define VM_MIXEDMAP     0x10000000      /* Can contain "struct page" and pure PFN pages */
 #ifndef VM_STACK_DEFAULT_FLAGS          /* arch can override this */
 #define VM_STACK_DEFAULT_FLAGS VM_DATA_DEFAULT_FLAGS
@@ -164,8 +165,6 @@ struct vm_operations_struct {
        void (*open)(struct vm_area_struct * area);
        void (*close)(struct vm_area_struct * area);
        int (*fault)(struct vm_area_struct *vma, struct vm_fault *vmf);
-        struct page *(*nopage)(struct vm_area_struct *area,
-                        unsigned long address, int *type);
        unsigned long (*nopfn)(struct vm_area_struct *area,
                        unsigned long address);
@@ -173,7 +172,25 @@ struct vm_operations_struct {
         * writable, if an error is returned it will cause a SIGBUS */
        int (*page_mkwrite)(struct vm_area_struct *vma, struct page *page);
 #ifdef CONFIG_NUMA
+        /*
+         * set_policy() op must add a reference to any non-NULL @new mempolicy
+         * to hold the policy upon return.  Caller should pass NULL @new to
+         * remove a policy and fall back to surrounding context--i.e. do not
+         * install a MPOL_DEFAULT policy, nor the task or system default
+         * mempolicy.
+         */
        int (*set_policy)(struct vm_area_struct *vma, struct mempolicy *new);
+        /*
+         * get_policy() op must add reference [mpol_get()] to any policy at
+         * (vma,addr) marked as MPOL_SHARED.  The shared policy infrastructure
+         * in mm/mempolicy.c will do this automatically.
+         * get_policy() must NOT add a ref if the policy at (vma,addr) is not
+         * marked as MPOL_SHARED. vma policies are protected by the mmap_sem.
+         * If no [shared/vma] mempolicy exists at the addr, get_policy() op
+         * must return NULL--i.e., do not "fallback" to task or system default
+         * policy.
+         */
        struct mempolicy *(*get_policy)(struct vm_area_struct *vma,
                                        unsigned long addr);
        int (*migrate)(struct vm_area_struct *vma, const nodemask_t *from,
@@ -397,11 +414,11 @@ static inline void set_compound_order(struct page *page, unsigned long order)
 * we have run out of space and have to fall back to an
 * alternate (slower) way of determining the node.
 *
- *        No sparsemem: |       NODE     | ZONE | ... | FLAGS |
+ * No sparsemem or sparsemem vmemmap: |       NODE     | ZONE | ... | FLAGS |
- * with space for node: | SECTION | NODE | ZONE | ... | FLAGS |
+ * classic sparse with space for node:| SECTION | NODE | ZONE | ... | FLAGS |
- *   no space for node: | SECTION |     ZONE    | ... | FLAGS |
+ * classic sparse no space for node:  | SECTION |     ZONE    | ... | FLAGS |
 */
-#ifdef CONFIG_SPARSEMEM
+#if defined(CONFIG_SPARSEMEM) && !defined(CONFIG_SPARSEMEM_VMEMMAP)
 #define SECTIONS_WIDTH          SECTIONS_SHIFT
 #else
 #define SECTIONS_WIDTH          0
@@ -409,9 +426,12 @@ static inline void set_compound_order(struct page *page, unsigned long order)
 #define ZONES_WIDTH             ZONES_SHIFT
-#if SECTIONS_WIDTH+ZONES_WIDTH+NODES_SHIFT <= FLAGS_RESERVED
+#if SECTIONS_WIDTH+ZONES_WIDTH+NODES_SHIFT <= BITS_PER_LONG - NR_PAGEFLAGS
 #define NODES_WIDTH             NODES_SHIFT
 #else
+#ifdef CONFIG_SPARSEMEM_VMEMMAP
+#error "Vmemmap: No space for nodes field in page flags"
+#endif
 #define NODES_WIDTH             0
 #endif
@@ -454,8 +474,8 @@ static inline void set_compound_order(struct page *page, unsigned long order)
 #define ZONEID_PGSHIFT          (ZONEID_PGOFF * (ZONEID_SHIFT != 0))
-#if SECTIONS_WIDTH+NODES_WIDTH+ZONES_WIDTH > FLAGS_RESERVED
+#if SECTIONS_WIDTH+NODES_WIDTH+ZONES_WIDTH > BITS_PER_LONG - NR_PAGEFLAGS
-#error SECTIONS_WIDTH+NODES_WIDTH+ZONES_WIDTH > FLAGS_RESERVED
+#error SECTIONS_WIDTH+NODES_WIDTH+ZONES_WIDTH > BITS_PER_LONG - NR_PAGEFLAGS
 #endif
 #define ZONES_MASK              ((1UL << ZONES_WIDTH) - 1)
@@ -504,10 +524,12 @@ static inline struct zone *page_zone(struct page *page)
        return &NODE_DATA(page_to_nid(page))->node_zones[page_zonenum(page)];
 }
+#if defined(CONFIG_SPARSEMEM) && !defined(CONFIG_SPARSEMEM_VMEMMAP)
 static inline unsigned long page_to_section(struct page *page)
 {
        return (page->flags >> SECTIONS_PGSHIFT) & SECTIONS_MASK;
 }
+#endif
 static inline void set_page_zone(struct page *page, enum zone_type zone)
 {
@@ -602,9 +624,12 @@ static inline struct address_space *page_mapping(struct page *page)
        struct address_space *mapping = page->mapping;
        VM_BUG_ON(PageSlab(page));
+#ifdef CONFIG_SWAP
        if (unlikely(PageSwapCache(page)))
                mapping = &swapper_space;
-        else if (unlikely((unsigned long)mapping & PAGE_MAPPING_ANON))
+        else
+#endif
+        if (unlikely((unsigned long)mapping & PAGE_MAPPING_ANON))
                mapping = NULL;
        return mapping;
 }
@@ -649,12 +674,6 @@ static inline int page_mapped(struct page *page)
 }
 /*
- * Error return values for the *_nopage functions
- */
-#define NOPAGE_SIGBUS   (NULL)
-#define NOPAGE_OOM      ((struct page *) (-1))
-/*
 * Error return values for the *_nopfn functions
 */
 #define NOPFN_SIGBUS    ((unsigned long) -1)
@@ -720,7 +739,9 @@ struct zap_details {
        unsigned long truncate_count;           /* Compare vm_truncate_count */
 };
-struct page *vm_normal_page(struct vm_area_struct *, unsigned long, pte_t);
+struct page *vm_normal_page(struct vm_area_struct *vma, unsigned long addr,
+                pte_t pte);
 unsigned long zap_page_range(struct vm_area_struct *vma, unsigned long address,
                unsigned long size, struct zap_details *);
 unsigned long unmap_vmas(struct mmu_gather **tlb,
@@ -1045,6 +1066,19 @@ extern void unlink_file_vma(struct vm_area_struct *);
 extern struct vm_area_struct *copy_vma(struct vm_area_struct **,
        unsigned long addr, unsigned long len, pgoff_t pgoff);
 extern void exit_mmap(struct mm_struct *);
+#ifdef CONFIG_PROC_FS
+/* From fs/proc/base.c. callers must _not_ hold the mm's exe_file_lock */
+extern void added_exe_file_vma(struct mm_struct *mm);
+extern void removed_exe_file_vma(struct mm_struct *mm);
+#else
+static inline void added_exe_file_vma(struct mm_struct *mm)
+{}
+static inline void removed_exe_file_vma(struct mm_struct *mm)
+{}
+#endif /* CONFIG_PROC_FS */
 extern int may_expand_vm(struct mm_struct *mm, unsigned long npages);
 extern int install_special_mapping(struct mm_struct *mm,
                                   unsigned long addr, unsigned long len,
@@ -1149,6 +1183,8 @@ int remap_pfn_range(struct vm_area_struct *, unsigned long addr,
 int vm_insert_page(struct vm_area_struct *, unsigned long addr, struct page *);
 int vm_insert_pfn(struct vm_area_struct *vma, unsigned long addr,
                        unsigned long pfn);
+int vm_insert_mixed(struct vm_area_struct *vma, unsigned long addr,
+                        unsigned long pfn);
 struct page *follow_page(struct vm_area_struct *, unsigned long address,
                        unsigned int foll_flags);
@@ -1207,8 +1243,6 @@ int drop_caches_sysctl_handler(struct ctl_table *, int, struct file *,
                                        void __user *, size_t *, loff_t *);
 unsigned long shrink_slab(unsigned long scanned, gfp_t gfp_mask,
                        unsigned long lru_pages);
-void drop_pagecache(void);
-void drop_slab(void);
 #ifndef CONFIG_MMU
 #define randomize_va_space 0
diff --git a/include/linux/mm_types.h b/include/linux/mm_types.h
index af190ceab971..eb7c16cc9559 100644
--- a/include/linux/mm_types.h
+++ b/include/linux/mm_types.h
@@ -42,7 +42,10 @@ struct page {
                                         * to show when page is mapped
                                         * & limit reverse map searches.
                                         */
-                unsigned int inuse;     /* SLUB: Nr of objects */
+                struct {                /* SLUB */
+                        u16 inuse;
+                        u16 objects;
+                };
        };
        union {
            struct {
@@ -172,6 +175,7 @@ struct mm_struct {
        atomic_t mm_users;                      /* How many users with user space? */
        atomic_t mm_count;                      /* How many references to "struct mm_struct" (users count as 1) */
        int map_count;                          /* number of VMAs */
+        int core_waiters;
        struct rw_semaphore mmap_sem;
        spinlock_t page_table_lock;             /* Protects page tables and some counters */
@@ -216,14 +220,20 @@ struct mm_struct {
        unsigned long flags; /* Must use atomic bitops to access the bits */
        /* coredumping support */
-        int core_waiters;
        struct completion *core_startup_done, core_done;
        /* aio bits */
-        rwlock_t                ioctx_list_lock;
+        rwlock_t                ioctx_list_lock;        /* aio lock */
        struct kioctx           *ioctx_list;
-#ifdef CONFIG_CGROUP_MEM_RES_CTLR
+#ifdef CONFIG_MM_OWNER
-        struct mem_cgroup *mem_cgroup;
+        struct task_struct *owner;      /* The thread group leader that */
+                                        /* owns the mm_struct.          */
+#endif
+#ifdef CONFIG_PROC_FS
+        /* store ref to file /proc/<pid>/exe symlink points to */
+        struct file *exe_file;
+        unsigned long num_exe_file_vmas;
 #endif
 };
diff --git a/include/linux/mmzone.h b/include/linux/mmzone.h
index 9f274a687c7e..aad98003176f 100644
--- a/include/linux/mmzone.h
+++ b/include/linux/mmzone.h
@@ -3,6 +3,7 @@
 #ifdef __KERNEL__
 #ifndef __ASSEMBLY__
+#ifndef __GENERATING_BOUNDS_H
 #include <linux/spinlock.h>
 #include <linux/list.h>
@@ -15,6 +16,7 @@
 #include <linux/seqlock.h>
 #include <linux/nodemask.h>
 #include <linux/pageblock-flags.h>
+#include <linux/bounds.h>
 #include <asm/atomic.h>
 #include <asm/page.h>
@@ -129,6 +131,8 @@ struct per_cpu_pageset {
 #define zone_pcp(__z, __cpu) (&(__z)->pageset[(__cpu)])
 #endif
+#endif /* !__GENERATING_BOUNDS.H */
 enum zone_type {
 #ifdef CONFIG_ZONE_DMA
        /*
@@ -177,9 +181,11 @@ enum zone_type {
        ZONE_HIGHMEM,
 #endif
        ZONE_MOVABLE,
-        MAX_NR_ZONES
+        __MAX_NR_ZONES
 };
+#ifndef __GENERATING_BOUNDS_H
 /*
 * When a memory allocation must conform to specific limitations (such
 * as being suitable for DMA) the caller will pass in hints to the
@@ -188,28 +194,15 @@ enum zone_type {
 * match the requested limits. See gfp_zone() in include/linux/gfp.h
 */
-/*
+#if MAX_NR_ZONES < 2
- * Count the active zones.  Note that the use of defined(X) outside
- * #if and family is not necessarily defined so ensure we cannot use
- * it later.  Use __ZONE_COUNT to work out how many shift bits we need.
- */
-#define __ZONE_COUNT (                  \
-          defined(CONFIG_ZONE_DMA)      \
-        + defined(CONFIG_ZONE_DMA32)    \
-        + 1                             \
-        + defined(CONFIG_HIGHMEM)       \
-        + 1                             \
-)
-#if __ZONE_COUNT < 2
 #define ZONES_SHIFT 0
-#elif __ZONE_COUNT <= 2
+#elif MAX_NR_ZONES <= 2
 #define ZONES_SHIFT 1
-#elif __ZONE_COUNT <= 4
+#elif MAX_NR_ZONES <= 4
 #define ZONES_SHIFT 2
 #else
 #error ZONES_SHIFT -- too many zones configured adjust calculation
 #endif
-#undef __ZONE_COUNT
 struct zone {
        /* Fields commonly accessed by the page allocator */
@@ -393,10 +386,10 @@ static inline int zone_is_oom_locked(const struct zone *zone)
 * The NUMA zonelists are doubled becausse we need zonelists that restrict the
 * allocations to a single node for GFP_THISNODE.
 *
- * [0 .. MAX_NR_ZONES -1]               : Zonelists with fallback
+ * [0]  : Zonelist with fallback
- * [MAZ_NR_ZONES ... MAZ_ZONELISTS -1]  : No fallback (GFP_THISNODE)
+ * [1]  : No fallback (GFP_THISNODE)
 */
-#define MAX_ZONELISTS (2 * MAX_NR_ZONES)
+#define MAX_ZONELISTS 2
 /*
@@ -464,11 +457,20 @@ struct zonelist_cache {
        unsigned long last_full_zap;            /* when last zap'd (jiffies) */
 };
 #else
-#define MAX_ZONELISTS MAX_NR_ZONES
+#define MAX_ZONELISTS 1
 struct zonelist_cache;
 #endif
 /*
+ * This struct contains information about a zone in a zonelist. It is stored
+ * here to avoid dereferences into large structures and lookups of tables
+ */
+struct zoneref {
+        struct zone *zone;      /* Pointer to actual zone */
+        int zone_idx;           /* zone_idx(zoneref->zone) */
+};
+/*
 * One allocation request operates on a zonelist. A zonelist
 * is a list of zones, the first one is the 'goal' of the
 * allocation, the other zones are fallback zones, in decreasing
@@ -476,34 +478,23 @@ struct zonelist_cache;
 *
 * If zlcache_ptr is not NULL, then it is just the address of zlcache,
 * as explained above.  If zlcache_ptr is NULL, there is no zlcache.
+ * *
+ * To speed the reading of the zonelist, the zonerefs contain the zone index
+ * of the entry being read. Helper functions to access information given
+ * a struct zoneref are
+ *
+ * zonelist_zone()      - Return the struct zone * for an entry in _zonerefs
+ * zonelist_zone_idx()  - Return the index of the zone for an entry
+ * zonelist_node_idx()  - Return the index of the node for an entry
 */
 struct zonelist {
        struct zonelist_cache *zlcache_ptr;                  // NULL or &zlcache
-        struct zone *zones[MAX_ZONES_PER_ZONELIST + 1];      // NULL delimited
+        struct zoneref _zonerefs[MAX_ZONES_PER_ZONELIST + 1];
 #ifdef CONFIG_NUMA
        struct zonelist_cache zlcache;                       // optional ...
 #endif
 };
-#ifdef CONFIG_NUMA
-/*
- * Only custom zonelists like MPOL_BIND need to be filtered as part of
- * policies. As described in the comment for struct zonelist_cache, these
- * zonelists will not have a zlcache so zlcache_ptr will not be set. Use
- * that to determine if the zonelists needs to be filtered or not.
- */
-static inline int alloc_should_filter_zonelist(struct zonelist *zonelist)
-{
-        return !zonelist->zlcache_ptr;
-}
-#else
-static inline int alloc_should_filter_zonelist(struct zonelist *zonelist)
-{
-        return 0;
-}
-#endif /* CONFIG_NUMA */
 #ifdef CONFIG_ARCH_POPULATES_NODE_MAP
 struct node_active_region {
        unsigned long start_pfn;
@@ -637,9 +628,10 @@ static inline int is_normal_idx(enum zone_type idx)
 static inline int is_highmem(struct zone *zone)
 {
 #ifdef CONFIG_HIGHMEM
-        int zone_idx = zone - zone->zone_pgdat->node_zones;
+        int zone_off = (char *)zone - (char *)zone->zone_pgdat->node_zones;
-        return zone_idx == ZONE_HIGHMEM ||
+        return zone_off == ZONE_HIGHMEM * sizeof(*zone) ||
-                (zone_idx == ZONE_MOVABLE && zone_movable_is_highmem());
+               (zone_off == ZONE_MOVABLE * sizeof(*zone) &&
+                zone_movable_is_highmem());
 #else
        return 0;
 #endif
@@ -730,32 +722,103 @@ extern struct zone *next_zone(struct zone *zone);
             zone;                                      \
             zone = next_zone(zone))
-#ifdef CONFIG_SPARSEMEM
+static inline struct zone *zonelist_zone(struct zoneref *zoneref)
-#include <asm/sparsemem.h>
+{
-#endif
+        return zoneref->zone;
+}
-#if BITS_PER_LONG == 32
+static inline int zonelist_zone_idx(struct zoneref *zoneref)
-/*
+{
- * with 32 bit page->flags field, we reserve 9 bits for node/zone info.
+        return zoneref->zone_idx;
- * there are 4 zones (3 bits) and this leaves 9-3=6 bits for nodes.
+}
+static inline int zonelist_node_idx(struct zoneref *zoneref)
+{
+#ifdef CONFIG_NUMA
+        /* zone_to_nid not available in this context */
+        return zoneref->zone->node;
+#else
+        return 0;
+#endif /* CONFIG_NUMA */
+}
+/**
+ * next_zones_zonelist - Returns the next zone at or below highest_zoneidx within the allowed nodemask using a cursor within a zonelist as a starting point
+ * @z - The cursor used as a starting point for the search
+ * @highest_zoneidx - The zone index of the highest zone to return
+ * @nodes - An optional nodemask to filter the zonelist with
+ * @zone - The first suitable zone found is returned via this parameter
+ *
+ * This function returns the next zone at or below a given zone index that is
+ * within the allowed nodemask using a cursor as the starting point for the
+ * search. The zoneref returned is a cursor that is used as the next starting
+ * point for future calls to next_zones_zonelist().
 */
-#define FLAGS_RESERVED          9
+struct zoneref *next_zones_zonelist(struct zoneref *z,
+                                        enum zone_type highest_zoneidx,
+                                        nodemask_t *nodes,
+                                        struct zone **zone);
-#elif BITS_PER_LONG == 64
+/**
-/*
+ * first_zones_zonelist - Returns the first zone at or below highest_zoneidx within the allowed nodemask in a zonelist
- * with 64 bit flags field, there's plenty of room.
+ * @zonelist - The zonelist to search for a suitable zone
+ * @highest_zoneidx - The zone index of the highest zone to return
+ * @nodes - An optional nodemask to filter the zonelist with
+ * @zone - The first suitable zone found is returned via this parameter
+ *
+ * This function returns the first zone at or below a given zone index that is
+ * within the allowed nodemask. The zoneref returned is a cursor that can be
+ * used to iterate the zonelist with next_zones_zonelist. The cursor should
+ * not be used by the caller as it does not match the value of the zone
+ * returned.
 */
-#define FLAGS_RESERVED          32
+static inline struct zoneref *first_zones_zonelist(struct zonelist *zonelist,
+                                        enum zone_type highest_zoneidx,
+                                        nodemask_t *nodes,
+                                        struct zone **zone)
+{
+        return next_zones_zonelist(zonelist->_zonerefs, highest_zoneidx, nodes,
+                                                                zone);
+}
-#else
+/**
+ * for_each_zone_zonelist_nodemask - helper macro to iterate over valid zones in a zonelist at or below a given zone index and within a nodemask
+ * @zone - The current zone in the iterator
+ * @z - The current pointer within zonelist->zones being iterated
+ * @zlist - The zonelist being iterated
+ * @highidx - The zone index of the highest zone to return
+ * @nodemask - Nodemask allowed by the allocator
+ *
+ * This iterator iterates though all zones at or below a given zone index and
+ * within a given nodemask
+ */
+#define for_each_zone_zonelist_nodemask(zone, z, zlist, highidx, nodemask) \
+        for (z = first_zones_zonelist(zlist, highidx, nodemask, &zone); \
+                zone;                                                   \
+                z = next_zones_zonelist(z, highidx, nodemask, &zone))   \
-#error BITS_PER_LONG not defined
+/**
+ * for_each_zone_zonelist - helper macro to iterate over valid zones in a zonelist at or below a given zone index
+ * @zone - The current zone in the iterator
+ * @z - The current pointer within zonelist->zones being iterated
+ * @zlist - The zonelist being iterated
+ * @highidx - The zone index of the highest zone to return
+ *
+ * This iterator iterates though all zones at or below a given zone index.
+ */
+#define for_each_zone_zonelist(zone, z, zlist, highidx) \
+        for_each_zone_zonelist_nodemask(zone, z, zlist, highidx, NULL)
+#ifdef CONFIG_SPARSEMEM
+#include <asm/sparsemem.h>
 #endif
 #if !defined(CONFIG_HAVE_ARCH_EARLY_PFN_TO_NID) && \
        !defined(CONFIG_ARCH_POPULATES_NODE_MAP)
-#define early_pfn_to_nid(nid)  (0UL)
+static inline unsigned long early_pfn_to_nid(unsigned long pfn)
+{
+        return 0;
+}
 #endif
 #ifdef CONFIG_FLATMEM
@@ -833,6 +896,7 @@ static inline struct mem_section *__nr_to_section(unsigned long nr)
        return &mem_section[SECTION_NR_TO_ROOT(nr)][nr & SECTION_ROOT_MASK];
 }
 extern int __section_nr(struct mem_section* ms);
+extern unsigned long usemap_size(void);
 /*
 * We use the lower bits of the mem_map pointer to store
@@ -938,6 +1002,7 @@ unsigned long __init node_memmap_size_bytes(int, unsigned long, unsigned long);
 #define pfn_valid_within(pfn) (1)
 #endif
+#endif /* !__GENERATING_BOUNDS.H */
 #endif /* !__ASSEMBLY__ */
 #endif /* __KERNEL__ */
 #endif /* _LINUX_MMZONE_H */
diff --git a/include/linux/mod_devicetable.h b/include/linux/mod_devicetable.h
index 139d49d2f078..d73eceaa7afb 100644
--- a/include/linux/mod_devicetable.h
+++ b/include/linux/mod_devicetable.h
@@ -368,4 +368,15 @@ struct virtio_device_id {
 };
 #define VIRTIO_DEV_ANY_ID       0xffffffff
+/* i2c */
+#define I2C_NAME_SIZE   20
+#define I2C_MODULE_PREFIX "i2c:"
+struct i2c_device_id {
+        char name[I2C_NAME_SIZE];
+        kernel_ulong_t driver_data;     /* Data private to the driver */
+};
 #endif /* LINUX_MOD_DEVICETABLE_H */
diff --git a/include/linux/msdos_fs.h b/include/linux/msdos_fs.h
index f950921523f5..b03b27457413 100644
--- a/include/linux/msdos_fs.h
+++ b/include/linux/msdos_fs.h
@@ -58,7 +58,11 @@
 #define MSDOS_DOTDOT    "..         "   /* "..", padded to MSDOS_NAME chars */
 /* media of boot sector */
-#define FAT_VALID_MEDIA(x)      ((0xF8 <= (x) && (x) <= 0xFF) || (x) == 0xF0)
+static inline int fat_valid_media(u8 media)
+{
+        return 0xf8 <= media || media == 0xf0;
+}
 #define FAT_FIRST_ENT(s, x)     ((MSDOS_SB(s)->fat_bits == 32 ? 0x0FFFFF00 : \
        MSDOS_SB(s)->fat_bits == 16 ? 0xFF00 : 0xF00) | (x))
@@ -195,6 +199,7 @@ struct fat_mount_options {
        char *iocharset;          /* Charset used for filename input/display */
        unsigned short shortname; /* flags for shortname display/create rule */
        unsigned char name_check; /* r = relaxed, n = normal, s = strict */
+        unsigned short allow_utime;/* permission for setting the [am]time */
        unsigned quiet:1,         /* set = fake successful chmods and chowns */
                 showexec:1,      /* set = only set x bit for com/exe/bat */
                 sys_immutable:1, /* set = system files are immutable */
@@ -232,6 +237,7 @@ struct msdos_sb_info {
        struct mutex fat_lock;
        unsigned int prev_free;      /* previously allocated cluster number */
        unsigned int free_clusters;  /* -1 if undefined */
+        unsigned int free_clus_valid; /* is free_clusters valid? */
        struct fat_mount_options options;
        struct nls_table *nls_disk;  /* Codepage used on disk */
        struct nls_table *nls_io;    /* Charset used for input and display */
@@ -401,7 +407,7 @@ extern int fat_generic_ioctl(struct inode *inode, struct file *filp,
                             unsigned int cmd, unsigned long arg);
 extern const struct file_operations fat_file_operations;
 extern const struct inode_operations fat_file_inode_operations;
-extern int fat_notify_change(struct dentry * dentry, struct iattr * attr);
+extern int fat_setattr(struct dentry * dentry, struct iattr * attr);
 extern void fat_truncate(struct inode *inode);
 extern int fat_getattr(struct vfsmount *mnt, struct dentry *dentry,
                       struct kstat *stat);
diff --git a/include/linux/msg.h b/include/linux/msg.h
index 10a3d5a1abff..6f3b8e79a991 100644
--- a/include/linux/msg.h
+++ b/include/linux/msg.h
@@ -49,16 +49,26 @@ struct msginfo {
        unsigned short  msgseg; 
 };
+/*
+ * Scaling factor to compute msgmni:
+ * the memory dedicated to msg queues (msgmni * msgmnb) should occupy
+ * at most 1/MSG_MEM_SCALE of the lowmem (see the formula in ipc/msg.c):
+ * up to 8MB       : msgmni = 16 (MSGMNI)
+ * 4 GB            : msgmni = 8K
+ * more than 16 GB : msgmni = 32K (IPCMNI)
+ */
+#define MSG_MEM_SCALE 32
 #define MSGMNI    16   /* <= IPCMNI */     /* max # of msg queue identifiers */
 #define MSGMAX  8192   /* <= INT_MAX */   /* max size of message (bytes) */
 #define MSGMNB 16384   /* <= INT_MAX */   /* default max size of a message queue */
 /* unused */
-#define MSGPOOL (MSGMNI*MSGMNB/1024)  /* size in kilobytes of message pool */
+#define MSGPOOL (MSGMNI * MSGMNB) /* size in bytes of message pool */
 #define MSGTQL  MSGMNB            /* number of system message headers */
 #define MSGMAP  MSGMNB            /* number of entries in message map */
 #define MSGSSZ  16                /* message segment size */
-#define __MSGSEG ((MSGPOOL*1024)/ MSGSSZ) /* max no. of segments */
+#define __MSGSEG (MSGPOOL / MSGSSZ) /* max no. of segments */
 #define MSGSEG (__MSGSEG <= 0xffff ? __MSGSEG : 0xffff)
 #ifdef __KERNEL__
diff --git a/include/linux/msi.h b/include/linux/msi.h
index 94bb46d82efd..8f2939227207 100644
--- a/include/linux/msi.h
+++ b/include/linux/msi.h
@@ -22,6 +22,7 @@ struct msi_desc {
                __u8    masked  : 1;
                __u8    is_64   : 1;    /* Address size: 0=32bit 1=64bit  */
                __u8    pos;            /* Location of the msi capability */
+                __u32   maskbits_mask;  /* mask bits mask */
                __u16   entry_nr;       /* specific enabled entry         */
                unsigned default_irq;   /* default pre-assigned irq       */
        }msi_attrib;
diff --git a/include/linux/nbd.h b/include/linux/nbd.h
index 986572081e19..155719dab813 100644
--- a/include/linux/nbd.h
+++ b/include/linux/nbd.h
@@ -56,9 +56,11 @@ struct nbd_device {
        int magic;
        spinlock_t queue_lock;
-        struct list_head queue_head;/* Requests are added here...       */
+        struct list_head queue_head;    /* Requests waiting result */
        struct request *active_req;
        wait_queue_head_t active_wq;
+        struct list_head waiting_queue; /* Requests to be sent */
+        wait_queue_head_t waiting_wq;
        struct mutex tx_lock;
        struct gendisk *disk;
@@ -86,11 +88,7 @@ struct nbd_request {
        char handle[8];
        __be64 from;
        __be32 len;
-}
+} __attribute__ ((packed));
-#ifdef __GNUC__
-        __attribute__ ((packed))
-#endif
-;
 /*
 * This is the reply packet that nbd-server sends back to the client after
diff --git a/include/linux/ncp_fs.h b/include/linux/ncp_fs.h
index 88766e43e121..9f2d76347f19 100644
--- a/include/linux/ncp_fs.h
+++ b/include/linux/ncp_fs.h
@@ -204,6 +204,7 @@ void ncp_update_inode2(struct inode *, struct ncp_entry_info *);
 /* linux/fs/ncpfs/dir.c */
 extern const struct inode_operations ncp_dir_inode_operations;
 extern const struct file_operations ncp_dir_operations;
+extern struct dentry_operations ncp_root_dentry_operations;
 int ncp_conn_logged_in(struct super_block *);
 int ncp_date_dos2unix(__le16 time, __le16 date);
 void ncp_date_unix2dos(int unix_date, __le16 * time, __le16 * date);
@@ -223,6 +224,12 @@ int ncp_disconnect(struct ncp_server *server);
 void ncp_lock_server(struct ncp_server *server);
 void ncp_unlock_server(struct ncp_server *server);
+/* linux/fs/ncpfs/symlink.c */
+#if defined(CONFIG_NCPFS_EXTRAS) || defined(CONFIG_NCPFS_NFS_NS)
+extern const struct address_space_operations ncp_symlink_aops;
+int ncp_symlink(struct inode*, struct dentry*, const char*);
+#endif
 /* linux/fs/ncpfs/file.c */
 extern const struct inode_operations ncp_file_inode_operations;
 extern const struct file_operations ncp_file_operations;
diff --git a/include/linux/netlink.h b/include/linux/netlink.h
index fb0713b6ffaf..bec1062a25a1 100644
--- a/include/linux/netlink.h
+++ b/include/linux/netlink.h
@@ -166,6 +166,7 @@ struct netlink_skb_parms
        __u32                   dst_group;
        kernel_cap_t            eff_cap;
        __u32                   loginuid;       /* Login (audit) uid */
+        __u32                   sessionid;      /* Session id (audit) */
        __u32                   sid;            /* SELinux security id */
 };
diff --git a/include/linux/nodemask.h b/include/linux/nodemask.h
index 905e18f4b412..848025cd7087 100644
--- a/include/linux/nodemask.h
+++ b/include/linux/nodemask.h
@@ -14,6 +14,8 @@
 * bitmap_scnlistprintf() and bitmap_parselist(), also in bitmap.c.
 * For details of node_remap(), see bitmap_bitremap in lib/bitmap.c.
 * For details of nodes_remap(), see bitmap_remap in lib/bitmap.c.
+ * For details of nodes_onto(), see bitmap_onto in lib/bitmap.c.
+ * For details of nodes_fold(), see bitmap_fold in lib/bitmap.c.
 *
 * The available nodemask operations are:
 *
@@ -55,7 +57,9 @@
 * int nodelist_scnprintf(buf, len, mask) Format nodemask as list for printing
 * int nodelist_parse(buf, map)         Parse ascii string as nodelist
 * int node_remap(oldbit, old, new)     newbit = map(old, new)(oldbit)
- * int nodes_remap(dst, src, old, new)  *dst = map(old, new)(dst)
+ * void nodes_remap(dst, src, old, new) *dst = map(old, new)(src)
+ * void nodes_onto(dst, orig, relmap)   *dst = orig relative to relmap
+ * void nodes_fold(dst, orig, sz)       dst bits = orig bits mod sz
 *
 * for_each_node_mask(node, mask)       for-loop node over mask
 *
@@ -326,6 +330,22 @@ static inline void __nodes_remap(nodemask_t *dstp, const nodemask_t *srcp,
        bitmap_remap(dstp->bits, srcp->bits, oldp->bits, newp->bits, nbits);
 }
+#define nodes_onto(dst, orig, relmap) \
+                __nodes_onto(&(dst), &(orig), &(relmap), MAX_NUMNODES)
+static inline void __nodes_onto(nodemask_t *dstp, const nodemask_t *origp,
+                const nodemask_t *relmapp, int nbits)
+{
+        bitmap_onto(dstp->bits, origp->bits, relmapp->bits, nbits);
+}
+#define nodes_fold(dst, orig, sz) \
+                __nodes_fold(&(dst), &(orig), sz, MAX_NUMNODES)
+static inline void __nodes_fold(nodemask_t *dstp, const nodemask_t *origp,
+                int sz, int nbits)
+{
+        bitmap_fold(dstp->bits, origp->bits, sz, nbits);
+}
 #if MAX_NUMNODES > 1
 #define for_each_node_mask(node, mask)                  \
        for ((node) = first_node(mask);                 \
diff --git a/include/linux/notifier.h b/include/linux/notifier.h
index f4df40038f0c..0ff6224d172a 100644
--- a/include/linux/notifier.h
+++ b/include/linux/notifier.h
@@ -121,6 +121,10 @@ extern int raw_notifier_chain_register(struct raw_notifier_head *nh,
 extern int srcu_notifier_chain_register(struct srcu_notifier_head *nh,
                struct notifier_block *nb);
+extern int blocking_notifier_chain_cond_register(
+                struct blocking_notifier_head *nh,
+                struct notifier_block *nb);
 extern int atomic_notifier_chain_unregister(struct atomic_notifier_head *nh,
                struct notifier_block *nb);
 extern int blocking_notifier_chain_unregister(struct blocking_notifier_head *nh,
@@ -247,6 +251,7 @@ extern struct blocking_notifier_head reboot_notifier_list;
 #define VT_DEALLOCATE           0x0002 /* Console will be deallocated */
 #define VT_WRITE                0x0003 /* A char got output */
 #define VT_UPDATE               0x0004 /* A bigger update occurred */
+#define VT_PREWRITE             0x0005 /* A char is about to be written to the console */
 #endif /* __KERNEL__ */
 #endif /* _LINUX_NOTIFIER_H */
diff --git a/include/linux/oom.h b/include/linux/oom.h
index 3852436b652a..a7979baf1e39 100644
--- a/include/linux/oom.h
+++ b/include/linux/oom.h
@@ -23,8 +23,8 @@ enum oom_constraint {
        CONSTRAINT_MEMORY_POLICY,
 };
-extern int try_set_zone_oom(struct zonelist *zonelist);
+extern int try_set_zone_oom(struct zonelist *zonelist, gfp_t gfp_flags);
-extern void clear_zonelist_oom(struct zonelist *zonelist);
+extern void clear_zonelist_oom(struct zonelist *zonelist, gfp_t gfp_flags);
 extern void out_of_memory(struct zonelist *zonelist, gfp_t gfp_mask, int order);
 extern int register_oom_notifier(struct notifier_block *nb);
diff --git a/include/linux/page-flags.h b/include/linux/page-flags.h
index b5b30f1c1e59..590cff32415d 100644
--- a/include/linux/page-flags.h
+++ b/include/linux/page-flags.h
@@ -6,7 +6,10 @@
 #define PAGE_FLAGS_H
 #include <linux/types.h>
+#ifndef __GENERATING_BOUNDS_H
 #include <linux/mm_types.h>
+#include <linux/bounds.h>
+#endif /* !__GENERATING_BOUNDS_H */
 /*
 * Various page->flags bits:
@@ -59,77 +62,138 @@
 * extends from the high bits downwards.
 *
 *  | FIELD | ... | FLAGS |
- *  N-1     ^             0
+ *  N-1           ^       0
- *          (N-FLAGS_RESERVED)
+ *               (NR_PAGEFLAGS)
 *
- * The fields area is reserved for fields mapping zone, node and SPARSEMEM
+ * The fields area is reserved for fields mapping zone, node (for NUMA) and
- * section.  The boundry between these two areas is defined by
+ * SPARSEMEM section (for variants of SPARSEMEM that require section ids like
- * FLAGS_RESERVED which defines the width of the fields section
+ * SPARSEMEM_EXTREME with !SPARSEMEM_VMEMMAP).
- * (see linux/mmzone.h).  New flags must _not_ overlap with this area.
 */
-#define PG_locked                0      /* Page is locked. Don't touch. */
+enum pageflags {
-#define PG_error                 1
+        PG_locked,              /* Page is locked. Don't touch. */
-#define PG_referenced            2
+        PG_error,
-#define PG_uptodate              3
+        PG_referenced,
+        PG_uptodate,
+        PG_dirty,
+        PG_lru,
+        PG_active,
+        PG_slab,
+        PG_owner_priv_1,        /* Owner use. If pagecache, fs may use*/
+        PG_arch_1,
+        PG_reserved,
+        PG_private,             /* If pagecache, has fs-private data */
+        PG_writeback,           /* Page is under writeback */
+#ifdef CONFIG_PAGEFLAGS_EXTENDED
+        PG_head,                /* A head page */
+        PG_tail,                /* A tail page */
+#else
+        PG_compound,            /* A compound page */
+#endif
+        PG_swapcache,           /* Swap page: swp_entry_t in private */
+        PG_mappedtodisk,        /* Has blocks allocated on-disk */
+        PG_reclaim,             /* To be reclaimed asap */
+        PG_buddy,               /* Page is free, on buddy lists */
+#ifdef CONFIG_IA64_UNCACHED_ALLOCATOR
+        PG_uncached,            /* Page has been mapped as uncached */
+#endif
+        __NR_PAGEFLAGS
+};
+#ifndef __GENERATING_BOUNDS_H
+/*
+ * Macros to create function definitions for page flags
+ */
+#define TESTPAGEFLAG(uname, lname)                                      \
+static inline int Page##uname(struct page *page)                        \
+                        { return test_bit(PG_##lname, &page->flags); }
-#define PG_dirty                 4
+#define SETPAGEFLAG(uname, lname)                                       \
-#define PG_lru                   5
+static inline void SetPage##uname(struct page *page)                    \
-#define PG_active                6
+                        { set_bit(PG_##lname, &page->flags); }
-#define PG_slab                  7      /* slab debug (Suparna wants this) */
-#define PG_owner_priv_1          8      /* Owner use. If pagecache, fs may use*/
+#define CLEARPAGEFLAG(uname, lname)                                     \
-#define PG_arch_1                9
+static inline void ClearPage##uname(struct page *page)                  \
-#define PG_reserved             10
+                        { clear_bit(PG_##lname, &page->flags); }
-#define PG_private              11      /* If pagecache, has fs-private data */
-#define PG_writeback            12      /* Page is under writeback */
+#define __SETPAGEFLAG(uname, lname)                                     \
-#define PG_compound             14      /* Part of a compound page */
+static inline void __SetPage##uname(struct page *page)                  \
-#define PG_swapcache            15      /* Swap page: swp_entry_t in private */
+                        { __set_bit(PG_##lname, &page->flags); }
-#define PG_mappedtodisk         16      /* Has blocks allocated on-disk */
+#define __CLEARPAGEFLAG(uname, lname)                                   \
-#define PG_reclaim              17      /* To be reclaimed asap */
+static inline void __ClearPage##uname(struct page *page)                \
-#define PG_buddy                19      /* Page is free, on buddy lists */
+                        { __clear_bit(PG_##lname, &page->flags); }
+#define TESTSETFLAG(uname, lname)                                       \
+static inline int TestSetPage##uname(struct page *page)                 \
+                { return test_and_set_bit(PG_##lname, &page->flags); }
+#define TESTCLEARFLAG(uname, lname)                                     \
+static inline int TestClearPage##uname(struct page *page)               \
+                { return test_and_clear_bit(PG_##lname, &page->flags); }
-/* PG_readahead is only used for file reads; PG_reclaim is only for writes */
-#define PG_readahead            PG_reclaim /* Reminder to do async read-ahead */
-/* PG_owner_priv_1 users should have descriptive aliases */
+#define PAGEFLAG(uname, lname) TESTPAGEFLAG(uname, lname)               \
-#define PG_checked              PG_owner_priv_1 /* Used by some filesystems */
+        SETPAGEFLAG(uname, lname) CLEARPAGEFLAG(uname, lname)
-#define PG_pinned               PG_owner_priv_1 /* Xen pinned pagetable */
+#define __PAGEFLAG(uname, lname) TESTPAGEFLAG(uname, lname)             \
+        __SETPAGEFLAG(uname, lname)  __CLEARPAGEFLAG(uname, lname)
+#define PAGEFLAG_FALSE(uname)                                           \
+static inline int Page##uname(struct page *page)                        \
+                        { return 0; }
+#define TESTSCFLAG(uname, lname)                                        \
+        TESTSETFLAG(uname, lname) TESTCLEARFLAG(uname, lname)
+struct page;    /* forward declaration */
+PAGEFLAG(Locked, locked) TESTSCFLAG(Locked, locked)
+PAGEFLAG(Error, error)
+PAGEFLAG(Referenced, referenced) TESTCLEARFLAG(Referenced, referenced)
+PAGEFLAG(Dirty, dirty) TESTSCFLAG(Dirty, dirty) __CLEARPAGEFLAG(Dirty, dirty)
+PAGEFLAG(LRU, lru) __CLEARPAGEFLAG(LRU, lru)
+PAGEFLAG(Active, active) __CLEARPAGEFLAG(Active, active)
+__PAGEFLAG(Slab, slab)
+PAGEFLAG(Checked, owner_priv_1)         /* Used by some filesystems */
+PAGEFLAG(Pinned, owner_priv_1) TESTSCFLAG(Pinned, owner_priv_1) /* Xen */
+PAGEFLAG(Reserved, reserved) __CLEARPAGEFLAG(Reserved, reserved)
+PAGEFLAG(Private, private) __CLEARPAGEFLAG(Private, private)
+        __SETPAGEFLAG(Private, private)
-#if (BITS_PER_LONG > 32)
 /*
- * 64-bit-only flags build down from bit 31
+ * Only test-and-set exist for PG_writeback.  The unconditional operators are
- *
+ * risky: they bypass page accounting.
- * 32 bit  -------------------------------| FIELDS |       FLAGS         |
- * 64 bit  |           FIELDS             | ??????         FLAGS         |
- *         63                            32                              0
 */
-#define PG_uncached             31      /* Page has been mapped as uncached */
+TESTPAGEFLAG(Writeback, writeback) TESTSCFLAG(Writeback, writeback)
-#endif
+__PAGEFLAG(Buddy, buddy)
+PAGEFLAG(MappedToDisk, mappedtodisk)
+/* PG_readahead is only used for file reads; PG_reclaim is only for writes */
+PAGEFLAG(Reclaim, reclaim) TESTCLEARFLAG(Reclaim, reclaim)
+PAGEFLAG(Readahead, reclaim)            /* Reminder to do async read-ahead */
+#ifdef CONFIG_HIGHMEM
 /*
- * Manipulation of page state flags
+ * Must use a macro here due to header dependency issues. page_zone() is not
+ * available at this point.
 */
-#define PageLocked(page)                \
+#define PageHighMem(__p) is_highmem(page_zone(__p))
-                test_bit(PG_locked, &(page)->flags)
+#else
-#define SetPageLocked(page)             \
+PAGEFLAG_FALSE(HighMem)
-                set_bit(PG_locked, &(page)->flags)
+#endif
-#define TestSetPageLocked(page)         \
-                test_and_set_bit(PG_locked, &(page)->flags)
+#ifdef CONFIG_SWAP
-#define ClearPageLocked(page)           \
+PAGEFLAG(SwapCache, swapcache)
-                clear_bit(PG_locked, &(page)->flags)
+#else
-#define TestClearPageLocked(page)       \
+PAGEFLAG_FALSE(SwapCache)
-                test_and_clear_bit(PG_locked, &(page)->flags)
+#endif
-#define PageError(page)         test_bit(PG_error, &(page)->flags)
+#ifdef CONFIG_IA64_UNCACHED_ALLOCATOR
-#define SetPageError(page)      set_bit(PG_error, &(page)->flags)
+PAGEFLAG(Uncached, uncached)
-#define ClearPageError(page)    clear_bit(PG_error, &(page)->flags)
+#else
+PAGEFLAG_FALSE(Uncached)
-#define PageReferenced(page)    test_bit(PG_referenced, &(page)->flags)
+#endif
-#define SetPageReferenced(page) set_bit(PG_referenced, &(page)->flags)
-#define ClearPageReferenced(page)       clear_bit(PG_referenced, &(page)->flags)
-#define TestClearPageReferenced(page) test_and_clear_bit(PG_referenced, &(page)->flags)
 static inline int PageUptodate(struct page *page)
 {
@@ -177,97 +241,59 @@ static inline void SetPageUptodate(struct page *page)
 #endif
 }
-#define ClearPageUptodate(page) clear_bit(PG_uptodate, &(page)->flags)
+CLEARPAGEFLAG(Uptodate, uptodate)
-#define PageDirty(page)         test_bit(PG_dirty, &(page)->flags)
-#define SetPageDirty(page)      set_bit(PG_dirty, &(page)->flags)
-#define TestSetPageDirty(page)  test_and_set_bit(PG_dirty, &(page)->flags)
-#define ClearPageDirty(page)    clear_bit(PG_dirty, &(page)->flags)
-#define __ClearPageDirty(page)  __clear_bit(PG_dirty, &(page)->flags)
-#define TestClearPageDirty(page) test_and_clear_bit(PG_dirty, &(page)->flags)
-#define PageLRU(page)           test_bit(PG_lru, &(page)->flags)
-#define SetPageLRU(page)        set_bit(PG_lru, &(page)->flags)
-#define ClearPageLRU(page)      clear_bit(PG_lru, &(page)->flags)
-#define __ClearPageLRU(page)    __clear_bit(PG_lru, &(page)->flags)
-#define PageActive(page)        test_bit(PG_active, &(page)->flags)
-#define SetPageActive(page)     set_bit(PG_active, &(page)->flags)
-#define ClearPageActive(page)   clear_bit(PG_active, &(page)->flags)
-#define __ClearPageActive(page) __clear_bit(PG_active, &(page)->flags)
-#define PageSlab(page)          test_bit(PG_slab, &(page)->flags)
-#define __SetPageSlab(page)     __set_bit(PG_slab, &(page)->flags)
-#define __ClearPageSlab(page)   __clear_bit(PG_slab, &(page)->flags)
-#ifdef CONFIG_HIGHMEM
-#define PageHighMem(page)       is_highmem(page_zone(page))
-#else
-#define PageHighMem(page)       0 /* needed to optimize away at compile time */
-#endif
-#define PageChecked(page)       test_bit(PG_checked, &(page)->flags)
+extern void cancel_dirty_page(struct page *page, unsigned int account_size);
-#define SetPageChecked(page)    set_bit(PG_checked, &(page)->flags)
-#define ClearPageChecked(page)  clear_bit(PG_checked, &(page)->flags)
-#define PagePinned(page)        test_bit(PG_pinned, &(page)->flags)
-#define SetPagePinned(page)     set_bit(PG_pinned, &(page)->flags)
-#define ClearPagePinned(page)   clear_bit(PG_pinned, &(page)->flags)
-#define PageReserved(page)      test_bit(PG_reserved, &(page)->flags)
+int test_clear_page_writeback(struct page *page);
-#define SetPageReserved(page)   set_bit(PG_reserved, &(page)->flags)
+int test_set_page_writeback(struct page *page);
-#define ClearPageReserved(page) clear_bit(PG_reserved, &(page)->flags)
-#define __ClearPageReserved(page)       __clear_bit(PG_reserved, &(page)->flags)
-#define SetPagePrivate(page)    set_bit(PG_private, &(page)->flags)
+static inline void set_page_writeback(struct page *page)
-#define ClearPagePrivate(page)  clear_bit(PG_private, &(page)->flags)
+{
-#define PagePrivate(page)       test_bit(PG_private, &(page)->flags)
+        test_set_page_writeback(page);
-#define __SetPagePrivate(page)  __set_bit(PG_private, &(page)->flags)
+}
-#define __ClearPagePrivate(page) __clear_bit(PG_private, &(page)->flags)
+#ifdef CONFIG_PAGEFLAGS_EXTENDED
 /*
- * Only test-and-set exist for PG_writeback.  The unconditional operators are
+ * System with lots of page flags available. This allows separate
- * risky: they bypass page accounting.
+ * flags for PageHead() and PageTail() checks of compound pages so that bit
+ * tests can be used in performance sensitive paths. PageCompound is
+ * generally not used in hot code paths.
 */
-#define PageWriteback(page)     test_bit(PG_writeback, &(page)->flags)
+__PAGEFLAG(Head, head)
-#define TestSetPageWriteback(page) test_and_set_bit(PG_writeback,       \
+__PAGEFLAG(Tail, tail)
-                                                        &(page)->flags)
-#define TestClearPageWriteback(page) test_and_clear_bit(PG_writeback,   \
-                                                        &(page)->flags)
-#define PageBuddy(page)         test_bit(PG_buddy, &(page)->flags)
+static inline int PageCompound(struct page *page)
-#define __SetPageBuddy(page)    __set_bit(PG_buddy, &(page)->flags)
+{
-#define __ClearPageBuddy(page)  __clear_bit(PG_buddy, &(page)->flags)
+        return page->flags & ((1L << PG_head) | (1L << PG_tail));
-#define PageMappedToDisk(page)  test_bit(PG_mappedtodisk, &(page)->flags)
-#define SetPageMappedToDisk(page) set_bit(PG_mappedtodisk, &(page)->flags)
-#define ClearPageMappedToDisk(page) clear_bit(PG_mappedtodisk, &(page)->flags)
-#define PageReadahead(page)     test_bit(PG_readahead, &(page)->flags)
-#define SetPageReadahead(page)  set_bit(PG_readahead, &(page)->flags)
-#define ClearPageReadahead(page) clear_bit(PG_readahead, &(page)->flags)
-#define PageReclaim(page)       test_bit(PG_reclaim, &(page)->flags)
-#define SetPageReclaim(page)    set_bit(PG_reclaim, &(page)->flags)
-#define ClearPageReclaim(page)  clear_bit(PG_reclaim, &(page)->flags)
-#define TestClearPageReclaim(page) test_and_clear_bit(PG_reclaim, &(page)->flags)
-#define PageCompound(page)      test_bit(PG_compound, &(page)->flags)
+}
-#define __SetPageCompound(page) __set_bit(PG_compound, &(page)->flags)
+#else
-#define __ClearPageCompound(page) __clear_bit(PG_compound, &(page)->flags)
+/*
+ * Reduce page flag use as much as possible by overlapping
+ * compound page flags with the flags used for page cache pages. Possible
+ * because PageCompound is always set for compound pages and not for
+ * pages on the LRU and/or pagecache.
+ */
+TESTPAGEFLAG(Compound, compound)
+__PAGEFLAG(Head, compound)
 /*
 * PG_reclaim is used in combination with PG_compound to mark the
- * head and tail of a compound page
+ * head and tail of a compound page. This saves one page flag
+ * but makes it impossible to use compound pages for the page cache.
+ * The PG_reclaim bit would have to be used for reclaim or readahead
+ * if compound pages enter the page cache.
 *
 * PG_compound & PG_reclaim     => Tail page
 * PG_compound & ~PG_reclaim    => Head page
 */
 #define PG_head_tail_mask ((1L << PG_compound) | (1L << PG_reclaim))
-#define PageTail(page)  (((page)->flags & PG_head_tail_mask)    \
+static inline int PageTail(struct page *page)
-                                == PG_head_tail_mask)
+{
+        return ((page->flags & PG_head_tail_mask) == PG_head_tail_mask);
+}
 static inline void __SetPageTail(struct page *page)
 {
@@ -279,33 +305,6 @@ static inline void __ClearPageTail(struct page *page)
        page->flags &= ~PG_head_tail_mask;
 }
-#define PageHead(page)  (((page)->flags & PG_head_tail_mask)    \
+#endif /* !PAGEFLAGS_EXTENDED */
-                                == (1L << PG_compound))
+#endif /* !__GENERATING_BOUNDS_H */
-#define __SetPageHead(page)     __SetPageCompound(page)
-#define __ClearPageHead(page)   __ClearPageCompound(page)
-#ifdef CONFIG_SWAP
-#define PageSwapCache(page)     test_bit(PG_swapcache, &(page)->flags)
-#define SetPageSwapCache(page)  set_bit(PG_swapcache, &(page)->flags)
-#define ClearPageSwapCache(page) clear_bit(PG_swapcache, &(page)->flags)
-#else
-#define PageSwapCache(page)     0
-#endif
-#define PageUncached(page)      test_bit(PG_uncached, &(page)->flags)
-#define SetPageUncached(page)   set_bit(PG_uncached, &(page)->flags)
-#define ClearPageUncached(page) clear_bit(PG_uncached, &(page)->flags)
-struct page;    /* forward declaration */
-extern void cancel_dirty_page(struct page *page, unsigned int account_size);
-int test_clear_page_writeback(struct page *page);
-int test_set_page_writeback(struct page *page);
-static inline void set_page_writeback(struct page *page)
-{
-        test_set_page_writeback(page);
-}
 #endif  /* PAGE_FLAGS_H */
diff --git a/include/linux/pci.h b/include/linux/pci.h
index 292491324b01..96acd0dae241 100644
--- a/include/linux/pci.h
+++ b/include/linux/pci.h
@@ -20,8 +20,6 @@
 /* Include the pci register defines */
 #include <linux/pci_regs.h>
-struct pci_vpd;
 /*
 * The PCI interface treats multi-function devices as independent
 * devices.  The slot/function address of each device is encoded
@@ -131,6 +129,8 @@ struct pci_cap_saved_state {
 };
 struct pcie_link_state;
+struct pci_vpd;
 /*
 * The pci_dev structure is used to describe PCI devices.
 */
@@ -254,7 +254,7 @@ static inline void pci_add_saved_cap(struct pci_dev *pci_dev,
 #define PCI_NUM_RESOURCES       11
 #ifndef PCI_BUS_NUM_RESOURCES
-#define PCI_BUS_NUM_RESOURCES   8
+#define PCI_BUS_NUM_RESOURCES   16
 #endif
 #define PCI_REGION_FLAG_MASK    0x0fU   /* These bits of resource flags tell us the PCI region flags */
@@ -666,6 +666,7 @@ int pci_scan_bridge(struct pci_bus *bus, struct pci_dev *dev, int max,
 void pci_walk_bus(struct pci_bus *top, void (*cb)(struct pci_dev *, void *),
                  void *userdata);
+int pci_cfg_space_size_ext(struct pci_dev *dev, unsigned check_exp_pcix);
 int pci_cfg_space_size(struct pci_dev *dev);
 unsigned char pci_bus_max_busnr(struct pci_bus *bus);
@@ -701,6 +702,8 @@ static inline int pci_enable_msi(struct pci_dev *dev)
        return -1;
 }
+static inline void pci_msi_shutdown(struct pci_dev *dev)
+{ }
 static inline void pci_disable_msi(struct pci_dev *dev)
 { }
@@ -710,6 +713,8 @@ static inline int pci_enable_msix(struct pci_dev *dev,
        return -1;
 }
+static inline void pci_msix_shutdown(struct pci_dev *dev)
+{ }
 static inline void pci_disable_msix(struct pci_dev *dev)
 { }
@@ -720,9 +725,11 @@ static inline void pci_restore_msi_state(struct pci_dev *dev)
 { }
 #else
 extern int pci_enable_msi(struct pci_dev *dev);
+extern void pci_msi_shutdown(struct pci_dev *dev);
 extern void pci_disable_msi(struct pci_dev *dev);
 extern int pci_enable_msix(struct pci_dev *dev,
        struct msix_entry *entries, int nvec);
+extern void pci_msix_shutdown(struct pci_dev *dev);
 extern void pci_disable_msix(struct pci_dev *dev);
 extern void msi_remove_pci_irq_vectors(struct pci_dev *dev);
 extern void pci_restore_msi_state(struct pci_dev *dev);
@@ -1053,5 +1060,13 @@ extern unsigned long pci_cardbus_mem_size;
 extern int pcibios_add_platform_entries(struct pci_dev *dev);
+#ifdef CONFIG_PCI_MMCONFIG
+extern void __init pci_mmcfg_early_init(void);
+extern void __init pci_mmcfg_late_init(void);
+#else
+static inline void pci_mmcfg_early_init(void) { }
+static inline void pci_mmcfg_late_init(void) { }
+#endif
 #endif /* __KERNEL__ */
 #endif /* LINUX_PCI_H */
diff --git a/include/linux/pci_ids.h b/include/linux/pci_ids.h
index 70eb3c803d47..e5a53daf17f1 100644
--- a/include/linux/pci_ids.h
+++ b/include/linux/pci_ids.h
@@ -2413,6 +2413,8 @@
 #define PCI_DEVICE_ID_INTEL_82443GX_0   0x71a0
 #define PCI_DEVICE_ID_INTEL_82443GX_2   0x71a2
 #define PCI_DEVICE_ID_INTEL_82372FB_1   0x7601
+#define PCI_DEVICE_ID_INTEL_SCH_LPC     0x8119
+#define PCI_DEVICE_ID_INTEL_SCH_IDE     0x811a
 #define PCI_DEVICE_ID_INTEL_82454GX     0x84c4
 #define PCI_DEVICE_ID_INTEL_82450GX     0x84c5
 #define PCI_DEVICE_ID_INTEL_82451NX     0x84ca
diff --git a/include/linux/percpu.h b/include/linux/percpu.h
index 1ac969724bb2..d746a2abb322 100644
--- a/include/linux/percpu.h
+++ b/include/linux/percpu.h
@@ -4,7 +4,6 @@
 #include <linux/preempt.h>
 #include <linux/slab.h> /* For kmalloc() */
 #include <linux/smp.h>
-#include <linux/string.h> /* For memset() */
 #include <linux/cpumask.h>
 #include <asm/percpu.h>
diff --git a/include/linux/personality.h b/include/linux/personality.h
index 012cd558189b..a84e9ff9b27e 100644
--- a/include/linux/personality.h
+++ b/include/linux/personality.h
@@ -105,10 +105,6 @@ struct exec_domain {
 */
 #define personality(pers)       (pers & PER_MASK)
-/*
- * Personality of the currently running process.
- */
-#define get_personality         (current->personality)
 /*
 * Change personality of the currently running process.
diff --git a/include/linux/phantom.h b/include/linux/phantom.h
index 96f4048a6cc3..02268c54c250 100644
--- a/include/linux/phantom.h
+++ b/include/linux/phantom.h
@@ -27,14 +27,17 @@ struct phm_regs {
 #define PH_IOC_MAGIC            'p'
 #define PHN_GET_REG             _IOWR(PH_IOC_MAGIC, 0, struct phm_reg *)
-#define PHN_SET_REG             _IOW (PH_IOC_MAGIC, 1, struct phm_reg *)
+#define PHN_SET_REG             _IOW(PH_IOC_MAGIC, 1, struct phm_reg *)
 #define PHN_GET_REGS            _IOWR(PH_IOC_MAGIC, 2, struct phm_regs *)
-#define PHN_SET_REGS            _IOW (PH_IOC_MAGIC, 3, struct phm_regs *)
+#define PHN_SET_REGS            _IOW(PH_IOC_MAGIC, 3, struct phm_regs *)
 /* this ioctl tells the driver, that the caller is not OpenHaptics and might
 * use improved registers update (no more phantom switchoffs when using
 * libphantom) */
-#define PHN_NOT_OH              _IO  (PH_IOC_MAGIC, 4)
+#define PHN_NOT_OH              _IO(PH_IOC_MAGIC, 4)
-#define PH_IOC_MAXNR            4
+#define PHN_GETREG              _IOWR(PH_IOC_MAGIC, 5, struct phm_reg)
+#define PHN_SETREG              _IOW(PH_IOC_MAGIC, 6, struct phm_reg)
+#define PHN_GETREGS             _IOWR(PH_IOC_MAGIC, 7, struct phm_regs)
+#define PHN_SETREGS             _IOW(PH_IOC_MAGIC, 8, struct phm_regs)
 #define PHN_CONTROL             0x6     /* control byte in iaddr space */
 #define PHN_CTL_AMP             0x1     /*   switch after torques change */
diff --git a/include/linux/prctl.h b/include/linux/prctl.h
index 5c80b1939636..5ad79198d6f9 100644
--- a/include/linux/prctl.h
+++ b/include/linux/prctl.h
@@ -16,7 +16,8 @@
 # define PR_UNALIGN_NOPRINT     1       /* silently fix up unaligned user accesses */
 # define PR_UNALIGN_SIGBUS      2       /* generate SIGBUS on unaligned user access */
-/* Get/set whether or not to drop capabilities on setuid() away from uid 0 */
+/* Get/set whether or not to drop capabilities on setuid() away from
+ * uid 0 (as per security/commoncap.c) */
 #define PR_GET_KEEPCAPS   7
 #define PR_SET_KEEPCAPS   8
@@ -63,7 +64,7 @@
 #define PR_GET_SECCOMP  21
 #define PR_SET_SECCOMP  22
-/* Get/set the capability bounding set */
+/* Get/set the capability bounding set (as per security/commoncap.c) */
 #define PR_CAPBSET_READ 23
 #define PR_CAPBSET_DROP 24
@@ -73,4 +74,8 @@
 # define PR_TSC_ENABLE          1       /* allow the use of the timestamp counter */
 # define PR_TSC_SIGSEGV         2       /* throw a SIGSEGV instead of reading the TSC */
+/* Get/set securebits (as per security/commoncap.c) */
+#define PR_GET_SECUREBITS 27
+#define PR_SET_SECUREBITS 28
 #endif /* _LINUX_PRCTL_H */
diff --git a/include/linux/proc_fs.h b/include/linux/proc_fs.h
index 9b6c935f69cf..9883bc942262 100644
--- a/include/linux/proc_fs.h
+++ b/include/linux/proc_fs.h
@@ -9,7 +9,6 @@
 struct net;
 struct completion;
 /*
 * The proc filesystem constants/structures
 */
@@ -41,7 +40,7 @@ enum {
 * /proc file has a parent, but "subdir" is NULL for all
 * non-directory entries).
 *
- * "get_info" is called at "read", while "owner" is used to protect module
+ * "owner" is used to protect module
 * from unloading while proc_dir_entry is in use
 */
@@ -49,7 +48,6 @@ typedef	int (read_proc_t)(char *page, char **start, off_t off,
                          int count, int *eof, void *data);
 typedef int (write_proc_t)(struct file *file, const char __user *buffer,
                           unsigned long count, void *data);
-typedef int (get_info_t)(char *, char **, off_t, int);
 struct proc_dir_entry {
        unsigned int low_ino;
@@ -70,7 +68,6 @@ struct proc_dir_entry {
         * somewhere.
         */
        const struct file_operations *proc_fops;
-        get_info_t *get_info;
        struct module *owner;
        struct proc_dir_entry *next, *parent, *subdir;
        void *data;
@@ -97,10 +94,6 @@ struct vmcore {
 #ifdef CONFIG_PROC_FS
-extern struct proc_dir_entry proc_root;
-extern struct proc_dir_entry *proc_root_fs;
-extern struct proc_dir_entry *proc_bus;
-extern struct proc_dir_entry *proc_root_driver;
 extern struct proc_dir_entry *proc_root_kcore;
 extern spinlock_t proc_subdir_lock;
@@ -123,9 +116,10 @@ void de_put(struct proc_dir_entry *de);
 extern struct proc_dir_entry *create_proc_entry(const char *name, mode_t mode,
                                                struct proc_dir_entry *parent);
-struct proc_dir_entry *proc_create(const char *name, mode_t mode,
+struct proc_dir_entry *proc_create_data(const char *name, mode_t mode,
                                struct proc_dir_entry *parent,
-                                const struct file_operations *proc_fops);
+                                const struct file_operations *proc_fops,
+                                void *data);
 extern void remove_proc_entry(const char *name, struct proc_dir_entry *parent);
 extern struct vfsmount *proc_mnt;
@@ -180,6 +174,12 @@ extern struct proc_dir_entry *proc_mkdir(const char *,struct proc_dir_entry *);
 extern struct proc_dir_entry *proc_mkdir_mode(const char *name, mode_t mode,
                        struct proc_dir_entry *parent);
+static inline struct proc_dir_entry *proc_create(const char *name, mode_t mode,
+        struct proc_dir_entry *parent, const struct file_operations *proc_fops)
+{
+        return proc_create_data(name, mode, parent, proc_fops, NULL);
+}
 static inline struct proc_dir_entry *create_proc_read_entry(const char *name,
        mode_t mode, struct proc_dir_entry *base, 
        read_proc_t *read_proc, void * data)
@@ -192,24 +192,19 @@ static inline struct proc_dir_entry *create_proc_read_entry(const char *name,
        return res;
 }
 
-static inline struct proc_dir_entry *create_proc_info_entry(const char *name,
-        mode_t mode, struct proc_dir_entry *base, get_info_t *get_info)
-{
-        struct proc_dir_entry *res=create_proc_entry(name,mode,base);
-        if (res) res->get_info=get_info;
-        return res;
-}
 extern struct proc_dir_entry *proc_net_fops_create(struct net *net,
        const char *name, mode_t mode, const struct file_operations *fops);
 extern void proc_net_remove(struct net *net, const char *name);
 extern struct proc_dir_entry *proc_net_mkdir(struct net *net, const char *name,
        struct proc_dir_entry *parent);
-#else
+/* While the {get|set|dup}_mm_exe_file functions are for mm_structs, they are
+ * only needed to implement /proc/<pid>|self/exe so we define them here. */
+extern void set_mm_exe_file(struct mm_struct *mm, struct file *new_exe_file);
+extern struct file *get_mm_exe_file(struct mm_struct *mm);
+extern void dup_mm_exe_file(struct mm_struct *oldmm, struct mm_struct *newmm);
-#define proc_root_driver NULL
+#else
-#define proc_bus NULL
 #define proc_net_fops_create(net, name, mode, fops)  ({ (void)(mode), NULL; })
 static inline void proc_net_remove(struct net *net, const char *name) {}
@@ -226,6 +221,12 @@ static inline struct proc_dir_entry *proc_create(const char *name,
 {
        return NULL;
 }
+static inline struct proc_dir_entry *proc_create_data(const char *name,
+        mode_t mode, struct proc_dir_entry *parent,
+        const struct file_operations *proc_fops, void *data)
+{
+        return NULL;
+}
 #define remove_proc_entry(name, parent) do {} while (0)
 static inline struct proc_dir_entry *proc_symlink(const char *name,
@@ -236,16 +237,11 @@ static inline struct proc_dir_entry *proc_mkdir(const char *name,
 static inline struct proc_dir_entry *create_proc_read_entry(const char *name,
        mode_t mode, struct proc_dir_entry *base, 
        read_proc_t *read_proc, void * data) { return NULL; }
-static inline struct proc_dir_entry *create_proc_info_entry(const char *name,
-        mode_t mode, struct proc_dir_entry *base, get_info_t *get_info)
-        { return NULL; }
 struct tty_driver;
 static inline void proc_tty_register_driver(struct tty_driver *driver) {};
 static inline void proc_tty_unregister_driver(struct tty_driver *driver) {};
-extern struct proc_dir_entry proc_root;
 static inline int pid_ns_prepare_proc(struct pid_namespace *ns)
 {
        return 0;
@@ -255,6 +251,19 @@ static inline void pid_ns_release_proc(struct pid_namespace *ns)
 {
 }
+static inline void set_mm_exe_file(struct mm_struct *mm,
+                                   struct file *new_exe_file)
+{}
+static inline struct file *get_mm_exe_file(struct mm_struct *mm)
+{
+        return NULL;
+}
+static inline void dup_mm_exe_file(struct mm_struct *oldmm,
+                                   struct mm_struct *newmm)
+{}
 #endif /* CONFIG_PROC_FS */
 #if !defined(CONFIG_PROC_KCORE)
diff --git a/include/linux/quota.h b/include/linux/quota.h
index eb560d031acd..52e49dce6584 100644
--- a/include/linux/quota.h
+++ b/include/linux/quota.h
@@ -202,10 +202,14 @@ struct quota_format_type;
 struct mem_dqinfo {
        struct quota_format_type *dqi_format;
+        int dqi_fmt_id;         /* Id of the dqi_format - used when turning
+                                 * quotas on after remount RW */
        struct list_head dqi_dirty_list;        /* List of dirty dquots */
        unsigned long dqi_flags;
        unsigned int dqi_bgrace;
        unsigned int dqi_igrace;
+        qsize_t dqi_maxblimit;
+        qsize_t dqi_maxilimit;
        union {
                struct v1_mem_dqinfo v1_i;
                struct v2_mem_dqinfo v2_i;
@@ -296,8 +300,8 @@ struct dquot_operations {
 /* Operations handling requests from userspace */
 struct quotactl_ops {
-        int (*quota_on)(struct super_block *, int, int, char *);
+        int (*quota_on)(struct super_block *, int, int, char *, int);
-        int (*quota_off)(struct super_block *, int);
+        int (*quota_off)(struct super_block *, int, int);
        int (*quota_sync)(struct super_block *, int);
        int (*get_info)(struct super_block *, int, struct if_dqinfo *);
        int (*set_info)(struct super_block *, int, struct if_dqinfo *);
@@ -318,6 +322,10 @@ struct quota_format_type {
 #define DQUOT_USR_ENABLED       0x01            /* User diskquotas enabled */
 #define DQUOT_GRP_ENABLED       0x02            /* Group diskquotas enabled */
+#define DQUOT_USR_SUSPENDED     0x04            /* User diskquotas are off, but
+                                                 * we have necessary info in
+                                                 * memory to turn them on */
+#define DQUOT_GRP_SUSPENDED     0x08            /* The same for group quotas */
 struct quota_info {
        unsigned int flags;                     /* Flags for diskquotas on this device */
@@ -329,17 +337,16 @@ struct quota_info {
        struct quota_format_ops *ops[MAXQUOTAS];        /* Operations for each type */
 };
-/* Inline would be better but we need to dereference super_block which is not defined yet */
-int mark_dquot_dirty(struct dquot *dquot);
-#define dquot_dirty(dquot) test_bit(DQ_MOD_B, &(dquot)->dq_flags)
 #define sb_has_quota_enabled(sb, type) ((type)==USRQUOTA ? \
        (sb_dqopt(sb)->flags & DQUOT_USR_ENABLED) : (sb_dqopt(sb)->flags & DQUOT_GRP_ENABLED))
 #define sb_any_quota_enabled(sb) (sb_has_quota_enabled(sb, USRQUOTA) | \
                                  sb_has_quota_enabled(sb, GRPQUOTA))
+#define sb_has_quota_suspended(sb, type) \
+        ((type) == USRQUOTA ? (sb_dqopt(sb)->flags & DQUOT_USR_SUSPENDED) : \
+                              (sb_dqopt(sb)->flags & DQUOT_GRP_SUSPENDED))
 int register_quota_format(struct quota_format_type *fmt);
 void unregister_quota_format(struct quota_format_type *fmt);
diff --git a/include/linux/quotaops.h b/include/linux/quotaops.h
index 5110201a4159..f86702053853 100644
--- a/include/linux/quotaops.h
+++ b/include/linux/quotaops.h
@@ -37,11 +37,11 @@ extern int dquot_release(struct dquot *dquot);
 extern int dquot_commit_info(struct super_block *sb, int type);
 extern int dquot_mark_dquot_dirty(struct dquot *dquot);
-extern int vfs_quota_on(struct super_block *sb, int type, int format_id, char *path);
+extern int vfs_quota_on(struct super_block *sb, int type, int format_id,
+                char *path, int remount);
 extern int vfs_quota_on_mount(struct super_block *sb, char *qf_name,
                int format_id, int type);
-extern int vfs_quota_off(struct super_block *sb, int type);
+extern int vfs_quota_off(struct super_block *sb, int type, int remount);
-#define vfs_quota_off_mount(sb, type) vfs_quota_off(sb, type)
 extern int vfs_quota_sync(struct super_block *sb, int type);
 extern int vfs_get_dqinfo(struct super_block *sb, int type, struct if_dqinfo *ii);
 extern int vfs_set_dqinfo(struct super_block *sb, int type, struct if_dqinfo *ii);
@@ -59,7 +59,7 @@ extern struct quotactl_ops vfs_quotactl_ops;
 /* It is better to call this function outside of any transaction as it might
 * need a lot of space in journal for dquot structure allocation. */
-static __inline__ void DQUOT_INIT(struct inode *inode)
+static inline void DQUOT_INIT(struct inode *inode)
 {
        BUG_ON(!inode->i_sb);
        if (sb_any_quota_enabled(inode->i_sb) && !IS_NOQUOTA(inode))
@@ -67,7 +67,7 @@ static __inline__ void DQUOT_INIT(struct inode *inode)
 }
 /* The same as with DQUOT_INIT */
-static __inline__ void DQUOT_DROP(struct inode *inode)
+static inline void DQUOT_DROP(struct inode *inode)
 {
        /* Here we can get arbitrary inode from clear_inode() so we have
         * to be careful. OTOH we don't need locking as quota operations
@@ -90,7 +90,7 @@ static __inline__ void DQUOT_DROP(struct inode *inode)
 /* The following allocation/freeing/transfer functions *must* be called inside
 * a transaction (deadlocks possible otherwise) */
-static __inline__ int DQUOT_PREALLOC_SPACE_NODIRTY(struct inode *inode, qsize_t nr)
+static inline int DQUOT_PREALLOC_SPACE_NODIRTY(struct inode *inode, qsize_t nr)
 {
        if (sb_any_quota_enabled(inode->i_sb)) {
                /* Used space is updated in alloc_space() */
@@ -102,7 +102,7 @@ static __inline__ int DQUOT_PREALLOC_SPACE_NODIRTY(struct inode *inode, qsize_t
        return 0;
 }
-static __inline__ int DQUOT_PREALLOC_SPACE(struct inode *inode, qsize_t nr)
+static inline int DQUOT_PREALLOC_SPACE(struct inode *inode, qsize_t nr)
 {
        int ret;
        if (!(ret =  DQUOT_PREALLOC_SPACE_NODIRTY(inode, nr)))
@@ -110,7 +110,7 @@ static __inline__ int DQUOT_PREALLOC_SPACE(struct inode *inode, qsize_t nr)
        return ret;
 }
-static __inline__ int DQUOT_ALLOC_SPACE_NODIRTY(struct inode *inode, qsize_t nr)
+static inline int DQUOT_ALLOC_SPACE_NODIRTY(struct inode *inode, qsize_t nr)
 {
        if (sb_any_quota_enabled(inode->i_sb)) {
                /* Used space is updated in alloc_space() */
@@ -122,7 +122,7 @@ static __inline__ int DQUOT_ALLOC_SPACE_NODIRTY(struct inode *inode, qsize_t nr)
        return 0;
 }
-static __inline__ int DQUOT_ALLOC_SPACE(struct inode *inode, qsize_t nr)
+static inline int DQUOT_ALLOC_SPACE(struct inode *inode, qsize_t nr)
 {
        int ret;
        if (!(ret = DQUOT_ALLOC_SPACE_NODIRTY(inode, nr)))
@@ -130,7 +130,7 @@ static __inline__ int DQUOT_ALLOC_SPACE(struct inode *inode, qsize_t nr)
        return ret;
 }
-static __inline__ int DQUOT_ALLOC_INODE(struct inode *inode)
+static inline int DQUOT_ALLOC_INODE(struct inode *inode)
 {
        if (sb_any_quota_enabled(inode->i_sb)) {
                DQUOT_INIT(inode);
@@ -140,7 +140,7 @@ static __inline__ int DQUOT_ALLOC_INODE(struct inode *inode)
        return 0;
 }
-static __inline__ void DQUOT_FREE_SPACE_NODIRTY(struct inode *inode, qsize_t nr)
+static inline void DQUOT_FREE_SPACE_NODIRTY(struct inode *inode, qsize_t nr)
 {
        if (sb_any_quota_enabled(inode->i_sb))
                inode->i_sb->dq_op->free_space(inode, nr);
@@ -148,19 +148,19 @@ static __inline__ void DQUOT_FREE_SPACE_NODIRTY(struct inode *inode, qsize_t nr)
                inode_sub_bytes(inode, nr);
 }
-static __inline__ void DQUOT_FREE_SPACE(struct inode *inode, qsize_t nr)
+static inline void DQUOT_FREE_SPACE(struct inode *inode, qsize_t nr)
 {
        DQUOT_FREE_SPACE_NODIRTY(inode, nr);
        mark_inode_dirty(inode);
 }
-static __inline__ void DQUOT_FREE_INODE(struct inode *inode)
+static inline void DQUOT_FREE_INODE(struct inode *inode)
 {
        if (sb_any_quota_enabled(inode->i_sb))
                inode->i_sb->dq_op->free_inode(inode, 1);
 }
-static __inline__ int DQUOT_TRANSFER(struct inode *inode, struct iattr *iattr)
+static inline int DQUOT_TRANSFER(struct inode *inode, struct iattr *iattr)
 {
        if (sb_any_quota_enabled(inode->i_sb) && !IS_NOQUOTA(inode)) {
                DQUOT_INIT(inode);
@@ -171,14 +171,32 @@ static __inline__ int DQUOT_TRANSFER(struct inode *inode, struct iattr *iattr)
 }
 /* The following two functions cannot be called inside a transaction */
-#define DQUOT_SYNC(sb)  sync_dquots(sb, -1)
+static inline void DQUOT_SYNC(struct super_block *sb)
+{
+        sync_dquots(sb, -1);
+}
-static __inline__ int DQUOT_OFF(struct super_block *sb)
+static inline int DQUOT_OFF(struct super_block *sb, int remount)
 {
        int ret = -ENOSYS;
-        if (sb_any_quota_enabled(sb) && sb->s_qcop && sb->s_qcop->quota_off)
+        if (sb->s_qcop && sb->s_qcop->quota_off)
-                ret = sb->s_qcop->quota_off(sb, -1);
+                ret = sb->s_qcop->quota_off(sb, -1, remount);
+        return ret;
+}
+static inline int DQUOT_ON_REMOUNT(struct super_block *sb)
+{
+        int cnt;
+        int ret = 0, err;
+        if (!sb->s_qcop || !sb->s_qcop->quota_on)
+                return -ENOSYS;
+        for (cnt = 0; cnt < MAXQUOTAS; cnt++) {
+                err = sb->s_qcop->quota_on(sb, cnt, 0, NULL, 1);
+                if (err < 0 && !ret)
+                        ret = err;
+        }
        return ret;
 }
@@ -189,13 +207,43 @@ static __inline__ int DQUOT_OFF(struct super_block *sb)
 */
 #define sb_dquot_ops                            (NULL)
 #define sb_quotactl_ops                         (NULL)
-#define DQUOT_INIT(inode)                       do { } while(0)
-#define DQUOT_DROP(inode)                       do { } while(0)
+static inline void DQUOT_INIT(struct inode *inode)
-#define DQUOT_ALLOC_INODE(inode)                (0)
+{
-#define DQUOT_FREE_INODE(inode)                 do { } while(0)
+}
-#define DQUOT_SYNC(sb)                          do { } while(0)
-#define DQUOT_OFF(sb)                           do { } while(0)
+static inline void DQUOT_DROP(struct inode *inode)
-#define DQUOT_TRANSFER(inode, iattr)            (0)
+{
+}
+static inline int DQUOT_ALLOC_INODE(struct inode *inode)
+{
+        return 0;
+}
+static inline void DQUOT_FREE_INODE(struct inode *inode)
+{
+}
+static inline void DQUOT_SYNC(struct super_block *sb)
+{
+}
+static inline int DQUOT_OFF(struct super_block *sb, int remount)
+{
+        return 0;
+}
+static inline int DQUOT_ON_REMOUNT(struct super_block *sb)
+{
+        return 0;
+}
+static inline int DQUOT_TRANSFER(struct inode *inode, struct iattr *iattr)
+{
+        return 0;
+}
 static inline int DQUOT_PREALLOC_SPACE_NODIRTY(struct inode *inode, qsize_t nr)
 {
        inode_add_bytes(inode, nr);
@@ -235,11 +283,38 @@ static inline void DQUOT_FREE_SPACE(struct inode *inode, qsize_t nr)
 #endif /* CONFIG_QUOTA */
-#define DQUOT_PREALLOC_BLOCK_NODIRTY(inode, nr) DQUOT_PREALLOC_SPACE_NODIRTY(inode, ((qsize_t)(nr)) << (inode)->i_sb->s_blocksize_bits)
+static inline int DQUOT_PREALLOC_BLOCK_NODIRTY(struct inode *inode, qsize_t nr)
-#define DQUOT_PREALLOC_BLOCK(inode, nr) DQUOT_PREALLOC_SPACE(inode, ((qsize_t)(nr)) << (inode)->i_sb->s_blocksize_bits)
+{
-#define DQUOT_ALLOC_BLOCK_NODIRTY(inode, nr) DQUOT_ALLOC_SPACE_NODIRTY(inode, ((qsize_t)(nr)) << (inode)->i_sb->s_blocksize_bits)
+        return DQUOT_PREALLOC_SPACE_NODIRTY(inode,
-#define DQUOT_ALLOC_BLOCK(inode, nr) DQUOT_ALLOC_SPACE(inode, ((qsize_t)(nr)) << (inode)->i_sb->s_blocksize_bits)
+                        nr << inode->i_sb->s_blocksize_bits);
-#define DQUOT_FREE_BLOCK_NODIRTY(inode, nr) DQUOT_FREE_SPACE_NODIRTY(inode, ((qsize_t)(nr)) << (inode)->i_sb->s_blocksize_bits)
+}
-#define DQUOT_FREE_BLOCK(inode, nr) DQUOT_FREE_SPACE(inode, ((qsize_t)(nr)) << (inode)->i_sb->s_blocksize_bits)
+static inline int DQUOT_PREALLOC_BLOCK(struct inode *inode, qsize_t nr)
+{
+        return DQUOT_PREALLOC_SPACE(inode,
+                        nr << inode->i_sb->s_blocksize_bits);
+}
+static inline int DQUOT_ALLOC_BLOCK_NODIRTY(struct inode *inode, qsize_t nr)
+{
+        return DQUOT_ALLOC_SPACE_NODIRTY(inode,
+                        nr << inode->i_sb->s_blocksize_bits);
+}
+static inline int DQUOT_ALLOC_BLOCK(struct inode *inode, qsize_t nr)
+{
+        return DQUOT_ALLOC_SPACE(inode,
+                        nr << inode->i_sb->s_blocksize_bits);
+}
+static inline void DQUOT_FREE_BLOCK_NODIRTY(struct inode *inode, qsize_t nr)
+{
+        DQUOT_FREE_SPACE_NODIRTY(inode, nr << inode->i_sb->s_blocksize_bits);
+}
+static inline void DQUOT_FREE_BLOCK(struct inode *inode, qsize_t nr)
+{
+        DQUOT_FREE_SPACE(inode, nr << inode->i_sb->s_blocksize_bits);
+}
 #endif /* _LINUX_QUOTAOPS_ */
diff --git a/include/linux/raid/raid5.h b/include/linux/raid/raid5.h
index 93678f57ccbe..f0827d31ae6f 100644
--- a/include/linux/raid/raid5.h
+++ b/include/linux/raid/raid5.h
@@ -252,6 +252,8 @@ struct r6_state {
 #define STRIPE_EXPANDING        9
 #define STRIPE_EXPAND_SOURCE    10
 #define STRIPE_EXPAND_READY     11
+#define STRIPE_IO_STARTED       12 /* do not count towards 'bypass_count' */
+#define STRIPE_FULL_WRITE       13 /* all blocks are set to be overwritten */
 /*
 * Operations flags (in issue order)
 */
@@ -316,12 +318,17 @@ struct raid5_private_data {
        int                     previous_raid_disks;
        struct list_head        handle_list; /* stripes needing handling */
+        struct list_head        hold_list; /* preread ready stripes */
        struct list_head        delayed_list; /* stripes that have plugged requests */
        struct list_head        bitmap_list; /* stripes delaying awaiting bitmap update */
        struct bio              *retry_read_aligned; /* currently retrying aligned bios   */
        struct bio              *retry_read_aligned_list; /* aligned bios retry list  */
        atomic_t                preread_active_stripes; /* stripes with scheduled io */
        atomic_t                active_aligned_reads;
+        atomic_t                pending_full_writes; /* full write backlog */
+        int                     bypass_count; /* bypassed prereads */
+        int                     bypass_threshold; /* preread nice */
+        struct list_head        *last_hold; /* detect hold_list promotions */
        atomic_t                reshape_stripes; /* stripes with pending writes for reshape */
        /* unfortunately we need two cache names as we temporarily have
diff --git a/include/linux/reiserfs_fs.h b/include/linux/reiserfs_fs.h
index 8e7eff2cd0ab..4aacaeecb56f 100644
--- a/include/linux/reiserfs_fs.h
+++ b/include/linux/reiserfs_fs.h
@@ -2176,6 +2176,7 @@ int reiserfs_ioctl(struct inode *inode, struct file *filp,
                   unsigned int cmd, unsigned long arg);
 long reiserfs_compat_ioctl(struct file *filp,
                   unsigned int cmd, unsigned long arg);
+int reiserfs_unpack(struct inode *inode, struct file *filp);
 /* ioctl's command */
 #define REISERFS_IOC_UNPACK             _IOW(0xCD,1,long)
diff --git a/include/linux/res_counter.h b/include/linux/res_counter.h
index 61363ce896d5..6d9e1fca098c 100644
--- a/include/linux/res_counter.h
+++ b/include/linux/res_counter.h
@@ -9,6 +9,8 @@
 *
 * Author: Pavel Emelianov <xemul@openvz.org>
 *
+ * See Documentation/controllers/resource_counter.txt for more
+ * info about what this counter is.
 */
 #include <linux/cgroup.h>
@@ -25,6 +27,10 @@ struct res_counter {
         */
        unsigned long long usage;
        /*
+         * the maximal value of the usage from the counter creation
+         */
+        unsigned long long max_usage;
+        /*
         * the limit that usage cannot exceed
         */
        unsigned long long limit;
@@ -39,8 +45,9 @@ struct res_counter {
        spinlock_t lock;
 };
-/*
+/**
 * Helpers to interact with userspace
+ * res_counter_read_u64() - returns the value of the specified member.
 * res_counter_read/_write - put/get the specified fields from the
 * res_counter struct to/from the user
 *
@@ -51,6 +58,8 @@ struct res_counter {
 * @pos:     and the offset.
 */
+u64 res_counter_read_u64(struct res_counter *counter, int member);
 ssize_t res_counter_read(struct res_counter *counter, int member,
                const char __user *buf, size_t nbytes, loff_t *pos,
                int (*read_strategy)(unsigned long long val, char *s));
@@ -64,6 +73,7 @@ ssize_t res_counter_write(struct res_counter *counter, int member,
 enum {
        RES_USAGE,
+        RES_MAX_USAGE,
        RES_LIMIT,
        RES_FAILCNT,
 };
@@ -124,4 +134,21 @@ static inline bool res_counter_check_under_limit(struct res_counter *cnt)
        return ret;
 }
+static inline void res_counter_reset_max(struct res_counter *cnt)
+{
+        unsigned long flags;
+        spin_lock_irqsave(&cnt->lock, flags);
+        cnt->max_usage = cnt->usage;
+        spin_unlock_irqrestore(&cnt->lock, flags);
+}
+static inline void res_counter_reset_failcnt(struct res_counter *cnt)
+{
+        unsigned long flags;
+        spin_lock_irqsave(&cnt->lock, flags);
+        cnt->failcnt = 0;
+        spin_unlock_irqrestore(&cnt->lock, flags);
+}
 #endif
diff --git a/include/linux/resource.h b/include/linux/resource.h
index ae13db714742..aaa423a6f3d9 100644
--- a/include/linux/resource.h
+++ b/include/linux/resource.h
@@ -19,6 +19,7 @@ struct task_struct;
 #define RUSAGE_SELF     0
 #define RUSAGE_CHILDREN (-1)
 #define RUSAGE_BOTH     (-2)            /* sys_wait4() uses this */
+#define RUSAGE_THREAD   1               /* only the calling thread */
 struct  rusage {
        struct timeval ru_utime;        /* user time used */
diff --git a/include/linux/rio.h b/include/linux/rio.h
index 68e3f6853fa6..cfb66bbc0f27 100644
--- a/include/linux/rio.h
+++ b/include/linux/rio.h
@@ -23,7 +23,6 @@
 #include <linux/device.h>
 #include <linux/rio_regs.h>
-#define RIO_ANY_DESTID          0xff
 #define RIO_NO_HOPCOUNT         -1
 #define RIO_INVALID_DESTID      0xffff
@@ -39,11 +38,8 @@
                                           entry is invalid (no route
                                           exists for the device ID) */
-#ifdef CONFIG_RAPIDIO_8_BIT_TRANSPORT
+#define RIO_MAX_ROUTE_ENTRIES(size)     (size ? (1 << 16) : (1 << 8))
-#define RIO_MAX_ROUTE_ENTRIES   (1 << 8)
+#define RIO_ANY_DESTID(size)            (size ? 0xffff : 0xff)
-#else
-#define RIO_MAX_ROUTE_ENTRIES   (1 << 16)
-#endif
 #define RIO_MAX_MBOX            4
 #define RIO_MAX_MSG_SIZE        0x1000
@@ -149,6 +145,11 @@ struct rio_dbell {
        void *dev_id;
 };
+enum rio_phy_type {
+        RIO_PHY_PARALLEL,
+        RIO_PHY_SERIAL,
+};
 /**
 * struct rio_mport - RIO master port info
 * @dbells: List of doorbell events
@@ -163,6 +164,7 @@ struct rio_dbell {
 * @id: Port ID, unique among all ports
 * @index: Port index, unique among all port interfaces of the same type
 * @name: Port name string
+ * @priv: Master port private data
 */
 struct rio_mport {
        struct list_head dbells;        /* list of doorbell events */
@@ -177,7 +179,13 @@ struct rio_mport {
        unsigned char id;       /* port ID, unique among all ports */
        unsigned char index;    /* port index, unique among all port
                                   interfaces of the same type */
+        unsigned int sys_size;  /* RapidIO common transport system size.
+                                 * 0 - Small size. 256 devices.
+                                 * 1 - Large size, 65536 devices.
+                                 */
+        enum rio_phy_type phy_type;     /* RapidIO phy type */
        unsigned char name[40];
+        void *priv;             /* Master port private data */
 };
 /**
@@ -211,7 +219,7 @@ struct rio_switch {
        u16 switchid;
        u16 hopcount;
        u16 destid;
-        u8 route_table[RIO_MAX_ROUTE_ENTRIES];
+        u8 *route_table;
        int (*add_entry) (struct rio_mport * mport, u16 destid, u8 hopcount,
                          u16 table, u16 route_destid, u8 route_port);
        int (*get_entry) (struct rio_mport * mport, u16 destid, u8 hopcount,
@@ -229,13 +237,15 @@ struct rio_switch {
 * @dsend: Callback to send a doorbell message.
 */
 struct rio_ops {
-        int (*lcread) (int index, u32 offset, int len, u32 * data);
+        int (*lcread) (struct rio_mport *mport, int index, u32 offset, int len,
-        int (*lcwrite) (int index, u32 offset, int len, u32 data);
+                        u32 *data);
-        int (*cread) (int index, u16 destid, u8 hopcount, u32 offset, int len,
+        int (*lcwrite) (struct rio_mport *mport, int index, u32 offset, int len,
-                      u32 * data);
+                        u32 data);
-        int (*cwrite) (int index, u16 destid, u8 hopcount, u32 offset, int len,
+        int (*cread) (struct rio_mport *mport, int index, u16 destid,
-                       u32 data);
+                        u8 hopcount, u32 offset, int len, u32 *data);
-        int (*dsend) (int index, u16 destid, u16 data);
+        int (*cwrite) (struct rio_mport *mport, int index, u16 destid,
+                        u8 hopcount, u32 offset, int len, u32 data);
+        int (*dsend) (struct rio_mport *mport, int index, u16 destid, u16 data);
 };
 #define RIO_RESOURCE_MEM        0x00000100
diff --git a/include/linux/sched.h b/include/linux/sched.h
index 9a4f3e63e3bf..1d02babdb2c7 100644
--- a/include/linux/sched.h
+++ b/include/linux/sched.h
@@ -68,7 +68,6 @@ struct sched_param {
 #include <linux/smp.h>
 #include <linux/sem.h>
 #include <linux/signal.h>
-#include <linux/securebits.h>
 #include <linux/fs_struct.h>
 #include <linux/compiler.h>
 #include <linux/completion.h>
@@ -1133,7 +1132,7 @@ struct task_struct {
        gid_t gid,egid,sgid,fsgid;
        struct group_info *group_info;
        kernel_cap_t   cap_effective, cap_inheritable, cap_permitted, cap_bset;
-        unsigned keep_capabilities:1;
+        unsigned securebits;
        struct user_struct *user;
 #ifdef CONFIG_KEYS
        struct key *request_key_auth;   /* assumed request_key authority */
@@ -2149,6 +2148,19 @@ static inline void migration_init(void)
 #define TASK_SIZE_OF(tsk)       TASK_SIZE
 #endif
+#ifdef CONFIG_MM_OWNER
+extern void mm_update_next_owner(struct mm_struct *mm);
+extern void mm_init_owner(struct mm_struct *mm, struct task_struct *p);
+#else
+static inline void mm_update_next_owner(struct mm_struct *mm)
+{
+}
+static inline void mm_init_owner(struct mm_struct *mm, struct task_struct *p)
+{
+}
+#endif /* CONFIG_MM_OWNER */
 #endif /* __KERNEL__ */
 #endif
diff --git a/include/linux/securebits.h b/include/linux/securebits.h
index 5b0617840fa4..c1f19dbceb05 100644
--- a/include/linux/securebits.h
+++ b/include/linux/securebits.h
@@ -3,28 +3,39 @@
 #define SECUREBITS_DEFAULT 0x00000000
-extern unsigned securebits;
 /* When set UID 0 has no special privileges. When unset, we support
   inheritance of root-permissions and suid-root executable under
   compatibility mode. We raise the effective and inheritable bitmasks
   *of the executable file* if the effective uid of the new process is
   0. If the real uid is 0, we raise the inheritable bitmask of the
   executable file. */
-#define SECURE_NOROOT            0
+#define SECURE_NOROOT                   0
+#define SECURE_NOROOT_LOCKED            1  /* make bit-0 immutable */
 /* When set, setuid to/from uid 0 does not trigger capability-"fixes"
   to be compatible with old programs relying on set*uid to loose
   privileges. When unset, setuid doesn't change privileges. */
-#define SECURE_NO_SETUID_FIXUP   2
+#define SECURE_NO_SETUID_FIXUP          2
+#define SECURE_NO_SETUID_FIXUP_LOCKED   3  /* make bit-2 immutable */
+/* When set, a process can retain its capabilities even after
+   transitioning to a non-root user (the set-uid fixup suppressed by
+   bit 2). Bit-4 is cleared when a process calls exec(); setting both
+   bit 4 and 5 will create a barrier through exec that no exec()'d
+   child can use this feature again. */
+#define SECURE_KEEP_CAPS                4
+#define SECURE_KEEP_CAPS_LOCKED         5  /* make bit-4 immutable */
 /* Each securesetting is implemented using two bits. One bit specify
   whether the setting is on or off. The other bit specify whether the
   setting is fixed or not. A setting which is fixed cannot be changed
   from user-level. */
+#define issecure_mask(X)        (1 << (X))
+#define issecure(X)             (issecure_mask(X) & current->securebits)
-#define issecure(X) ( (1 << (X+1)) & SECUREBITS_DEFAULT ?       \
+#define SECURE_ALL_BITS         (issecure_mask(SECURE_NOROOT) | \
-                      (1 << (X)) & SECUREBITS_DEFAULT :         \
+                                 issecure_mask(SECURE_NO_SETUID_FIXUP) | \
-                      (1 << (X)) & securebits )
+                                 issecure_mask(SECURE_KEEP_CAPS))
+#define SECURE_ALL_LOCKS        (SECURE_ALL_BITS << 1)
 #endif /* !_LINUX_SECUREBITS_H */
diff --git a/include/linux/security.h b/include/linux/security.h
index 53a34539382a..50737c70e78e 100644
--- a/include/linux/security.h
+++ b/include/linux/security.h
@@ -34,8 +34,6 @@
 #include <linux/xfrm.h>
 #include <net/flow.h>
-extern unsigned securebits;
 /* Maximum number of letters for an LSM name string */
 #define SECURITY_NAME_MAX       10
@@ -46,25 +44,28 @@ struct audit_krule;
 * These functions are in security/capability.c and are used
 * as the default capabilities functions
 */
-extern int cap_capable (struct task_struct *tsk, int cap);
+extern int cap_capable(struct task_struct *tsk, int cap);
-extern int cap_settime (struct timespec *ts, struct timezone *tz);
+extern int cap_settime(struct timespec *ts, struct timezone *tz);
-extern int cap_ptrace (struct task_struct *parent, struct task_struct *child);
+extern int cap_ptrace(struct task_struct *parent, struct task_struct *child);
-extern int cap_capget (struct task_struct *target, kernel_cap_t *effective, kernel_cap_t *inheritable, kernel_cap_t *permitted);
+extern int cap_capget(struct task_struct *target, kernel_cap_t *effective, kernel_cap_t *inheritable, kernel_cap_t *permitted);
-extern int cap_capset_check (struct task_struct *target, kernel_cap_t *effective, kernel_cap_t *inheritable, kernel_cap_t *permitted);
+extern int cap_capset_check(struct task_struct *target, kernel_cap_t *effective, kernel_cap_t *inheritable, kernel_cap_t *permitted);
-extern void cap_capset_set (struct task_struct *target, kernel_cap_t *effective, kernel_cap_t *inheritable, kernel_cap_t *permitted);
+extern void cap_capset_set(struct task_struct *target, kernel_cap_t *effective, kernel_cap_t *inheritable, kernel_cap_t *permitted);
-extern int cap_bprm_set_security (struct linux_binprm *bprm);
+extern int cap_bprm_set_security(struct linux_binprm *bprm);
-extern void cap_bprm_apply_creds (struct linux_binprm *bprm, int unsafe);
+extern void cap_bprm_apply_creds(struct linux_binprm *bprm, int unsafe);
 extern int cap_bprm_secureexec(struct linux_binprm *bprm);
-extern int cap_inode_setxattr(struct dentry *dentry, char *name, void *value, size_t size, int flags);
+extern int cap_inode_setxattr(struct dentry *dentry, const char *name,
-extern int cap_inode_removexattr(struct dentry *dentry, char *name);
+                              const void *value, size_t size, int flags);
+extern int cap_inode_removexattr(struct dentry *dentry, const char *name);
 extern int cap_inode_need_killpriv(struct dentry *dentry);
 extern int cap_inode_killpriv(struct dentry *dentry);
-extern int cap_task_post_setuid (uid_t old_ruid, uid_t old_euid, uid_t old_suid, int flags);
+extern int cap_task_post_setuid(uid_t old_ruid, uid_t old_euid, uid_t old_suid, int flags);
-extern void cap_task_reparent_to_init (struct task_struct *p);
+extern void cap_task_reparent_to_init(struct task_struct *p);
-extern int cap_task_setscheduler (struct task_struct *p, int policy, struct sched_param *lp);
+extern int cap_task_prctl(int option, unsigned long arg2, unsigned long arg3,
-extern int cap_task_setioprio (struct task_struct *p, int ioprio);
+                          unsigned long arg4, unsigned long arg5, long *rc_p);
-extern int cap_task_setnice (struct task_struct *p, int nice);
+extern int cap_task_setscheduler(struct task_struct *p, int policy, struct sched_param *lp);
-extern int cap_syslog (int type);
+extern int cap_task_setioprio(struct task_struct *p, int ioprio);
+extern int cap_task_setnice(struct task_struct *p, int nice);
+extern int cap_syslog(int type);
 extern int cap_vm_enough_memory(struct mm_struct *mm, long pages);
 struct msghdr;
@@ -128,7 +129,7 @@ static inline void security_free_mnt_opts(struct security_mnt_opts *opts)
 {
        int i;
        if (opts->mnt_opts)
-                for(i = 0; i < opts->num_mnt_opts; i++)
+                for (i = 0; i < opts->num_mnt_opts; i++)
                        kfree(opts->mnt_opts[i]);
        kfree(opts->mnt_opts);
        opts->mnt_opts = NULL;
@@ -190,21 +191,21 @@ static inline void security_free_mnt_opts(struct security_mnt_opts *opts)
 *      @bprm contains the linux_binprm structure.
 *      Return 0 if the hook is successful and permission is granted.
 * @bprm_check_security:
- *      This hook mediates the point when a search for a binary handler will
+ *      This hook mediates the point when a search for a binary handler will
- *      begin.  It allows a check the @bprm->security value which is set in
+ *      begin.  It allows a check the @bprm->security value which is set in
- *      the preceding set_security call.  The primary difference from
+ *      the preceding set_security call.  The primary difference from
- *      set_security is that the argv list and envp list are reliably
+ *      set_security is that the argv list and envp list are reliably
- *      available in @bprm.  This hook may be called multiple times
+ *      available in @bprm.  This hook may be called multiple times
- *      during a single execve; and in each pass set_security is called
+ *      during a single execve; and in each pass set_security is called
- *      first.
+ *      first.
- *      @bprm contains the linux_binprm structure.
+ *      @bprm contains the linux_binprm structure.
 *      Return 0 if the hook is successful and permission is granted.
 * @bprm_secureexec:
- *      Return a boolean value (0 or 1) indicating whether a "secure exec" 
+ *      Return a boolean value (0 or 1) indicating whether a "secure exec"
- *      is required.  The flag is passed in the auxiliary table
+ *      is required.  The flag is passed in the auxiliary table
- *      on the initial stack to the ELF interpreter to indicate whether libc 
+ *      on the initial stack to the ELF interpreter to indicate whether libc
- *      should enable secure mode.
+ *      should enable secure mode.
- *      @bprm contains the linux_binprm structure.
+ *      @bprm contains the linux_binprm structure.
 *
 * Security hooks for filesystem operations.
 *
@@ -221,7 +222,7 @@ static inline void security_free_mnt_opts(struct security_mnt_opts *opts)
 *      Check permission before obtaining filesystem statistics for the @mnt
 *      mountpoint.
 *      @dentry is a handle on the superblock for the filesystem.
- *      Return 0 if permission is granted.  
+ *      Return 0 if permission is granted.
 * @sb_mount:
 *      Check permission before an object specified by @dev_name is mounted on
 *      the mount point named by @nd.  For an ordinary mount, @dev_name
@@ -282,12 +283,12 @@ static inline void security_free_mnt_opts(struct security_mnt_opts *opts)
 * @sb_pivotroot:
 *      Check permission before pivoting the root filesystem.
 *      @old_path contains the path for the new location of the current root (put_old).
- *      @new_path contains the path for the new root (new_root).
+ *      @new_path contains the path for the new root (new_root).
 *      Return 0 if permission is granted.
 * @sb_post_pivotroot:
 *      Update module state after a successful pivot.
 *      @old_path contains the path for the old root.
- *      @new_path contains the path for the new root.
+ *      @new_path contains the path for the new root.
 * @sb_get_mnt_opts:
 *      Get the security relevant mount options used for a superblock
 *      @sb the superblock to get security mount options from
@@ -316,9 +317,9 @@ static inline void security_free_mnt_opts(struct security_mnt_opts *opts)
 * @inode_free_security:
 *      @inode contains the inode structure.
 *      Deallocate the inode security structure and set @inode->i_security to
- *      NULL. 
+ *      NULL.
 * @inode_init_security:
- *      Obtain the security attribute name suffix and value to set on a newly
+ *      Obtain the security attribute name suffix and value to set on a newly
 *      created inode and set up the incore security field for the new inode.
 *      This hook is called by the fs code as part of the inode creation
 *      transaction and provides for atomic labeling of the inode, unlike
@@ -349,7 +350,7 @@ static inline void security_free_mnt_opts(struct security_mnt_opts *opts)
 *      @new_dentry contains the dentry structure for the new link.
 *      Return 0 if permission is granted.
 * @inode_unlink:
- *      Check the permission to remove a hard link to a file. 
+ *      Check the permission to remove a hard link to a file.
 *      @dir contains the inode structure of parent directory of the file.
 *      @dentry contains the dentry structure for file to be unlinked.
 *      Return 0 if permission is granted.
@@ -361,7 +362,7 @@ static inline void security_free_mnt_opts(struct security_mnt_opts *opts)
 *      Return 0 if permission is granted.
 * @inode_mkdir:
 *      Check permissions to create a new directory in the existing directory
- *      associated with inode strcture @dir. 
+ *      associated with inode strcture @dir.
 *      @dir containst the inode structure of parent of the directory to be created.
 *      @dentry contains the dentry structure of new directory.
 *      @mode contains the mode of new directory.
@@ -406,7 +407,7 @@ static inline void security_free_mnt_opts(struct security_mnt_opts *opts)
 *      called when the actual read/write operations are performed.
 *      @inode contains the inode structure to check.
 *      @mask contains the permission mask.
- *     @nd contains the nameidata (may be NULL).
+ *      @nd contains the nameidata (may be NULL).
 *      Return 0 if permission is granted.
 * @inode_setattr:
 *      Check permission before setting file attributes.  Note that the kernel
@@ -428,24 +429,24 @@ static inline void security_free_mnt_opts(struct security_mnt_opts *opts)
 *      can use this hook to release any persistent label associated with the
 *      inode.
 * @inode_setxattr:
- *      Check permission before setting the extended attributes
+ *      Check permission before setting the extended attributes
- *      @value identified by @name for @dentry.
+ *      @value identified by @name for @dentry.
- *      Return 0 if permission is granted.
+ *      Return 0 if permission is granted.
 * @inode_post_setxattr:
- *      Update inode security field after successful setxattr operation.
+ *      Update inode security field after successful setxattr operation.
- *      @value identified by @name for @dentry.
+ *      @value identified by @name for @dentry.
 * @inode_getxattr:
- *      Check permission before obtaining the extended attributes
+ *      Check permission before obtaining the extended attributes
- *      identified by @name for @dentry.
+ *      identified by @name for @dentry.
- *      Return 0 if permission is granted.
+ *      Return 0 if permission is granted.
 * @inode_listxattr:
- *      Check permission before obtaining the list of extended attribute 
+ *      Check permission before obtaining the list of extended attribute
- *      names for @dentry.
+ *      names for @dentry.
- *      Return 0 if permission is granted.
+ *      Return 0 if permission is granted.
 * @inode_removexattr:
- *      Check permission before removing the extended attribute
+ *      Check permission before removing the extended attribute
- *      identified by @name for @dentry.
+ *      identified by @name for @dentry.
- *      Return 0 if permission is granted.
+ *      Return 0 if permission is granted.
 * @inode_getsecurity:
 *      Retrieve a copy of the extended attribute representation of the
 *      security label associated with @name for @inode via @buffer.  Note that
@@ -457,7 +458,7 @@ static inline void security_free_mnt_opts(struct security_mnt_opts *opts)
 *      Set the security label associated with @name for @inode from the
 *      extended attribute value @value.  @size indicates the size of the
 *      @value in bytes.  @flags may be XATTR_CREATE, XATTR_REPLACE, or 0.
- *      Note that @name is the remainder of the attribute name after the 
+ *      Note that @name is the remainder of the attribute name after the
 *      security. prefix has been removed.
 *      Return 0 on success.
 * @inode_listsecurity:
@@ -564,7 +565,7 @@ static inline void security_free_mnt_opts(struct security_mnt_opts *opts)
 *      struct file, so the file structure (and associated security information)
 *      can always be obtained:
 *              container_of(fown, struct file, f_owner)
- *      @tsk contains the structure of task receiving signal.
+ *      @tsk contains the structure of task receiving signal.
 *      @fown contains the file owner information.
 *      @sig is the signal that will be sent.  When 0, kernel sends SIGIO.
 *      Return 0 if permission is granted.
@@ -720,14 +721,16 @@ static inline void security_free_mnt_opts(struct security_mnt_opts *opts)
 *      @arg3 contains a argument.
 *      @arg4 contains a argument.
 *      @arg5 contains a argument.
- *      Return 0 if permission is granted.
+ *      @rc_p contains a pointer to communicate back the forced return code
+ *      Return 0 if permission is granted, and non-zero if the security module
+ *      has taken responsibility (setting *rc_p) for the prctl call.
 * @task_reparent_to_init:
- *      Set the security attributes in @p->security for a kernel thread that
+ *      Set the security attributes in @p->security for a kernel thread that
- *      is being reparented to the init task.
+ *      is being reparented to the init task.
 *      @p contains the task_struct for the kernel thread.
 * @task_to_inode:
- *      Set the security attributes for an inode based on an associated task's
+ *      Set the security attributes for an inode based on an associated task's
- *      security attributes, e.g. for /proc/pid inodes.
+ *      security attributes, e.g. for /proc/pid inodes.
 *      @p contains the task_struct for the task.
 *      @inode contains the inode structure for the inode.
 *
@@ -737,7 +740,7 @@ static inline void security_free_mnt_opts(struct security_mnt_opts *opts)
 *      Save security information for a netlink message so that permission
 *      checking can be performed when the message is processed.  The security
 *      information can be saved using the eff_cap field of the
- *      netlink_skb_parms structure.  Also may be used to provide fine
+ *      netlink_skb_parms structure.  Also may be used to provide fine
 *      grained control over message transmission.
 *      @sk associated sock of task sending the message.,
 *      @skb contains the sk_buff structure for the netlink message.
@@ -805,14 +808,14 @@ static inline void security_free_mnt_opts(struct security_mnt_opts *opts)
 *      @sock contains the socket structure.
 *      @address contains the address to bind to.
 *      @addrlen contains the length of address.
- *      Return 0 if permission is granted.  
+ *      Return 0 if permission is granted.
 * @socket_connect:
 *      Check permission before socket protocol layer connect operation
 *      attempts to connect socket @sock to a remote address, @address.
 *      @sock contains the socket structure.
 *      @address contains the address of remote endpoint.
 *      @addrlen contains the length of address.
- *      Return 0 if permission is granted.  
+ *      Return 0 if permission is granted.
 * @socket_listen:
 *      Check permission before socket protocol layer listen operation.
 *      @sock contains the socket structure.
@@ -842,7 +845,7 @@ static inline void security_free_mnt_opts(struct security_mnt_opts *opts)
 *      @msg contains the message structure.
 *      @size contains the size of message structure.
 *      @flags contains the operational flags.
- *      Return 0 if permission is granted.  
+ *      Return 0 if permission is granted.
 * @socket_getsockname:
 *      Check permission before the local address (name) of the socket object
 *      @sock is retrieved.
@@ -866,7 +869,7 @@ static inline void security_free_mnt_opts(struct security_mnt_opts *opts)
 *      @sock contains the socket structure.
 *      @level contains the protocol level to set options for.
 *      @optname contains the name of the option to set.
- *      Return 0 if permission is granted.  
+ *      Return 0 if permission is granted.
 * @socket_shutdown:
 *      Checks permission before all or part of a connection on the socket
 *      @sock is shut down.
@@ -893,19 +896,19 @@ static inline void security_free_mnt_opts(struct security_mnt_opts *opts)
 *      Return 0 if all is well, otherwise, typical getsockopt return
 *      values.
 * @socket_getpeersec_dgram:
- *      This hook allows the security module to provide peer socket security
+ *      This hook allows the security module to provide peer socket security
- *      state for udp sockets on a per-packet basis to userspace via
+ *      state for udp sockets on a per-packet basis to userspace via
- *      getsockopt SO_GETPEERSEC.  The application must first have indicated
+ *      getsockopt SO_GETPEERSEC.  The application must first have indicated
- *      the IP_PASSSEC option via getsockopt.  It can then retrieve the
+ *      the IP_PASSSEC option via getsockopt.  It can then retrieve the
- *      security state returned by this hook for a packet via the SCM_SECURITY
+ *      security state returned by this hook for a packet via the SCM_SECURITY
- *      ancillary message type.
+ *      ancillary message type.
- *      @skb is the skbuff for the packet being queried
+ *      @skb is the skbuff for the packet being queried
- *      @secdata is a pointer to a buffer in which to copy the security data
+ *      @secdata is a pointer to a buffer in which to copy the security data
- *      @seclen is the maximum length for @secdata
+ *      @seclen is the maximum length for @secdata
- *      Return 0 on success, error on failure.
+ *      Return 0 on success, error on failure.
 * @sk_alloc_security:
- *      Allocate and attach a security structure to the sk->sk_security field,
+ *      Allocate and attach a security structure to the sk->sk_security field,
- *      which is used to copy security attributes between local stream sockets.
+ *      which is used to copy security attributes between local stream sockets.
 * @sk_free_security:
 *      Deallocate security structure.
 * @sk_clone_security:
@@ -920,7 +923,7 @@ static inline void security_free_mnt_opts(struct security_mnt_opts *opts)
 * @inet_csk_clone:
 *      Sets the new child socket's sid to the openreq sid.
 * @inet_conn_established:
- *     Sets the connection's peersid to the secmark on skb.
+ *      Sets the connection's peersid to the secmark on skb.
 * @req_classify_flow:
 *      Sets the flow's sid to the openreq sid.
 *
@@ -999,13 +1002,24 @@ static inline void security_free_mnt_opts(struct security_mnt_opts *opts)
 *      No return value.
 * @key_permission:
 *      See whether a specific operational right is granted to a process on a
- *      key.
+ *      key.
 *      @key_ref refers to the key (key pointer + possession attribute bit).
 *      @context points to the process to provide the context against which to
- *       evaluate the security data on the key.
+ *      evaluate the security data on the key.
 *      @perm describes the combination of permissions required of this key.
 *      Return 1 if permission granted, 0 if permission denied and -ve it the
- *      normal permissions model should be effected.
+ *      normal permissions model should be effected.
+ * @key_getsecurity:
+ *      Get a textual representation of the security context attached to a key
+ *      for the purposes of honouring KEYCTL_GETSECURITY.  This function
+ *      allocates the storage for the NUL-terminated string and the caller
+ *      should free it.
+ *      @key points to the key to be queried.
+ *      @_buffer points to a pointer that should be set to point to the
+ *       resulting string (if no label or an error occurs).
+ *      Return the length of the string (including terminating NUL) or -ve if
+ *      an error.
+ *      May also return 0 (and a NULL buffer pointer) if there is no label.
 *
 * Security hooks affecting all System V IPC operations.
 *
@@ -1056,7 +1070,7 @@ static inline void security_free_mnt_opts(struct security_mnt_opts *opts)
 *      The @msq may be NULL, e.g. for IPC_INFO or MSG_INFO.
 *      @msq contains the message queue to act upon.  May be NULL.
 *      @cmd contains the operation to be performed.
- *      Return 0 if permission is granted.  
+ *      Return 0 if permission is granted.
 * @msg_queue_msgsnd:
 *      Check permission before a message, @msg, is enqueued on the message
 *      queue, @msq.
@@ -1066,8 +1080,8 @@ static inline void security_free_mnt_opts(struct security_mnt_opts *opts)
 *      Return 0 if permission is granted.
 * @msg_queue_msgrcv:
 *      Check permission before a message, @msg, is removed from the message
- *      queue, @msq.  The @target task structure contains a pointer to the 
+ *      queue, @msq.  The @target task structure contains a pointer to the
- *      process that will be receiving the message (not equal to the current 
+ *      process that will be receiving the message (not equal to the current
 *      process when inline receives are being performed).
 *      @msq contains the message queue to retrieve message from.
 *      @msg contains the message destination.
@@ -1132,15 +1146,15 @@ static inline void security_free_mnt_opts(struct security_mnt_opts *opts)
 *      Return 0 if permission is granted.
 * @sem_semctl:
 *      Check permission when a semaphore operation specified by @cmd is to be
- *      performed on the semaphore @sma.  The @sma may be NULL, e.g. for 
+ *      performed on the semaphore @sma.  The @sma may be NULL, e.g. for
 *      IPC_INFO or SEM_INFO.
 *      @sma contains the semaphore structure.  May be NULL.
 *      @cmd contains the operation to be performed.
 *      Return 0 if permission is granted.
 * @sem_semop
 *      Check permissions before performing operations on members of the
- *      semaphore set @sma.  If the @alter flag is nonzero, the semaphore set 
+ *      semaphore set @sma.  If the @alter flag is nonzero, the semaphore set
- *      may be modified.
+ *      may be modified.
 *      @sma contains the semaphore structure.
 *      @sops contains the operations to perform.
 *      @nsops contains the number of operations to perform.
@@ -1211,7 +1225,7 @@ static inline void security_free_mnt_opts(struct security_mnt_opts *opts)
 * @syslog:
 *      Check permission before accessing the kernel message ring or changing
 *      logging to the console.
- *      See the syslog(2) manual page for an explanation of the @type values.  
+ *      See the syslog(2) manual page for an explanation of the @type values.
 *      @type contains the type of action.
 *      Return 0 if permission is granted.
 * @settime:
@@ -1223,22 +1237,22 @@ static inline void security_free_mnt_opts(struct security_mnt_opts *opts)
 * @vm_enough_memory:
 *      Check permissions for allocating a new virtual mapping.
 *      @mm contains the mm struct it is being added to.
- *      @pages contains the number of pages.
+ *      @pages contains the number of pages.
 *      Return 0 if permission is granted.
 *
 * @register_security:
- *      allow module stacking.
+ *      allow module stacking.
- *      @name contains the name of the security module being stacked.
+ *      @name contains the name of the security module being stacked.
- *      @ops contains a pointer to the struct security_operations of the module to stack.
+ *      @ops contains a pointer to the struct security_operations of the module to stack.
- * 
+ *
 * @secid_to_secctx:
 *      Convert secid to security context.
 *      @secid contains the security ID.
 *      @secdata contains the pointer that stores the converted security context.
 * @secctx_to_secid:
- *      Convert security context to secid.
+ *      Convert security context to secid.
- *      @secid contains the pointer to the generated security ID.
+ *      @secid contains the pointer to the generated security ID.
- *      @secdata contains the security context.
+ *      @secdata contains the security context.
 *
 * @release_secctx:
 *      Release the security context.
@@ -1281,49 +1295,49 @@ static inline void security_free_mnt_opts(struct security_mnt_opts *opts)
 struct security_operations {
        char name[SECURITY_NAME_MAX + 1];
-        int (*ptrace) (struct task_struct * parent, struct task_struct * child);
+        int (*ptrace) (struct task_struct *parent, struct task_struct *child);
-        int (*capget) (struct task_struct * target,
+        int (*capget) (struct task_struct *target,
-                       kernel_cap_t * effective,
+                       kernel_cap_t *effective,
-                       kernel_cap_t * inheritable, kernel_cap_t * permitted);
+                       kernel_cap_t *inheritable, kernel_cap_t *permitted);
-        int (*capset_check) (struct task_struct * target,
+        int (*capset_check) (struct task_struct *target,
-                             kernel_cap_t * effective,
+                             kernel_cap_t *effective,
-                             kernel_cap_t * inheritable,
+                             kernel_cap_t *inheritable,
-                             kernel_cap_t * permitted);
+                             kernel_cap_t *permitted);
-        void (*capset_set) (struct task_struct * target,
+        void (*capset_set) (struct task_struct *target,
-                            kernel_cap_t * effective,
+                            kernel_cap_t *effective,
-                            kernel_cap_t * inheritable,
+                            kernel_cap_t *inheritable,
-                            kernel_cap_t * permitted);
+                            kernel_cap_t *permitted);
-        int (*capable) (struct task_struct * tsk, int cap);
+        int (*capable) (struct task_struct *tsk, int cap);
-        int (*acct) (struct file * file);
+        int (*acct) (struct file *file);
-        int (*sysctl) (struct ctl_table * table, int op);
+        int (*sysctl) (struct ctl_table *table, int op);
-        int (*quotactl) (int cmds, int type, int id, struct super_block * sb);
+        int (*quotactl) (int cmds, int type, int id, struct super_block *sb);
-        int (*quota_on) (struct dentry * dentry);
+        int (*quota_on) (struct dentry *dentry);
        int (*syslog) (int type);
        int (*settime) (struct timespec *ts, struct timezone *tz);
        int (*vm_enough_memory) (struct mm_struct *mm, long pages);
-        int (*bprm_alloc_security) (struct linux_binprm * bprm);
+        int (*bprm_alloc_security) (struct linux_binprm *bprm);
-        void (*bprm_free_security) (struct linux_binprm * bprm);
+        void (*bprm_free_security) (struct linux_binprm *bprm);
-        void (*bprm_apply_creds) (struct linux_binprm * bprm, int unsafe);
+        void (*bprm_apply_creds) (struct linux_binprm *bprm, int unsafe);
-        void (*bprm_post_apply_creds) (struct linux_binprm * bprm);
+        void (*bprm_post_apply_creds) (struct linux_binprm *bprm);
-        int (*bprm_set_security) (struct linux_binprm * bprm);
+        int (*bprm_set_security) (struct linux_binprm *bprm);
-        int (*bprm_check_security) (struct linux_binprm * bprm);
+        int (*bprm_check_security) (struct linux_binprm *bprm);
-        int (*bprm_secureexec) (struct linux_binprm * bprm);
+        int (*bprm_secureexec) (struct linux_binprm *bprm);
-        int (*sb_alloc_security) (struct super_block * sb);
+        int (*sb_alloc_security) (struct super_block *sb);
-        void (*sb_free_security) (struct super_block * sb);
+        void (*sb_free_security) (struct super_block *sb);
-        int (*sb_copy_data)(char *orig, char *copy);
+        int (*sb_copy_data) (char *orig, char *copy);
        int (*sb_kern_mount) (struct super_block *sb, void *data);
        int (*sb_statfs) (struct dentry *dentry);
        int (*sb_mount) (char *dev_name, struct path *path,
                         char *type, unsigned long flags, void *data);
-        int (*sb_check_sb) (struct vfsmount * mnt, struct path *path);
+        int (*sb_check_sb) (struct vfsmount *mnt, struct path *path);
-        int (*sb_umount) (struct vfsmount * mnt, int flags);
+        int (*sb_umount) (struct vfsmount *mnt, int flags);
-        void (*sb_umount_close) (struct vfsmount * mnt);
+        void (*sb_umount_close) (struct vfsmount *mnt);
-        void (*sb_umount_busy) (struct vfsmount * mnt);
+        void (*sb_umount_busy) (struct vfsmount *mnt);
-        void (*sb_post_remount) (struct vfsmount * mnt,
+        void (*sb_post_remount) (struct vfsmount *mnt,
                                 unsigned long flags, void *data);
-        void (*sb_post_addmount) (struct vfsmount * mnt,
+        void (*sb_post_addmount) (struct vfsmount *mnt,
                                  struct path *mountpoint);
        int (*sb_pivotroot) (struct path *old_path,
                             struct path *new_path);
@@ -1337,177 +1351,177 @@ struct security_operations {
                                   struct super_block *newsb);
        int (*sb_parse_opts_str) (char *options, struct security_mnt_opts *opts);
-        int (*inode_alloc_security) (struct inode *inode);      
+        int (*inode_alloc_security) (struct inode *inode);
        void (*inode_free_security) (struct inode *inode);
        int (*inode_init_security) (struct inode *inode, struct inode *dir,
                                    char **name, void **value, size_t *len);
        int (*inode_create) (struct inode *dir,
-                             struct dentry *dentry, int mode);
+                             struct dentry *dentry, int mode);
        int (*inode_link) (struct dentry *old_dentry,
-                           struct inode *dir, struct dentry *new_dentry);
+                           struct inode *dir, struct dentry *new_dentry);
        int (*inode_unlink) (struct inode *dir, struct dentry *dentry);
        int (*inode_symlink) (struct inode *dir,
-                              struct dentry *dentry, const char *old_name);
+                              struct dentry *dentry, const char *old_name);
        int (*inode_mkdir) (struct inode *dir, struct dentry *dentry, int mode);
        int (*inode_rmdir) (struct inode *dir, struct dentry *dentry);
        int (*inode_mknod) (struct inode *dir, struct dentry *dentry,
-                            int mode, dev_t dev);
+                            int mode, dev_t dev);
        int (*inode_rename) (struct inode *old_dir, struct dentry *old_dentry,
-                             struct inode *new_dir, struct dentry *new_dentry);
+                             struct inode *new_dir, struct dentry *new_dentry);
        int (*inode_readlink) (struct dentry *dentry);
        int (*inode_follow_link) (struct dentry *dentry, struct nameidata *nd);
        int (*inode_permission) (struct inode *inode, int mask, struct nameidata *nd);
        int (*inode_setattr)    (struct dentry *dentry, struct iattr *attr);
        int (*inode_getattr) (struct vfsmount *mnt, struct dentry *dentry);
-        void (*inode_delete) (struct inode *inode);
+        void (*inode_delete) (struct inode *inode);
-        int (*inode_setxattr) (struct dentry *dentry, char *name, void *value,
+        int (*inode_setxattr) (struct dentry *dentry, const char *name,
-                               size_t size, int flags);
+                               const void *value, size_t size, int flags);
-        void (*inode_post_setxattr) (struct dentry *dentry, char *name, void *value,
+        void (*inode_post_setxattr) (struct dentry *dentry, const char *name,
-                                     size_t size, int flags);
+                                     const void *value, size_t size, int flags);
-        int (*inode_getxattr) (struct dentry *dentry, char *name);
+        int (*inode_getxattr) (struct dentry *dentry, const char *name);
        int (*inode_listxattr) (struct dentry *dentry);
-        int (*inode_removexattr) (struct dentry *dentry, char *name);
+        int (*inode_removexattr) (struct dentry *dentry, const char *name);
        int (*inode_need_killpriv) (struct dentry *dentry);
        int (*inode_killpriv) (struct dentry *dentry);
-        int (*inode_getsecurity)(const struct inode *inode, const char *name, void **buffer, bool alloc);
+        int (*inode_getsecurity) (const struct inode *inode, const char *name, void **buffer, bool alloc);
-        int (*inode_setsecurity)(struct inode *inode, const char *name, const void *value, size_t size, int flags);
+        int (*inode_setsecurity) (struct inode *inode, const char *name, const void *value, size_t size, int flags);
-        int (*inode_listsecurity)(struct inode *inode, char *buffer, size_t buffer_size);
+        int (*inode_listsecurity) (struct inode *inode, char *buffer, size_t buffer_size);
-        void (*inode_getsecid)(const struct inode *inode, u32 *secid);
+        void (*inode_getsecid) (const struct inode *inode, u32 *secid);
-        int (*file_permission) (struct file * file, int mask);
+        int (*file_permission) (struct file *file, int mask);
-        int (*file_alloc_security) (struct file * file);
+        int (*file_alloc_security) (struct file *file);
-        void (*file_free_security) (struct file * file);
+        void (*file_free_security) (struct file *file);
-        int (*file_ioctl) (struct file * file, unsigned int cmd,
+        int (*file_ioctl) (struct file *file, unsigned int cmd,
                           unsigned long arg);
-        int (*file_mmap) (struct file * file,
+        int (*file_mmap) (struct file *file,
                          unsigned long reqprot, unsigned long prot,
                          unsigned long flags, unsigned long addr,
                          unsigned long addr_only);
-        int (*file_mprotect) (struct vm_area_struct * vma,
+        int (*file_mprotect) (struct vm_area_struct *vma,
                              unsigned long reqprot,
                              unsigned long prot);
-        int (*file_lock) (struct file * file, unsigned int cmd);
+        int (*file_lock) (struct file *file, unsigned int cmd);
-        int (*file_fcntl) (struct file * file, unsigned int cmd,
+        int (*file_fcntl) (struct file *file, unsigned int cmd,
                           unsigned long arg);
-        int (*file_set_fowner) (struct file * file);
+        int (*file_set_fowner) (struct file *file);
-        int (*file_send_sigiotask) (struct task_struct * tsk,
+        int (*file_send_sigiotask) (struct task_struct *tsk,
-                                    struct fown_struct * fown, int sig);
+                                    struct fown_struct *fown, int sig);
-        int (*file_receive) (struct file * file);
+        int (*file_receive) (struct file *file);
-        int (*dentry_open)  (struct file *file);
+        int (*dentry_open) (struct file *file);
        int (*task_create) (unsigned long clone_flags);
-        int (*task_alloc_security) (struct task_struct * p);
+        int (*task_alloc_security) (struct task_struct *p);
-        void (*task_free_security) (struct task_struct * p);
+        void (*task_free_security) (struct task_struct *p);
        int (*task_setuid) (uid_t id0, uid_t id1, uid_t id2, int flags);
        int (*task_post_setuid) (uid_t old_ruid /* or fsuid */ ,
                                 uid_t old_euid, uid_t old_suid, int flags);
        int (*task_setgid) (gid_t id0, gid_t id1, gid_t id2, int flags);
-        int (*task_setpgid) (struct task_struct * p, pid_t pgid);
+        int (*task_setpgid) (struct task_struct *p, pid_t pgid);
-        int (*task_getpgid) (struct task_struct * p);
+        int (*task_getpgid) (struct task_struct *p);
-        int (*task_getsid) (struct task_struct * p);
+        int (*task_getsid) (struct task_struct *p);
-        void (*task_getsecid) (struct task_struct * p, u32 * secid);
+        void (*task_getsecid) (struct task_struct *p, u32 *secid);
        int (*task_setgroups) (struct group_info *group_info);
-        int (*task_setnice) (struct task_struct * p, int nice);
+        int (*task_setnice) (struct task_struct *p, int nice);
-        int (*task_setioprio) (struct task_struct * p, int ioprio);
+        int (*task_setioprio) (struct task_struct *p, int ioprio);
-        int (*task_getioprio) (struct task_struct * p);
+        int (*task_getioprio) (struct task_struct *p);
-        int (*task_setrlimit) (unsigned int resource, struct rlimit * new_rlim);
+        int (*task_setrlimit) (unsigned int resource, struct rlimit *new_rlim);
-        int (*task_setscheduler) (struct task_struct * p, int policy,
+        int (*task_setscheduler) (struct task_struct *p, int policy,
-                                  struct sched_param * lp);
+                                  struct sched_param *lp);
-        int (*task_getscheduler) (struct task_struct * p);
+        int (*task_getscheduler) (struct task_struct *p);
-        int (*task_movememory) (struct task_struct * p);
+        int (*task_movememory) (struct task_struct *p);
-        int (*task_kill) (struct task_struct * p,
+        int (*task_kill) (struct task_struct *p,
-                          struct siginfo * info, int sig, u32 secid);
+                          struct siginfo *info, int sig, u32 secid);
-        int (*task_wait) (struct task_struct * p);
+        int (*task_wait) (struct task_struct *p);
        int (*task_prctl) (int option, unsigned long arg2,
                           unsigned long arg3, unsigned long arg4,
-                           unsigned long arg5);
+                           unsigned long arg5, long *rc_p);
-        void (*task_reparent_to_init) (struct task_struct * p);
+        void (*task_reparent_to_init) (struct task_struct *p);
-        void (*task_to_inode)(struct task_struct *p, struct inode *inode);
+        void (*task_to_inode) (struct task_struct *p, struct inode *inode);
-        int (*ipc_permission) (struct kern_ipc_perm * ipcp, short flag);
+        int (*ipc_permission) (struct kern_ipc_perm *ipcp, short flag);
        void (*ipc_getsecid) (struct kern_ipc_perm *ipcp, u32 *secid);
-        int (*msg_msg_alloc_security) (struct msg_msg * msg);
+        int (*msg_msg_alloc_security) (struct msg_msg *msg);
-        void (*msg_msg_free_security) (struct msg_msg * msg);
+        void (*msg_msg_free_security) (struct msg_msg *msg);
-        int (*msg_queue_alloc_security) (struct msg_queue * msq);
+        int (*msg_queue_alloc_security) (struct msg_queue *msq);
-        void (*msg_queue_free_security) (struct msg_queue * msq);
+        void (*msg_queue_free_security) (struct msg_queue *msq);
-        int (*msg_queue_associate) (struct msg_queue * msq, int msqflg);
+        int (*msg_queue_associate) (struct msg_queue *msq, int msqflg);
-        int (*msg_queue_msgctl) (struct msg_queue * msq, int cmd);
+        int (*msg_queue_msgctl) (struct msg_queue *msq, int cmd);
-        int (*msg_queue_msgsnd) (struct msg_queue * msq,
+        int (*msg_queue_msgsnd) (struct msg_queue *msq,
-                                 struct msg_msg * msg, int msqflg);
+                                 struct msg_msg *msg, int msqflg);
-        int (*msg_queue_msgrcv) (struct msg_queue * msq,
+        int (*msg_queue_msgrcv) (struct msg_queue *msq,
-                                 struct msg_msg * msg,
+                                 struct msg_msg *msg,
-                                 struct task_struct * target,
+                                 struct task_struct *target,
                                 long type, int mode);
-        int (*shm_alloc_security) (struct shmid_kernel * shp);
+        int (*shm_alloc_security) (struct shmid_kernel *shp);
-        void (*shm_free_security) (struct shmid_kernel * shp);
+        void (*shm_free_security) (struct shmid_kernel *shp);
-        int (*shm_associate) (struct shmid_kernel * shp, int shmflg);
+        int (*shm_associate) (struct shmid_kernel *shp, int shmflg);
-        int (*shm_shmctl) (struct shmid_kernel * shp, int cmd);
+        int (*shm_shmctl) (struct shmid_kernel *shp, int cmd);
-        int (*shm_shmat) (struct shmid_kernel * shp, 
+        int (*shm_shmat) (struct shmid_kernel *shp,
                          char __user *shmaddr, int shmflg);
-        int (*sem_alloc_security) (struct sem_array * sma);
+        int (*sem_alloc_security) (struct sem_array *sma);
-        void (*sem_free_security) (struct sem_array * sma);
+        void (*sem_free_security) (struct sem_array *sma);
-        int (*sem_associate) (struct sem_array * sma, int semflg);
+        int (*sem_associate) (struct sem_array *sma, int semflg);
-        int (*sem_semctl) (struct sem_array * sma, int cmd);
+        int (*sem_semctl) (struct sem_array *sma, int cmd);
-        int (*sem_semop) (struct sem_array * sma, 
+        int (*sem_semop) (struct sem_array *sma,
-                          struct sembuf * sops, unsigned nsops, int alter);
+                          struct sembuf *sops, unsigned nsops, int alter);
-        int (*netlink_send) (struct sock * sk, struct sk_buff * skb);
+        int (*netlink_send) (struct sock *sk, struct sk_buff *skb);
-        int (*netlink_recv) (struct sk_buff * skb, int cap);
+        int (*netlink_recv) (struct sk_buff *skb, int cap);
        /* allow module stacking */
        int (*register_security) (const char *name,
-                                  struct security_operations *ops);
+                                  struct security_operations *ops);
        void (*d_instantiate) (struct dentry *dentry, struct inode *inode);
-        int (*getprocattr)(struct task_struct *p, char *name, char **value);
+        int (*getprocattr) (struct task_struct *p, char *name, char **value);
-        int (*setprocattr)(struct task_struct *p, char *name, void *value, size_t size);
+        int (*setprocattr) (struct task_struct *p, char *name, void *value, size_t size);
-        int (*secid_to_secctx)(u32 secid, char **secdata, u32 *seclen);
+        int (*secid_to_secctx) (u32 secid, char **secdata, u32 *seclen);
-        int (*secctx_to_secid)(char *secdata, u32 seclen, u32 *secid);
+        int (*secctx_to_secid) (const char *secdata, u32 seclen, u32 *secid);
-        void (*release_secctx)(char *secdata, u32 seclen);
+        void (*release_secctx) (char *secdata, u32 seclen);
 #ifdef CONFIG_SECURITY_NETWORK
-        int (*unix_stream_connect) (struct socket * sock,
+        int (*unix_stream_connect) (struct socket *sock,
-                                    struct socket * other, struct sock * newsk);
+                                    struct socket *other, struct sock *newsk);
-        int (*unix_may_send) (struct socket * sock, struct socket * other);
+        int (*unix_may_send) (struct socket *sock, struct socket *other);
        int (*socket_create) (int family, int type, int protocol, int kern);
-        int (*socket_post_create) (struct socket * sock, int family,
+        int (*socket_post_create) (struct socket *sock, int family,
                                   int type, int protocol, int kern);
-        int (*socket_bind) (struct socket * sock,
+        int (*socket_bind) (struct socket *sock,
-                            struct sockaddr * address, int addrlen);
+                            struct sockaddr *address, int addrlen);
-        int (*socket_connect) (struct socket * sock,
+        int (*socket_connect) (struct socket *sock,
-                               struct sockaddr * address, int addrlen);
+                               struct sockaddr *address, int addrlen);
-        int (*socket_listen) (struct socket * sock, int backlog);
+        int (*socket_listen) (struct socket *sock, int backlog);
-        int (*socket_accept) (struct socket * sock, struct socket * newsock);
+        int (*socket_accept) (struct socket *sock, struct socket *newsock);
-        void (*socket_post_accept) (struct socket * sock,
+        void (*socket_post_accept) (struct socket *sock,
-                                    struct socket * newsock);
+                                    struct socket *newsock);
-        int (*socket_sendmsg) (struct socket * sock,
+        int (*socket_sendmsg) (struct socket *sock,
-                               struct msghdr * msg, int size);
+                               struct msghdr *msg, int size);
-        int (*socket_recvmsg) (struct socket * sock,
+        int (*socket_recvmsg) (struct socket *sock,
-                               struct msghdr * msg, int size, int flags);
+                               struct msghdr *msg, int size, int flags);
-        int (*socket_getsockname) (struct socket * sock);
+        int (*socket_getsockname) (struct socket *sock);
-        int (*socket_getpeername) (struct socket * sock);
+        int (*socket_getpeername) (struct socket *sock);
-        int (*socket_getsockopt) (struct socket * sock, int level, int optname);
+        int (*socket_getsockopt) (struct socket *sock, int level, int optname);
-        int (*socket_setsockopt) (struct socket * sock, int level, int optname);
+        int (*socket_setsockopt) (struct socket *sock, int level, int optname);
-        int (*socket_shutdown) (struct socket * sock, int how);
+        int (*socket_shutdown) (struct socket *sock, int how);
-        int (*socket_sock_rcv_skb) (struct sock * sk, struct sk_buff * skb);
+        int (*socket_sock_rcv_skb) (struct sock *sk, struct sk_buff *skb);
        int (*socket_getpeersec_stream) (struct socket *sock, char __user *optval, int __user *optlen, unsigned len);
        int (*socket_getpeersec_dgram) (struct socket *sock, struct sk_buff *skb, u32 *secid);
        int (*sk_alloc_security) (struct sock *sk, int family, gfp_t priority);
        void (*sk_free_security) (struct sock *sk);
        void (*sk_clone_security) (const struct sock *sk, struct sock *newsk);
        void (*sk_getsecid) (struct sock *sk, u32 *secid);
-        void (*sock_graft)(struct sock* sk, struct socket *parent);
+        void (*sock_graft) (struct sock *sk, struct socket *parent);
-        int (*inet_conn_request)(struct sock *sk, struct sk_buff *skb,
+        int (*inet_conn_request) (struct sock *sk, struct sk_buff *skb,
-                                        struct request_sock *req);
+                                  struct request_sock *req);
-        void (*inet_csk_clone)(struct sock *newsk, const struct request_sock *req);
+        void (*inet_csk_clone) (struct sock *newsk, const struct request_sock *req);
-        void (*inet_conn_established)(struct sock *sk, struct sk_buff *skb);
+        void (*inet_conn_established) (struct sock *sk, struct sk_buff *skb);
-        void (*req_classify_flow)(const struct request_sock *req, struct flowi *fl);
+        void (*req_classify_flow) (const struct request_sock *req, struct flowi *fl);
 #endif  /* CONFIG_SECURITY_NETWORK */
 #ifdef CONFIG_SECURITY_NETWORK_XFRM
@@ -1521,57 +1535,57 @@ struct security_operations {
                u32 secid);
        void (*xfrm_state_free_security) (struct xfrm_state *x);
        int (*xfrm_state_delete_security) (struct xfrm_state *x);
-        int (*xfrm_policy_lookup)(struct xfrm_sec_ctx *ctx, u32 fl_secid, u8 dir);
+        int (*xfrm_policy_lookup) (struct xfrm_sec_ctx *ctx, u32 fl_secid, u8 dir);
-        int (*xfrm_state_pol_flow_match)(struct xfrm_state *x,
+        int (*xfrm_state_pol_flow_match) (struct xfrm_state *x,
-                        struct xfrm_policy *xp, struct flowi *fl);
+                                          struct xfrm_policy *xp,
-        int (*xfrm_decode_session)(struct sk_buff *skb, u32 *secid, int ckall);
+                                          struct flowi *fl);
+        int (*xfrm_decode_session) (struct sk_buff *skb, u32 *secid, int ckall);
 #endif  /* CONFIG_SECURITY_NETWORK_XFRM */
        /* key management security hooks */
 #ifdef CONFIG_KEYS
-        int (*key_alloc)(struct key *key, struct task_struct *tsk, unsigned long flags);
+        int (*key_alloc) (struct key *key, struct task_struct *tsk, unsigned long flags);
-        void (*key_free)(struct key *key);
+        void (*key_free) (struct key *key);
-        int (*key_permission)(key_ref_t key_ref,
+        int (*key_permission) (key_ref_t key_ref,
-                              struct task_struct *context,
+                               struct task_struct *context,
-                              key_perm_t perm);
+                               key_perm_t perm);
+        int (*key_getsecurity)(struct key *key, char **_buffer);
 #endif  /* CONFIG_KEYS */
 #ifdef CONFIG_AUDIT
-        int (*audit_rule_init)(u32 field, u32 op, char *rulestr, void **lsmrule);
+        int (*audit_rule_init) (u32 field, u32 op, char *rulestr, void **lsmrule);
-        int (*audit_rule_known)(struct audit_krule *krule);
+        int (*audit_rule_known) (struct audit_krule *krule);
-        int (*audit_rule_match)(u32 secid, u32 field, u32 op, void *lsmrule,
+        int (*audit_rule_match) (u32 secid, u32 field, u32 op, void *lsmrule,
-                                struct audit_context *actx);
+                                 struct audit_context *actx);
-        void (*audit_rule_free)(void *lsmrule);
+        void (*audit_rule_free) (void *lsmrule);
 #endif /* CONFIG_AUDIT */
 };
 /* prototypes */
-extern int security_init        (void);
+extern int security_init(void);
 extern int security_module_enable(struct security_operations *ops);
-extern int register_security    (struct security_operations *ops);
+extern int register_security(struct security_operations *ops);
-extern int mod_reg_security     (const char *name, struct security_operations *ops);
+extern int mod_reg_security(const char *name, struct security_operations *ops);
 extern struct dentry *securityfs_create_file(const char *name, mode_t mode,
                                             struct dentry *parent, void *data,
                                             const struct file_operations *fops);
 extern struct dentry *securityfs_create_dir(const char *name, struct dentry *parent);
 extern void securityfs_remove(struct dentry *dentry);
 /* Security operations */
 int security_ptrace(struct task_struct *parent, struct task_struct *child);
 int security_capget(struct task_struct *target,
-                     kernel_cap_t *effective,
+                    kernel_cap_t *effective,
-                     kernel_cap_t *inheritable,
+                    kernel_cap_t *inheritable,
-                     kernel_cap_t *permitted);
+                    kernel_cap_t *permitted);
 int security_capset_check(struct task_struct *target,
-                           kernel_cap_t *effective,
-                           kernel_cap_t *inheritable,
-                           kernel_cap_t *permitted);
-void security_capset_set(struct task_struct *target,
                          kernel_cap_t *effective,
                          kernel_cap_t *inheritable,
                          kernel_cap_t *permitted);
+void security_capset_set(struct task_struct *target,
+                         kernel_cap_t *effective,
+                         kernel_cap_t *inheritable,
+                         kernel_cap_t *permitted);
 int security_capable(struct task_struct *tsk, int cap);
 int security_acct(struct file *file);
 int security_sysctl(struct ctl_table *table, int op);
@@ -1594,7 +1608,7 @@ int security_sb_copy_data(char *orig, char *copy);
 int security_sb_kern_mount(struct super_block *sb, void *data);
 int security_sb_statfs(struct dentry *dentry);
 int security_sb_mount(char *dev_name, struct path *path,
-                       char *type, unsigned long flags, void *data);
+                      char *type, unsigned long flags, void *data);
 int security_sb_check_sb(struct vfsmount *mnt, struct path *path);
 int security_sb_umount(struct vfsmount *mnt, int flags);
 void security_sb_umount_close(struct vfsmount *mnt);
@@ -1619,25 +1633,25 @@ int security_inode_link(struct dentry *old_dentry, struct inode *dir,
                         struct dentry *new_dentry);
 int security_inode_unlink(struct inode *dir, struct dentry *dentry);
 int security_inode_symlink(struct inode *dir, struct dentry *dentry,
-                            const char *old_name);
+                           const char *old_name);
 int security_inode_mkdir(struct inode *dir, struct dentry *dentry, int mode);
 int security_inode_rmdir(struct inode *dir, struct dentry *dentry);
 int security_inode_mknod(struct inode *dir, struct dentry *dentry, int mode, dev_t dev);
 int security_inode_rename(struct inode *old_dir, struct dentry *old_dentry,
-                           struct inode *new_dir, struct dentry *new_dentry);
+                          struct inode *new_dir, struct dentry *new_dentry);
 int security_inode_readlink(struct dentry *dentry);
 int security_inode_follow_link(struct dentry *dentry, struct nameidata *nd);
 int security_inode_permission(struct inode *inode, int mask, struct nameidata *nd);
 int security_inode_setattr(struct dentry *dentry, struct iattr *attr);
 int security_inode_getattr(struct vfsmount *mnt, struct dentry *dentry);
 void security_inode_delete(struct inode *inode);
-int security_inode_setxattr(struct dentry *dentry, char *name,
+int security_inode_setxattr(struct dentry *dentry, const char *name,
-                             void *value, size_t size, int flags);
+                            const void *value, size_t size, int flags);
-void security_inode_post_setxattr(struct dentry *dentry, char *name,
+void security_inode_post_setxattr(struct dentry *dentry, const char *name,
-                                   void *value, size_t size, int flags);
+                                  const void *value, size_t size, int flags);
-int security_inode_getxattr(struct dentry *dentry, char *name);
+int security_inode_getxattr(struct dentry *dentry, const char *name);
 int security_inode_listxattr(struct dentry *dentry);
-int security_inode_removexattr(struct dentry *dentry, char *name);
+int security_inode_removexattr(struct dentry *dentry, const char *name);
 int security_inode_need_killpriv(struct dentry *dentry);
 int security_inode_killpriv(struct dentry *dentry);
 int security_inode_getsecurity(const struct inode *inode, const char *name, void **buffer, bool alloc);
@@ -1652,12 +1666,12 @@ int security_file_mmap(struct file *file, unsigned long reqprot,
                        unsigned long prot, unsigned long flags,
                        unsigned long addr, unsigned long addr_only);
 int security_file_mprotect(struct vm_area_struct *vma, unsigned long reqprot,
-                            unsigned long prot);
+                           unsigned long prot);
 int security_file_lock(struct file *file, unsigned int cmd);
 int security_file_fcntl(struct file *file, unsigned int cmd, unsigned long arg);
 int security_file_set_fowner(struct file *file);
 int security_file_send_sigiotask(struct task_struct *tsk,
-                                  struct fown_struct *fown, int sig);
+                                 struct fown_struct *fown, int sig);
 int security_file_receive(struct file *file);
 int security_dentry_open(struct file *file);
 int security_task_create(unsigned long clone_flags);
@@ -1665,7 +1679,7 @@ int security_task_alloc(struct task_struct *p);
 void security_task_free(struct task_struct *p);
 int security_task_setuid(uid_t id0, uid_t id1, uid_t id2, int flags);
 int security_task_post_setuid(uid_t old_ruid, uid_t old_euid,
-                               uid_t old_suid, int flags);
+                              uid_t old_suid, int flags);
 int security_task_setgid(gid_t id0, gid_t id1, gid_t id2, int flags);
 int security_task_setpgid(struct task_struct *p, pid_t pgid);
 int security_task_getpgid(struct task_struct *p);
@@ -1684,7 +1698,7 @@ int security_task_kill(struct task_struct *p, struct siginfo *info,
                        int sig, u32 secid);
 int security_task_wait(struct task_struct *p);
 int security_task_prctl(int option, unsigned long arg2, unsigned long arg3,
-                         unsigned long arg4, unsigned long arg5);
+                         unsigned long arg4, unsigned long arg5, long *rc_p);
 void security_task_reparent_to_init(struct task_struct *p);
 void security_task_to_inode(struct task_struct *p, struct inode *inode);
 int security_ipc_permission(struct kern_ipc_perm *ipcp, short flag);
@@ -1696,9 +1710,9 @@ void security_msg_queue_free(struct msg_queue *msq);
 int security_msg_queue_associate(struct msg_queue *msq, int msqflg);
 int security_msg_queue_msgctl(struct msg_queue *msq, int cmd);
 int security_msg_queue_msgsnd(struct msg_queue *msq,
-                               struct msg_msg *msg, int msqflg);
+                              struct msg_msg *msg, int msqflg);
 int security_msg_queue_msgrcv(struct msg_queue *msq, struct msg_msg *msg,
-                               struct task_struct *target, long type, int mode);
+                              struct task_struct *target, long type, int mode);
 int security_shm_alloc(struct shmid_kernel *shp);
 void security_shm_free(struct shmid_kernel *shp);
 int security_shm_associate(struct shmid_kernel *shp, int shmflg);
@@ -1710,13 +1724,13 @@ int security_sem_associate(struct sem_array *sma, int semflg);
 int security_sem_semctl(struct sem_array *sma, int cmd);
 int security_sem_semop(struct sem_array *sma, struct sembuf *sops,
                        unsigned nsops, int alter);
-void security_d_instantiate (struct dentry *dentry, struct inode *inode);
+void security_d_instantiate(struct dentry *dentry, struct inode *inode);
 int security_getprocattr(struct task_struct *p, char *name, char **value);
 int security_setprocattr(struct task_struct *p, char *name, void *value, size_t size);
 int security_netlink_send(struct sock *sk, struct sk_buff *skb);
 int security_netlink_recv(struct sk_buff *skb, int cap);
 int security_secid_to_secctx(u32 secid, char **secdata, u32 *seclen);
-int security_secctx_to_secid(char *secdata, u32 seclen, u32 *secid);
+int security_secctx_to_secid(const char *secdata, u32 seclen, u32 *secid);
 void security_release_secctx(char *secdata, u32 seclen);
 #else /* CONFIG_SECURITY */
@@ -1741,33 +1755,33 @@ static inline int security_init(void)
        return 0;
 }
-static inline int security_ptrace (struct task_struct *parent, struct task_struct * child)
+static inline int security_ptrace(struct task_struct *parent, struct task_struct *child)
 {
-        return cap_ptrace (parent, child);
+        return cap_ptrace(parent, child);
 }
-static inline int security_capget (struct task_struct *target,
+static inline int security_capget(struct task_struct *target,
                                   kernel_cap_t *effective,
                                   kernel_cap_t *inheritable,
                                   kernel_cap_t *permitted)
 {
-        return cap_capget (target, effective, inheritable, permitted);
+        return cap_capget(target, effective, inheritable, permitted);
 }
-static inline int security_capset_check (struct task_struct *target,
+static inline int security_capset_check(struct task_struct *target,
                                         kernel_cap_t *effective,
                                         kernel_cap_t *inheritable,
                                         kernel_cap_t *permitted)
 {
-        return cap_capset_check (target, effective, inheritable, permitted);
+        return cap_capset_check(target, effective, inheritable, permitted);
 }
-static inline void security_capset_set (struct task_struct *target,
+static inline void security_capset_set(struct task_struct *target,
                                        kernel_cap_t *effective,
                                        kernel_cap_t *inheritable,
                                        kernel_cap_t *permitted)
 {
-        cap_capset_set (target, effective, inheritable, permitted);
+        cap_capset_set(target, effective, inheritable, permitted);
 }
 static inline int security_capable(struct task_struct *tsk, int cap)
@@ -1775,7 +1789,7 @@ static inline int security_capable(struct task_struct *tsk, int cap)
        return cap_capable(tsk, cap);
 }
-static inline int security_acct (struct file *file)
+static inline int security_acct(struct file *file)
 {
        return 0;
 }
@@ -1785,13 +1799,13 @@ static inline int security_sysctl(struct ctl_table *table, int op)
        return 0;
 }
-static inline int security_quotactl (int cmds, int type, int id,
+static inline int security_quotactl(int cmds, int type, int id,
-                                     struct super_block * sb)
+                                     struct super_block *sb)
 {
        return 0;
 }
-static inline int security_quota_on (struct dentry * dentry)
+static inline int security_quota_on(struct dentry *dentry)
 {
        return 0;
 }
@@ -1816,102 +1830,102 @@ static inline int security_vm_enough_memory_mm(struct mm_struct *mm, long pages)
        return cap_vm_enough_memory(mm, pages);
 }
-static inline int security_bprm_alloc (struct linux_binprm *bprm)
+static inline int security_bprm_alloc(struct linux_binprm *bprm)
 {
        return 0;
 }
-static inline void security_bprm_free (struct linux_binprm *bprm)
+static inline void security_bprm_free(struct linux_binprm *bprm)
 { }
-static inline void security_bprm_apply_creds (struct linux_binprm *bprm, int unsafe)
+static inline void security_bprm_apply_creds(struct linux_binprm *bprm, int unsafe)
-{ 
+{
-        cap_bprm_apply_creds (bprm, unsafe);
+        cap_bprm_apply_creds(bprm, unsafe);
 }
-static inline void security_bprm_post_apply_creds (struct linux_binprm *bprm)
+static inline void security_bprm_post_apply_creds(struct linux_binprm *bprm)
 {
        return;
 }
-static inline int security_bprm_set (struct linux_binprm *bprm)
+static inline int security_bprm_set(struct linux_binprm *bprm)
 {
-        return cap_bprm_set_security (bprm);
+        return cap_bprm_set_security(bprm);
 }
-static inline int security_bprm_check (struct linux_binprm *bprm)
+static inline int security_bprm_check(struct linux_binprm *bprm)
 {
        return 0;
 }
-static inline int security_bprm_secureexec (struct linux_binprm *bprm)
+static inline int security_bprm_secureexec(struct linux_binprm *bprm)
 {
        return cap_bprm_secureexec(bprm);
 }
-static inline int security_sb_alloc (struct super_block *sb)
+static inline int security_sb_alloc(struct super_block *sb)
 {
        return 0;
 }
-static inline void security_sb_free (struct super_block *sb)
+static inline void security_sb_free(struct super_block *sb)
 { }
-static inline int security_sb_copy_data (char *orig, char *copy)
+static inline int security_sb_copy_data(char *orig, char *copy)
 {
        return 0;
 }
-static inline int security_sb_kern_mount (struct super_block *sb, void *data)
+static inline int security_sb_kern_mount(struct super_block *sb, void *data)
 {
        return 0;
 }
-static inline int security_sb_statfs (struct dentry *dentry)
+static inline int security_sb_statfs(struct dentry *dentry)
 {
        return 0;
 }
-static inline int security_sb_mount (char *dev_name, struct path *path,
+static inline int security_sb_mount(char *dev_name, struct path *path,
                                    char *type, unsigned long flags,
                                    void *data)
 {
        return 0;
 }
-static inline int security_sb_check_sb (struct vfsmount *mnt,
+static inline int security_sb_check_sb(struct vfsmount *mnt,
-                                        struct path *path)
+                                       struct path *path)
 {
        return 0;
 }
-static inline int security_sb_umount (struct vfsmount *mnt, int flags)
+static inline int security_sb_umount(struct vfsmount *mnt, int flags)
 {
        return 0;
 }
-static inline void security_sb_umount_close (struct vfsmount *mnt)
+static inline void security_sb_umount_close(struct vfsmount *mnt)
 { }
-static inline void security_sb_umount_busy (struct vfsmount *mnt)
+static inline void security_sb_umount_busy(struct vfsmount *mnt)
 { }
-static inline void security_sb_post_remount (struct vfsmount *mnt,
+static inline void security_sb_post_remount(struct vfsmount *mnt,
                                             unsigned long flags, void *data)
 { }
-static inline void security_sb_post_addmount (struct vfsmount *mnt,
+static inline void security_sb_post_addmount(struct vfsmount *mnt,
-                                              struct path *mountpoint)
+                                             struct path *mountpoint)
 { }
-static inline int security_sb_pivotroot (struct path *old_path,
+static inline int security_sb_pivotroot(struct path *old_path,
-                                         struct path *new_path)
+                                        struct path *new_path)
 {
        return 0;
 }
-static inline void security_sb_post_pivotroot (struct path *old_path,
+static inline void security_sb_post_pivotroot(struct path *old_path,
-                                               struct path *new_path)
+                                              struct path *new_path)
 { }
 static inline int security_sb_get_mnt_opts(const struct super_block *sb,
                                           struct security_mnt_opts *opts)
@@ -1935,15 +1949,15 @@ static inline int security_sb_parse_opts_str(char *options, struct security_mnt_
        return 0;
 }
-static inline int security_inode_alloc (struct inode *inode)
+static inline int security_inode_alloc(struct inode *inode)
 {
        return 0;
 }
-static inline void security_inode_free (struct inode *inode)
+static inline void security_inode_free(struct inode *inode)
 { }
-static inline int security_inode_init_security (struct inode *inode,
+static inline int security_inode_init_security(struct inode *inode,
                                                struct inode *dir,
                                                char **name,
                                                void **value,
@@ -1951,55 +1965,55 @@ static inline int security_inode_init_security (struct inode *inode,
 {
        return -EOPNOTSUPP;
 }
-        
-static inline int security_inode_create (struct inode *dir,
+static inline int security_inode_create(struct inode *dir,
                                         struct dentry *dentry,
                                         int mode)
 {
        return 0;
 }
-static inline int security_inode_link (struct dentry *old_dentry,
+static inline int security_inode_link(struct dentry *old_dentry,
                                       struct inode *dir,
                                       struct dentry *new_dentry)
 {
        return 0;
 }
-static inline int security_inode_unlink (struct inode *dir,
+static inline int security_inode_unlink(struct inode *dir,
                                         struct dentry *dentry)
 {
        return 0;
 }
-static inline int security_inode_symlink (struct inode *dir,
+static inline int security_inode_symlink(struct inode *dir,
                                          struct dentry *dentry,
                                          const char *old_name)
 {
        return 0;
 }
-static inline int security_inode_mkdir (struct inode *dir,
+static inline int security_inode_mkdir(struct inode *dir,
                                        struct dentry *dentry,
                                        int mode)
 {
        return 0;
 }
-static inline int security_inode_rmdir (struct inode *dir,
+static inline int security_inode_rmdir(struct inode *dir,
                                        struct dentry *dentry)
 {
        return 0;
 }
-static inline int security_inode_mknod (struct inode *dir,
+static inline int security_inode_mknod(struct inode *dir,
                                        struct dentry *dentry,
                                        int mode, dev_t dev)
 {
        return 0;
 }
-static inline int security_inode_rename (struct inode *old_dir,
+static inline int security_inode_rename(struct inode *old_dir,
                                         struct dentry *old_dentry,
                                         struct inode *new_dir,
                                         struct dentry *new_dentry)
@@ -2007,59 +2021,61 @@ static inline int security_inode_rename (struct inode *old_dir,
        return 0;
 }
-static inline int security_inode_readlink (struct dentry *dentry)
+static inline int security_inode_readlink(struct dentry *dentry)
 {
        return 0;
 }
-static inline int security_inode_follow_link (struct dentry *dentry,
+static inline int security_inode_follow_link(struct dentry *dentry,
                                              struct nameidata *nd)
 {
        return 0;
 }
-static inline int security_inode_permission (struct inode *inode, int mask,
+static inline int security_inode_permission(struct inode *inode, int mask,
                                             struct nameidata *nd)
 {
        return 0;
 }
-static inline int security_inode_setattr (struct dentry *dentry,
+static inline int security_inode_setattr(struct dentry *dentry,
                                          struct iattr *attr)
 {
        return 0;
 }
-static inline int security_inode_getattr (struct vfsmount *mnt,
+static inline int security_inode_getattr(struct vfsmount *mnt,
                                          struct dentry *dentry)
 {
        return 0;
 }
-static inline void security_inode_delete (struct inode *inode)
+static inline void security_inode_delete(struct inode *inode)
 { }
-static inline int security_inode_setxattr (struct dentry *dentry, char *name,
+static inline int security_inode_setxattr(struct dentry *dentry,
-                                           void *value, size_t size, int flags)
+                const char *name, const void *value, size_t size, int flags)
 {
        return cap_inode_setxattr(dentry, name, value, size, flags);
 }
-static inline void security_inode_post_setxattr (struct dentry *dentry, char *name,
+static inline void security_inode_post_setxattr(struct dentry *dentry,
-                                                 void *value, size_t size, int flags)
+                const char *name, const void *value, size_t size, int flags)
 { }
-static inline int security_inode_getxattr (struct dentry *dentry, char *name)
+static inline int security_inode_getxattr(struct dentry *dentry,
+                        const char *name)
 {
        return 0;
 }
-static inline int security_inode_listxattr (struct dentry *dentry)
+static inline int security_inode_listxattr(struct dentry *dentry)
 {
        return 0;
 }
-static inline int security_inode_removexattr (struct dentry *dentry, char *name)
+static inline int security_inode_removexattr(struct dentry *dentry,
+                        const char *name)
 {
        return cap_inode_removexattr(dentry, name);
 }
@@ -2094,198 +2110,198 @@ static inline void security_inode_getsecid(const struct inode *inode, u32 *secid
        *secid = 0;
 }
-static inline int security_file_permission (struct file *file, int mask)
+static inline int security_file_permission(struct file *file, int mask)
 {
        return 0;
 }
-static inline int security_file_alloc (struct file *file)
+static inline int security_file_alloc(struct file *file)
 {
        return 0;
 }
-static inline void security_file_free (struct file *file)
+static inline void security_file_free(struct file *file)
 { }
-static inline int security_file_ioctl (struct file *file, unsigned int cmd,
+static inline int security_file_ioctl(struct file *file, unsigned int cmd,
-                                       unsigned long arg)
+                                      unsigned long arg)
 {
        return 0;
 }
-static inline int security_file_mmap (struct file *file, unsigned long reqprot,
+static inline int security_file_mmap(struct file *file, unsigned long reqprot,
-                                      unsigned long prot,
+                                     unsigned long prot,
-                                      unsigned long flags,
+                                     unsigned long flags,
-                                      unsigned long addr,
+                                     unsigned long addr,
-                                      unsigned long addr_only)
+                                     unsigned long addr_only)
 {
        return 0;
 }
-static inline int security_file_mprotect (struct vm_area_struct *vma,
+static inline int security_file_mprotect(struct vm_area_struct *vma,
-                                          unsigned long reqprot,
+                                         unsigned long reqprot,
-                                          unsigned long prot)
+                                         unsigned long prot)
 {
        return 0;
 }
-static inline int security_file_lock (struct file *file, unsigned int cmd)
+static inline int security_file_lock(struct file *file, unsigned int cmd)
 {
        return 0;
 }
-static inline int security_file_fcntl (struct file *file, unsigned int cmd,
+static inline int security_file_fcntl(struct file *file, unsigned int cmd,
-                                       unsigned long arg)
+                                      unsigned long arg)
 {
        return 0;
 }
-static inline int security_file_set_fowner (struct file *file)
+static inline int security_file_set_fowner(struct file *file)
 {
        return 0;
 }
-static inline int security_file_send_sigiotask (struct task_struct *tsk,
+static inline int security_file_send_sigiotask(struct task_struct *tsk,
-                                                struct fown_struct *fown,
+                                               struct fown_struct *fown,
-                                                int sig)
+                                               int sig)
 {
        return 0;
 }
-static inline int security_file_receive (struct file *file)
+static inline int security_file_receive(struct file *file)
 {
        return 0;
 }
-static inline int security_dentry_open (struct file *file)
+static inline int security_dentry_open(struct file *file)
 {
        return 0;
 }
-static inline int security_task_create (unsigned long clone_flags)
+static inline int security_task_create(unsigned long clone_flags)
 {
        return 0;
 }
-static inline int security_task_alloc (struct task_struct *p)
+static inline int security_task_alloc(struct task_struct *p)
 {
        return 0;
 }
-static inline void security_task_free (struct task_struct *p)
+static inline void security_task_free(struct task_struct *p)
 { }
-static inline int security_task_setuid (uid_t id0, uid_t id1, uid_t id2,
+static inline int security_task_setuid(uid_t id0, uid_t id1, uid_t id2,
-                                        int flags)
+                                       int flags)
 {
        return 0;
 }
-static inline int security_task_post_setuid (uid_t old_ruid, uid_t old_euid,
+static inline int security_task_post_setuid(uid_t old_ruid, uid_t old_euid,
-                                             uid_t old_suid, int flags)
+                                            uid_t old_suid, int flags)
 {
-        return cap_task_post_setuid (old_ruid, old_euid, old_suid, flags);
+        return cap_task_post_setuid(old_ruid, old_euid, old_suid, flags);
 }
-static inline int security_task_setgid (gid_t id0, gid_t id1, gid_t id2,
+static inline int security_task_setgid(gid_t id0, gid_t id1, gid_t id2,
-                                        int flags)
+                                       int flags)
 {
        return 0;
 }
-static inline int security_task_setpgid (struct task_struct *p, pid_t pgid)
+static inline int security_task_setpgid(struct task_struct *p, pid_t pgid)
 {
        return 0;
 }
-static inline int security_task_getpgid (struct task_struct *p)
+static inline int security_task_getpgid(struct task_struct *p)
 {
        return 0;
 }
-static inline int security_task_getsid (struct task_struct *p)
+static inline int security_task_getsid(struct task_struct *p)
 {
        return 0;
 }
-static inline void security_task_getsecid (struct task_struct *p, u32 *secid)
+static inline void security_task_getsecid(struct task_struct *p, u32 *secid)
 {
        *secid = 0;
 }
-static inline int security_task_setgroups (struct group_info *group_info)
+static inline int security_task_setgroups(struct group_info *group_info)
 {
        return 0;
 }
-static inline int security_task_setnice (struct task_struct *p, int nice)
+static inline int security_task_setnice(struct task_struct *p, int nice)
 {
        return cap_task_setnice(p, nice);
 }
-static inline int security_task_setioprio (struct task_struct *p, int ioprio)
+static inline int security_task_setioprio(struct task_struct *p, int ioprio)
 {
        return cap_task_setioprio(p, ioprio);
 }
-static inline int security_task_getioprio (struct task_struct *p)
+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(unsigned int resource,
-                                           struct rlimit *new_rlim)
+                                          struct rlimit *new_rlim)
 {
        return 0;
 }
-static inline int security_task_setscheduler (struct task_struct *p,
+static inline int security_task_setscheduler(struct task_struct *p,
-                                              int policy,
+                                             int policy,
-                                              struct sched_param *lp)
+                                             struct sched_param *lp)
 {
        return cap_task_setscheduler(p, policy, lp);
 }
-static inline int security_task_getscheduler (struct task_struct *p)
+static inline int security_task_getscheduler(struct task_struct *p)
 {
        return 0;
 }
-static inline int security_task_movememory (struct task_struct *p)
+static inline int security_task_movememory(struct task_struct *p)
 {
        return 0;
 }
-static inline int security_task_kill (struct task_struct *p,
+static inline int security_task_kill(struct task_struct *p,
-                                      struct siginfo *info, int sig,
+                                     struct siginfo *info, int sig,
-                                      u32 secid)
+                                     u32 secid)
 {
        return 0;
 }
-static inline int security_task_wait (struct task_struct *p)
+static inline int security_task_wait(struct task_struct *p)
 {
        return 0;
 }
-static inline int security_task_prctl (int option, unsigned long arg2,
+static inline int security_task_prctl(int option, unsigned long arg2,
-                                       unsigned long arg3,
+                                      unsigned long arg3,
-                                       unsigned long arg4,
+                                      unsigned long arg4,
-                                       unsigned long arg5)
+                                      unsigned long arg5, long *rc_p)
 {
-        return 0;
+        return cap_task_prctl(option, arg2, arg3, arg3, arg5, rc_p);
 }
-static inline void security_task_reparent_to_init (struct task_struct *p)
+static inline void security_task_reparent_to_init(struct task_struct *p)
 {
-        cap_task_reparent_to_init (p);
+        cap_task_reparent_to_init(p);
 }
 static inline void security_task_to_inode(struct task_struct *p, struct inode *inode)
 { }
-static inline int security_ipc_permission (struct kern_ipc_perm *ipcp,
+static inline int security_ipc_permission(struct kern_ipc_perm *ipcp,
-                                           short flag)
+                                          short flag)
 {
        return 0;
 }
@@ -2295,98 +2311,98 @@ static inline void security_ipc_getsecid(struct kern_ipc_perm *ipcp, u32 *secid)
        *secid = 0;
 }
-static inline int security_msg_msg_alloc (struct msg_msg * msg)
+static inline int security_msg_msg_alloc(struct msg_msg *msg)
 {
        return 0;
 }
-static inline void security_msg_msg_free (struct msg_msg * msg)
+static inline void security_msg_msg_free(struct msg_msg *msg)
 { }
-static inline int security_msg_queue_alloc (struct msg_queue *msq)
+static inline int security_msg_queue_alloc(struct msg_queue *msq)
 {
        return 0;
 }
-static inline void security_msg_queue_free (struct msg_queue *msq)
+static inline void security_msg_queue_free(struct msg_queue *msq)
 { }
-static inline int security_msg_queue_associate (struct msg_queue * msq, 
+static inline int security_msg_queue_associate(struct msg_queue *msq,
-                                                int msqflg)
+                                               int msqflg)
 {
        return 0;
 }
-static inline int security_msg_queue_msgctl (struct msg_queue * msq, int cmd)
+static inline int security_msg_queue_msgctl(struct msg_queue *msq, int cmd)
 {
        return 0;
 }
-static inline int security_msg_queue_msgsnd (struct msg_queue * msq,
+static inline int security_msg_queue_msgsnd(struct msg_queue *msq,
-                                             struct msg_msg * msg, int msqflg)
+                                            struct msg_msg *msg, int msqflg)
 {
        return 0;
 }
-static inline int security_msg_queue_msgrcv (struct msg_queue * msq,
+static inline int security_msg_queue_msgrcv(struct msg_queue *msq,
-                                             struct msg_msg * msg,
+                                            struct msg_msg *msg,
-                                             struct task_struct * target,
+                                            struct task_struct *target,
-                                             long type, int mode)
+                                            long type, int mode)
 {
        return 0;
 }
-static inline int security_shm_alloc (struct shmid_kernel *shp)
+static inline int security_shm_alloc(struct shmid_kernel *shp)
 {
        return 0;
 }
-static inline void security_shm_free (struct shmid_kernel *shp)
+static inline void security_shm_free(struct shmid_kernel *shp)
 { }
-static inline int security_shm_associate (struct shmid_kernel * shp, 
+static inline int security_shm_associate(struct shmid_kernel *shp,
-                                          int shmflg)
+                                         int shmflg)
 {
        return 0;
 }
-static inline int security_shm_shmctl (struct shmid_kernel * shp, int cmd)
+static inline int security_shm_shmctl(struct shmid_kernel *shp, int cmd)
 {
        return 0;
 }
-static inline int security_shm_shmat (struct shmid_kernel * shp, 
+static inline int security_shm_shmat(struct shmid_kernel *shp,
-                                      char __user *shmaddr, int shmflg)
+                                     char __user *shmaddr, int shmflg)
 {
        return 0;
 }
-static inline int security_sem_alloc (struct sem_array *sma)
+static inline int security_sem_alloc(struct sem_array *sma)
 {
        return 0;
 }
-static inline void security_sem_free (struct sem_array *sma)
+static inline void security_sem_free(struct sem_array *sma)
 { }
-static inline int security_sem_associate (struct sem_array * sma, int semflg)
+static inline int security_sem_associate(struct sem_array *sma, int semflg)
 {
        return 0;
 }
-static inline int security_sem_semctl (struct sem_array * sma, int cmd)
+static inline int security_sem_semctl(struct sem_array *sma, int cmd)
 {
        return 0;
 }
-static inline int security_sem_semop (struct sem_array * sma, 
+static inline int security_sem_semop(struct sem_array *sma,
-                                      struct sembuf * sops, unsigned nsops, 
+                                     struct sembuf *sops, unsigned nsops,
-                                      int alter)
+                                     int alter)
 {
        return 0;
 }
-static inline void security_d_instantiate (struct dentry *dentry, struct inode *inode)
+static inline void security_d_instantiate(struct dentry *dentry, struct inode *inode)
 { }
 static inline int security_getprocattr(struct task_struct *p, char *name, char **value)
@@ -2399,14 +2415,14 @@ static inline int security_setprocattr(struct task_struct *p, char *name, void *
        return -EINVAL;
 }
-static inline int security_netlink_send (struct sock *sk, struct sk_buff *skb)
+static inline int security_netlink_send(struct sock *sk, struct sk_buff *skb)
 {
-        return cap_netlink_send (sk, skb);
+        return cap_netlink_send(sk, skb);
 }
-static inline int security_netlink_recv (struct sk_buff *skb, int cap)
+static inline int security_netlink_recv(struct sk_buff *skb, int cap)
 {
-        return cap_netlink_recv (skb, cap);
+        return cap_netlink_recv(skb, cap);
 }
 static inline struct dentry *securityfs_create_dir(const char *name,
@@ -2433,7 +2449,7 @@ static inline int security_secid_to_secctx(u32 secid, char **secdata, u32 *secle
        return -EOPNOTSUPP;
 }
-static inline int security_secctx_to_secid(char *secdata,
+static inline int security_secctx_to_secid(const char *secdata,
                                           u32 seclen,
                                           u32 *secid)
 {
@@ -2484,26 +2500,26 @@ void security_inet_conn_established(struct sock *sk,
                        struct sk_buff *skb);
 #else   /* CONFIG_SECURITY_NETWORK */
-static inline int security_unix_stream_connect(struct socket * sock,
+static inline int security_unix_stream_connect(struct socket *sock,
-                                               struct socket * other,
+                                               struct socket *other,
-                                               struct sock * newsk)
+                                               struct sock *newsk)
 {
        return 0;
 }
-static inline int security_unix_may_send(struct socket * sock, 
+static inline int security_unix_may_send(struct socket *sock,
-                                         struct socket * other)
+                                         struct socket *other)
 {
        return 0;
 }
-static inline int security_socket_create (int family, int type,
+static inline int security_socket_create(int family, int type,
-                                          int protocol, int kern)
+                                         int protocol, int kern)
 {
        return 0;
 }
-static inline int security_socket_post_create(struct socket * sock,
+static inline int security_socket_post_create(struct socket *sock,
                                              int family,
                                              int type,
                                              int protocol, int kern)
@@ -2511,77 +2527,77 @@ static inline int security_socket_post_create(struct socket * sock,
        return 0;
 }
-static inline int security_socket_bind(struct socket * sock, 
+static inline int security_socket_bind(struct socket *sock,
-                                       struct sockaddr * address, 
+                                       struct sockaddr *address,
                                       int addrlen)
 {
        return 0;
 }
-static inline int security_socket_connect(struct socket * sock, 
+static inline int security_socket_connect(struct socket *sock,
-                                          struct sockaddr * address, 
+                                          struct sockaddr *address,
                                          int addrlen)
 {
        return 0;
 }
-static inline int security_socket_listen(struct socket * sock, int backlog)
+static inline int security_socket_listen(struct socket *sock, int backlog)
 {
        return 0;
 }
-static inline int security_socket_accept(struct socket * sock, 
+static inline int security_socket_accept(struct socket *sock,
-                                         struct socket * newsock)
+                                         struct socket *newsock)
 {
        return 0;
 }
-static inline void security_socket_post_accept(struct socket * sock, 
+static inline void security_socket_post_accept(struct socket *sock,
-                                               struct socket * newsock)
+                                               struct socket *newsock)
 {
 }
-static inline int security_socket_sendmsg(struct socket * sock, 
+static inline int security_socket_sendmsg(struct socket *sock,
-                                          struct msghdr * msg, int size)
+                                          struct msghdr *msg, int size)
 {
        return 0;
 }
-static inline int security_socket_recvmsg(struct socket * sock, 
+static inline int security_socket_recvmsg(struct socket *sock,
-                                          struct msghdr * msg, int size, 
+                                          struct msghdr *msg, int size,
                                          int flags)
 {
        return 0;
 }
-static inline int security_socket_getsockname(struct socket * sock)
+static inline int security_socket_getsockname(struct socket *sock)
 {
        return 0;
 }
-static inline int security_socket_getpeername(struct socket * sock)
+static inline int security_socket_getpeername(struct socket *sock)
 {
        return 0;
 }
-static inline int security_socket_getsockopt(struct socket * sock, 
+static inline int security_socket_getsockopt(struct socket *sock,
                                             int level, int optname)
 {
        return 0;
 }
-static inline int security_socket_setsockopt(struct socket * sock, 
+static inline int security_socket_setsockopt(struct socket *sock,
                                             int level, int optname)
 {
        return 0;
 }
-static inline int security_socket_shutdown(struct socket * sock, int how)
+static inline int security_socket_shutdown(struct socket *sock, int how)
 {
        return 0;
 }
-static inline int security_sock_rcv_skb (struct sock * sk, 
+static inline int security_sock_rcv_skb(struct sock *sk,
-                                         struct sk_buff * skb)
+                                        struct sk_buff *skb)
 {
        return 0;
 }
@@ -2618,7 +2634,7 @@ static inline void security_req_classify_flow(const struct request_sock *req, st
 {
 }
-static inline void security_sock_graft(struct sock* sk, struct socket *parent)
+static inline void security_sock_graft(struct sock *sk, struct socket *parent)
 {
 }
@@ -2727,6 +2743,7 @@ int security_key_alloc(struct key *key, struct task_struct *tsk, unsigned long f
 void security_key_free(struct key *key);
 int security_key_permission(key_ref_t key_ref,
                            struct task_struct *context, key_perm_t perm);
+int security_key_getsecurity(struct key *key, char **_buffer);
 #else
@@ -2748,6 +2765,12 @@ static inline int security_key_permission(key_ref_t key_ref,
        return 0;
 }
+static inline int security_key_getsecurity(struct key *key, char **_buffer)
+{
+        *_buffer = NULL;
+        return 0;
+}
 #endif
 #endif /* CONFIG_KEYS */
diff --git a/include/linux/serial_8250.h b/include/linux/serial_8250.h
index 00b65c0a82ca..3d37c94abbc8 100644
--- a/include/linux/serial_8250.h
+++ b/include/linux/serial_8250.h
@@ -46,6 +46,7 @@ enum {
        PLAT8250_DEV_HUB6,
        PLAT8250_DEV_MCA,
        PLAT8250_DEV_AU1X00,
+        PLAT8250_DEV_SM501,
 };
 /*
diff --git a/include/linux/shmem_fs.h b/include/linux/shmem_fs.h
index 8d5fb36ea047..f2d12d5a21b8 100644
--- a/include/linux/shmem_fs.h
+++ b/include/linux/shmem_fs.h
@@ -34,8 +34,7 @@ struct shmem_sb_info {
        uid_t uid;                  /* Mount uid for root directory */
        gid_t gid;                  /* Mount gid for root directory */
        mode_t mode;                /* Mount mode for root directory */
-        int policy;                 /* Default NUMA memory alloc policy */
+        struct mempolicy *mpol;     /* default memory policy for mappings */
-        nodemask_t policy_nodes;    /* nodemask for preferred and bind */
 };
 static inline struct shmem_inode_info *SHMEM_I(struct inode *inode)
diff --git a/include/linux/slub_def.h b/include/linux/slub_def.h
index 79d59c937fac..71e43a12ebbb 100644
--- a/include/linux/slub_def.h
+++ b/include/linux/slub_def.h
@@ -29,6 +29,7 @@ enum stat_item {
        DEACTIVATE_TO_HEAD,     /* Cpu slab was moved to the head of partials */
        DEACTIVATE_TO_TAIL,     /* Cpu slab was moved to the tail of partials */
        DEACTIVATE_REMOTE_FREES,/* Slab contained remotely freed objects */
+        ORDER_FALLBACK,         /* Number of times fallback was necessary */
        NR_SLUB_STAT_ITEMS };
 struct kmem_cache_cpu {
@@ -48,11 +49,21 @@ struct kmem_cache_node {
        struct list_head partial;
 #ifdef CONFIG_SLUB_DEBUG
        atomic_long_t nr_slabs;
+        atomic_long_t total_objects;
        struct list_head full;
 #endif
 };
 /*
+ * Word size structure that can be atomically updated or read and that
+ * contains both the order and the number of objects that a slab of the
+ * given order would contain.
+ */
+struct kmem_cache_order_objects {
+        unsigned long x;
+};
+/*
 * Slab cache management.
 */
 struct kmem_cache {
@@ -61,7 +72,7 @@ struct kmem_cache {
        int size;               /* The size of an object including meta data */
        int objsize;            /* The size of an object without meta data */
        int offset;             /* Free pointer offset. */
-        int order;              /* Current preferred allocation order */
+        struct kmem_cache_order_objects oo;
        /*
         * Avoid an extra cache line for UP, SMP and for the node local to
@@ -70,7 +81,8 @@ struct kmem_cache {
        struct kmem_cache_node local_node;
        /* Allocation and freeing of slabs */
-        int objects;            /* Number of objects in slab */
+        struct kmem_cache_order_objects max;
+        struct kmem_cache_order_objects min;
        gfp_t allocflags;       /* gfp flags to use on each alloc */
        int refcount;           /* Refcount for slab cache destroy */
        void (*ctor)(struct kmem_cache *, void *);
diff --git a/include/linux/smb.h b/include/linux/smb.h
index f098dff93f6b..caa43b2370cb 100644
--- a/include/linux/smb.h
+++ b/include/linux/smb.h
@@ -11,6 +11,7 @@
 #include <linux/types.h>
 #include <linux/magic.h>
+#include <linux/time.h>
 enum smb_protocol { 
        SMB_PROTOCOL_NONE, 
diff --git a/include/linux/suspend.h b/include/linux/suspend.h
index 1d7d4c5797ee..a6977423baf7 100644
--- a/include/linux/suspend.h
+++ b/include/linux/suspend.h
@@ -12,11 +12,22 @@
 #include <asm/errno.h>
 #if defined(CONFIG_PM_SLEEP) && defined(CONFIG_VT) && defined(CONFIG_VT_CONSOLE)
+extern void pm_set_vt_switch(int);
 extern int pm_prepare_console(void);
 extern void pm_restore_console(void);
 #else
-static inline int pm_prepare_console(void) { return 0; }
+static inline void pm_set_vt_switch(int do_switch)
-static inline void pm_restore_console(void) {}
+{
+}
+static inline int pm_prepare_console(void)
+{
+        return 0;
+}
+static inline void pm_restore_console(void)
+{
+}
 #endif
 typedef int __bitwise suspend_state_t;
diff --git a/include/linux/swap.h b/include/linux/swap.h
index 878459ae0454..0b3377650c85 100644
--- a/include/linux/swap.h
+++ b/include/linux/swap.h
@@ -177,11 +177,11 @@ extern void activate_page(struct page *);
 extern void mark_page_accessed(struct page *);
 extern void lru_add_drain(void);
 extern int lru_add_drain_all(void);
-extern int rotate_reclaimable_page(struct page *page);
+extern void rotate_reclaimable_page(struct page *page);
 extern void swap_setup(void);
 /* linux/mm/vmscan.c */
-extern unsigned long try_to_free_pages(struct zone **zones, int order,
+extern unsigned long try_to_free_pages(struct zonelist *zonelist, int order,
                                        gfp_t gfp_mask);
 extern unsigned long try_to_free_mem_cgroup_pages(struct mem_cgroup *mem,
                                                        gfp_t gfp_mask);
diff --git a/include/linux/synclink.h b/include/linux/synclink.h
index 5562fbf72095..45f6bc82d317 100644
--- a/include/linux/synclink.h
+++ b/include/linux/synclink.h
@@ -13,10 +13,6 @@
 #define _SYNCLINK_H_
 #define SYNCLINK_H_VERSION 3.6
-#define BOOLEAN int
-#define TRUE 1
-#define FALSE 0
 #define BIT0    0x0001
 #define BIT1    0x0002
 #define BIT2    0x0004
diff --git a/include/linux/syscalls.h b/include/linux/syscalls.h
index 8df6d1382ac8..0522f368f9d7 100644
--- a/include/linux/syscalls.h
+++ b/include/linux/syscalls.h
@@ -240,26 +240,28 @@ asmlinkage long sys_truncate64(const char __user *path, loff_t length);
 asmlinkage long sys_ftruncate64(unsigned int fd, loff_t length);
 #endif
-asmlinkage long sys_setxattr(char __user *path, char __user *name,
+asmlinkage long sys_setxattr(const char __user *path, const char __user *name,
-                                void __user *value, size_t size, int flags);
+                             const void __user *value, size_t size, int flags);
-asmlinkage long sys_lsetxattr(char __user *path, char __user *name,
+asmlinkage long sys_lsetxattr(const char __user *path, const char __user *name,
-                                void __user *value, size_t size, int flags);
+                              const void __user *value, size_t size, int flags);
-asmlinkage long sys_fsetxattr(int fd, char __user *name, void __user *value,
+asmlinkage long sys_fsetxattr(int fd, const char __user *name,
-                                size_t size, int flags);
+                              const void __user *value, size_t size, int flags);
-asmlinkage ssize_t sys_getxattr(char __user *path, char __user *name,
+asmlinkage ssize_t sys_getxattr(const char __user *path, const char __user *name,
                                void __user *value, size_t size);
-asmlinkage ssize_t sys_lgetxattr(char __user *path, char __user *name,
+asmlinkage ssize_t sys_lgetxattr(const char __user *path, const char __user *name,
                                void __user *value, size_t size);
-asmlinkage ssize_t sys_fgetxattr(int fd, char __user *name,
+asmlinkage ssize_t sys_fgetxattr(int fd, const char __user *name,
                                void __user *value, size_t size);
-asmlinkage ssize_t sys_listxattr(char __user *path, char __user *list,
+asmlinkage ssize_t sys_listxattr(const char __user *path, char __user *list,
                                size_t size);
-asmlinkage ssize_t sys_llistxattr(char __user *path, char __user *list,
+asmlinkage ssize_t sys_llistxattr(const char __user *path, char __user *list,
                                size_t size);
 asmlinkage ssize_t sys_flistxattr(int fd, char __user *list, size_t size);
-asmlinkage long sys_removexattr(char __user *path, char __user *name);
+asmlinkage long sys_removexattr(const char __user *path,
-asmlinkage long sys_lremovexattr(char __user *path, char __user *name);
+                                const char __user *name);
-asmlinkage long sys_fremovexattr(int fd, char __user *name);
+asmlinkage long sys_lremovexattr(const char __user *path,
+                                 const char __user *name);
+asmlinkage long sys_fremovexattr(int fd, const char __user *name);
 asmlinkage unsigned long sys_brk(unsigned long brk);
 asmlinkage long sys_mprotect(unsigned long start, size_t len,
diff --git a/include/linux/sysctl.h b/include/linux/sysctl.h
index 571f01d20a86..24141b4d1a11 100644
--- a/include/linux/sysctl.h
+++ b/include/linux/sysctl.h
@@ -945,11 +945,14 @@ enum
 /* For the /proc/sys support */
 struct ctl_table;
 struct nsproxy;
+struct ctl_table_root;
 extern struct ctl_table_header *sysctl_head_next(struct ctl_table_header *prev);
 extern struct ctl_table_header *__sysctl_head_next(struct nsproxy *namespaces,
                                                struct ctl_table_header *prev);
 extern void sysctl_head_finish(struct ctl_table_header *prev);
-extern int sysctl_perm(struct ctl_table *table, int op);
+extern int sysctl_perm(struct ctl_table_root *root,
+                struct ctl_table *table, int op);
 typedef struct ctl_table ctl_table;
@@ -981,11 +984,6 @@ extern int do_sysctl (int __user *name, int nlen,
                      void __user *oldval, size_t __user *oldlenp,
                      void __user *newval, size_t newlen);
-extern int do_sysctl_strategy (struct ctl_table *table,
-                               int __user *name, int nlen,
-                               void __user *oldval, size_t __user *oldlenp,
-                               void __user *newval, size_t newlen);
 extern ctl_handler sysctl_data;
 extern ctl_handler sysctl_string;
 extern ctl_handler sysctl_intvec;
@@ -1054,6 +1052,8 @@ struct ctl_table_root {
        struct list_head header_list;
        struct list_head *(*lookup)(struct ctl_table_root *root,
                                           struct nsproxy *namespaces);
+        int (*permissions)(struct ctl_table_root *root,
+                        struct nsproxy *namespaces, struct ctl_table *table);
 };
 /* struct ctl_table_header is used to maintain dynamic lists of
@@ -1085,8 +1085,6 @@ struct ctl_table_header *register_sysctl_paths(const struct ctl_path *path,
 void unregister_sysctl_table(struct ctl_table_header * table);
 int sysctl_check_table(struct nsproxy *namespaces, struct ctl_table *table);
-#else /* __KERNEL__ */
 #endif /* __KERNEL__ */
 #endif /* _LINUX_SYSCTL_H */
diff --git a/include/linux/sysv_fs.h b/include/linux/sysv_fs.h
index e0248631e461..96411306eec6 100644
--- a/include/linux/sysv_fs.h
+++ b/include/linux/sysv_fs.h
@@ -1,11 +1,7 @@
 #ifndef _LINUX_SYSV_FS_H
 #define _LINUX_SYSV_FS_H
-#if defined(__GNUC__)
+#define __packed2__     __attribute__((packed, aligned(2)))
-# define __packed2__    __attribute__((packed, aligned(2)))
-#else
->> I want to scream! <<
-#endif
 #ifndef __KERNEL__
diff --git a/include/linux/tty.h b/include/linux/tty.h
index dd8e08fe8855..265831ccaa88 100644
--- a/include/linux/tty.h
+++ b/include/linux/tty.h
@@ -300,7 +300,6 @@ extern void tty_hangup(struct tty_struct * tty);
 extern void tty_vhangup(struct tty_struct * tty);
 extern void tty_unhangup(struct file *filp);
 extern int tty_hung_up_p(struct file * filp);
-extern int is_tty(struct file *filp);
 extern void do_SAK(struct tty_struct *tty);
 extern void __do_SAK(struct tty_struct *tty);
 extern void disassociate_ctty(int priv);
@@ -351,8 +350,7 @@ extern void tty_audit_add_data(struct tty_struct *tty, unsigned char *data,
 extern void tty_audit_exit(void);
 extern void tty_audit_fork(struct signal_struct *sig);
 extern void tty_audit_push(struct tty_struct *tty);
-extern void tty_audit_push_task(struct task_struct *tsk, uid_t loginuid);
+extern void tty_audit_push_task(struct task_struct *tsk, uid_t loginuid, u32 sessionid);
-extern void tty_audit_opening(void);
 #else
 static inline void tty_audit_add_data(struct tty_struct *tty,
                                      unsigned char *data, size_t size)
@@ -367,10 +365,7 @@ static inline void tty_audit_fork(struct signal_struct *sig)
 static inline void tty_audit_push(struct tty_struct *tty)
 {
 }
-static inline void tty_audit_push_task(struct task_struct *tsk, uid_t loginuid)
+static inline void tty_audit_push_task(struct task_struct *tsk, uid_t loginuid, u32 sessionid)
-{
-}
-static inline void tty_audit_opening(void)
 {
 }
 #endif
diff --git a/include/linux/unaligned/access_ok.h b/include/linux/unaligned/access_ok.h
new file mode 100644
index 000000000000..99c1b4d20b0f
--- /dev/null
+++ b/include/linux/unaligned/access_ok.h
@@ -0,0 +1,67 @@
+#ifndef _LINUX_UNALIGNED_ACCESS_OK_H
+#define _LINUX_UNALIGNED_ACCESS_OK_H
+#include <linux/kernel.h>
+#include <asm/byteorder.h>
+static inline u16 get_unaligned_le16(const void *p)
+{
+        return le16_to_cpup((__le16 *)p);
+}
+static inline u32 get_unaligned_le32(const void *p)
+{
+        return le32_to_cpup((__le32 *)p);
+}
+static inline u64 get_unaligned_le64(const void *p)
+{
+        return le64_to_cpup((__le64 *)p);
+}
+static inline u16 get_unaligned_be16(const void *p)
+{
+        return be16_to_cpup((__be16 *)p);
+}
+static inline u32 get_unaligned_be32(const void *p)
+{
+        return be32_to_cpup((__be32 *)p);
+}
+static inline u64 get_unaligned_be64(const void *p)
+{
+        return be64_to_cpup((__be64 *)p);
+}
+static inline void put_unaligned_le16(u16 val, void *p)
+{
+        *((__le16 *)p) = cpu_to_le16(val);
+}
+static inline void put_unaligned_le32(u32 val, void *p)
+{
+        *((__le32 *)p) = cpu_to_le32(val);
+}
+static inline void put_unaligned_le64(u64 val, void *p)
+{
+        *((__le64 *)p) = cpu_to_le64(val);
+}
+static inline void put_unaligned_be16(u16 val, void *p)
+{
+        *((__be16 *)p) = cpu_to_be16(val);
+}
+static inline void put_unaligned_be32(u32 val, void *p)
+{
+        *((__be32 *)p) = cpu_to_be32(val);
+}
+static inline void put_unaligned_be64(u64 val, void *p)
+{
+        *((__be64 *)p) = cpu_to_be64(val);
+}
+#endif /* _LINUX_UNALIGNED_ACCESS_OK_H */
diff --git a/include/linux/unaligned/be_byteshift.h b/include/linux/unaligned/be_byteshift.h
new file mode 100644
index 000000000000..46dd12c5709e
--- /dev/null
+++ b/include/linux/unaligned/be_byteshift.h
@@ -0,0 +1,70 @@
+#ifndef _LINUX_UNALIGNED_BE_BYTESHIFT_H
+#define _LINUX_UNALIGNED_BE_BYTESHIFT_H
+#include <linux/kernel.h>
+static inline u16 __get_unaligned_be16(const u8 *p)
+{
+        return p[0] << 8 | p[1];
+}
+static inline u32 __get_unaligned_be32(const u8 *p)
+{
+        return p[0] << 24 | p[1] << 16 | p[2] << 8 | p[3];
+}
+static inline u64 __get_unaligned_be64(const u8 *p)
+{
+        return (u64)__get_unaligned_be32(p) << 32 |
+               __get_unaligned_be32(p + 4);
+}
+static inline void __put_unaligned_be16(u16 val, u8 *p)
+{
+        *p++ = val >> 8;
+        *p++ = val;
+}
+static inline void __put_unaligned_be32(u32 val, u8 *p)
+{
+        __put_unaligned_be16(val >> 16, p);
+        __put_unaligned_be16(val, p + 2);
+}
+static inline void __put_unaligned_be64(u64 val, u8 *p)
+{
+        __put_unaligned_be32(val >> 32, p);
+        __put_unaligned_be32(val, p + 4);
+}
+static inline u16 get_unaligned_be16(const void *p)
+{
+        return __get_unaligned_be16((const u8 *)p);
+}
+static inline u32 get_unaligned_be32(const void *p)
+{
+        return __get_unaligned_be32((const u8 *)p);
+}
+static inline u64 get_unaligned_be64(const void *p)
+{
+        return __get_unaligned_be64((const u8 *)p);
+}
+static inline void put_unaligned_be16(u16 val, void *p)
+{
+        __put_unaligned_be16(val, p);
+}
+static inline void put_unaligned_be32(u32 val, void *p)
+{
+        __put_unaligned_be32(val, p);
+}
+static inline void put_unaligned_be64(u64 val, void *p)
+{
+        __put_unaligned_be64(val, p);
+}
+#endif /* _LINUX_UNALIGNED_BE_BYTESHIFT_H */
diff --git a/include/linux/unaligned/be_memmove.h b/include/linux/unaligned/be_memmove.h
new file mode 100644
index 000000000000..c2a76c5c9ed0
--- /dev/null
+++ b/include/linux/unaligned/be_memmove.h
@@ -0,0 +1,36 @@
+#ifndef _LINUX_UNALIGNED_BE_MEMMOVE_H
+#define _LINUX_UNALIGNED_BE_MEMMOVE_H
+#include <linux/unaligned/memmove.h>
+static inline u16 get_unaligned_be16(const void *p)
+{
+        return __get_unaligned_memmove16((const u8 *)p);
+}
+static inline u32 get_unaligned_be32(const void *p)
+{
+        return __get_unaligned_memmove32((const u8 *)p);
+}
+static inline u64 get_unaligned_be64(const void *p)
+{
+        return __get_unaligned_memmove64((const u8 *)p);
+}
+static inline void put_unaligned_be16(u16 val, void *p)
+{
+        __put_unaligned_memmove16(val, p);
+}
+static inline void put_unaligned_be32(u32 val, void *p)
+{
+        __put_unaligned_memmove32(val, p);
+}
+static inline void put_unaligned_be64(u64 val, void *p)
+{
+        __put_unaligned_memmove64(val, p);
+}
+#endif /* _LINUX_UNALIGNED_LE_MEMMOVE_H */
diff --git a/include/linux/unaligned/be_struct.h b/include/linux/unaligned/be_struct.h
new file mode 100644
index 000000000000..132415836c50
--- /dev/null
+++ b/include/linux/unaligned/be_struct.h
@@ -0,0 +1,36 @@
+#ifndef _LINUX_UNALIGNED_BE_STRUCT_H
+#define _LINUX_UNALIGNED_BE_STRUCT_H
+#include <linux/unaligned/packed_struct.h>
+static inline u16 get_unaligned_be16(const void *p)
+{
+        return __get_unaligned_cpu16((const u8 *)p);
+}
+static inline u32 get_unaligned_be32(const void *p)
+{
+        return __get_unaligned_cpu32((const u8 *)p);
+}
+static inline u64 get_unaligned_be64(const void *p)
+{
+        return __get_unaligned_cpu64((const u8 *)p);
+}
+static inline void put_unaligned_be16(u16 val, void *p)
+{
+        __put_unaligned_cpu16(val, p);
+}
+static inline void put_unaligned_be32(u32 val, void *p)
+{
+        __put_unaligned_cpu32(val, p);
+}
+static inline void put_unaligned_be64(u64 val, void *p)
+{
+        __put_unaligned_cpu64(val, p);
+}
+#endif /* _LINUX_UNALIGNED_BE_STRUCT_H */
diff --git a/include/linux/unaligned/generic.h b/include/linux/unaligned/generic.h
new file mode 100644
index 000000000000..02d97ff3df70
--- /dev/null
+++ b/include/linux/unaligned/generic.h
@@ -0,0 +1,68 @@
+#ifndef _LINUX_UNALIGNED_GENERIC_H
+#define _LINUX_UNALIGNED_GENERIC_H
+/*
+ * Cause a link-time error if we try an unaligned access other than
+ * 1,2,4 or 8 bytes long
+ */
+extern void __bad_unaligned_access_size(void);
+#define __get_unaligned_le(ptr) ((__force typeof(*(ptr)))({                     \
+        __builtin_choose_expr(sizeof(*(ptr)) == 1, *(ptr),                      \
+        __builtin_choose_expr(sizeof(*(ptr)) == 2, get_unaligned_le16((ptr)),   \
+        __builtin_choose_expr(sizeof(*(ptr)) == 4, get_unaligned_le32((ptr)),   \
+        __builtin_choose_expr(sizeof(*(ptr)) == 8, get_unaligned_le64((ptr)),   \
+        __bad_unaligned_access_size()))));                                      \
+        }))
+#define __get_unaligned_be(ptr) ((__force typeof(*(ptr)))({                     \
+        __builtin_choose_expr(sizeof(*(ptr)) == 1, *(ptr),                      \
+        __builtin_choose_expr(sizeof(*(ptr)) == 2, get_unaligned_be16((ptr)),   \
+        __builtin_choose_expr(sizeof(*(ptr)) == 4, get_unaligned_be32((ptr)),   \
+        __builtin_choose_expr(sizeof(*(ptr)) == 8, get_unaligned_be64((ptr)),   \
+        __bad_unaligned_access_size()))));                                      \
+        }))
+#define __put_unaligned_le(val, ptr) ({                                 \
+        void *__gu_p = (ptr);                                           \
+        switch (sizeof(*(ptr))) {                                       \
+        case 1:                                                         \
+                *(u8 *)__gu_p = (__force u8)(val);                      \
+                break;                                                  \
+        case 2:                                                         \
+                put_unaligned_le16((__force u16)(val), __gu_p);         \
+                break;                                                  \
+        case 4:                                                         \
+                put_unaligned_le32((__force u32)(val), __gu_p);         \
+                break;                                                  \
+        case 8:                                                         \
+                put_unaligned_le64((__force u64)(val), __gu_p);         \
+                break;                                                  \
+        default:                                                        \
+                __bad_unaligned_access_size();                          \
+                break;                                                  \
+        }                                                               \
+        (void)0; })
+#define __put_unaligned_be(val, ptr) ({                                 \
+        void *__gu_p = (ptr);                                           \
+        switch (sizeof(*(ptr))) {                                       \
+        case 1:                                                         \
+                *(u8 *)__gu_p = (__force u8)(val);                      \
+                break;                                                  \
+        case 2:                                                         \
+                put_unaligned_be16((__force u16)(val), __gu_p);         \
+                break;                                                  \
+        case 4:                                                         \
+                put_unaligned_be32((__force u32)(val), __gu_p);         \
+                break;                                                  \
+        case 8:                                                         \
+                put_unaligned_be64((__force u64)(val), __gu_p);         \
+                break;                                                  \
+        default:                                                        \
+                __bad_unaligned_access_size();                          \
+                break;                                                  \
+        }                                                               \
+        (void)0; })
+#endif /* _LINUX_UNALIGNED_GENERIC_H */
diff --git a/include/linux/unaligned/le_byteshift.h b/include/linux/unaligned/le_byteshift.h
new file mode 100644
index 000000000000..59777e951baf
--- /dev/null
+++ b/include/linux/unaligned/le_byteshift.h
@@ -0,0 +1,70 @@
+#ifndef _LINUX_UNALIGNED_LE_BYTESHIFT_H
+#define _LINUX_UNALIGNED_LE_BYTESHIFT_H
+#include <linux/kernel.h>
+static inline u16 __get_unaligned_le16(const u8 *p)
+{
+        return p[0] | p[1] << 8;
+}
+static inline u32 __get_unaligned_le32(const u8 *p)
+{
+        return p[0] | p[1] << 8 | p[2] << 16 | p[3] << 24;
+}
+static inline u64 __get_unaligned_le64(const u8 *p)
+{
+        return (u64)__get_unaligned_le32(p + 4) << 32 |
+               __get_unaligned_le32(p);
+}
+static inline void __put_unaligned_le16(u16 val, u8 *p)
+{
+        *p++ = val;
+        *p++ = val >> 8;
+}
+static inline void __put_unaligned_le32(u32 val, u8 *p)
+{
+        __put_unaligned_le16(val >> 16, p + 2);
+        __put_unaligned_le16(val, p);
+}
+static inline void __put_unaligned_le64(u64 val, u8 *p)
+{
+        __put_unaligned_le32(val >> 32, p + 4);
+        __put_unaligned_le32(val, p);
+}
+static inline u16 get_unaligned_le16(const void *p)
+{
+        return __get_unaligned_le16((const u8 *)p);
+}
+static inline u32 get_unaligned_le32(const void *p)
+{
+        return __get_unaligned_le32((const u8 *)p);
+}
+static inline u64 get_unaligned_le64(const void *p)
+{
+        return __get_unaligned_le64((const u8 *)p);
+}
+static inline void put_unaligned_le16(u16 val, void *p)
+{
+        __put_unaligned_le16(val, p);
+}
+static inline void put_unaligned_le32(u32 val, void *p)
+{
+        __put_unaligned_le32(val, p);
+}
+static inline void put_unaligned_le64(u64 val, void *p)
+{
+        __put_unaligned_le64(val, p);
+}
+#endif /* _LINUX_UNALIGNED_LE_BYTESHIFT_H */
diff --git a/include/linux/unaligned/le_memmove.h b/include/linux/unaligned/le_memmove.h
new file mode 100644
index 000000000000..269849bee4ec
--- /dev/null
+++ b/include/linux/unaligned/le_memmove.h
@@ -0,0 +1,36 @@
+#ifndef _LINUX_UNALIGNED_LE_MEMMOVE_H
+#define _LINUX_UNALIGNED_LE_MEMMOVE_H
+#include <linux/unaligned/memmove.h>
+static inline u16 get_unaligned_le16(const void *p)
+{
+        return __get_unaligned_memmove16((const u8 *)p);
+}
+static inline u32 get_unaligned_le32(const void *p)
+{
+        return __get_unaligned_memmove32((const u8 *)p);
+}
+static inline u64 get_unaligned_le64(const void *p)
+{
+        return __get_unaligned_memmove64((const u8 *)p);
+}
+static inline void put_unaligned_le16(u16 val, void *p)
+{
+        __put_unaligned_memmove16(val, p);
+}
+static inline void put_unaligned_le32(u32 val, void *p)
+{
+        __put_unaligned_memmove32(val, p);
+}
+static inline void put_unaligned_le64(u64 val, void *p)
+{
+        __put_unaligned_memmove64(val, p);
+}
+#endif /* _LINUX_UNALIGNED_LE_MEMMOVE_H */
diff --git a/include/linux/unaligned/le_struct.h b/include/linux/unaligned/le_struct.h
new file mode 100644
index 000000000000..088c4572faa8
--- /dev/null
+++ b/include/linux/unaligned/le_struct.h
@@ -0,0 +1,36 @@
+#ifndef _LINUX_UNALIGNED_LE_STRUCT_H
+#define _LINUX_UNALIGNED_LE_STRUCT_H
+#include <linux/unaligned/packed_struct.h>
+static inline u16 get_unaligned_le16(const void *p)
+{
+        return __get_unaligned_cpu16((const u8 *)p);
+}
+static inline u32 get_unaligned_le32(const void *p)
+{
+        return __get_unaligned_cpu32((const u8 *)p);
+}
+static inline u64 get_unaligned_le64(const void *p)
+{
+        return __get_unaligned_cpu64((const u8 *)p);
+}
+static inline void put_unaligned_le16(u16 val, void *p)
+{
+        __put_unaligned_cpu16(val, p);
+}
+static inline void put_unaligned_le32(u32 val, void *p)
+{
+        __put_unaligned_cpu32(val, p);
+}
+static inline void put_unaligned_le64(u64 val, void *p)
+{
+        __put_unaligned_cpu64(val, p);
+}
+#endif /* _LINUX_UNALIGNED_LE_STRUCT_H */
diff --git a/include/linux/unaligned/memmove.h b/include/linux/unaligned/memmove.h
new file mode 100644
index 000000000000..eeb5a779a4fd
--- /dev/null
+++ b/include/linux/unaligned/memmove.h
@@ -0,0 +1,45 @@
+#ifndef _LINUX_UNALIGNED_MEMMOVE_H
+#define _LINUX_UNALIGNED_MEMMOVE_H
+#include <linux/kernel.h>
+#include <linux/string.h>
+/* Use memmove here, so gcc does not insert a __builtin_memcpy. */
+static inline u16 __get_unaligned_memmove16(const void *p)
+{
+        u16 tmp;
+        memmove(&tmp, p, 2);
+        return tmp;
+}
+static inline u32 __get_unaligned_memmove32(const void *p)
+{
+        u32 tmp;
+        memmove(&tmp, p, 4);
+        return tmp;
+}
+static inline u64 __get_unaligned_memmove64(const void *p)
+{
+        u64 tmp;
+        memmove(&tmp, p, 8);
+        return tmp;
+}
+static inline void __put_unaligned_memmove16(u16 val, void *p)
+{
+        memmove(p, &val, 2);
+}
+static inline void __put_unaligned_memmove32(u32 val, void *p)
+{
+        memmove(p, &val, 4);
+}
+static inline void __put_unaligned_memmove64(u64 val, void *p)
+{
+        memmove(p, &val, 8);
+}
+#endif /* _LINUX_UNALIGNED_MEMMOVE_H */
diff --git a/include/linux/unaligned/packed_struct.h b/include/linux/unaligned/packed_struct.h
new file mode 100644
index 000000000000..2498bb9fe002
--- /dev/null
+++ b/include/linux/unaligned/packed_struct.h
@@ -0,0 +1,46 @@
+#ifndef _LINUX_UNALIGNED_PACKED_STRUCT_H
+#define _LINUX_UNALIGNED_PACKED_STRUCT_H
+#include <linux/kernel.h>
+struct __una_u16 { u16 x __attribute__((packed)); };
+struct __una_u32 { u32 x __attribute__((packed)); };
+struct __una_u64 { u64 x __attribute__((packed)); };
+static inline u16 __get_unaligned_cpu16(const void *p)
+{
+        const struct __una_u16 *ptr = (const struct __una_u16 *)p;
+        return ptr->x;
+}
+static inline u32 __get_unaligned_cpu32(const void *p)
+{
+        const struct __una_u32 *ptr = (const struct __una_u32 *)p;
+        return ptr->x;
+}
+static inline u64 __get_unaligned_cpu64(const void *p)
+{
+        const struct __una_u64 *ptr = (const struct __una_u64 *)p;
+        return ptr->x;
+}
+static inline void __put_unaligned_cpu16(u16 val, void *p)
+{
+        struct __una_u16 *ptr = (struct __una_u16 *)p;
+        ptr->x = val;
+}
+static inline void __put_unaligned_cpu32(u32 val, void *p)
+{
+        struct __una_u32 *ptr = (struct __una_u32 *)p;
+        ptr->x = val;
+}
+static inline void __put_unaligned_cpu64(u64 val, void *p)
+{
+        struct __una_u64 *ptr = (struct __una_u64 *)p;
+        ptr->x = val;
+}
+#endif /* _LINUX_UNALIGNED_PACKED_STRUCT_H */
diff --git a/include/linux/vmalloc.h b/include/linux/vmalloc.h
index ce8e7da05807..364789aae9f3 100644
--- a/include/linux/vmalloc.h
+++ b/include/linux/vmalloc.h
@@ -31,6 +31,7 @@ struct vm_struct {
        struct page             **pages;
        unsigned int            nr_pages;
        unsigned long           phys_addr;
+        void                    *caller;
 };
 /*
@@ -66,6 +67,8 @@ static inline size_t get_vm_area_size(const struct vm_struct *area)
 }
 extern struct vm_struct *get_vm_area(unsigned long size, unsigned long flags);
+extern struct vm_struct *get_vm_area_caller(unsigned long size,
+                                        unsigned long flags, void *caller);
 extern struct vm_struct *__get_vm_area(unsigned long size, unsigned long flags,
                                        unsigned long start, unsigned long end);
 extern struct vm_struct *get_vm_area_node(unsigned long size,
@@ -87,4 +90,6 @@ extern void free_vm_area(struct vm_struct *area);
 extern rwlock_t vmlist_lock;
 extern struct vm_struct *vmlist;
+extern const struct seq_operations vmalloc_op;
 #endif /* _LINUX_VMALLOC_H */
diff --git a/include/linux/vmstat.h b/include/linux/vmstat.h
index 9f1b4b46151e..e83b69346d23 100644
--- a/include/linux/vmstat.h
+++ b/include/linux/vmstat.h
@@ -25,6 +25,7 @@
 #define HIGHMEM_ZONE(xx)
 #endif
 #define FOR_ALL_ZONES(xx) DMA_ZONE(xx) DMA32_ZONE(xx) xx##_NORMAL HIGHMEM_ZONE(xx) , xx##_MOVABLE
 enum vm_event_item { PGPGIN, PGPGOUT, PSWPIN, PSWPOUT,
@@ -37,6 +38,9 @@ enum vm_event_item { PGPGIN, PGPGOUT, PSWPIN, PSWPOUT,
                FOR_ALL_ZONES(PGSCAN_DIRECT),
                PGINODESTEAL, SLABS_SCANNED, KSWAPD_STEAL, KSWAPD_INODESTEAL,
                PAGEOUTRUN, ALLOCSTALL, PGROTATED,
+#ifdef CONFIG_HUGETLB_PAGE
+                HTLB_BUDDY_PGALLOC, HTLB_BUDDY_PGALLOC_FAIL,
+#endif
                NR_VM_EVENT_ITEMS
 };
@@ -174,7 +178,7 @@ static inline unsigned long node_page_state(int node,
                zone_page_state(&zones[ZONE_MOVABLE], item);
 }
-extern void zone_statistics(struct zonelist *, struct zone *);
+extern void zone_statistics(struct zone *, struct zone *);
 #else
diff --git a/include/linux/xattr.h b/include/linux/xattr.h
index df6b95d2218e..d131e352cfe1 100644
--- a/include/linux/xattr.h
+++ b/include/linux/xattr.h
@@ -47,10 +47,10 @@ struct xattr_handler {
 };
 ssize_t xattr_getsecurity(struct inode *, const char *, void *, size_t);
-ssize_t vfs_getxattr(struct dentry *, char *, void *, size_t);
+ssize_t vfs_getxattr(struct dentry *, const char *, void *, size_t);
 ssize_t vfs_listxattr(struct dentry *d, char *list, size_t size);
-int vfs_setxattr(struct dentry *, char *, void *, size_t, int);
+int vfs_setxattr(struct dentry *, const char *, const void *, size_t, int);
-int vfs_removexattr(struct dentry *, char *);
+int vfs_removexattr(struct dentry *, const char *);
 ssize_t generic_getxattr(struct dentry *dentry, const char *name, void *buffer, size_t size);
 ssize_t generic_listxattr(struct dentry *dentry, char *buffer, size_t buffer_size);