209 files changed, 3568 insertions, 4247 deletions

diff --git a/include/linux/Kbuild b/include/linux/Kbuild
index bda6f04791d4..b7d81b2a9041 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
@@ -347,6 +346,11 @@ unifdef-y += videodev.h
 unifdef-y += virtio_config.h
 unifdef-y += virtio_blk.h
 unifdef-y += virtio_net.h
+unifdef-y += virtio_9p.h
+unifdef-y += virtio_balloon.h
+unifdef-y += virtio_console.h
+unifdef-y += virtio_pci.h
+unifdef-y += virtio_ring.h
 unifdef-y += vt.h
 unifdef-y += wait.h
 unifdef-y += wanrouter.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/agp_backend.h b/include/linux/agp_backend.h
index 03e34547d489..661d90d6cf7c 100644
--- a/include/linux/agp_backend.h
+++ b/include/linux/agp_backend.h
@@ -30,8 +30,6 @@
 #ifndef _AGP_BACKEND_H
 #define _AGP_BACKEND_H 1
 
-#ifdef __KERNEL__
-
 #ifndef TRUE
 #define TRUE 1
 #endif
@@ -111,5 +109,4 @@ extern struct agp_bridge_data *agp_backend_acquire(struct pci_dev *);
 extern void agp_backend_release(struct agp_bridge_data *);
 extern void agp_flush_chipset(struct agp_bridge_data *);
 
-#endif                          /* __KERNEL__ */
 #endif                          /* _AGP_BACKEND_H */
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/anon_inodes.h b/include/linux/anon_inodes.h
index b2e1ba325b9a..6129e58ca7c9 100644
--- a/include/linux/anon_inodes.h
+++ b/include/linux/anon_inodes.h
@@ -8,8 +8,7 @@
 #ifndef _LINUX_ANON_INODES_H
 #define _LINUX_ANON_INODES_H
 
-int anon_inode_getfd(int *pfd, struct inode **pinode, struct file **pfile,
-                     const char *name, const struct file_operations *fops,
+int anon_inode_getfd(const char *name, const struct file_operations *fops,
                      void *priv);
 
 #endif /* _LINUX_ANON_INODES_H */
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_untrustedstring(a,s) do { ; } while (0)
+#define audit_log_n_hex(a,b,l) 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..0a24d5550eb3 100644
--- a/include/linux/backing-dev.h
+++ b/include/linux/backing-dev.h
@@ -11,9 +11,13 @@
 #include <linux/percpu_counter.h>
 #include <linux/log2.h>
 #include <linux/proportions.h>
+#include <linux/kernel.h>
+#include <linux/fs.h>
 #include <asm/atomic.h>
 
 struct page;
+struct device;
+struct dentry;
 
 /*
  * Bits in backing_dev_info.state
@@ -48,11 +52,26 @@ struct backing_dev_info {
 
         struct prop_local_percpu completions;
         int dirty_exceeded;
+
+        unsigned int min_ratio;
+        unsigned int max_ratio, max_prop_frac;
+
+        struct device *dev;
+
+#ifdef CONFIG_DEBUG_FS
+        struct dentry *debug_dir;
+        struct dentry *debug_stats;
+#endif
 };
 
 int bdi_init(struct backing_dev_info *bdi);
 void bdi_destroy(struct backing_dev_info *bdi);
 
+int bdi_register(struct backing_dev_info *bdi, struct device *parent,
+                const char *fmt, ...);
+int bdi_register_dev(struct backing_dev_info *bdi, dev_t dev);
+void bdi_unregister(struct backing_dev_info *bdi);
+
 static inline void __add_bdi_stat(struct backing_dev_info *bdi,
                 enum bdi_stat_item item, s64 amount)
 {
@@ -116,6 +135,8 @@ static inline s64 bdi_stat_sum(struct backing_dev_info *bdi,
         return sum;
 }
 
+extern void bdi_writeout_inc(struct backing_dev_info *bdi);
+
 /*
  * maximal error of a stat counter.
  */
@@ -128,24 +149,48 @@ static inline unsigned long bdi_stat_error(struct backing_dev_info *bdi)
 #endif
 }
 
+int bdi_set_min_ratio(struct backing_dev_info *bdi, unsigned int min_ratio);
+int bdi_set_max_ratio(struct backing_dev_info *bdi, unsigned int max_ratio);
+
 /*
  * Flags in backing_dev_info::capability
- * - The first two flags control whether dirty pages will contribute to the
- *   VM's accounting and whether writepages() should be called for dirty pages
- *   (something that would not, for example, be appropriate for ramfs)
- * - These flags let !MMU mmap() govern direct device mapping vs immediate
- *   copying more easily for MAP_PRIVATE, especially for ROM filesystems
+ *
+ * The first three flags control whether dirty pages will contribute to the
+ * VM's accounting and whether writepages() should be called for dirty pages
+ * (something that would not, for example, be appropriate for ramfs)
+ *
+ * WARNING: these flags are closely related and should not normally be
+ * used separately.  The BDI_CAP_NO_ACCT_AND_WRITEBACK combines these
+ * three flags into a single convenience macro.
+ *
+ * BDI_CAP_NO_ACCT_DIRTY:  Dirty pages shouldn't contribute to accounting
+ * BDI_CAP_NO_WRITEBACK:   Don't write pages back
+ * BDI_CAP_NO_ACCT_WB:     Don't automatically account writeback pages
+ *
+ * These flags let !MMU mmap() govern direct device mapping vs immediate
+ * copying more easily for MAP_PRIVATE, especially for ROM filesystems.
+ *
+ * BDI_CAP_MAP_COPY:       Copy can be mapped (MAP_PRIVATE)
+ * BDI_CAP_MAP_DIRECT:     Can be mapped directly (MAP_SHARED)
+ * BDI_CAP_READ_MAP:       Can be mapped for reading
+ * BDI_CAP_WRITE_MAP:      Can be mapped for writing
+ * BDI_CAP_EXEC_MAP:       Can be mapped for execution
  */
-#define BDI_CAP_NO_ACCT_DIRTY   0x00000001      /* Dirty pages shouldn't contribute to accounting */
-#define BDI_CAP_NO_WRITEBACK    0x00000002      /* Don't write pages back */
-#define BDI_CAP_MAP_COPY        0x00000004      /* Copy can be mapped (MAP_PRIVATE) */
-#define BDI_CAP_MAP_DIRECT      0x00000008      /* Can be mapped directly (MAP_SHARED) */
-#define BDI_CAP_READ_MAP        0x00000010      /* Can be mapped for reading */
-#define BDI_CAP_WRITE_MAP       0x00000020      /* Can be mapped for writing */
-#define BDI_CAP_EXEC_MAP        0x00000040      /* Can be mapped for execution */
+#define BDI_CAP_NO_ACCT_DIRTY   0x00000001
+#define BDI_CAP_NO_WRITEBACK    0x00000002
+#define BDI_CAP_MAP_COPY        0x00000004
+#define BDI_CAP_MAP_DIRECT      0x00000008
+#define BDI_CAP_READ_MAP        0x00000010
+#define BDI_CAP_WRITE_MAP       0x00000020
+#define BDI_CAP_EXEC_MAP        0x00000040
+#define BDI_CAP_NO_ACCT_WB      0x00000080
+
 #define BDI_CAP_VMFLAGS \
         (BDI_CAP_READ_MAP | BDI_CAP_WRITE_MAP | BDI_CAP_EXEC_MAP)
 
+#define BDI_CAP_NO_ACCT_AND_WRITEBACK \
+        (BDI_CAP_NO_WRITEBACK | BDI_CAP_NO_ACCT_DIRTY | BDI_CAP_NO_ACCT_WB)
+
 #if defined(VM_MAYREAD) && \
         (BDI_CAP_READ_MAP != VM_MAYREAD || \
          BDI_CAP_WRITE_MAP != VM_MAYWRITE || \
@@ -156,9 +201,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)
 {
@@ -187,17 +230,32 @@ void clear_bdi_congested(struct backing_dev_info *bdi, int rw);
 void set_bdi_congested(struct backing_dev_info *bdi, int rw);
 long congestion_wait(int rw, long timeout);
 
-#define bdi_cap_writeback_dirty(bdi) \
-        (!((bdi)->capabilities & BDI_CAP_NO_WRITEBACK))
 
-#define bdi_cap_account_dirty(bdi) \
-        (!((bdi)->capabilities & BDI_CAP_NO_ACCT_DIRTY))
+static inline bool bdi_cap_writeback_dirty(struct backing_dev_info *bdi)
+{
+        return !(bdi->capabilities & BDI_CAP_NO_WRITEBACK);
+}
+
+static inline bool bdi_cap_account_dirty(struct backing_dev_info *bdi)
+{
+        return !(bdi->capabilities & BDI_CAP_NO_ACCT_DIRTY);
+}
 
-#define mapping_cap_writeback_dirty(mapping) \
-        bdi_cap_writeback_dirty((mapping)->backing_dev_info)
+static inline bool bdi_cap_account_writeback(struct backing_dev_info *bdi)
+{
+        /* Paranoia: BDI_CAP_NO_WRITEBACK implies BDI_CAP_NO_ACCT_WB */
+        return !(bdi->capabilities & (BDI_CAP_NO_ACCT_WB |
+                                      BDI_CAP_NO_WRITEBACK));
+}
 
-#define mapping_cap_account_dirty(mapping) \
-        bdi_cap_account_dirty((mapping)->backing_dev_info)
+static inline bool mapping_cap_writeback_dirty(struct address_space *mapping)
+{
+        return bdi_cap_writeback_dirty(mapping->backing_dev_info);
+}
 
+static inline bool mapping_cap_account_dirty(struct address_space *mapping)
+{
+        return bdi_cap_account_dirty(mapping->backing_dev_info);
+}
 
 #endif          /* _LINUX_BACKING_DEV_H */
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
-find_first_bit(const unsigned long *addr, 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);
+extern unsigned long find_first_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
-find_first_zero_bit(const unsigned long *addr, 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);
-}
+extern unsigned long find_first_zero_bit(const unsigned long *addr,
+                                         unsigned long 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
-find_next_bit(const unsigned long *addr, 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_bit(addr, size, offset);
-}
-
-extern unsigned long __find_next_zero_bit(const unsigned long *addr,
-                unsigned long size, unsigned long offset);
+extern unsigned long find_next_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,
-                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);
-}
+
+extern unsigned long find_next_zero_bit(const unsigned long *addr,
+                                        unsigned long size,
+                                        unsigned long 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 char cmd[BLK_MAX_CDB];
+        unsigned short cmd_len;
+        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/byteorder/Kbuild b/include/linux/byteorder/Kbuild
index 79bedddfd9ca..1133d5f9d818 100644
--- a/include/linux/byteorder/Kbuild
+++ b/include/linux/byteorder/Kbuild
@@ -1,5 +1,3 @@
-header-y += big_endian.h
-header-y += little_endian.h
-
-unifdef-y += generic.h
+unifdef-y += big_endian.h
+unifdef-y += little_endian.h
 unifdef-y += swab.h
diff --git a/include/linux/byteorder/big_endian.h b/include/linux/byteorder/big_endian.h
index bef87891cb24..961ed4b48d8e 100644
--- a/include/linux/byteorder/big_endian.h
+++ b/include/linux/byteorder/big_endian.h
@@ -101,6 +101,8 @@ static inline __u16 __be16_to_cpup(const __be16 *p)
 #define __cpu_to_be16s(x) do {} while (0)
 #define __be16_to_cpus(x) do {} while (0)
 
+#ifdef __KERNEL__
 #include <linux/byteorder/generic.h>
+#endif
 
 #endif /* _LINUX_BYTEORDER_BIG_ENDIAN_H */
diff --git a/include/linux/byteorder/generic.h b/include/linux/byteorder/generic.h
index d3771551fdd9..0846e6b931ce 100644
--- a/include/linux/byteorder/generic.h
+++ b/include/linux/byteorder/generic.h
@@ -82,12 +82,6 @@
  *
  */
 
-
-#if defined(__KERNEL__)
-/*
- * inside the kernel, we can use nicknames;
- * outside of it, we must avoid POSIX namespace pollution...
- */
 #define cpu_to_le64 __cpu_to_le64
 #define le64_to_cpu __le64_to_cpu
 #define cpu_to_le32 __cpu_to_le32
@@ -176,6 +170,4 @@ static inline void be64_add_cpu(__be64 *var, u64 val)
         *var = cpu_to_be64(be64_to_cpu(*var) + val);
 }
 
-#endif /* KERNEL */
-
 #endif /* _LINUX_BYTEORDER_GENERIC_H */
diff --git a/include/linux/byteorder/little_endian.h b/include/linux/byteorder/little_endian.h
index 86e62b750176..05dc7c35b3b2 100644
--- a/include/linux/byteorder/little_endian.h
+++ b/include/linux/byteorder/little_endian.h
@@ -101,6 +101,8 @@ static inline __u16 __be16_to_cpup(const __be16 *p)
 #define __cpu_to_be16s(x) __swab16s((x))
 #define __be16_to_cpus(x) __swab16s((x))
 
+#ifdef __KERNEL__
 #include <linux/byteorder/generic.h>
+#endif
 
 #endif /* _LINUX_BYTEORDER_LITTLE_ENDIAN_H */
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/calc64.h b/include/linux/calc64.h
deleted file mode 100644
index ebf4b8f38d88..000000000000
--- a/include/linux/calc64.h
+++ /dev/null
@@ -1,49 +0,0 @@
-#ifndef _LINUX_CALC64_H
-#define _LINUX_CALC64_H
-
-#include <linux/types.h>
-#include <asm/div64.h>
-
-/*
- * This is a generic macro which is used when the architecture
- * specific div64.h does not provide a optimized one.
- *
- * The 64bit dividend is divided by the divisor (data type long), the
- * result is returned and the remainder stored in the variable
- * referenced by remainder (data type long *). In contrast to the
- * do_div macro the dividend is kept intact.
- */
-#ifndef div_long_long_rem
-#define div_long_long_rem(dividend, divisor, remainder) \
-        do_div_llr((dividend), divisor, remainder)
-
-static inline unsigned long do_div_llr(const long long dividend,
-                                       const long divisor, long *remainder)
-{
-        u64 result = dividend;
-
-        *(remainder) = do_div(result, divisor);
-        return (unsigned long) result;
-}
-#endif
-
-/*
- * Sign aware variation of the above. On some architectures a
- * negative dividend leads to an divide overflow exception, which
- * is avoided by the sign check.
- */
-static inline long div_long_long_rem_signed(const long long dividend,
-                                            const long divisor, long *remainder)
-{
-        long res;
-
-        if (unlikely(dividend < 0)) {
-                res = -div_long_long_rem(-dividend, divisor, remainder);
-                *remainder = -(*remainder);
-        } else
-                res = div_long_long_rem(dividend, divisor, remainder);
-
-        return res;
-}
-
-#endif
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_FULL_SET     {{ ~0, ~0 }}
-# define CAP_INIT_EFF_SET {{ ~CAP_TO_MASK(CAP_SETPCAP), ~0 }}
-# define CAP_FS_SET       {{ CAP_FS_MASK_B0, CAP_FS_MASK_B1 } }
-# define CAP_NFSD_SET     {{ CAP_FS_MASK_B0|CAP_TO_MASK(CAP_SYS_RESOURCE), \
-                             CAP_FS_MASK_B1 } }
+# define CAP_EMPTY_SET    ((kernel_cap_t){{ 0, 0 }})
+# define CAP_FULL_SET     ((kernel_cap_t){{ ~0, ~0 }})
+# define CAP_INIT_EFF_SET ((kernel_cap_t){{ ~CAP_TO_MASK(CAP_SETPCAP), ~0 }})
+# define CAP_FS_SET       ((kernel_cap_t){{ CAP_FS_MASK_B0, CAP_FS_MASK_B1 } })
+# define CAP_NFSD_SET     ((kernel_cap_t){{ CAP_FS_MASK_B0|CAP_TO_MASK(CAP_SYS_RESOURCE), \
+                                        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/cdev.h b/include/linux/cdev.h
index 1e29b13d0062..fb4591977b03 100644
--- a/include/linux/cdev.h
+++ b/include/linux/cdev.h
@@ -1,6 +1,5 @@
 #ifndef _LINUX_CDEV_H
 #define _LINUX_CDEV_H
-#ifdef __KERNEL__
 
 #include <linux/kobject.h>
 #include <linux/kdev_t.h>
@@ -34,4 +33,3 @@ void cd_forget(struct inode *);
 extern struct backing_dev_info directly_mappable_cdev_bdi;
 
 #endif
-#endif
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
-         * css_set_lock
+         * List running through all cgroup groups in the same hash
+         * 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/clocksource.h b/include/linux/clocksource.h
index 35094479ca55..55e434feec99 100644
--- a/include/linux/clocksource.h
+++ b/include/linux/clocksource.h
@@ -93,6 +93,8 @@ struct clocksource {
 #endif
 };
 
+extern struct clocksource *clock;       /* current clocksource */
+
 /*
  * Clock source flags bits::
  */
diff --git a/include/linux/coda_fs_i.h b/include/linux/coda_fs_i.h
index 424fe9cf02c4..b3ef0c461578 100644
--- a/include/linux/coda_fs_i.h
+++ b/include/linux/coda_fs_i.h
@@ -8,7 +8,6 @@
 #ifndef _LINUX_CODA_FS_I
 #define _LINUX_CODA_FS_I
 
-#ifdef __KERNEL__
 #include <linux/types.h>
 #include <linux/list.h>
 #include <linux/coda.h>
@@ -52,4 +51,3 @@ struct inode *coda_fid_to_inode(struct CodaFid *fid, struct super_block *sb);
 void coda_replace_fid(struct inode *, struct CodaFid *, struct CodaFid *);
 
 #endif
-#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/compat.h b/include/linux/compat.h
index 8fa7857e153b..cf8d11cad5ae 100644
--- a/include/linux/compat.h
+++ b/include/linux/compat.h
@@ -65,10 +65,11 @@ struct compat_timex {
         compat_long_t calcnt;
         compat_long_t errcnt;
         compat_long_t stbcnt;
+        compat_int_t tai;
 
         compat_int_t :32; compat_int_t :32; compat_int_t :32; compat_int_t :32;
         compat_int_t :32; compat_int_t :32; compat_int_t :32; compat_int_t :32;
-        compat_int_t :32; compat_int_t :32; compat_int_t :32; compat_int_t :32;
+        compat_int_t :32; compat_int_t :32; compat_int_t :32;
 };
 
 #define _COMPAT_NSIG_WORDS      (_COMPAT_NSIG / _COMPAT_NSIG_BPW)
diff --git a/include/linux/compiler-gcc.h b/include/linux/compiler-gcc.h
index b2fd7547b58d..5c8351b859f0 100644
--- a/include/linux/compiler-gcc.h
+++ b/include/linux/compiler-gcc.h
@@ -29,10 +29,11 @@
   BUILD_BUG_ON_ZERO(__builtin_types_compatible_p(typeof(a), typeof(&a[0])))
 
 /*
- * Force always-inline if the user requests it so via the .config:
+ * Force always-inline if the user requests it so via the .config,
+ * or if gcc is too old:
  */
 #if !defined(CONFIG_ARCH_SUPPORTS_OPTIMIZED_INLINING) || \
-    !defined(CONFIG_OPTIMIZE_INLINING) && (__GNUC__ >= 4)
+    !defined(CONFIG_OPTIMIZE_INLINING) || (__GNUC__ < 4)
 # define inline         inline          __attribute__((always_inline))
 # define __inline__     __inline__      __attribute__((always_inline))
 # define __inline       __inline        __attribute__((always_inline))
diff --git a/include/linux/concap.h b/include/linux/concap.h
index 27304651d700..977acb3d1fb2 100644
--- a/include/linux/concap.h
+++ b/include/linux/concap.h
@@ -8,7 +8,7 @@
 
 #ifndef _LINUX_CONCAP_H
 #define _LINUX_CONCAP_H
-#ifdef __KERNEL__
+
 #include <linux/skbuff.h>
 #include <linux/netdevice.h>
 
@@ -110,4 +110,3 @@ extern int concap_nop(struct concap_proto *cprot);
  */
 extern int concap_drop_skb(struct concap_proto *cprot, struct sk_buff *skb);
 #endif
-#endif
diff --git a/include/linux/configfs.h b/include/linux/configfs.h
index 4b287ad9371a..3ae65b1bf90f 100644
--- a/include/linux/configfs.h
+++ b/include/linux/configfs.h
@@ -35,8 +35,6 @@
 #ifndef _CONFIGFS_H_
 #define _CONFIGFS_H_
 
-#ifdef __KERNEL__
-
 #include <linux/kernel.h>
 #include <linux/types.h>
 #include <linux/list.h>
@@ -194,6 +192,4 @@ void configfs_unregister_subsystem(struct configfs_subsystem *subsys);
 int configfs_depend_item(struct configfs_subsystem *subsys, struct config_item *target);
 void configfs_undepend_item(struct configfs_subsystem *subsys, struct config_item *target);
 
-#endif  /* __KERNEL__ */
-
 #endif /* _CONFIGFS_H_ */
diff --git a/include/linux/console.h b/include/linux/console.h
index a5f88a6a259d..a4f27fbdf549 100644
--- a/include/linux/console.h
+++ b/include/linux/console.h
@@ -91,6 +91,7 @@ void give_up_console(const struct consw *sw);
 #define CON_ENABLED     (4)
 #define CON_BOOT        (8)
 #define CON_ANYTIME     (16) /* Safe to call when cpu is offline */
+#define CON_BRL         (32) /* Used for a braille device */
 
 struct console {
         char    name[16];
@@ -121,6 +122,9 @@ extern struct tty_driver *console_device(int *);
 extern void console_stop(struct console *);
 extern void console_start(struct console *);
 extern int is_console_locked(void);
+extern int braille_register_console(struct console *, int index,
+                char *console_options, char *braille_options);
+extern int braille_unregister_console(struct console *);
 
 extern int console_suspend_enabled;
 
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/crc-ccitt.h b/include/linux/crc-ccitt.h
index 90037617da8f..f52696a1ff0d 100644
--- a/include/linux/crc-ccitt.h
+++ b/include/linux/crc-ccitt.h
@@ -1,6 +1,5 @@
 #ifndef _LINUX_CRC_CCITT_H
 #define _LINUX_CRC_CCITT_H
-#ifdef __KERNEL__
 
 #include <linux/types.h>
 
@@ -13,5 +12,4 @@ static inline u16 crc_ccitt_byte(u16 crc, const u8 c)
         return (crc >> 8) ^ crc_ccitt_table[(crc ^ c) & 0xff];
 }
 
-#endif /* __KERNEL__ */
 #endif /* _LINUX_CRC_CCITT_H */
diff --git a/include/linux/dcache.h b/include/linux/dcache.h
index cfb1627ac51c..2a6639407c80 100644
--- a/include/linux/dcache.h
+++ b/include/linux/dcache.h
@@ -1,8 +1,6 @@
 #ifndef __LINUX_DCACHE_H
 #define __LINUX_DCACHE_H
 
-#ifdef __KERNEL__
-
 #include <asm/atomic.h>
 #include <linux/list.h>
 #include <linux/spinlock.h>
@@ -365,6 +363,4 @@ extern struct dentry *lookup_create(struct nameidata *nd, int is_dir);
 
 extern int sysctl_vfs_cache_pressure;
 
-#endif /* __KERNEL__ */
-
 #endif  /* __LINUX_DCACHE_H */
diff --git a/include/linux/debugobjects.h b/include/linux/debugobjects.h
new file mode 100644
index 000000000000..8c243aaa86a7
--- /dev/null
+++ b/include/linux/debugobjects.h
@@ -0,0 +1,90 @@
+#ifndef _LINUX_DEBUGOBJECTS_H
+#define _LINUX_DEBUGOBJECTS_H
+
+#include <linux/list.h>
+#include <linux/spinlock.h>
+
+enum debug_obj_state {
+        ODEBUG_STATE_NONE,
+        ODEBUG_STATE_INIT,
+        ODEBUG_STATE_INACTIVE,
+        ODEBUG_STATE_ACTIVE,
+        ODEBUG_STATE_DESTROYED,
+        ODEBUG_STATE_NOTAVAILABLE,
+        ODEBUG_STATE_MAX,
+};
+
+struct debug_obj_descr;
+
+/**
+ * struct debug_obj - representaion of an tracked object
+ * @node:       hlist node to link the object into the tracker list
+ * @state:      tracked object state
+ * @object:     pointer to the real object
+ * @descr:      pointer to an object type specific debug description structure
+ */
+struct debug_obj {
+        struct hlist_node       node;
+        enum debug_obj_state    state;
+        void                    *object;
+        struct debug_obj_descr  *descr;
+};
+
+/**
+ * struct debug_obj_descr - object type specific debug description structure
+ * @name:               name of the object typee
+ * @fixup_init:         fixup function, which is called when the init check
+ *                      fails
+ * @fixup_activate:     fixup function, which is called when the activate check
+ *                      fails
+ * @fixup_destroy:      fixup function, which is called when the destroy check
+ *                      fails
+ * @fixup_free:         fixup function, which is called when the free check
+ *                      fails
+ */
+struct debug_obj_descr {
+        const char              *name;
+
+        int (*fixup_init)       (void *addr, enum debug_obj_state state);
+        int (*fixup_activate)   (void *addr, enum debug_obj_state state);
+        int (*fixup_destroy)    (void *addr, enum debug_obj_state state);
+        int (*fixup_free)       (void *addr, enum debug_obj_state state);
+};
+
+#ifdef CONFIG_DEBUG_OBJECTS
+extern void debug_object_init      (void *addr, struct debug_obj_descr *descr);
+extern void
+debug_object_init_on_stack(void *addr, struct debug_obj_descr *descr);
+extern void debug_object_activate  (void *addr, struct debug_obj_descr *descr);
+extern void debug_object_deactivate(void *addr, struct debug_obj_descr *descr);
+extern void debug_object_destroy   (void *addr, struct debug_obj_descr *descr);
+extern void debug_object_free      (void *addr, struct debug_obj_descr *descr);
+
+extern void debug_objects_early_init(void);
+extern void debug_objects_mem_init(void);
+#else
+static inline void
+debug_object_init      (void *addr, struct debug_obj_descr *descr) { }
+static inline void
+debug_object_init_on_stack(void *addr, struct debug_obj_descr *descr) { }
+static inline void
+debug_object_activate  (void *addr, struct debug_obj_descr *descr) { }
+static inline void
+debug_object_deactivate(void *addr, struct debug_obj_descr *descr) { }
+static inline void
+debug_object_destroy   (void *addr, struct debug_obj_descr *descr) { }
+static inline void
+debug_object_free      (void *addr, struct debug_obj_descr *descr) { }
+
+static inline void debug_objects_early_init(void) { }
+static inline void debug_objects_mem_init(void) { }
+#endif
+
+#ifdef CONFIG_DEBUG_OBJECTS_FREE
+extern void debug_check_no_obj_freed(const void *address, unsigned long size);
+#else
+static inline void
+debug_check_no_obj_freed(const void *address, unsigned long size) { }
+#endif
+
+#endif
diff --git a/include/linux/device-mapper.h b/include/linux/device-mapper.h
index ad3b787479a4..0d8d419d191a 100644
--- a/include/linux/device-mapper.h
+++ b/include/linux/device-mapper.h
@@ -8,8 +8,6 @@
 #ifndef _LINUX_DEVICE_MAPPER_H
 #define _LINUX_DEVICE_MAPPER_H
 
-#ifdef __KERNEL__
-
 #include <linux/bio.h>
 
 struct dm_target;
@@ -344,5 +342,4 @@ static inline unsigned long to_bytes(sector_t n)
         return (n << SECTOR_SHIFT);
 }
 
-#endif  /* __KERNEL__ */
 #endif  /* _LINUX_DEVICE_MAPPER_H */
diff --git a/include/linux/device.h b/include/linux/device.h
index 1a060265acea..8c23e3dfe3ac 100644
--- a/include/linux/device.h
+++ b/include/linux/device.h
@@ -35,7 +35,6 @@ struct device;
 struct device_driver;
 struct driver_private;
 struct class;
-struct class_device;
 struct bus_type;
 struct bus_type_private;
 
@@ -190,13 +189,10 @@ struct class {
         struct kset             class_dirs;
         struct semaphore        sem; /* locks children, devices, interfaces */
         struct class_attribute          *class_attrs;
-        struct class_device_attribute   *class_dev_attrs;
         struct device_attribute         *dev_attrs;
 
-        int (*uevent)(struct class_device *dev, struct kobj_uevent_env *env);
         int (*dev_uevent)(struct device *dev, struct kobj_uevent_env *env);
 
-        void (*release)(struct class_device *dev);
         void (*class_release)(struct class *class);
         void (*dev_release)(struct device *dev);
 
@@ -210,9 +206,6 @@ extern int class_for_each_device(struct class *class, void *data,
                                  int (*fn)(struct device *dev, void *data));
 extern struct device *class_find_device(struct class *class, void *data,
                                         int (*match)(struct device *, void *));
-extern struct class_device *class_find_child(struct class *class, void *data,
-                                   int (*match)(struct class_device *, void *));
-
 
 struct class_attribute {
         struct attribute attr;
@@ -228,92 +221,10 @@ extern int __must_check class_create_file(struct class *class,
 extern void class_remove_file(struct class *class,
                               const struct class_attribute *attr);
 
-struct class_device_attribute {
-        struct attribute attr;
-        ssize_t (*show)(struct class_device *, char *buf);
-        ssize_t (*store)(struct class_device *, const char *buf, size_t count);
-};
-
-#define CLASS_DEVICE_ATTR(_name, _mode, _show, _store)          \
-struct class_device_attribute class_device_attr_##_name =       \
-        __ATTR(_name, _mode, _show, _store)
-
-extern int __must_check class_device_create_file(struct class_device *,
-                                    const struct class_device_attribute *);
-
-/**
- * struct class_device - class devices
- * @class: pointer to the parent class for this class device.  This is required.
- * @devt: for internal use by the driver core only.
- * @node: for internal use by the driver core only.
- * @kobj: for internal use by the driver core only.
- * @groups: optional additional groups to be created
- * @dev: if set, a symlink to the struct device is created in the sysfs
- * directory for this struct class device.
- * @class_data: pointer to whatever you want to store here for this struct
- * class_device.  Use class_get_devdata() and class_set_devdata() to get and
- * set this pointer.
- * @parent: pointer to a struct class_device that is the parent of this struct
- * class_device.  If NULL, this class_device will show up at the root of the
- * struct class in sysfs (which is probably what you want to have happen.)
- * @release: pointer to a release function for this struct class_device.  If
- * set, this will be called instead of the class specific release function.
- * Only use this if you want to override the default release function, like
- * when you are nesting class_device structures.
- * @uevent: pointer to a uevent function for this struct class_device.  If
- * set, this will be called instead of the class specific uevent function.
- * Only use this if you want to override the default uevent function, like
- * when you are nesting class_device structures.
- */
-struct class_device {
-        struct list_head        node;
-
-        struct kobject          kobj;
-        struct class            *class;
-        dev_t                   devt;
-        struct device           *dev;
-        void                    *class_data;
-        struct class_device     *parent;
-        struct attribute_group  **groups;
-
-        void (*release)(struct class_device *dev);
-        int (*uevent)(struct class_device *dev, struct kobj_uevent_env *env);
-        char class_id[BUS_ID_SIZE];
-};
-
-static inline void *class_get_devdata(struct class_device *dev)
-{
-        return dev->class_data;
-}
-
-static inline void class_set_devdata(struct class_device *dev, void *data)
-{
-        dev->class_data = data;
-}
-
-
-extern int __must_check class_device_register(struct class_device *);
-extern void class_device_unregister(struct class_device *);
-extern void class_device_initialize(struct class_device *);
-extern int __must_check class_device_add(struct class_device *);
-extern void class_device_del(struct class_device *);
-
-extern struct class_device *class_device_get(struct class_device *);
-extern void class_device_put(struct class_device *);
-
-extern void class_device_remove_file(struct class_device *,
-                                     const struct class_device_attribute *);
-extern int __must_check class_device_create_bin_file(struct class_device *,
-                                        struct bin_attribute *);
-extern void class_device_remove_bin_file(struct class_device *,
-                                         struct bin_attribute *);
-
 struct class_interface {
         struct list_head        node;
         struct class            *class;
 
-        int (*add)      (struct class_device *, struct class_interface *);
-        void (*remove)  (struct class_device *, struct class_interface *);
         int (*add_dev)          (struct device *, struct class_interface *);
         void (*remove_dev)      (struct device *, struct class_interface *);
 };
@@ -323,13 +234,6 @@ extern void class_interface_unregister(struct class_interface *);
 
 extern struct class *class_create(struct module *owner, const char *name);
 extern void class_destroy(struct class *cls);
-extern struct class_device *class_device_create(struct class *cls,
-                                                struct class_device *parent,
-                                                dev_t devt,
-                                                struct device *device,
-                                                const char *fmt, ...)
-                                        __attribute__((format(printf, 5, 6)));
-extern void class_device_destroy(struct class *cls, dev_t devt);
 
 /*
  * The type of device, "struct device" is embedded in. A class
@@ -465,7 +369,6 @@ struct device {
         spinlock_t              devres_lock;
         struct list_head        devres_head;
 
-        /* class_device migration path */
         struct list_head        node;
         struct class            *class;
         dev_t                   devt;   /* dev_t, creates the sysfs "dev" */
@@ -477,6 +380,12 @@ struct device {
 /* Get the wakeup routines, which depend on struct device */
 #include <linux/pm_wakeup.h>
 
+static inline const char *dev_name(struct device *dev)
+{
+        /* will be changed into kobject_name(&dev->kobj) in the near future */
+        return dev->bus_id;
+}
+
 #ifdef CONFIG_NUMA
 static inline int dev_to_node(struct device *dev)
 {
@@ -575,7 +484,7 @@ extern void sysdev_shutdown(void);
 extern const char *dev_driver_string(struct device *dev);
 #define dev_printk(level, dev, format, arg...)  \
         printk(level "%s %s: " format , dev_driver_string(dev) , \
-               (dev)->bus_id , ## arg)
+               dev_name(dev) , ## arg)
 
 #define dev_emerg(dev, format, arg...)          \
         dev_printk(KERN_EMERG , dev , format , ## arg)
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/devpts_fs.h b/include/linux/devpts_fs.h
index b672ddc00735..154769cad3f3 100644
--- a/include/linux/devpts_fs.h
+++ b/include/linux/devpts_fs.h
@@ -17,6 +17,8 @@
 
 #ifdef CONFIG_UNIX98_PTYS
 
+int devpts_new_index(void);
+void devpts_kill_index(int idx);
 int devpts_pty_new(struct tty_struct *tty);      /* mknod in devpts */
 struct tty_struct *devpts_get_tty(int number);   /* get tty structure */
 void devpts_pty_kill(int number);                /* unlink */
@@ -24,6 +26,8 @@ void devpts_pty_kill(int number);		 /* unlink */
 #else
 
 /* Dummy stubs in the no-pty case */
+static inline int devpts_new_index(void) { return -EINVAL; }
+static inline void devpts_kill_index(int idx) { }
 static inline int devpts_pty_new(struct tty_struct *tty) { return -EINVAL; }
 static inline struct tty_struct *devpts_get_tty(int number) { return NULL; }
 static inline void devpts_pty_kill(int number) { }
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/eventfd.h b/include/linux/eventfd.h
index b489fc6d0b62..a701399b7fed 100644
--- a/include/linux/eventfd.h
+++ b/include/linux/eventfd.h
@@ -8,9 +8,6 @@
 #ifndef _LINUX_EVENTFD_H
 #define _LINUX_EVENTFD_H
 
-
-#ifdef __KERNEL__
-
 #ifdef CONFIG_EVENTFD
 
 struct file *eventfd_fget(int fd);
@@ -24,7 +21,5 @@ static inline int eventfd_signal(struct file *file, int n)
 
 #endif /* CONFIG_EVENTFD */
 
-#endif /* __KERNEL__ */
-
 #endif /* _LINUX_EVENTFD_H */
 
diff --git a/include/linux/ext4_fs.h b/include/linux/ext4_fs.h
deleted file mode 100644
index 250032548597..000000000000
--- a/include/linux/ext4_fs.h
+++ /dev/null
@@ -1,1207 +0,0 @@
-/*
- *  linux/include/linux/ext4_fs.h
- *
- * Copyright (C) 1992, 1993, 1994, 1995
- * Remy Card (card@masi.ibp.fr)
- * Laboratoire MASI - Institut Blaise Pascal
- * Universite Pierre et Marie Curie (Paris VI)
- *
- *  from
- *
- *  linux/include/linux/minix_fs.h
- *
- *  Copyright (C) 1991, 1992  Linus Torvalds
- */
-
-#ifndef _LINUX_EXT4_FS_H
-#define _LINUX_EXT4_FS_H
-
-#include <linux/types.h>
-#include <linux/blkdev.h>
-#include <linux/magic.h>
-
-#include <linux/ext4_fs_i.h>
-
-/*
- * The second extended filesystem constants/structures
- */
-
-/*
- * Define EXT4FS_DEBUG to produce debug messages
- */
-#undef EXT4FS_DEBUG
-
-/*
- * Define EXT4_RESERVATION to reserve data blocks for expanding files
- */
-#define EXT4_DEFAULT_RESERVE_BLOCKS     8
-/*max window size: 1024(direct blocks) + 3([t,d]indirect blocks) */
-#define EXT4_MAX_RESERVE_BLOCKS         1027
-#define EXT4_RESERVE_WINDOW_NOT_ALLOCATED 0
-
-/*
- * Debug code
- */
-#ifdef EXT4FS_DEBUG
-#define ext4_debug(f, a...)                                             \
-        do {                                                            \
-                printk (KERN_DEBUG "EXT4-fs DEBUG (%s, %d): %s:",       \
-                        __FILE__, __LINE__, __FUNCTION__);              \
-                printk (KERN_DEBUG f, ## a);                            \
-        } while (0)
-#else
-#define ext4_debug(f, a...)     do {} while (0)
-#endif
-
-#define EXT4_MULTIBLOCK_ALLOCATOR       1
-
-/* prefer goal again. length */
-#define EXT4_MB_HINT_MERGE              1
-/* blocks already reserved */
-#define EXT4_MB_HINT_RESERVED           2
-/* metadata is being allocated */
-#define EXT4_MB_HINT_METADATA           4
-/* first blocks in the file */
-#define EXT4_MB_HINT_FIRST              8
-/* search for the best chunk */
-#define EXT4_MB_HINT_BEST               16
-/* data is being allocated */
-#define EXT4_MB_HINT_DATA               32
-/* don't preallocate (for tails) */
-#define EXT4_MB_HINT_NOPREALLOC         64
-/* allocate for locality group */
-#define EXT4_MB_HINT_GROUP_ALLOC        128
-/* allocate goal blocks or none */
-#define EXT4_MB_HINT_GOAL_ONLY          256
-/* goal is meaningful */
-#define EXT4_MB_HINT_TRY_GOAL           512
-
-struct ext4_allocation_request {
-        /* target inode for block we're allocating */
-        struct inode *inode;
-        /* logical block in target inode */
-        ext4_lblk_t logical;
-        /* phys. target (a hint) */
-        ext4_fsblk_t goal;
-        /* the closest logical allocated block to the left */
-        ext4_lblk_t lleft;
-        /* phys. block for ^^^ */
-        ext4_fsblk_t pleft;
-        /* the closest logical allocated block to the right */
-        ext4_lblk_t lright;
-        /* phys. block for ^^^ */
-        ext4_fsblk_t pright;
-        /* how many blocks we want to allocate */
-        unsigned long len;
-        /* flags. see above EXT4_MB_HINT_* */
-        unsigned long flags;
-};
-
-/*
- * Special inodes numbers
- */
-#define EXT4_BAD_INO             1      /* Bad blocks inode */
-#define EXT4_ROOT_INO            2      /* Root inode */
-#define EXT4_BOOT_LOADER_INO     5      /* Boot loader inode */
-#define EXT4_UNDEL_DIR_INO       6      /* Undelete directory inode */
-#define EXT4_RESIZE_INO          7      /* Reserved group descriptors inode */
-#define EXT4_JOURNAL_INO         8      /* Journal inode */
-
-/* First non-reserved inode for old ext4 filesystems */
-#define EXT4_GOOD_OLD_FIRST_INO 11
-
-/*
- * Maximal count of links to a file
- */
-#define EXT4_LINK_MAX           65000
-
-/*
- * Macro-instructions used to manage several block sizes
- */
-#define EXT4_MIN_BLOCK_SIZE             1024
-#define EXT4_MAX_BLOCK_SIZE             65536
-#define EXT4_MIN_BLOCK_LOG_SIZE         10
-#ifdef __KERNEL__
-# define EXT4_BLOCK_SIZE(s)             ((s)->s_blocksize)
-#else
-# define EXT4_BLOCK_SIZE(s)             (EXT4_MIN_BLOCK_SIZE << (s)->s_log_block_size)
-#endif
-#define EXT4_ADDR_PER_BLOCK(s)          (EXT4_BLOCK_SIZE(s) / sizeof (__u32))
-#ifdef __KERNEL__
-# define EXT4_BLOCK_SIZE_BITS(s)        ((s)->s_blocksize_bits)
-#else
-# define EXT4_BLOCK_SIZE_BITS(s)        ((s)->s_log_block_size + 10)
-#endif
-#ifdef __KERNEL__
-#define EXT4_ADDR_PER_BLOCK_BITS(s)     (EXT4_SB(s)->s_addr_per_block_bits)
-#define EXT4_INODE_SIZE(s)              (EXT4_SB(s)->s_inode_size)
-#define EXT4_FIRST_INO(s)               (EXT4_SB(s)->s_first_ino)
-#else
-#define EXT4_INODE_SIZE(s)      (((s)->s_rev_level == EXT4_GOOD_OLD_REV) ? \
-                                 EXT4_GOOD_OLD_INODE_SIZE : \
-                                 (s)->s_inode_size)
-#define EXT4_FIRST_INO(s)       (((s)->s_rev_level == EXT4_GOOD_OLD_REV) ? \
-                                 EXT4_GOOD_OLD_FIRST_INO : \
-                                 (s)->s_first_ino)
-#endif
-#define EXT4_BLOCK_ALIGN(size, blkbits)         ALIGN((size), (1 << (blkbits)))
-
-/*
- * Structure of a blocks group descriptor
- */
-struct ext4_group_desc
-{
-        __le32  bg_block_bitmap_lo;     /* Blocks bitmap block */
-        __le32  bg_inode_bitmap_lo;     /* Inodes bitmap block */
-        __le32  bg_inode_table_lo;      /* Inodes table block */
-        __le16  bg_free_blocks_count;   /* Free blocks count */
-        __le16  bg_free_inodes_count;   /* Free inodes count */
-        __le16  bg_used_dirs_count;     /* Directories count */
-        __le16  bg_flags;               /* EXT4_BG_flags (INODE_UNINIT, etc) */
-        __u32   bg_reserved[2];         /* Likely block/inode bitmap checksum */
-        __le16  bg_itable_unused;       /* Unused inodes count */
-        __le16  bg_checksum;            /* crc16(sb_uuid+group+desc) */
-        __le32  bg_block_bitmap_hi;     /* Blocks bitmap block MSB */
-        __le32  bg_inode_bitmap_hi;     /* Inodes bitmap block MSB */
-        __le32  bg_inode_table_hi;      /* Inodes table block MSB */
-        __le16  bg_free_blocks_count_hi;/* Free blocks count MSB */
-        __le16  bg_free_inodes_count_hi;/* Free inodes count MSB */
-        __le16  bg_used_dirs_count_hi;  /* Directories count MSB */
-        __le16  bg_itable_unused_hi;    /* Unused inodes count MSB */
-        __u32   bg_reserved2[3];
-};
-
-#define EXT4_BG_INODE_UNINIT    0x0001 /* Inode table/bitmap not in use */
-#define EXT4_BG_BLOCK_UNINIT    0x0002 /* Block bitmap not in use */
-#define EXT4_BG_INODE_ZEROED    0x0004 /* On-disk itable initialized to zero */
-
-#ifdef __KERNEL__
-#include <linux/ext4_fs_i.h>
-#include <linux/ext4_fs_sb.h>
-#endif
-/*
- * Macro-instructions used to manage group descriptors
- */
-#define EXT4_MIN_DESC_SIZE              32
-#define EXT4_MIN_DESC_SIZE_64BIT        64
-#define EXT4_MAX_DESC_SIZE              EXT4_MIN_BLOCK_SIZE
-#define EXT4_DESC_SIZE(s)               (EXT4_SB(s)->s_desc_size)
-#ifdef __KERNEL__
-# define EXT4_BLOCKS_PER_GROUP(s)       (EXT4_SB(s)->s_blocks_per_group)
-# define EXT4_DESC_PER_BLOCK(s)         (EXT4_SB(s)->s_desc_per_block)
-# define EXT4_INODES_PER_GROUP(s)       (EXT4_SB(s)->s_inodes_per_group)
-# define EXT4_DESC_PER_BLOCK_BITS(s)    (EXT4_SB(s)->s_desc_per_block_bits)
-#else
-# define EXT4_BLOCKS_PER_GROUP(s)       ((s)->s_blocks_per_group)
-# define EXT4_DESC_PER_BLOCK(s)         (EXT4_BLOCK_SIZE(s) / EXT4_DESC_SIZE(s))
-# define EXT4_INODES_PER_GROUP(s)       ((s)->s_inodes_per_group)
-#endif
-
-/*
- * Constants relative to the data blocks
- */
-#define EXT4_NDIR_BLOCKS                12
-#define EXT4_IND_BLOCK                  EXT4_NDIR_BLOCKS
-#define EXT4_DIND_BLOCK                 (EXT4_IND_BLOCK + 1)
-#define EXT4_TIND_BLOCK                 (EXT4_DIND_BLOCK + 1)
-#define EXT4_N_BLOCKS                   (EXT4_TIND_BLOCK + 1)
-
-/*
- * Inode flags
- */
-#define EXT4_SECRM_FL                   0x00000001 /* Secure deletion */
-#define EXT4_UNRM_FL                    0x00000002 /* Undelete */
-#define EXT4_COMPR_FL                   0x00000004 /* Compress file */
-#define EXT4_SYNC_FL                    0x00000008 /* Synchronous updates */
-#define EXT4_IMMUTABLE_FL               0x00000010 /* Immutable file */
-#define EXT4_APPEND_FL                  0x00000020 /* writes to file may only append */
-#define EXT4_NODUMP_FL                  0x00000040 /* do not dump file */
-#define EXT4_NOATIME_FL                 0x00000080 /* do not update atime */
-/* Reserved for compression usage... */
-#define EXT4_DIRTY_FL                   0x00000100
-#define EXT4_COMPRBLK_FL                0x00000200 /* One or more compressed clusters */
-#define EXT4_NOCOMPR_FL                 0x00000400 /* Don't compress */
-#define EXT4_ECOMPR_FL                  0x00000800 /* Compression error */
-/* End compression flags --- maybe not all used */
-#define EXT4_INDEX_FL                   0x00001000 /* hash-indexed directory */
-#define EXT4_IMAGIC_FL                  0x00002000 /* AFS directory */
-#define EXT4_JOURNAL_DATA_FL            0x00004000 /* file data should be journaled */
-#define EXT4_NOTAIL_FL                  0x00008000 /* file tail should not be merged */
-#define EXT4_DIRSYNC_FL                 0x00010000 /* dirsync behaviour (directories only) */
-#define EXT4_TOPDIR_FL                  0x00020000 /* Top of directory hierarchies*/
-#define EXT4_HUGE_FILE_FL               0x00040000 /* Set to each huge file */
-#define EXT4_EXTENTS_FL                 0x00080000 /* Inode uses extents */
-#define EXT4_RESERVED_FL                0x80000000 /* reserved for ext4 lib */
-
-#define EXT4_FL_USER_VISIBLE            0x000BDFFF /* User visible flags */
-#define EXT4_FL_USER_MODIFIABLE         0x000380FF /* User modifiable flags */
-
-/*
- * Inode dynamic state flags
- */
-#define EXT4_STATE_JDATA                0x00000001 /* journaled data exists */
-#define EXT4_STATE_NEW                  0x00000002 /* inode is newly created */
-#define EXT4_STATE_XATTR                0x00000004 /* has in-inode xattrs */
-#define EXT4_STATE_NO_EXPAND            0x00000008 /* No space for expansion */
-
-/* Used to pass group descriptor data when online resize is done */
-struct ext4_new_group_input {
-        __u32 group;            /* Group number for this data */
-        __u64 block_bitmap;     /* Absolute block number of block bitmap */
-        __u64 inode_bitmap;     /* Absolute block number of inode bitmap */
-        __u64 inode_table;      /* Absolute block number of inode table start */
-        __u32 blocks_count;     /* Total number of blocks in this group */
-        __u16 reserved_blocks;  /* Number of reserved blocks in this group */
-        __u16 unused;
-};
-
-/* The struct ext4_new_group_input in kernel space, with free_blocks_count */
-struct ext4_new_group_data {
-        __u32 group;
-        __u64 block_bitmap;
-        __u64 inode_bitmap;
-        __u64 inode_table;
-        __u32 blocks_count;
-        __u16 reserved_blocks;
-        __u16 unused;
-        __u32 free_blocks_count;
-};
-
-/*
- * Following is used by preallocation code to tell get_blocks() that we
- * want uninitialzed extents.
- */
-#define EXT4_CREATE_UNINITIALIZED_EXT           2
-
-/*
- * ioctl commands
- */
-#define EXT4_IOC_GETFLAGS               FS_IOC_GETFLAGS
-#define EXT4_IOC_SETFLAGS               FS_IOC_SETFLAGS
-#define EXT4_IOC_GETVERSION             _IOR('f', 3, long)
-#define EXT4_IOC_SETVERSION             _IOW('f', 4, long)
-#define EXT4_IOC_GROUP_EXTEND           _IOW('f', 7, unsigned long)
-#define EXT4_IOC_GROUP_ADD              _IOW('f', 8,struct ext4_new_group_input)
-#define EXT4_IOC_GETVERSION_OLD         FS_IOC_GETVERSION
-#define EXT4_IOC_SETVERSION_OLD         FS_IOC_SETVERSION
-#ifdef CONFIG_JBD2_DEBUG
-#define EXT4_IOC_WAIT_FOR_READONLY      _IOR('f', 99, long)
-#endif
-#define EXT4_IOC_GETRSVSZ               _IOR('f', 5, long)
-#define EXT4_IOC_SETRSVSZ               _IOW('f', 6, long)
-#define EXT4_IOC_MIGRATE                _IO('f', 7)
-
-/*
- * ioctl commands in 32 bit emulation
- */
-#define EXT4_IOC32_GETFLAGS             FS_IOC32_GETFLAGS
-#define EXT4_IOC32_SETFLAGS             FS_IOC32_SETFLAGS
-#define EXT4_IOC32_GETVERSION           _IOR('f', 3, int)
-#define EXT4_IOC32_SETVERSION           _IOW('f', 4, int)
-#define EXT4_IOC32_GETRSVSZ             _IOR('f', 5, int)
-#define EXT4_IOC32_SETRSVSZ             _IOW('f', 6, int)
-#define EXT4_IOC32_GROUP_EXTEND         _IOW('f', 7, unsigned int)
-#ifdef CONFIG_JBD2_DEBUG
-#define EXT4_IOC32_WAIT_FOR_READONLY    _IOR('f', 99, int)
-#endif
-#define EXT4_IOC32_GETVERSION_OLD       FS_IOC32_GETVERSION
-#define EXT4_IOC32_SETVERSION_OLD       FS_IOC32_SETVERSION
-
-
-/*
- *  Mount options
- */
-struct ext4_mount_options {
-        unsigned long s_mount_opt;
-        uid_t s_resuid;
-        gid_t s_resgid;
-        unsigned long s_commit_interval;
-#ifdef CONFIG_QUOTA
-        int s_jquota_fmt;
-        char *s_qf_names[MAXQUOTAS];
-#endif
-};
-
-/*
- * Structure of an inode on the disk
- */
-struct ext4_inode {
-        __le16  i_mode;         /* File mode */
-        __le16  i_uid;          /* Low 16 bits of Owner Uid */
-        __le32  i_size_lo;      /* Size in bytes */
-        __le32  i_atime;        /* Access time */
-        __le32  i_ctime;        /* Inode Change time */
-        __le32  i_mtime;        /* Modification time */
-        __le32  i_dtime;        /* Deletion Time */
-        __le16  i_gid;          /* Low 16 bits of Group Id */
-        __le16  i_links_count;  /* Links count */
-        __le32  i_blocks_lo;    /* Blocks count */
-        __le32  i_flags;        /* File flags */
-        union {
-                struct {
-                        __le32  l_i_version;
-                } linux1;
-                struct {
-                        __u32  h_i_translator;
-                } hurd1;
-                struct {
-                        __u32  m_i_reserved1;
-                } masix1;
-        } osd1;                         /* OS dependent 1 */
-        __le32  i_block[EXT4_N_BLOCKS];/* Pointers to blocks */
-        __le32  i_generation;   /* File version (for NFS) */
-        __le32  i_file_acl_lo;  /* File ACL */
-        __le32  i_size_high;
-        __le32  i_obso_faddr;   /* Obsoleted fragment address */
-        union {
-                struct {
-                        __le16  l_i_blocks_high; /* were l_i_reserved1 */
-                        __le16  l_i_file_acl_high;
-                        __le16  l_i_uid_high;   /* these 2 fields */
-                        __le16  l_i_gid_high;   /* were reserved2[0] */
-                        __u32   l_i_reserved2;
-                } linux2;
-                struct {
-                        __le16  h_i_reserved1;  /* Obsoleted fragment number/size which are removed in ext4 */
-                        __u16   h_i_mode_high;
-                        __u16   h_i_uid_high;
-                        __u16   h_i_gid_high;
-                        __u32   h_i_author;
-                } hurd2;
-                struct {
-                        __le16  h_i_reserved1;  /* Obsoleted fragment number/size which are removed in ext4 */
-                        __le16  m_i_file_acl_high;
-                        __u32   m_i_reserved2[2];
-                } masix2;
-        } osd2;                         /* OS dependent 2 */
-        __le16  i_extra_isize;
-        __le16  i_pad1;
-        __le32  i_ctime_extra;  /* extra Change time      (nsec << 2 | epoch) */
-        __le32  i_mtime_extra;  /* extra Modification time(nsec << 2 | epoch) */
-        __le32  i_atime_extra;  /* extra Access time      (nsec << 2 | epoch) */
-        __le32  i_crtime;       /* File Creation time */
-        __le32  i_crtime_extra; /* extra FileCreationtime (nsec << 2 | epoch) */
-        __le32  i_version_hi;   /* high 32 bits for 64-bit version */
-};
-
-
-#define EXT4_EPOCH_BITS 2
-#define EXT4_EPOCH_MASK ((1 << EXT4_EPOCH_BITS) - 1)
-#define EXT4_NSEC_MASK  (~0UL << EXT4_EPOCH_BITS)
-
-/*
- * Extended fields will fit into an inode if the filesystem was formatted
- * with large inodes (-I 256 or larger) and there are not currently any EAs
- * consuming all of the available space. For new inodes we always reserve
- * enough space for the kernel's known extended fields, but for inodes
- * created with an old kernel this might not have been the case. None of
- * the extended inode fields is critical for correct filesystem operation.
- * This macro checks if a certain field fits in the inode. Note that
- * inode-size = GOOD_OLD_INODE_SIZE + i_extra_isize
- */
-#define EXT4_FITS_IN_INODE(ext4_inode, einode, field)   \
-        ((offsetof(typeof(*ext4_inode), field) +        \
-          sizeof((ext4_inode)->field))                  \
-        <= (EXT4_GOOD_OLD_INODE_SIZE +                  \
-            (einode)->i_extra_isize))                   \
-
-static inline __le32 ext4_encode_extra_time(struct timespec *time)
-{
-       return cpu_to_le32((sizeof(time->tv_sec) > 4 ?
-                           time->tv_sec >> 32 : 0) |
-                           ((time->tv_nsec << 2) & EXT4_NSEC_MASK));
-}
-
-static inline void ext4_decode_extra_time(struct timespec *time, __le32 extra)
-{
-       if (sizeof(time->tv_sec) > 4)
-               time->tv_sec |= (__u64)(le32_to_cpu(extra) & EXT4_EPOCH_MASK)
-                               << 32;
-       time->tv_nsec = (le32_to_cpu(extra) & EXT4_NSEC_MASK) >> 2;
-}
-
-#define EXT4_INODE_SET_XTIME(xtime, inode, raw_inode)                          \
-do {                                                                           \
-        (raw_inode)->xtime = cpu_to_le32((inode)->xtime.tv_sec);               \
-        if (EXT4_FITS_IN_INODE(raw_inode, EXT4_I(inode), xtime ## _extra))     \
-                (raw_inode)->xtime ## _extra =                                 \
-                                ext4_encode_extra_time(&(inode)->xtime);       \
-} while (0)
-
-#define EXT4_EINODE_SET_XTIME(xtime, einode, raw_inode)                        \
-do {                                                                           \
-        if (EXT4_FITS_IN_INODE(raw_inode, einode, xtime))                      \
-                (raw_inode)->xtime = cpu_to_le32((einode)->xtime.tv_sec);      \
-        if (EXT4_FITS_IN_INODE(raw_inode, einode, xtime ## _extra))            \
-                (raw_inode)->xtime ## _extra =                                 \
-                                ext4_encode_extra_time(&(einode)->xtime);      \
-} while (0)
-
-#define EXT4_INODE_GET_XTIME(xtime, inode, raw_inode)                          \
-do {                                                                           \
-        (inode)->xtime.tv_sec = (signed)le32_to_cpu((raw_inode)->xtime);       \
-        if (EXT4_FITS_IN_INODE(raw_inode, EXT4_I(inode), xtime ## _extra))     \
-                ext4_decode_extra_time(&(inode)->xtime,                        \
-                                       raw_inode->xtime ## _extra);            \
-} while (0)
-
-#define EXT4_EINODE_GET_XTIME(xtime, einode, raw_inode)                        \
-do {                                                                           \
-        if (EXT4_FITS_IN_INODE(raw_inode, einode, xtime))                      \
-                (einode)->xtime.tv_sec =                                       \
-                        (signed)le32_to_cpu((raw_inode)->xtime);               \
-        if (EXT4_FITS_IN_INODE(raw_inode, einode, xtime ## _extra))            \
-                ext4_decode_extra_time(&(einode)->xtime,                       \
-                                       raw_inode->xtime ## _extra);            \
-} while (0)
-
-#define i_disk_version osd1.linux1.l_i_version
-
-#if defined(__KERNEL__) || defined(__linux__)
-#define i_reserved1     osd1.linux1.l_i_reserved1
-#define i_file_acl_high osd2.linux2.l_i_file_acl_high
-#define i_blocks_high   osd2.linux2.l_i_blocks_high
-#define i_uid_low       i_uid
-#define i_gid_low       i_gid
-#define i_uid_high      osd2.linux2.l_i_uid_high
-#define i_gid_high      osd2.linux2.l_i_gid_high
-#define i_reserved2     osd2.linux2.l_i_reserved2
-
-#elif defined(__GNU__)
-
-#define i_translator    osd1.hurd1.h_i_translator
-#define i_uid_high      osd2.hurd2.h_i_uid_high
-#define i_gid_high      osd2.hurd2.h_i_gid_high
-#define i_author        osd2.hurd2.h_i_author
-
-#elif defined(__masix__)
-
-#define i_reserved1     osd1.masix1.m_i_reserved1
-#define i_file_acl_high osd2.masix2.m_i_file_acl_high
-#define i_reserved2     osd2.masix2.m_i_reserved2
-
-#endif /* defined(__KERNEL__) || defined(__linux__) */
-
-/*
- * File system states
- */
-#define EXT4_VALID_FS                   0x0001  /* Unmounted cleanly */
-#define EXT4_ERROR_FS                   0x0002  /* Errors detected */
-#define EXT4_ORPHAN_FS                  0x0004  /* Orphans being recovered */
-
-/*
- * Misc. filesystem flags
- */
-#define EXT2_FLAGS_SIGNED_HASH          0x0001  /* Signed dirhash in use */
-#define EXT2_FLAGS_UNSIGNED_HASH        0x0002  /* Unsigned dirhash in use */
-#define EXT2_FLAGS_TEST_FILESYS         0x0004  /* to test development code */
-
-/*
- * Mount flags
- */
-#define EXT4_MOUNT_CHECK                0x00001 /* Do mount-time checks */
-#define EXT4_MOUNT_OLDALLOC             0x00002  /* Don't use the new Orlov allocator */
-#define EXT4_MOUNT_GRPID                0x00004 /* Create files with directory's group */
-#define EXT4_MOUNT_DEBUG                0x00008 /* Some debugging messages */
-#define EXT4_MOUNT_ERRORS_CONT          0x00010 /* Continue on errors */
-#define EXT4_MOUNT_ERRORS_RO            0x00020 /* Remount fs ro on errors */
-#define EXT4_MOUNT_ERRORS_PANIC         0x00040 /* Panic on errors */
-#define EXT4_MOUNT_MINIX_DF             0x00080 /* Mimics the Minix statfs */
-#define EXT4_MOUNT_NOLOAD               0x00100 /* Don't use existing journal*/
-#define EXT4_MOUNT_ABORT                0x00200 /* Fatal error detected */
-#define EXT4_MOUNT_DATA_FLAGS           0x00C00 /* Mode for data writes: */
-#define EXT4_MOUNT_JOURNAL_DATA         0x00400 /* Write data to journal */
-#define EXT4_MOUNT_ORDERED_DATA         0x00800 /* Flush data before commit */
-#define EXT4_MOUNT_WRITEBACK_DATA       0x00C00 /* No data ordering */
-#define EXT4_MOUNT_UPDATE_JOURNAL       0x01000 /* Update the journal format */
-#define EXT4_MOUNT_NO_UID32             0x02000  /* Disable 32-bit UIDs */
-#define EXT4_MOUNT_XATTR_USER           0x04000 /* Extended user attributes */
-#define EXT4_MOUNT_POSIX_ACL            0x08000 /* POSIX Access Control Lists */
-#define EXT4_MOUNT_RESERVATION          0x10000 /* Preallocation */
-#define EXT4_MOUNT_BARRIER              0x20000 /* Use block barriers */
-#define EXT4_MOUNT_NOBH                 0x40000 /* No bufferheads */
-#define EXT4_MOUNT_QUOTA                0x80000 /* Some quota option set */
-#define EXT4_MOUNT_USRQUOTA             0x100000 /* "old" user quota */
-#define EXT4_MOUNT_GRPQUOTA             0x200000 /* "old" group quota */
-#define EXT4_MOUNT_EXTENTS              0x400000 /* Extents support */
-#define EXT4_MOUNT_JOURNAL_CHECKSUM     0x800000 /* Journal checksums */
-#define EXT4_MOUNT_JOURNAL_ASYNC_COMMIT 0x1000000 /* Journal Async Commit */
-#define EXT4_MOUNT_I_VERSION            0x2000000 /* i_version support */
-#define EXT4_MOUNT_MBALLOC              0x4000000 /* Buddy allocation support */
-/* Compatibility, for having both ext2_fs.h and ext4_fs.h included at once */
-#ifndef _LINUX_EXT2_FS_H
-#define clear_opt(o, opt)               o &= ~EXT4_MOUNT_##opt
-#define set_opt(o, opt)                 o |= EXT4_MOUNT_##opt
-#define test_opt(sb, opt)               (EXT4_SB(sb)->s_mount_opt & \
-                                         EXT4_MOUNT_##opt)
-#else
-#define EXT2_MOUNT_NOLOAD               EXT4_MOUNT_NOLOAD
-#define EXT2_MOUNT_ABORT                EXT4_MOUNT_ABORT
-#define EXT2_MOUNT_DATA_FLAGS           EXT4_MOUNT_DATA_FLAGS
-#endif
-
-#define ext4_set_bit                    ext2_set_bit
-#define ext4_set_bit_atomic             ext2_set_bit_atomic
-#define ext4_clear_bit                  ext2_clear_bit
-#define ext4_clear_bit_atomic           ext2_clear_bit_atomic
-#define ext4_test_bit                   ext2_test_bit
-#define ext4_find_first_zero_bit        ext2_find_first_zero_bit
-#define ext4_find_next_zero_bit         ext2_find_next_zero_bit
-#define ext4_find_next_bit              ext2_find_next_bit
-
-/*
- * Maximal mount counts between two filesystem checks
- */
-#define EXT4_DFL_MAX_MNT_COUNT          20      /* Allow 20 mounts */
-#define EXT4_DFL_CHECKINTERVAL          0       /* Don't use interval check */
-
-/*
- * Behaviour when detecting errors
- */
-#define EXT4_ERRORS_CONTINUE            1       /* Continue execution */
-#define EXT4_ERRORS_RO                  2       /* Remount fs read-only */
-#define EXT4_ERRORS_PANIC               3       /* Panic */
-#define EXT4_ERRORS_DEFAULT             EXT4_ERRORS_CONTINUE
-
-/*
- * Structure of the super block
- */
-struct ext4_super_block {
-/*00*/  __le32  s_inodes_count;         /* Inodes count */
-        __le32  s_blocks_count_lo;      /* Blocks count */
-        __le32  s_r_blocks_count_lo;    /* Reserved blocks count */
-        __le32  s_free_blocks_count_lo; /* Free blocks count */
-/*10*/  __le32  s_free_inodes_count;    /* Free inodes count */
-        __le32  s_first_data_block;     /* First Data Block */
-        __le32  s_log_block_size;       /* Block size */
-        __le32  s_obso_log_frag_size;   /* Obsoleted fragment size */
-/*20*/  __le32  s_blocks_per_group;     /* # Blocks per group */
-        __le32  s_obso_frags_per_group; /* Obsoleted fragments per group */
-        __le32  s_inodes_per_group;     /* # Inodes per group */
-        __le32  s_mtime;                /* Mount time */
-/*30*/  __le32  s_wtime;                /* Write time */
-        __le16  s_mnt_count;            /* Mount count */
-        __le16  s_max_mnt_count;        /* Maximal mount count */
-        __le16  s_magic;                /* Magic signature */
-        __le16  s_state;                /* File system state */
-        __le16  s_errors;               /* Behaviour when detecting errors */
-        __le16  s_minor_rev_level;      /* minor revision level */
-/*40*/  __le32  s_lastcheck;            /* time of last check */
-        __le32  s_checkinterval;        /* max. time between checks */
-        __le32  s_creator_os;           /* OS */
-        __le32  s_rev_level;            /* Revision level */
-/*50*/  __le16  s_def_resuid;           /* Default uid for reserved blocks */
-        __le16  s_def_resgid;           /* Default gid for reserved blocks */
-        /*
-         * These fields are for EXT4_DYNAMIC_REV superblocks only.
-         *
-         * Note: the difference between the compatible feature set and
-         * the incompatible feature set is that if there is a bit set
-         * in the incompatible feature set that the kernel doesn't
-         * know about, it should refuse to mount the filesystem.
-         *
-         * e2fsck's requirements are more strict; if it doesn't know
-         * about a feature in either the compatible or incompatible
-         * feature set, it must abort and not try to meddle with
-         * things it doesn't understand...
-         */
-        __le32  s_first_ino;            /* First non-reserved inode */
-        __le16  s_inode_size;           /* size of inode structure */
-        __le16  s_block_group_nr;       /* block group # of this superblock */
-        __le32  s_feature_compat;       /* compatible feature set */
-/*60*/  __le32  s_feature_incompat;     /* incompatible feature set */
-        __le32  s_feature_ro_compat;    /* readonly-compatible feature set */
-/*68*/  __u8    s_uuid[16];             /* 128-bit uuid for volume */
-/*78*/  char    s_volume_name[16];      /* volume name */
-/*88*/  char    s_last_mounted[64];     /* directory where last mounted */
-/*C8*/  __le32  s_algorithm_usage_bitmap; /* For compression */
-        /*
-         * Performance hints.  Directory preallocation should only
-         * happen if the EXT4_FEATURE_COMPAT_DIR_PREALLOC flag is on.
-         */
-        __u8    s_prealloc_blocks;      /* Nr of blocks to try to preallocate*/
-        __u8    s_prealloc_dir_blocks;  /* Nr to preallocate for dirs */
-        __le16  s_reserved_gdt_blocks;  /* Per group desc for online growth */
-        /*
-         * Journaling support valid if EXT4_FEATURE_COMPAT_HAS_JOURNAL set.
-         */
-/*D0*/  __u8    s_journal_uuid[16];     /* uuid of journal superblock */
-/*E0*/  __le32  s_journal_inum;         /* inode number of journal file */
-        __le32  s_journal_dev;          /* device number of journal file */
-        __le32  s_last_orphan;          /* start of list of inodes to delete */
-        __le32  s_hash_seed[4];         /* HTREE hash seed */
-        __u8    s_def_hash_version;     /* Default hash version to use */
-        __u8    s_reserved_char_pad;
-        __le16  s_desc_size;            /* size of group descriptor */
-/*100*/ __le32  s_default_mount_opts;
-        __le32  s_first_meta_bg;        /* First metablock block group */
-        __le32  s_mkfs_time;            /* When the filesystem was created */
-        __le32  s_jnl_blocks[17];       /* Backup of the journal inode */
-        /* 64bit support valid if EXT4_FEATURE_COMPAT_64BIT */
-/*150*/ __le32  s_blocks_count_hi;      /* Blocks count */
-        __le32  s_r_blocks_count_hi;    /* Reserved blocks count */
-        __le32  s_free_blocks_count_hi; /* Free blocks count */
-        __le16  s_min_extra_isize;      /* All inodes have at least # bytes */
-        __le16  s_want_extra_isize;     /* New inodes should reserve # bytes */
-        __le32  s_flags;                /* Miscellaneous flags */
-        __le16  s_raid_stride;          /* RAID stride */
-        __le16  s_mmp_interval;         /* # seconds to wait in MMP checking */
-        __le64  s_mmp_block;            /* Block for multi-mount protection */
-        __le32  s_raid_stripe_width;    /* blocks on all data disks (N*stride)*/
-        __u32   s_reserved[163];        /* Padding to the end of the block */
-};
-
-#ifdef __KERNEL__
-static inline struct ext4_sb_info * EXT4_SB(struct super_block *sb)
-{
-        return sb->s_fs_info;
-}
-static inline struct ext4_inode_info *EXT4_I(struct inode *inode)
-{
-        return container_of(inode, struct ext4_inode_info, vfs_inode);
-}
-
-static inline struct timespec ext4_current_time(struct inode *inode)
-{
-        return (inode->i_sb->s_time_gran < NSEC_PER_SEC) ?
-                current_fs_time(inode->i_sb) : CURRENT_TIME_SEC;
-}
-
-
-static inline int ext4_valid_inum(struct super_block *sb, unsigned long ino)
-{
-        return ino == EXT4_ROOT_INO ||
-                ino == EXT4_JOURNAL_INO ||
-                ino == EXT4_RESIZE_INO ||
-                (ino >= EXT4_FIRST_INO(sb) &&
-                 ino <= le32_to_cpu(EXT4_SB(sb)->s_es->s_inodes_count));
-}
-#else
-/* Assume that user mode programs are passing in an ext4fs superblock, not
- * a kernel struct super_block.  This will allow us to call the feature-test
- * macros from user land. */
-#define EXT4_SB(sb)     (sb)
-#endif
-
-#define NEXT_ORPHAN(inode) EXT4_I(inode)->i_dtime
-
-/*
- * Codes for operating systems
- */
-#define EXT4_OS_LINUX           0
-#define EXT4_OS_HURD            1
-#define EXT4_OS_MASIX           2
-#define EXT4_OS_FREEBSD         3
-#define EXT4_OS_LITES           4
-
-/*
- * Revision levels
- */
-#define EXT4_GOOD_OLD_REV       0       /* The good old (original) format */
-#define EXT4_DYNAMIC_REV        1       /* V2 format w/ dynamic inode sizes */
-
-#define EXT4_CURRENT_REV        EXT4_GOOD_OLD_REV
-#define EXT4_MAX_SUPP_REV       EXT4_DYNAMIC_REV
-
-#define EXT4_GOOD_OLD_INODE_SIZE 128
-
-/*
- * Feature set definitions
- */
-
-#define EXT4_HAS_COMPAT_FEATURE(sb,mask)                        \
-        ( EXT4_SB(sb)->s_es->s_feature_compat & cpu_to_le32(mask) )
-#define EXT4_HAS_RO_COMPAT_FEATURE(sb,mask)                     \
-        ( EXT4_SB(sb)->s_es->s_feature_ro_compat & cpu_to_le32(mask) )
-#define EXT4_HAS_INCOMPAT_FEATURE(sb,mask)                      \
-        ( EXT4_SB(sb)->s_es->s_feature_incompat & cpu_to_le32(mask) )
-#define EXT4_SET_COMPAT_FEATURE(sb,mask)                        \
-        EXT4_SB(sb)->s_es->s_feature_compat |= cpu_to_le32(mask)
-#define EXT4_SET_RO_COMPAT_FEATURE(sb,mask)                     \
-        EXT4_SB(sb)->s_es->s_feature_ro_compat |= cpu_to_le32(mask)
-#define EXT4_SET_INCOMPAT_FEATURE(sb,mask)                      \
-        EXT4_SB(sb)->s_es->s_feature_incompat |= cpu_to_le32(mask)
-#define EXT4_CLEAR_COMPAT_FEATURE(sb,mask)                      \
-        EXT4_SB(sb)->s_es->s_feature_compat &= ~cpu_to_le32(mask)
-#define EXT4_CLEAR_RO_COMPAT_FEATURE(sb,mask)                   \
-        EXT4_SB(sb)->s_es->s_feature_ro_compat &= ~cpu_to_le32(mask)
-#define EXT4_CLEAR_INCOMPAT_FEATURE(sb,mask)                    \
-        EXT4_SB(sb)->s_es->s_feature_incompat &= ~cpu_to_le32(mask)
-
-#define EXT4_FEATURE_COMPAT_DIR_PREALLOC        0x0001
-#define EXT4_FEATURE_COMPAT_IMAGIC_INODES       0x0002
-#define EXT4_FEATURE_COMPAT_HAS_JOURNAL         0x0004
-#define EXT4_FEATURE_COMPAT_EXT_ATTR            0x0008
-#define EXT4_FEATURE_COMPAT_RESIZE_INODE        0x0010
-#define EXT4_FEATURE_COMPAT_DIR_INDEX           0x0020
-
-#define EXT4_FEATURE_RO_COMPAT_SPARSE_SUPER     0x0001
-#define EXT4_FEATURE_RO_COMPAT_LARGE_FILE       0x0002
-#define EXT4_FEATURE_RO_COMPAT_BTREE_DIR        0x0004
-#define EXT4_FEATURE_RO_COMPAT_HUGE_FILE        0x0008
-#define EXT4_FEATURE_RO_COMPAT_GDT_CSUM         0x0010
-#define EXT4_FEATURE_RO_COMPAT_DIR_NLINK        0x0020
-#define EXT4_FEATURE_RO_COMPAT_EXTRA_ISIZE      0x0040
-
-#define EXT4_FEATURE_INCOMPAT_COMPRESSION       0x0001
-#define EXT4_FEATURE_INCOMPAT_FILETYPE          0x0002
-#define EXT4_FEATURE_INCOMPAT_RECOVER           0x0004 /* Needs recovery */
-#define EXT4_FEATURE_INCOMPAT_JOURNAL_DEV       0x0008 /* Journal device */
-#define EXT4_FEATURE_INCOMPAT_META_BG           0x0010
-#define EXT4_FEATURE_INCOMPAT_EXTENTS           0x0040 /* extents support */
-#define EXT4_FEATURE_INCOMPAT_64BIT             0x0080
-#define EXT4_FEATURE_INCOMPAT_MMP               0x0100
-#define EXT4_FEATURE_INCOMPAT_FLEX_BG           0x0200
-
-#define EXT4_FEATURE_COMPAT_SUPP        EXT2_FEATURE_COMPAT_EXT_ATTR
-#define EXT4_FEATURE_INCOMPAT_SUPP      (EXT4_FEATURE_INCOMPAT_FILETYPE| \
-                                         EXT4_FEATURE_INCOMPAT_RECOVER| \
-                                         EXT4_FEATURE_INCOMPAT_META_BG| \
-                                         EXT4_FEATURE_INCOMPAT_EXTENTS| \
-                                         EXT4_FEATURE_INCOMPAT_64BIT| \
-                                         EXT4_FEATURE_INCOMPAT_FLEX_BG)
-#define EXT4_FEATURE_RO_COMPAT_SUPP     (EXT4_FEATURE_RO_COMPAT_SPARSE_SUPER| \
-                                         EXT4_FEATURE_RO_COMPAT_LARGE_FILE| \
-                                         EXT4_FEATURE_RO_COMPAT_GDT_CSUM| \
-                                         EXT4_FEATURE_RO_COMPAT_DIR_NLINK | \
-                                         EXT4_FEATURE_RO_COMPAT_EXTRA_ISIZE | \
-                                         EXT4_FEATURE_RO_COMPAT_BTREE_DIR |\
-                                         EXT4_FEATURE_RO_COMPAT_HUGE_FILE)
-
-/*
- * Default values for user and/or group using reserved blocks
- */
-#define EXT4_DEF_RESUID         0
-#define EXT4_DEF_RESGID         0
-
-/*
- * Default mount options
- */
-#define EXT4_DEFM_DEBUG         0x0001
-#define EXT4_DEFM_BSDGROUPS     0x0002
-#define EXT4_DEFM_XATTR_USER    0x0004
-#define EXT4_DEFM_ACL           0x0008
-#define EXT4_DEFM_UID16         0x0010
-#define EXT4_DEFM_JMODE         0x0060
-#define EXT4_DEFM_JMODE_DATA    0x0020
-#define EXT4_DEFM_JMODE_ORDERED 0x0040
-#define EXT4_DEFM_JMODE_WBACK   0x0060
-
-/*
- * Structure of a directory entry
- */
-#define EXT4_NAME_LEN 255
-
-struct ext4_dir_entry {
-        __le32  inode;                  /* Inode number */
-        __le16  rec_len;                /* Directory entry length */
-        __le16  name_len;               /* Name length */
-        char    name[EXT4_NAME_LEN];    /* File name */
-};
-
-/*
- * The new version of the directory entry.  Since EXT4 structures are
- * stored in intel byte order, and the name_len field could never be
- * bigger than 255 chars, it's safe to reclaim the extra byte for the
- * file_type field.
- */
-struct ext4_dir_entry_2 {
-        __le32  inode;                  /* Inode number */
-        __le16  rec_len;                /* Directory entry length */
-        __u8    name_len;               /* Name length */
-        __u8    file_type;
-        char    name[EXT4_NAME_LEN];    /* File name */
-};
-
-/*
- * Ext4 directory file types.  Only the low 3 bits are used.  The
- * other bits are reserved for now.
- */
-#define EXT4_FT_UNKNOWN         0
-#define EXT4_FT_REG_FILE        1
-#define EXT4_FT_DIR             2
-#define EXT4_FT_CHRDEV          3
-#define EXT4_FT_BLKDEV          4
-#define EXT4_FT_FIFO            5
-#define EXT4_FT_SOCK            6
-#define EXT4_FT_SYMLINK         7
-
-#define EXT4_FT_MAX             8
-
-/*
- * EXT4_DIR_PAD defines the directory entries boundaries
- *
- * NOTE: It must be a multiple of 4
- */
-#define EXT4_DIR_PAD                    4
-#define EXT4_DIR_ROUND                  (EXT4_DIR_PAD - 1)
-#define EXT4_DIR_REC_LEN(name_len)      (((name_len) + 8 + EXT4_DIR_ROUND) & \
-                                         ~EXT4_DIR_ROUND)
-#define EXT4_MAX_REC_LEN                ((1<<16)-1)
-
-static inline unsigned ext4_rec_len_from_disk(__le16 dlen)
-{
-        unsigned len = le16_to_cpu(dlen);
-
-        if (len == EXT4_MAX_REC_LEN)
-                return 1 << 16;
-        return len;
-}
-
-static inline __le16 ext4_rec_len_to_disk(unsigned len)
-{
-        if (len == (1 << 16))
-                return cpu_to_le16(EXT4_MAX_REC_LEN);
-        else if (len > (1 << 16))
-                BUG();
-        return cpu_to_le16(len);
-}
-
-/*
- * Hash Tree Directory indexing
- * (c) Daniel Phillips, 2001
- */
-
-#define is_dx(dir) (EXT4_HAS_COMPAT_FEATURE(dir->i_sb, \
-                                      EXT4_FEATURE_COMPAT_DIR_INDEX) && \
-                      (EXT4_I(dir)->i_flags & EXT4_INDEX_FL))
-#define EXT4_DIR_LINK_MAX(dir) (!is_dx(dir) && (dir)->i_nlink >= EXT4_LINK_MAX)
-#define EXT4_DIR_LINK_EMPTY(dir) ((dir)->i_nlink == 2 || (dir)->i_nlink == 1)
-
-/* Legal values for the dx_root hash_version field: */
-
-#define DX_HASH_LEGACY          0
-#define DX_HASH_HALF_MD4        1
-#define DX_HASH_TEA             2
-
-#ifdef __KERNEL__
-
-/* hash info structure used by the directory hash */
-struct dx_hash_info
-{
-        u32             hash;
-        u32             minor_hash;
-        int             hash_version;
-        u32             *seed;
-};
-
-#define EXT4_HTREE_EOF  0x7fffffff
-
-/*
- * Control parameters used by ext4_htree_next_block
- */
-#define HASH_NB_ALWAYS          1
-
-
-/*
- * Describe an inode's exact location on disk and in memory
- */
-struct ext4_iloc
-{
-        struct buffer_head *bh;
-        unsigned long offset;
-        ext4_group_t block_group;
-};
-
-static inline struct ext4_inode *ext4_raw_inode(struct ext4_iloc *iloc)
-{
-        return (struct ext4_inode *) (iloc->bh->b_data + iloc->offset);
-}
-
-/*
- * This structure is stuffed into the struct file's private_data field
- * for directories.  It is where we put information so that we can do
- * readdir operations in hash tree order.
- */
-struct dir_private_info {
-        struct rb_root  root;
-        struct rb_node  *curr_node;
-        struct fname    *extra_fname;
-        loff_t          last_pos;
-        __u32           curr_hash;
-        __u32           curr_minor_hash;
-        __u32           next_hash;
-};
-
-/* calculate the first block number of the group */
-static inline ext4_fsblk_t
-ext4_group_first_block_no(struct super_block *sb, ext4_group_t group_no)
-{
-        return group_no * (ext4_fsblk_t)EXT4_BLOCKS_PER_GROUP(sb) +
-                le32_to_cpu(EXT4_SB(sb)->s_es->s_first_data_block);
-}
-
-/*
- * Special error return code only used by dx_probe() and its callers.
- */
-#define ERR_BAD_DX_DIR  -75000
-
-void ext4_get_group_no_and_offset(struct super_block *sb, ext4_fsblk_t blocknr,
-                        unsigned long *blockgrpp, ext4_grpblk_t *offsetp);
-
-/*
- * Function prototypes
- */
-
-/*
- * Ok, these declarations are also in <linux/kernel.h> but none of the
- * ext4 source programs needs to include it so they are duplicated here.
- */
-# define NORET_TYPE     /**/
-# define ATTRIB_NORET   __attribute__((noreturn))
-# define NORET_AND      noreturn,
-
-/* balloc.c */
-extern unsigned int ext4_block_group(struct super_block *sb,
-                        ext4_fsblk_t blocknr);
-extern ext4_grpblk_t ext4_block_group_offset(struct super_block *sb,
-                        ext4_fsblk_t blocknr);
-extern int ext4_bg_has_super(struct super_block *sb, ext4_group_t group);
-extern unsigned long ext4_bg_num_gdb(struct super_block *sb,
-                        ext4_group_t group);
-extern ext4_fsblk_t ext4_new_block (handle_t *handle, struct inode *inode,
-                        ext4_fsblk_t goal, int *errp);
-extern ext4_fsblk_t ext4_new_blocks (handle_t *handle, struct inode *inode,
-                        ext4_fsblk_t goal, unsigned long *count, int *errp);
-extern ext4_fsblk_t ext4_new_blocks_old(handle_t *handle, struct inode *inode,
-                        ext4_fsblk_t goal, unsigned long *count, int *errp);
-extern void ext4_free_blocks (handle_t *handle, struct inode *inode,
-                        ext4_fsblk_t block, unsigned long count, int metadata);
-extern void ext4_free_blocks_sb (handle_t *handle, struct super_block *sb,
-                                 ext4_fsblk_t block, unsigned long count,
-                                unsigned long *pdquot_freed_blocks);
-extern ext4_fsblk_t ext4_count_free_blocks (struct super_block *);
-extern void ext4_check_blocks_bitmap (struct super_block *);
-extern struct ext4_group_desc * ext4_get_group_desc(struct super_block * sb,
-                                                    ext4_group_t block_group,
-                                                    struct buffer_head ** bh);
-extern int ext4_should_retry_alloc(struct super_block *sb, int *retries);
-extern void ext4_init_block_alloc_info(struct inode *);
-extern void ext4_rsv_window_add(struct super_block *sb, struct ext4_reserve_window_node *rsv);
-
-/* dir.c */
-extern int ext4_check_dir_entry(const char *, struct inode *,
-                                struct ext4_dir_entry_2 *,
-                                struct buffer_head *, unsigned long);
-extern int ext4_htree_store_dirent(struct file *dir_file, __u32 hash,
-                                    __u32 minor_hash,
-                                    struct ext4_dir_entry_2 *dirent);
-extern void ext4_htree_free_dir_info(struct dir_private_info *p);
-
-/* fsync.c */
-extern int ext4_sync_file (struct file *, struct dentry *, int);
-
-/* hash.c */
-extern int ext4fs_dirhash(const char *name, int len, struct
-                          dx_hash_info *hinfo);
-
-/* ialloc.c */
-extern struct inode * ext4_new_inode (handle_t *, struct inode *, int);
-extern void ext4_free_inode (handle_t *, struct inode *);
-extern struct inode * ext4_orphan_get (struct super_block *, unsigned long);
-extern unsigned long ext4_count_free_inodes (struct super_block *);
-extern unsigned long ext4_count_dirs (struct super_block *);
-extern void ext4_check_inodes_bitmap (struct super_block *);
-extern unsigned long ext4_count_free (struct buffer_head *, unsigned);
-
-/* mballoc.c */
-extern long ext4_mb_stats;
-extern long ext4_mb_max_to_scan;
-extern int ext4_mb_init(struct super_block *, int);
-extern int ext4_mb_release(struct super_block *);
-extern ext4_fsblk_t ext4_mb_new_blocks(handle_t *,
-                                struct ext4_allocation_request *, int *);
-extern int ext4_mb_reserve_blocks(struct super_block *, int);
-extern void ext4_mb_discard_inode_preallocations(struct inode *);
-extern int __init init_ext4_mballoc(void);
-extern void exit_ext4_mballoc(void);
-extern void ext4_mb_free_blocks(handle_t *, struct inode *,
-                unsigned long, unsigned long, int, unsigned long *);
-
-
-/* inode.c */
-int ext4_forget(handle_t *handle, int is_metadata, struct inode *inode,
-                struct buffer_head *bh, ext4_fsblk_t blocknr);
-struct buffer_head *ext4_getblk(handle_t *, struct inode *,
-                                                ext4_lblk_t, int, int *);
-struct buffer_head *ext4_bread(handle_t *, struct inode *,
-                                                ext4_lblk_t, int, int *);
-int ext4_get_blocks_handle(handle_t *handle, struct inode *inode,
-                                ext4_lblk_t iblock, unsigned long maxblocks,
-                                struct buffer_head *bh_result,
-                                int create, int extend_disksize);
-
-extern struct inode *ext4_iget(struct super_block *, unsigned long);
-extern int  ext4_write_inode (struct inode *, int);
-extern int  ext4_setattr (struct dentry *, struct iattr *);
-extern void ext4_delete_inode (struct inode *);
-extern int  ext4_sync_inode (handle_t *, struct inode *);
-extern void ext4_discard_reservation (struct inode *);
-extern void ext4_dirty_inode(struct inode *);
-extern int ext4_change_inode_journal_flag(struct inode *, int);
-extern int ext4_get_inode_loc(struct inode *, struct ext4_iloc *);
-extern void ext4_truncate (struct inode *);
-extern void ext4_set_inode_flags(struct inode *);
-extern void ext4_get_inode_flags(struct ext4_inode_info *);
-extern void ext4_set_aops(struct inode *inode);
-extern int ext4_writepage_trans_blocks(struct inode *);
-extern int ext4_block_truncate_page(handle_t *handle, struct page *page,
-                struct address_space *mapping, loff_t from);
-
-/* ioctl.c */
-extern int ext4_ioctl (struct inode *, struct file *, unsigned int,
-                       unsigned long);
-extern long ext4_compat_ioctl (struct file *, unsigned int, unsigned long);
-
-/* migrate.c */
-extern int ext4_ext_migrate(struct inode *, struct file *, unsigned int,
-                       unsigned long);
-/* namei.c */
-extern int ext4_orphan_add(handle_t *, struct inode *);
-extern int ext4_orphan_del(handle_t *, struct inode *);
-extern int ext4_htree_fill_tree(struct file *dir_file, __u32 start_hash,
-                                __u32 start_minor_hash, __u32 *next_hash);
-
-/* resize.c */
-extern int ext4_group_add(struct super_block *sb,
-                                struct ext4_new_group_data *input);
-extern int ext4_group_extend(struct super_block *sb,
-                                struct ext4_super_block *es,
-                                ext4_fsblk_t n_blocks_count);
-
-/* super.c */
-extern void ext4_error (struct super_block *, const char *, const char *, ...)
-        __attribute__ ((format (printf, 3, 4)));
-extern void __ext4_std_error (struct super_block *, const char *, int);
-extern void ext4_abort (struct super_block *, const char *, const char *, ...)
-        __attribute__ ((format (printf, 3, 4)));
-extern void ext4_warning (struct super_block *, const char *, const char *, ...)
-        __attribute__ ((format (printf, 3, 4)));
-extern void ext4_update_dynamic_rev (struct super_block *sb);
-extern int ext4_update_compat_feature(handle_t *handle, struct super_block *sb,
-                                        __u32 compat);
-extern int ext4_update_rocompat_feature(handle_t *handle,
-                                        struct super_block *sb, __u32 rocompat);
-extern int ext4_update_incompat_feature(handle_t *handle,
-                                        struct super_block *sb, __u32 incompat);
-extern ext4_fsblk_t ext4_block_bitmap(struct super_block *sb,
-                                      struct ext4_group_desc *bg);
-extern ext4_fsblk_t ext4_inode_bitmap(struct super_block *sb,
-                                      struct ext4_group_desc *bg);
-extern ext4_fsblk_t ext4_inode_table(struct super_block *sb,
-                                     struct ext4_group_desc *bg);
-extern void ext4_block_bitmap_set(struct super_block *sb,
-                                  struct ext4_group_desc *bg, ext4_fsblk_t blk);
-extern void ext4_inode_bitmap_set(struct super_block *sb,
-                                  struct ext4_group_desc *bg, ext4_fsblk_t blk);
-extern void ext4_inode_table_set(struct super_block *sb,
-                                 struct ext4_group_desc *bg, ext4_fsblk_t blk);
-
-static inline ext4_fsblk_t ext4_blocks_count(struct ext4_super_block *es)
-{
-        return ((ext4_fsblk_t)le32_to_cpu(es->s_blocks_count_hi) << 32) |
-                le32_to_cpu(es->s_blocks_count_lo);
-}
-
-static inline ext4_fsblk_t ext4_r_blocks_count(struct ext4_super_block *es)
-{
-        return ((ext4_fsblk_t)le32_to_cpu(es->s_r_blocks_count_hi) << 32) |
-                le32_to_cpu(es->s_r_blocks_count_lo);
-}
-
-static inline ext4_fsblk_t ext4_free_blocks_count(struct ext4_super_block *es)
-{
-        return ((ext4_fsblk_t)le32_to_cpu(es->s_free_blocks_count_hi) << 32) |
-                le32_to_cpu(es->s_free_blocks_count_lo);
-}
-
-static inline void ext4_blocks_count_set(struct ext4_super_block *es,
-                                         ext4_fsblk_t blk)
-{
-        es->s_blocks_count_lo = cpu_to_le32((u32)blk);
-        es->s_blocks_count_hi = cpu_to_le32(blk >> 32);
-}
-
-static inline void ext4_free_blocks_count_set(struct ext4_super_block *es,
-                                              ext4_fsblk_t blk)
-{
-        es->s_free_blocks_count_lo = cpu_to_le32((u32)blk);
-        es->s_free_blocks_count_hi = cpu_to_le32(blk >> 32);
-}
-
-static inline void ext4_r_blocks_count_set(struct ext4_super_block *es,
-                                           ext4_fsblk_t blk)
-{
-        es->s_r_blocks_count_lo = cpu_to_le32((u32)blk);
-        es->s_r_blocks_count_hi = cpu_to_le32(blk >> 32);
-}
-
-static inline loff_t ext4_isize(struct ext4_inode *raw_inode)
-{
-        return ((loff_t)le32_to_cpu(raw_inode->i_size_high) << 32) |
-                le32_to_cpu(raw_inode->i_size_lo);
-}
-
-static inline void ext4_isize_set(struct ext4_inode *raw_inode, loff_t i_size)
-{
-        raw_inode->i_size_lo = cpu_to_le32(i_size);
-        raw_inode->i_size_high = cpu_to_le32(i_size >> 32);
-}
-
-static inline
-struct ext4_group_info *ext4_get_group_info(struct super_block *sb,
-                                                        ext4_group_t group)
-{
-         struct ext4_group_info ***grp_info;
-         long indexv, indexh;
-         grp_info = EXT4_SB(sb)->s_group_info;
-         indexv = group >> (EXT4_DESC_PER_BLOCK_BITS(sb));
-         indexh = group & ((EXT4_DESC_PER_BLOCK(sb)) - 1);
-         return grp_info[indexv][indexh];
-}
-
-
-#define ext4_std_error(sb, errno)                               \
-do {                                                            \
-        if ((errno))                                            \
-                __ext4_std_error((sb), __FUNCTION__, (errno));  \
-} while (0)
-
-/*
- * Inodes and files operations
- */
-
-/* dir.c */
-extern const struct file_operations ext4_dir_operations;
-
-/* file.c */
-extern const struct inode_operations ext4_file_inode_operations;
-extern const struct file_operations ext4_file_operations;
-
-/* namei.c */
-extern const struct inode_operations ext4_dir_inode_operations;
-extern const struct inode_operations ext4_special_inode_operations;
-
-/* symlink.c */
-extern const struct inode_operations ext4_symlink_inode_operations;
-extern const struct inode_operations ext4_fast_symlink_inode_operations;
-
-/* extents.c */
-extern int ext4_ext_tree_init(handle_t *handle, struct inode *);
-extern int ext4_ext_writepage_trans_blocks(struct inode *, int);
-extern int ext4_ext_get_blocks(handle_t *handle, struct inode *inode,
-                        ext4_lblk_t iblock,
-                        unsigned long max_blocks, struct buffer_head *bh_result,
-                        int create, int extend_disksize);
-extern void ext4_ext_truncate(struct inode *, struct page *);
-extern void ext4_ext_init(struct super_block *);
-extern void ext4_ext_release(struct super_block *);
-extern long ext4_fallocate(struct inode *inode, int mode, loff_t offset,
-                          loff_t len);
-extern int ext4_get_blocks_wrap(handle_t *handle, struct inode *inode,
-                        sector_t block, unsigned long max_blocks,
-                        struct buffer_head *bh, int create,
-                        int extend_disksize);
-#endif  /* __KERNEL__ */
-
-#endif  /* _LINUX_EXT4_FS_H */
diff --git a/include/linux/ext4_fs_extents.h b/include/linux/ext4_fs_extents.h
deleted file mode 100644
index 1285c583b2d8..000000000000
--- a/include/linux/ext4_fs_extents.h
+++ /dev/null
@@ -1,232 +0,0 @@
-/*
- * Copyright (c) 2003-2006, Cluster File Systems, Inc, info@clusterfs.com
- * Written by Alex Tomas <alex@clusterfs.com>
- *
- * This program is free software; you can redistribute it and/or modify
- * it under the terms of the GNU General Public License version 2 as
- * published by the Free Software Foundation.
- *
- * This program is distributed in the hope that it will be useful,
- * but WITHOUT ANY WARRANTY; without even the implied warranty of
- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
- * GNU General Public License for more details.
- *
- * You should have received a copy of the GNU General Public Licens
- * along with this program; if not, write to the Free Software
- * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-
- */
-
-#ifndef _LINUX_EXT4_EXTENTS
-#define _LINUX_EXT4_EXTENTS
-
-#include <linux/ext4_fs.h>
-
-/*
- * With AGGRESSIVE_TEST defined, the capacity of index/leaf blocks
- * becomes very small, so index split, in-depth growing and
- * other hard changes happen much more often.
- * This is for debug purposes only.
- */
-#define AGGRESSIVE_TEST_
-
-/*
- * With EXTENTS_STATS defined, the number of blocks and extents
- * are collected in the truncate path. They'll be shown at
- * umount time.
- */
-#define EXTENTS_STATS__
-
-/*
- * If CHECK_BINSEARCH is defined, then the results of the binary search
- * will also be checked by linear search.
- */
-#define CHECK_BINSEARCH__
-
-/*
- * If EXT_DEBUG is defined you can use the 'extdebug' mount option
- * to get lots of info about what's going on.
- */
-#define EXT_DEBUG__
-#ifdef EXT_DEBUG
-#define ext_debug(a...)         printk(a)
-#else
-#define ext_debug(a...)
-#endif
-
-/*
- * If EXT_STATS is defined then stats numbers are collected.
- * These number will be displayed at umount time.
- */
-#define EXT_STATS_
-
-
-/*
- * ext4_inode has i_block array (60 bytes total).
- * The first 12 bytes store ext4_extent_header;
- * the remainder stores an array of ext4_extent.
- */
-
-/*
- * This is the extent on-disk structure.
- * It's used at the bottom of the tree.
- */
-struct ext4_extent {
-        __le32  ee_block;       /* first logical block extent covers */
-        __le16  ee_len;         /* number of blocks covered by extent */
-        __le16  ee_start_hi;    /* high 16 bits of physical block */
-        __le32  ee_start_lo;    /* low 32 bits of physical block */
-};
-
-/*
- * This is index on-disk structure.
- * It's used at all the levels except the bottom.
- */
-struct ext4_extent_idx {
-        __le32  ei_block;       /* index covers logical blocks from 'block' */
-        __le32  ei_leaf_lo;     /* pointer to the physical block of the next *
-                                 * level. leaf or next index could be there */
-        __le16  ei_leaf_hi;     /* high 16 bits of physical block */
-        __u16   ei_unused;
-};
-
-/*
- * Each block (leaves and indexes), even inode-stored has header.
- */
-struct ext4_extent_header {
-        __le16  eh_magic;       /* probably will support different formats */
-        __le16  eh_entries;     /* number of valid entries */
-        __le16  eh_max;         /* capacity of store in entries */
-        __le16  eh_depth;       /* has tree real underlying blocks? */
-        __le32  eh_generation;  /* generation of the tree */
-};
-
-#define EXT4_EXT_MAGIC          cpu_to_le16(0xf30a)
-
-/*
- * Array of ext4_ext_path contains path to some extent.
- * Creation/lookup routines use it for traversal/splitting/etc.
- * Truncate uses it to simulate recursive walking.
- */
-struct ext4_ext_path {
-        ext4_fsblk_t                    p_block;
-        __u16                           p_depth;
-        struct ext4_extent              *p_ext;
-        struct ext4_extent_idx          *p_idx;
-        struct ext4_extent_header       *p_hdr;
-        struct buffer_head              *p_bh;
-};
-
-/*
- * structure for external API
- */
-
-#define EXT4_EXT_CACHE_NO       0
-#define EXT4_EXT_CACHE_GAP      1
-#define EXT4_EXT_CACHE_EXTENT   2
-
-
-#define EXT_MAX_BLOCK   0xffffffff
-
-/*
- * EXT_INIT_MAX_LEN is the maximum number of blocks we can have in an
- * initialized extent. This is 2^15 and not (2^16 - 1), since we use the
- * MSB of ee_len field in the extent datastructure to signify if this
- * particular extent is an initialized extent or an uninitialized (i.e.
- * preallocated).
- * EXT_UNINIT_MAX_LEN is the maximum number of blocks we can have in an
- * uninitialized extent.
- * If ee_len is <= 0x8000, it is an initialized extent. Otherwise, it is an
- * uninitialized one. In other words, if MSB of ee_len is set, it is an
- * uninitialized extent with only one special scenario when ee_len = 0x8000.
- * In this case we can not have an uninitialized extent of zero length and
- * thus we make it as a special case of initialized extent with 0x8000 length.
- * This way we get better extent-to-group alignment for initialized extents.
- * Hence, the maximum number of blocks we can have in an *initialized*
- * extent is 2^15 (32768) and in an *uninitialized* extent is 2^15-1 (32767).
- */
-#define EXT_INIT_MAX_LEN        (1UL << 15)
-#define EXT_UNINIT_MAX_LEN      (EXT_INIT_MAX_LEN - 1)
-
-
-#define EXT_FIRST_EXTENT(__hdr__) \
-        ((struct ext4_extent *) (((char *) (__hdr__)) +         \
-                                 sizeof(struct ext4_extent_header)))
-#define EXT_FIRST_INDEX(__hdr__) \
-        ((struct ext4_extent_idx *) (((char *) (__hdr__)) +     \
-                                     sizeof(struct ext4_extent_header)))
-#define EXT_HAS_FREE_INDEX(__path__) \
-        (le16_to_cpu((__path__)->p_hdr->eh_entries) \
-                                     < le16_to_cpu((__path__)->p_hdr->eh_max))
-#define EXT_LAST_EXTENT(__hdr__) \
-        (EXT_FIRST_EXTENT((__hdr__)) + le16_to_cpu((__hdr__)->eh_entries) - 1)
-#define EXT_LAST_INDEX(__hdr__) \
-        (EXT_FIRST_INDEX((__hdr__)) + le16_to_cpu((__hdr__)->eh_entries) - 1)
-#define EXT_MAX_EXTENT(__hdr__) \
-        (EXT_FIRST_EXTENT((__hdr__)) + le16_to_cpu((__hdr__)->eh_max) - 1)
-#define EXT_MAX_INDEX(__hdr__) \
-        (EXT_FIRST_INDEX((__hdr__)) + le16_to_cpu((__hdr__)->eh_max) - 1)
-
-static inline struct ext4_extent_header *ext_inode_hdr(struct inode *inode)
-{
-        return (struct ext4_extent_header *) EXT4_I(inode)->i_data;
-}
-
-static inline struct ext4_extent_header *ext_block_hdr(struct buffer_head *bh)
-{
-        return (struct ext4_extent_header *) bh->b_data;
-}
-
-static inline unsigned short ext_depth(struct inode *inode)
-{
-        return le16_to_cpu(ext_inode_hdr(inode)->eh_depth);
-}
-
-static inline void ext4_ext_tree_changed(struct inode *inode)
-{
-        EXT4_I(inode)->i_ext_generation++;
-}
-
-static inline void
-ext4_ext_invalidate_cache(struct inode *inode)
-{
-        EXT4_I(inode)->i_cached_extent.ec_type = EXT4_EXT_CACHE_NO;
-}
-
-static inline void ext4_ext_mark_uninitialized(struct ext4_extent *ext)
-{
-        /* We can not have an uninitialized extent of zero length! */
-        BUG_ON((le16_to_cpu(ext->ee_len) & ~EXT_INIT_MAX_LEN) == 0);
-        ext->ee_len |= cpu_to_le16(EXT_INIT_MAX_LEN);
-}
-
-static inline int ext4_ext_is_uninitialized(struct ext4_extent *ext)
-{
-        /* Extent with ee_len of 0x8000 is treated as an initialized extent */
-        return (le16_to_cpu(ext->ee_len) > EXT_INIT_MAX_LEN);
-}
-
-static inline int ext4_ext_get_actual_len(struct ext4_extent *ext)
-{
-        return (le16_to_cpu(ext->ee_len) <= EXT_INIT_MAX_LEN ?
-                le16_to_cpu(ext->ee_len) :
-                (le16_to_cpu(ext->ee_len) - EXT_INIT_MAX_LEN));
-}
-
-extern ext4_fsblk_t idx_pblock(struct ext4_extent_idx *);
-extern void ext4_ext_store_pblock(struct ext4_extent *, ext4_fsblk_t);
-extern int ext4_extent_tree_init(handle_t *, struct inode *);
-extern int ext4_ext_calc_credits_for_insert(struct inode *, struct ext4_ext_path *);
-extern int ext4_ext_try_to_merge(struct inode *inode,
-                                 struct ext4_ext_path *path,
-                                 struct ext4_extent *);
-extern unsigned int ext4_ext_check_overlap(struct inode *, struct ext4_extent *, struct ext4_ext_path *);
-extern int ext4_ext_insert_extent(handle_t *, struct inode *, struct ext4_ext_path *, struct ext4_extent *);
-extern struct ext4_ext_path *ext4_ext_find_extent(struct inode *, ext4_lblk_t,
-                                                        struct ext4_ext_path *);
-extern int ext4_ext_search_left(struct inode *, struct ext4_ext_path *,
-                                                ext4_lblk_t *, ext4_fsblk_t *);
-extern int ext4_ext_search_right(struct inode *, struct ext4_ext_path *,
-                                                ext4_lblk_t *, ext4_fsblk_t *);
-extern void ext4_ext_drop_refs(struct ext4_ext_path *);
-#endif /* _LINUX_EXT4_EXTENTS */
-
diff --git a/include/linux/ext4_fs_i.h b/include/linux/ext4_fs_i.h
deleted file mode 100644
index d5508d3cf290..000000000000
--- a/include/linux/ext4_fs_i.h
+++ /dev/null
@@ -1,167 +0,0 @@
-/*
- *  linux/include/linux/ext4_fs_i.h
- *
- * Copyright (C) 1992, 1993, 1994, 1995
- * Remy Card (card@masi.ibp.fr)
- * Laboratoire MASI - Institut Blaise Pascal
- * Universite Pierre et Marie Curie (Paris VI)
- *
- *  from
- *
- *  linux/include/linux/minix_fs_i.h
- *
- *  Copyright (C) 1991, 1992  Linus Torvalds
- */
-
-#ifndef _LINUX_EXT4_FS_I
-#define _LINUX_EXT4_FS_I
-
-#include <linux/rwsem.h>
-#include <linux/rbtree.h>
-#include <linux/seqlock.h>
-#include <linux/mutex.h>
-
-/* data type for block offset of block group */
-typedef int ext4_grpblk_t;
-
-/* data type for filesystem-wide blocks number */
-typedef unsigned long long ext4_fsblk_t;
-
-/* data type for file logical block number */
-typedef __u32 ext4_lblk_t;
-
-/* data type for block group number */
-typedef unsigned long ext4_group_t;
-
-struct ext4_reserve_window {
-        ext4_fsblk_t    _rsv_start;     /* First byte reserved */
-        ext4_fsblk_t    _rsv_end;       /* Last byte reserved or 0 */
-};
-
-struct ext4_reserve_window_node {
-        struct rb_node          rsv_node;
-        __u32                   rsv_goal_size;
-        __u32                   rsv_alloc_hit;
-        struct ext4_reserve_window      rsv_window;
-};
-
-struct ext4_block_alloc_info {
-        /* information about reservation window */
-        struct ext4_reserve_window_node rsv_window_node;
-        /*
-         * was i_next_alloc_block in ext4_inode_info
-         * is the logical (file-relative) number of the
-         * most-recently-allocated block in this file.
-         * We use this for detecting linearly ascending allocation requests.
-         */
-        ext4_lblk_t last_alloc_logical_block;
-        /*
-         * Was i_next_alloc_goal in ext4_inode_info
-         * is the *physical* companion to i_next_alloc_block.
-         * it the physical block number of the block which was most-recentl
-         * allocated to this file.  This give us the goal (target) for the next
-         * allocation when we detect linearly ascending requests.
-         */
-        ext4_fsblk_t last_alloc_physical_block;
-};
-
-#define rsv_start rsv_window._rsv_start
-#define rsv_end rsv_window._rsv_end
-
-/*
- * storage for cached extent
- */
-struct ext4_ext_cache {
-        ext4_fsblk_t    ec_start;
-        ext4_lblk_t     ec_block;
-        __u32           ec_len; /* must be 32bit to return holes */
-        __u32           ec_type;
-};
-
-/*
- * third extended file system inode data in memory
- */
-struct ext4_inode_info {
-        __le32  i_data[15];     /* unconverted */
-        __u32   i_flags;
-        ext4_fsblk_t    i_file_acl;
-        __u32   i_dtime;
-
-        /*
-         * i_block_group is the number of the block group which contains
-         * this file's inode.  Constant across the lifetime of the inode,
-         * it is ued for making block allocation decisions - we try to
-         * place a file's data blocks near its inode block, and new inodes
-         * near to their parent directory's inode.
-         */
-        ext4_group_t    i_block_group;
-        __u32   i_state;                /* Dynamic state flags for ext4 */
-
-        /* block reservation info */
-        struct ext4_block_alloc_info *i_block_alloc_info;
-
-        ext4_lblk_t             i_dir_start_lookup;
-#ifdef CONFIG_EXT4DEV_FS_XATTR
-        /*
-         * Extended attributes can be read independently of the main file
-         * data. Taking i_mutex even when reading would cause contention
-         * between readers of EAs and writers of regular file data, so
-         * instead we synchronize on xattr_sem when reading or changing
-         * EAs.
-         */
-        struct rw_semaphore xattr_sem;
-#endif
-#ifdef CONFIG_EXT4DEV_FS_POSIX_ACL
-        struct posix_acl        *i_acl;
-        struct posix_acl        *i_default_acl;
-#endif
-
-        struct list_head i_orphan;      /* unlinked but open inodes */
-
-        /*
-         * i_disksize keeps track of what the inode size is ON DISK, not
-         * in memory.  During truncate, i_size is set to the new size by
-         * the VFS prior to calling ext4_truncate(), but the filesystem won't
-         * set i_disksize to 0 until the truncate is actually under way.
-         *
-         * The intent is that i_disksize always represents the blocks which
-         * are used by this file.  This allows recovery to restart truncate
-         * on orphans if we crash during truncate.  We actually write i_disksize
-         * into the on-disk inode when writing inodes out, instead of i_size.
-         *
-         * The only time when i_disksize and i_size may be different is when
-         * a truncate is in progress.  The only things which change i_disksize
-         * are ext4_get_block (growth) and ext4_truncate (shrinkth).
-         */
-        loff_t  i_disksize;
-
-        /* on-disk additional length */
-        __u16 i_extra_isize;
-
-        /*
-         * i_data_sem is for serialising ext4_truncate() against
-         * ext4_getblock().  In the 2.4 ext2 design, great chunks of inode's
-         * data tree are chopped off during truncate. We can't do that in
-         * ext4 because whenever we perform intermediate commits during
-         * truncate, the inode and all the metadata blocks *must* be in a
-         * consistent state which allows truncation of the orphans to restart
-         * during recovery.  Hence we must fix the get_block-vs-truncate race
-         * by other means, so we have i_data_sem.
-         */
-        struct rw_semaphore i_data_sem;
-        struct inode vfs_inode;
-
-        unsigned long i_ext_generation;
-        struct ext4_ext_cache i_cached_extent;
-        /*
-         * File creation time. Its function is same as that of
-         * struct timespec i_{a,c,m}time in the generic inode.
-         */
-        struct timespec i_crtime;
-
-        /* mballoc */
-        struct list_head i_prealloc_list;
-        spinlock_t i_prealloc_lock;
-};
-
-#endif  /* _LINUX_EXT4_FS_I */
diff --git a/include/linux/ext4_fs_sb.h b/include/linux/ext4_fs_sb.h
deleted file mode 100644
index abaae2c8cccf..000000000000
--- a/include/linux/ext4_fs_sb.h
+++ /dev/null
@@ -1,148 +0,0 @@
-/*
- *  linux/include/linux/ext4_fs_sb.h
- *
- * Copyright (C) 1992, 1993, 1994, 1995
- * Remy Card (card@masi.ibp.fr)
- * Laboratoire MASI - Institut Blaise Pascal
- * Universite Pierre et Marie Curie (Paris VI)
- *
- *  from
- *
- *  linux/include/linux/minix_fs_sb.h
- *
- *  Copyright (C) 1991, 1992  Linus Torvalds
- */
-
-#ifndef _LINUX_EXT4_FS_SB
-#define _LINUX_EXT4_FS_SB
-
-#ifdef __KERNEL__
-#include <linux/timer.h>
-#include <linux/wait.h>
-#include <linux/blockgroup_lock.h>
-#include <linux/percpu_counter.h>
-#endif
-#include <linux/rbtree.h>
-
-/*
- * third extended-fs super-block data in memory
- */
-struct ext4_sb_info {
-        unsigned long s_desc_size;      /* Size of a group descriptor in bytes */
-        unsigned long s_inodes_per_block;/* Number of inodes per block */
-        unsigned long s_blocks_per_group;/* Number of blocks in a group */
-        unsigned long s_inodes_per_group;/* Number of inodes in a group */
-        unsigned long s_itb_per_group;  /* Number of inode table blocks per group */
-        unsigned long s_gdb_count;      /* Number of group descriptor blocks */
-        unsigned long s_desc_per_block; /* Number of group descriptors per block */
-        ext4_group_t s_groups_count;    /* Number of groups in the fs */
-        unsigned long s_overhead_last;  /* Last calculated overhead */
-        unsigned long s_blocks_last;    /* Last seen block count */
-        loff_t s_bitmap_maxbytes;       /* max bytes for bitmap files */
-        struct buffer_head * s_sbh;     /* Buffer containing the super block */
-        struct ext4_super_block * s_es; /* Pointer to the super block in the buffer */
-        struct buffer_head ** s_group_desc;
-        unsigned long  s_mount_opt;
-        ext4_fsblk_t s_sb_block;
-        uid_t s_resuid;
-        gid_t s_resgid;
-        unsigned short s_mount_state;
-        unsigned short s_pad;
-        int s_addr_per_block_bits;
-        int s_desc_per_block_bits;
-        int s_inode_size;
-        int s_first_ino;
-        spinlock_t s_next_gen_lock;
-        u32 s_next_generation;
-        u32 s_hash_seed[4];
-        int s_def_hash_version;
-        struct percpu_counter s_freeblocks_counter;
-        struct percpu_counter s_freeinodes_counter;
-        struct percpu_counter s_dirs_counter;
-        struct blockgroup_lock s_blockgroup_lock;
-
-        /* root of the per fs reservation window tree */
-        spinlock_t s_rsv_window_lock;
-        struct rb_root s_rsv_window_root;
-        struct ext4_reserve_window_node s_rsv_window_head;
-
-        /* Journaling */
-        struct inode * s_journal_inode;
-        struct journal_s * s_journal;
-        struct list_head s_orphan;
-        unsigned long s_commit_interval;
-        struct block_device *journal_bdev;
-#ifdef CONFIG_JBD2_DEBUG
-        struct timer_list turn_ro_timer;        /* For turning read-only (crash simulation) */
-        wait_queue_head_t ro_wait_queue;        /* For people waiting for the fs to go read-only */
-#endif
-#ifdef CONFIG_QUOTA
-        char *s_qf_names[MAXQUOTAS];            /* Names of quota files with journalled quota */
-        int s_jquota_fmt;                       /* Format of quota to use */
-#endif
-        unsigned int s_want_extra_isize; /* New inodes should reserve # bytes */
-
-#ifdef EXTENTS_STATS
-        /* ext4 extents stats */
-        unsigned long s_ext_min;
-        unsigned long s_ext_max;
-        unsigned long s_depth_max;
-        spinlock_t s_ext_stats_lock;
-        unsigned long s_ext_blocks;
-        unsigned long s_ext_extents;
-#endif
-
-        /* for buddy allocator */
-        struct ext4_group_info ***s_group_info;
-        struct inode *s_buddy_cache;
-        long s_blocks_reserved;
-        spinlock_t s_reserve_lock;
-        struct list_head s_active_transaction;
-        struct list_head s_closed_transaction;
-        struct list_head s_committed_transaction;
-        spinlock_t s_md_lock;
-        tid_t s_last_transaction;
-        unsigned short *s_mb_offsets, *s_mb_maxs;
-
-        /* tunables */
-        unsigned long s_stripe;
-        unsigned long s_mb_stream_request;
-        unsigned long s_mb_max_to_scan;
-        unsigned long s_mb_min_to_scan;
-        unsigned long s_mb_stats;
-        unsigned long s_mb_order2_reqs;
-        unsigned long s_mb_group_prealloc;
-        /* where last allocation was done - for stream allocation */
-        unsigned long s_mb_last_group;
-        unsigned long s_mb_last_start;
-
-        /* history to debug policy */
-        struct ext4_mb_history *s_mb_history;
-        int s_mb_history_cur;
-        int s_mb_history_max;
-        int s_mb_history_num;
-        struct proc_dir_entry *s_mb_proc;
-        spinlock_t s_mb_history_lock;
-        int s_mb_history_filter;
-
-        /* stats for buddy allocator */
-        spinlock_t s_mb_pa_lock;
-        atomic_t s_bal_reqs;    /* number of reqs with len > 1 */
-        atomic_t s_bal_success; /* we found long enough chunks */
-        atomic_t s_bal_allocated;       /* in blocks */
-        atomic_t s_bal_ex_scanned;      /* total extents scanned */
-        atomic_t s_bal_goals;   /* goal hits */
-        atomic_t s_bal_breaks;  /* too long searches */
-        atomic_t s_bal_2orders; /* 2^order hits */
-        spinlock_t s_bal_lock;
-        unsigned long s_mb_buddies_generated;
-        unsigned long long s_mb_generation_time;
-        atomic_t s_mb_lost_chunks;
-        atomic_t s_mb_preallocated;
-        atomic_t s_mb_discarded;
-
-        /* locality groups */
-        struct ext4_locality_group *s_locality_groups;
-};
-
-#endif  /* _LINUX_EXT4_FS_SB */
diff --git a/include/linux/ext4_jbd2.h b/include/linux/ext4_jbd2.h
deleted file mode 100644
index 38c71d3c8dbf..000000000000
--- a/include/linux/ext4_jbd2.h
+++ /dev/null
@@ -1,231 +0,0 @@
-/*
- * linux/include/linux/ext4_jbd2.h
- *
- * Written by Stephen C. Tweedie <sct@redhat.com>, 1999
- *
- * Copyright 1998--1999 Red Hat corp --- All Rights Reserved
- *
- * This file is part of the Linux kernel and is made available under
- * the terms of the GNU General Public License, version 2, or at your
- * option, any later version, incorporated herein by reference.
- *
- * Ext4-specific journaling extensions.
- */
-
-#ifndef _LINUX_EXT4_JBD2_H
-#define _LINUX_EXT4_JBD2_H
-
-#include <linux/fs.h>
-#include <linux/jbd2.h>
-#include <linux/ext4_fs.h>
-
-#define EXT4_JOURNAL(inode)     (EXT4_SB((inode)->i_sb)->s_journal)
-
-/* Define the number of blocks we need to account to a transaction to
- * modify one block of data.
- *
- * We may have to touch one inode, one bitmap buffer, up to three
- * indirection blocks, the group and superblock summaries, and the data
- * block to complete the transaction.
- *
- * For extents-enabled fs we may have to allocate and modify up to
- * 5 levels of tree + root which are stored in the inode. */
-
-#define EXT4_SINGLEDATA_TRANS_BLOCKS(sb)                                \
-        (EXT4_HAS_INCOMPAT_FEATURE(sb, EXT4_FEATURE_INCOMPAT_EXTENTS)   \
-                || test_opt(sb, EXTENTS) ? 27U : 8U)
-
-/* Extended attribute operations touch at most two data buffers,
- * two bitmap buffers, and two group summaries, in addition to the inode
- * and the superblock, which are already accounted for. */
-
-#define EXT4_XATTR_TRANS_BLOCKS         6U
-
-/* Define the minimum size for a transaction which modifies data.  This
- * needs to take into account the fact that we may end up modifying two
- * quota files too (one for the group, one for the user quota).  The
- * superblock only gets updated once, of course, so don't bother
- * counting that again for the quota updates. */
-
-#define EXT4_DATA_TRANS_BLOCKS(sb)      (EXT4_SINGLEDATA_TRANS_BLOCKS(sb) + \
-                                         EXT4_XATTR_TRANS_BLOCKS - 2 + \
-                                         2*EXT4_QUOTA_TRANS_BLOCKS(sb))
-
-/* Delete operations potentially hit one directory's namespace plus an
- * entire inode, plus arbitrary amounts of bitmap/indirection data.  Be
- * generous.  We can grow the delete transaction later if necessary. */
-
-#define EXT4_DELETE_TRANS_BLOCKS(sb)    (2 * EXT4_DATA_TRANS_BLOCKS(sb) + 64)
-
-/* Define an arbitrary limit for the amount of data we will anticipate
- * writing to any given transaction.  For unbounded transactions such as
- * write(2) and truncate(2) we can write more than this, but we always
- * start off at the maximum transaction size and grow the transaction
- * optimistically as we go. */
-
-#define EXT4_MAX_TRANS_DATA             64U
-
-/* We break up a large truncate or write transaction once the handle's
- * buffer credits gets this low, we need either to extend the
- * transaction or to start a new one.  Reserve enough space here for
- * inode, bitmap, superblock, group and indirection updates for at least
- * one block, plus two quota updates.  Quota allocations are not
- * needed. */
-
-#define EXT4_RESERVE_TRANS_BLOCKS       12U
-
-#define EXT4_INDEX_EXTRA_TRANS_BLOCKS   8
-
-#ifdef CONFIG_QUOTA
-/* Amount of blocks needed for quota update - we know that the structure was
- * allocated so we need to update only inode+data */
-#define EXT4_QUOTA_TRANS_BLOCKS(sb) (test_opt(sb, QUOTA) ? 2 : 0)
-/* Amount of blocks needed for quota insert/delete - we do some block writes
- * but inode, sb and group updates are done only once */
-#define EXT4_QUOTA_INIT_BLOCKS(sb) (test_opt(sb, QUOTA) ? (DQUOT_INIT_ALLOC*\
-                (EXT4_SINGLEDATA_TRANS_BLOCKS(sb)-3)+3+DQUOT_INIT_REWRITE) : 0)
-#define EXT4_QUOTA_DEL_BLOCKS(sb) (test_opt(sb, QUOTA) ? (DQUOT_DEL_ALLOC*\
-                (EXT4_SINGLEDATA_TRANS_BLOCKS(sb)-3)+3+DQUOT_DEL_REWRITE) : 0)
-#else
-#define EXT4_QUOTA_TRANS_BLOCKS(sb) 0
-#define EXT4_QUOTA_INIT_BLOCKS(sb) 0
-#define EXT4_QUOTA_DEL_BLOCKS(sb) 0
-#endif
-
-int
-ext4_mark_iloc_dirty(handle_t *handle,
-                     struct inode *inode,
-                     struct ext4_iloc *iloc);
-
-/*
- * On success, We end up with an outstanding reference count against
- * iloc->bh.  This _must_ be cleaned up later.
- */
-
-int ext4_reserve_inode_write(handle_t *handle, struct inode *inode,
-                        struct ext4_iloc *iloc);
-
-int ext4_mark_inode_dirty(handle_t *handle, struct inode *inode);
-
-/*
- * Wrapper functions with which ext4 calls into JBD.  The intent here is
- * to allow these to be turned into appropriate stubs so ext4 can control
- * ext2 filesystems, so ext2+ext4 systems only nee one fs.  This work hasn't
- * been done yet.
- */
-
-static inline void ext4_journal_release_buffer(handle_t *handle,
-                                                struct buffer_head *bh)
-{
-        jbd2_journal_release_buffer(handle, bh);
-}
-
-void ext4_journal_abort_handle(const char *caller, const char *err_fn,
-                struct buffer_head *bh, handle_t *handle, int err);
-
-int __ext4_journal_get_undo_access(const char *where, handle_t *handle,
-                                struct buffer_head *bh);
-
-int __ext4_journal_get_write_access(const char *where, handle_t *handle,
-                                struct buffer_head *bh);
-
-int __ext4_journal_forget(const char *where, handle_t *handle,
-                                struct buffer_head *bh);
-
-int __ext4_journal_revoke(const char *where, handle_t *handle,
-                                ext4_fsblk_t blocknr, struct buffer_head *bh);
-
-int __ext4_journal_get_create_access(const char *where,
-                                handle_t *handle, struct buffer_head *bh);
-
-int __ext4_journal_dirty_metadata(const char *where,
-                                handle_t *handle, struct buffer_head *bh);
-
-#define ext4_journal_get_undo_access(handle, bh) \
-        __ext4_journal_get_undo_access(__FUNCTION__, (handle), (bh))
-#define ext4_journal_get_write_access(handle, bh) \
-        __ext4_journal_get_write_access(__FUNCTION__, (handle), (bh))
-#define ext4_journal_revoke(handle, blocknr, bh) \
-        __ext4_journal_revoke(__FUNCTION__, (handle), (blocknr), (bh))
-#define ext4_journal_get_create_access(handle, bh) \
-        __ext4_journal_get_create_access(__FUNCTION__, (handle), (bh))
-#define ext4_journal_dirty_metadata(handle, bh) \
-        __ext4_journal_dirty_metadata(__FUNCTION__, (handle), (bh))
-#define ext4_journal_forget(handle, bh) \
-        __ext4_journal_forget(__FUNCTION__, (handle), (bh))
-
-int ext4_journal_dirty_data(handle_t *handle, struct buffer_head *bh);
-
-handle_t *ext4_journal_start_sb(struct super_block *sb, int nblocks);
-int __ext4_journal_stop(const char *where, handle_t *handle);
-
-static inline handle_t *ext4_journal_start(struct inode *inode, int nblocks)
-{
-        return ext4_journal_start_sb(inode->i_sb, nblocks);
-}
-
-#define ext4_journal_stop(handle) \
-        __ext4_journal_stop(__FUNCTION__, (handle))
-
-static inline handle_t *ext4_journal_current_handle(void)
-{
-        return journal_current_handle();
-}
-
-static inline int ext4_journal_extend(handle_t *handle, int nblocks)
-{
-        return jbd2_journal_extend(handle, nblocks);
-}
-
-static inline int ext4_journal_restart(handle_t *handle, int nblocks)
-{
-        return jbd2_journal_restart(handle, nblocks);
-}
-
-static inline int ext4_journal_blocks_per_page(struct inode *inode)
-{
-        return jbd2_journal_blocks_per_page(inode);
-}
-
-static inline int ext4_journal_force_commit(journal_t *journal)
-{
-        return jbd2_journal_force_commit(journal);
-}
-
-/* super.c */
-int ext4_force_commit(struct super_block *sb);
-
-static inline int ext4_should_journal_data(struct inode *inode)
-{
-        if (!S_ISREG(inode->i_mode))
-                return 1;
-        if (test_opt(inode->i_sb, DATA_FLAGS) == EXT4_MOUNT_JOURNAL_DATA)
-                return 1;
-        if (EXT4_I(inode)->i_flags & EXT4_JOURNAL_DATA_FL)
-                return 1;
-        return 0;
-}
-
-static inline int ext4_should_order_data(struct inode *inode)
-{
-        if (!S_ISREG(inode->i_mode))
-                return 0;
-        if (EXT4_I(inode)->i_flags & EXT4_JOURNAL_DATA_FL)
-                return 0;
-        if (test_opt(inode->i_sb, DATA_FLAGS) == EXT4_MOUNT_ORDERED_DATA)
-                return 1;
-        return 0;
-}
-
-static inline int ext4_should_writeback_data(struct inode *inode)
-{
-        if (!S_ISREG(inode->i_mode))
-                return 0;
-        if (EXT4_I(inode)->i_flags & EXT4_JOURNAL_DATA_FL)
-                return 0;
-        if (test_opt(inode->i_sb, DATA_FLAGS) == EXT4_MOUNT_WRITEBACK_DATA)
-                return 1;
-        return 0;
-}
-
-#endif  /* _LINUX_EXT4_JBD2_H */
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(bpp)          (32 - bpp)
-#define FB_SHIFT_HIGH(val, bits)  ((val) >> (bits))
-#define FB_SHIFT_LOW(val, bits)   ((val) << (bits))
-#else
-#define FB_LEFT_POS(bpp)          (0)
-#define FB_SHIFT_HIGH(val, bits)  ((val) << (bits))
-#define FB_SHIFT_LOW(val, bits)   ((val) >> (bits))
-#endif
+#define FB_LEFT_POS(p, bpp)          (fb_be_math(p) ? (32 - (bpp)) : 0)
+#define FB_SHIFT_HIGH(p, val, bits)  (fb_be_math(p) ? (val) >> (bits) : \
+                                                      (val) << (bits))
+#define FB_SHIFT_LOW(p, val, bits)   (fb_be_math(p) ? (val) << (bits) : \
+                                                      (val) >> (bits))
 
     /*
      *  `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/fdtable.h b/include/linux/fdtable.h
new file mode 100644
index 000000000000..a118f3c0b240
--- /dev/null
+++ b/include/linux/fdtable.h
@@ -0,0 +1,99 @@
+/*
+ * descriptor table internals; you almost certainly want file.h instead.
+ */
+
+#ifndef __LINUX_FDTABLE_H
+#define __LINUX_FDTABLE_H
+
+#include <asm/atomic.h>
+#include <linux/posix_types.h>
+#include <linux/compiler.h>
+#include <linux/spinlock.h>
+#include <linux/rcupdate.h>
+#include <linux/types.h>
+
+/*
+ * The default fd array needs to be at least BITS_PER_LONG,
+ * as this is the granularity returned by copy_fdset().
+ */
+#define NR_OPEN_DEFAULT BITS_PER_LONG
+
+/*
+ * The embedded_fd_set is a small fd_set,
+ * suitable for most tasks (which open <= BITS_PER_LONG files)
+ */
+struct embedded_fd_set {
+        unsigned long fds_bits[1];
+};
+
+struct fdtable {
+        unsigned int max_fds;
+        struct file ** fd;      /* current fd array */
+        fd_set *close_on_exec;
+        fd_set *open_fds;
+        struct rcu_head rcu;
+        struct fdtable *next;
+};
+
+/*
+ * Open file table structure
+ */
+struct files_struct {
+  /*
+   * read mostly part
+   */
+        atomic_t count;
+        struct fdtable *fdt;
+        struct fdtable fdtab;
+  /*
+   * written part on a separate cache line in SMP
+   */
+        spinlock_t file_lock ____cacheline_aligned_in_smp;
+        int next_fd;
+        struct embedded_fd_set close_on_exec_init;
+        struct embedded_fd_set open_fds_init;
+        struct file * fd_array[NR_OPEN_DEFAULT];
+};
+
+#define files_fdtable(files) (rcu_dereference((files)->fdt))
+
+extern struct kmem_cache *filp_cachep;
+
+struct file_operations;
+struct vfsmount;
+struct dentry;
+
+extern int expand_files(struct files_struct *, int nr);
+extern void free_fdtable_rcu(struct rcu_head *rcu);
+extern void __init files_defer_init(void);
+
+static inline void free_fdtable(struct fdtable *fdt)
+{
+        call_rcu(&fdt->rcu, free_fdtable_rcu);
+}
+
+static inline struct file * fcheck_files(struct files_struct *files, unsigned int fd)
+{
+        struct file * file = NULL;
+        struct fdtable *fdt = files_fdtable(files);
+
+        if (fd < fdt->max_fds)
+                file = rcu_dereference(fdt->fd[fd]);
+        return file;
+}
+
+/*
+ * Check whether the specified fd has an open file.
+ */
+#define fcheck(fd)      fcheck_files(current->files, fd)
+
+struct task_struct;
+
+struct files_struct *get_files_struct(struct task_struct *);
+void put_files_struct(struct files_struct *fs);
+void reset_files_struct(struct files_struct *);
+int unshare_files(struct files_struct **);
+
+extern struct kmem_cache *files_cachep;
+
+#endif /* __LINUX_FDTABLE_H */
diff --git a/include/linux/file.h b/include/linux/file.h
index 69baf5a4f0a5..27c64bdc68c9 100644
--- a/include/linux/file.h
+++ b/include/linux/file.h
@@ -5,59 +5,11 @@
 #ifndef __LINUX_FILE_H
 #define __LINUX_FILE_H
 
-#include <asm/atomic.h>
-#include <linux/posix_types.h>
 #include <linux/compiler.h>
-#include <linux/spinlock.h>
-#include <linux/rcupdate.h>
 #include <linux/types.h>
+#include <linux/posix_types.h>
 
-/*
- * The default fd array needs to be at least BITS_PER_LONG,
- * as this is the granularity returned by copy_fdset().
- */
-#define NR_OPEN_DEFAULT BITS_PER_LONG
-
-/*
- * The embedded_fd_set is a small fd_set,
- * suitable for most tasks (which open <= BITS_PER_LONG files)
- */
-struct embedded_fd_set {
-        unsigned long fds_bits[1];
-};
-
-struct fdtable {
-        unsigned int max_fds;
-        struct file ** fd;      /* current fd array */
-        fd_set *close_on_exec;
-        fd_set *open_fds;
-        struct rcu_head rcu;
-        struct fdtable *next;
-};
-
-/*
- * Open file table structure
- */
-struct files_struct {
-  /*
-   * read mostly part
-   */
-        atomic_t count;
-        struct fdtable *fdt;
-        struct fdtable fdtab;
-  /*
-   * written part on a separate cache line in SMP
-   */
-        spinlock_t file_lock ____cacheline_aligned_in_smp;
-        int next_fd;
-        struct embedded_fd_set close_on_exec_init;
-        struct embedded_fd_set open_fds_init;
-        struct file * fd_array[NR_OPEN_DEFAULT];
-};
-
-#define files_fdtable(files) (rcu_dereference((files)->fdt))
-
-extern struct kmem_cache *filp_cachep;
+struct file;
 
 extern void __fput(struct file *);
 extern void fput(struct file *);
@@ -85,41 +37,7 @@ extern void put_filp(struct file *);
 extern int get_unused_fd(void);
 extern int get_unused_fd_flags(int flags);
 extern void put_unused_fd(unsigned int fd);
-struct kmem_cache;
-
-extern int expand_files(struct files_struct *, int nr);
-extern void free_fdtable_rcu(struct rcu_head *rcu);
-extern void __init files_defer_init(void);
-
-static inline void free_fdtable(struct fdtable *fdt)
-{
-        call_rcu(&fdt->rcu, free_fdtable_rcu);
-}
-
-static inline struct file * fcheck_files(struct files_struct *files, unsigned int fd)
-{
-        struct file * file = NULL;
-        struct fdtable *fdt = files_fdtable(files);
-
-        if (fd < fdt->max_fds)
-                file = rcu_dereference(fdt->fd[fd]);
-        return file;
-}
-
-/*
- * Check whether the specified fd has an open file.
- */
-#define fcheck(fd)      fcheck_files(current->files, fd)
 
 extern void fd_install(unsigned int fd, struct file *file);
 
-struct task_struct;
-
-struct files_struct *get_files_struct(struct task_struct *);
-void put_files_struct(struct files_struct *fs);
-void reset_files_struct(struct files_struct *);
-int unshare_files(struct files_struct **);
-
-extern struct kmem_cache *files_cachep;
-
 #endif /* __LINUX_FILE_H */
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);
+        int (*get_xip_mem)(struct address_space *, pgoff_t, 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/fsl_devices.h b/include/linux/fsl_devices.h
index 2cad5c67397e..c415a496de3a 100644
--- a/include/linux/fsl_devices.h
+++ b/include/linux/fsl_devices.h
@@ -14,7 +14,6 @@
  * option) any later version.
  */
 
-#ifdef __KERNEL__
 #ifndef _FSL_DEVICE_H_
 #define _FSL_DEVICE_H_
 
@@ -127,4 +126,3 @@ struct mpc8xx_pcmcia_ops {
 };
 
 #endif /* _FSL_DEVICE_H_ */
-#endif /* __KERNEL__ */
diff --git a/include/linux/fsnotify.h b/include/linux/fsnotify.h
index d4b7c4ac72e6..a89513188ce7 100644
--- a/include/linux/fsnotify.h
+++ b/include/linux/fsnotify.h
@@ -11,8 +11,6 @@
  * (C) Copyright 2005 Robert Love
  */
 
-#ifdef __KERNEL__
-
 #include <linux/dnotify.h>
 #include <linux/inotify.h>
 #include <linux/audit.h>
@@ -296,6 +294,4 @@ static inline void fsnotify_oldname_free(const char *old_name)
 
 #endif  /* ! CONFIG_INOTIFY */
 
-#endif  /* __KERNEL__ */
-
 #endif  /* _LINUX_FS_NOTIFY_H */
diff --git a/include/linux/generic_serial.h b/include/linux/generic_serial.h
index 5412da28fa47..110833666e37 100644
--- a/include/linux/generic_serial.h
+++ b/include/linux/generic_serial.h
@@ -78,7 +78,7 @@ struct gs_port {
 #define GS_DEBUG_WRITE   0x00000040
 
 #ifdef __KERNEL__
-void gs_put_char(struct tty_struct *tty, unsigned char ch);
+int gs_put_char(struct tty_struct *tty, unsigned char ch);
 int  gs_write(struct tty_struct *tty, 
              const unsigned char *buf, int count);
 int  gs_write_room(struct tty_struct *tty);
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_NOFAIL    ((__force gfp_t)0x800u) /* Retry for ever.  Cannot fail */
-#define __GFP_NORETRY   ((__force gfp_t)0x1000u)/* Do not retry.  Might fail */
+#define __GFP_REPEAT    ((__force gfp_t)0x400u) /* See above */
+#define __GFP_NOFAIL    ((__force gfp_t)0x800u) /* See above */
+#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;
-}
-
-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;
+        return ZONE_NORMAL;
 }
 
 /*
@@ -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,
-                NODE_DATA(nid)->node_zonelists + gfp_zone(gfp_mask));
+        return __alloc_pages(gfp_mask, order, node_zonelist(nid, 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/hrtimer.h b/include/linux/hrtimer.h
index 56f3236da829..31a4d653389f 100644
--- a/include/linux/hrtimer.h
+++ b/include/linux/hrtimer.h
@@ -266,6 +266,21 @@ extern ktime_t ktime_get_real(void);
 extern void hrtimer_init(struct hrtimer *timer, clockid_t which_clock,
                          enum hrtimer_mode mode);
 
+#ifdef CONFIG_DEBUG_OBJECTS_TIMERS
+extern void hrtimer_init_on_stack(struct hrtimer *timer, clockid_t which_clock,
+                                  enum hrtimer_mode mode);
+
+extern void destroy_hrtimer_on_stack(struct hrtimer *timer);
+#else
+static inline void hrtimer_init_on_stack(struct hrtimer *timer,
+                                         clockid_t which_clock,
+                                         enum hrtimer_mode mode)
+{
+        hrtimer_init(timer, which_clock, mode);
+}
+static inline void destroy_hrtimer_on_stack(struct hrtimer *timer) { }
+#endif
+
 /* Basic timer operations: */
 extern int hrtimer_start(struct hrtimer *timer, ktime_t tim,
                          const enum hrtimer_mode mode);
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/hw_random.h b/include/linux/hw_random.h
index 85d11916e9ea..7244456e7e65 100644
--- a/include/linux/hw_random.h
+++ b/include/linux/hw_random.h
@@ -11,7 +11,6 @@
 
 #ifndef LINUX_HWRANDOM_H_
 #define LINUX_HWRANDOM_H_
-#ifdef __KERNEL__
 
 #include <linux/types.h>
 #include <linux/list.h>
@@ -46,5 +45,4 @@ extern int hwrng_register(struct hwrng *rng);
 /** Unregister a Hardware Random Number Generator driver. */
 extern void hwrng_unregister(struct hwrng *rng);
 
-#endif /* __KERNEL__ */
 #endif /* LINUX_HWRANDOM_H_ */
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
- * @driver: identifies the driver to use with the device
+ * I2C_BOARD_INFO - macro used to list an i2c device and its address
+ * @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
- * platform_data) are provided using conventional syntax.
+ * fields (such as associated irq, or device-specific platform_data)
+ * are provided using conventional syntax.
  */
-#define I2C_BOARD_INFO(driver,dev_addr) \
-        .driver_name = (driver), .addr = (dev_addr)
+#define I2C_BOARD_INFO(dev_type,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..7d51cbca49ab 100644
--- a/include/linux/i2o.h
+++ b/include/linux/i2o.h
@@ -18,8 +18,6 @@
 #ifndef _I2O_H
 #define _I2O_H
 
-#ifdef __KERNEL__               /* This file to be included by kernel only */
-
 #include <linux/i2o-dev.h>
 
 /* How many different OSM's are we allowing */
@@ -613,14 +611,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 *);
@@ -1260,5 +1253,4 @@ extern void i2o_dump_message(struct i2o_message *);
 extern void i2o_dump_hrt(struct i2o_controller *c);
 extern void i2o_debug_state(struct i2o_controller *c);
 
-#endif                          /* __KERNEL__ */
 #endif                          /* _I2O_H */
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 (*ata_output_data)(ide_drive_t *, void *, u32);
+        void (*tf_load)(ide_drive_t *, struct ide_task_s *);
+        void (*tf_read)(ide_drive_t *, struct ide_task_s *);
 
-        void (*atapi_input_bytes)(ide_drive_t *, void *, u32);
-        void (*atapi_output_bytes)(ide_drive_t *, void *, u32);
+        void (*input_data)(ide_drive_t *, struct request *, void *, unsigned);
+        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_read(ide_drive_t *, ide_task_t *);
+void ide_tf_dump(const char *, struct ide_taskfile *);
 
 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/if_macvlan.h b/include/linux/if_macvlan.h
index 0d9d7ea2c1cc..5f200bac3749 100644
--- a/include/linux/if_macvlan.h
+++ b/include/linux/if_macvlan.h
@@ -1,9 +1,6 @@
 #ifndef _LINUX_IF_MACVLAN_H
 #define _LINUX_IF_MACVLAN_H
 
-#ifdef __KERNEL__
-
 extern struct sk_buff *(*macvlan_handle_frame_hook)(struct sk_buff *);
 
-#endif /* __KERNEL__ */
 #endif /* _LINUX_IF_MACVLAN_H */
diff --git a/include/linux/inet.h b/include/linux/inet.h
index 675a7dbe86f8..1354080cf8cf 100644
--- a/include/linux/inet.h
+++ b/include/linux/inet.h
@@ -42,11 +42,9 @@
 #ifndef _LINUX_INET_H
 #define _LINUX_INET_H
 
-#ifdef __KERNEL__
 #include <linux/types.h>
 
 extern __be32 in_aton(const char *str);
 extern int in4_pton(const char *src, int srclen, u8 *dst, int delim, const char **end);
 extern int in6_pton(const char *src, int srclen, u8 *dst, int delim, const char **end);
-#endif
 #endif  /* _LINUX_INET_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..b24c2875aa05 100644
--- a/include/linux/init_task.h
+++ b/include/linux/init_task.h
@@ -1,7 +1,7 @@
 #ifndef _LINUX__INIT_TASK_H
 #define _LINUX__INIT_TASK_H
 
-#include <linux/file.h>
+#include <linux/fdtable.h>
 #include <linux/rcupdate.h>
 #include <linux/irqflags.h>
 #include <linux/utsname.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/io.h b/include/linux/io.h
index e3b2dda6c8eb..3a03a3604cce 100644
--- a/include/linux/io.h
+++ b/include/linux/io.h
@@ -58,9 +58,9 @@ static inline void devm_ioport_unmap(struct device *dev, void __iomem *addr)
 }
 #endif
 
-void __iomem * devm_ioremap(struct device *dev, unsigned long offset,
+void __iomem *devm_ioremap(struct device *dev, resource_size_t offset,
                             unsigned long size);
-void __iomem * devm_ioremap_nocache(struct device *dev, unsigned long offset,
+void __iomem *devm_ioremap_nocache(struct device *dev, resource_size_t offset,
                                     unsigned long size);
 void devm_iounmap(struct device *dev, void __iomem *addr);
 int check_signature(const volatile void __iomem *io_addr,
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
-{
-        /* Routine type to call when a message needs to be routed to
+struct ipmi_user_hndl {
+        /* 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
- * for things like modifying the watchdog timeout when a panic occurs
- * or disabling the watchdog timer on a reboot.
+ * way.  This is useful if you need to spin waiting for something to
+ * happen in the IPMI driver.
  */
 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_GET_MY_CHANNEL_ADDRESS_CMD _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)
+#define IPMICTL_SET_MY_CHANNEL_ADDRESS_CMD \
+        _IOR(IPMI_IOC_MAGIC, 24, struct ipmi_channel_lun_address_set)
+#define IPMICTL_GET_MY_CHANNEL_ADDRESS_CMD \
+        _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/irq.h b/include/linux/irq.h
index 1883a85625dd..552e0ec269c9 100644
--- a/include/linux/irq.h
+++ b/include/linux/irq.h
@@ -61,6 +61,7 @@ typedef	void (*irq_flow_handler_t)(unsigned int irq,
 #define IRQ_WAKEUP              0x00100000      /* IRQ triggers system wakeup */
 #define IRQ_MOVE_PENDING        0x00200000      /* need to re-target IRQ destination */
 #define IRQ_NO_BALANCING        0x00400000      /* IRQ is excluded from balancing */
+#define IRQ_SPURIOUS_DISABLED   0x00800000      /* IRQ was disabled by the spurious trap */
 
 #ifdef CONFIG_IRQ_PER_CPU
 # define CHECK_IRQ_PER_CPU(var) ((var) & IRQ_PER_CPU)
diff --git a/include/linux/isapnp.h b/include/linux/isapnp.h
index 1e8728a9ee8a..cd5a269fdb5e 100644
--- a/include/linux/isapnp.h
+++ b/include/linux/isapnp.h
@@ -26,16 +26,6 @@
 #include <linux/pnp.h>
 
 /*
- *  Configuration registers (TODO: change by specification)
- */ 
-
-#define ISAPNP_CFG_ACTIVATE             0x30    /* byte */
-#define ISAPNP_CFG_MEM                  0x40    /* 4 * dword */
-#define ISAPNP_CFG_PORT                 0x60    /* 8 * word */
-#define ISAPNP_CFG_IRQ                  0x70    /* 2 * word */
-#define ISAPNP_CFG_DMA                  0x74    /* 2 * byte */
-
-/*
  *
  */
 
diff --git a/include/linux/isicom.h b/include/linux/isicom.h
index 8f4c71759d73..bbd42197298f 100644
--- a/include/linux/isicom.h
+++ b/include/linux/isicom.h
@@ -1,11 +1,6 @@
 #ifndef _LINUX_ISICOM_H
 #define _LINUX_ISICOM_H
 
-/*#define               ISICOM_DEBUG*/
-/*#define               ISICOM_DEBUG_DTR_RTS*/
-
-#ifdef __KERNEL__
-
 #define         YES     1
 #define         NO      0
 
@@ -85,6 +80,4 @@
 
 #define         ISI_TXOK                0x0001
 
-#endif  /*      __KERNEL__      */
-
 #endif  /*      ISICOM_H        */
diff --git a/include/linux/jiffies.h b/include/linux/jiffies.h
index 33ef710dac24..abb6ac639e8e 100644
--- a/include/linux/jiffies.h
+++ b/include/linux/jiffies.h
@@ -1,7 +1,7 @@
 #ifndef _LINUX_JIFFIES_H
 #define _LINUX_JIFFIES_H
 
-#include <linux/calc64.h>
+#include <linux/math64.h>
 #include <linux/kernel.h>
 #include <linux/types.h>
 #include <linux/time.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..4d46e299afb5 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;
 
@@ -333,33 +338,90 @@ extern void print_hex_dump_bytes(const char *prefix_str, int prefix_type,
 #endif /* __LITTLE_ENDIAN */
 
 /*
- * min()/max() macros that also do
+ * min()/max()/clamp() macros that also do
  * strict type-checking.. See the
  * "unnecessary" pointer comparison.
  */
-#define min(x,y) ({ \
-        typeof(x) _x = (x);     \
-        typeof(y) _y = (y);     \
-        (void) (&_x == &_y);            \
-        _x < _y ? _x : _y; })
-
-#define max(x,y) ({ \
-        typeof(x) _x = (x);     \
-        typeof(y) _y = (y);     \
-        (void) (&_x == &_y);            \
-        _x > _y ? _x : _y; })
+#define min(x, y) ({                            \
+        typeof(x) _min1 = (x);                  \
+        typeof(y) _min2 = (y);                  \
+        (void) (&_min1 == &_min2);              \
+        _min1 < _min2 ? _min1 : _min2; })
+
+#define max(x, y) ({                            \
+        typeof(x) _max1 = (x);                  \
+        typeof(y) _max2 = (y);                  \
+        (void) (&_max1 == &_max2);              \
+        _max1 > _max2 ? _max1 : _max2; })
+
+/**
+ * clamp - return a value clamped to a given range with strict typechecking
+ * @val: current value
+ * @min: minimum allowable value
+ * @max: maximum allowable value
+ *
+ * This macro does strict typechecking of min/max to make sure they are of the
+ * same type as val.  See the unnecessary pointer comparisons.
+ */
+#define clamp(val, min, max) ({                 \
+        typeof(val) __val = (val);              \
+        typeof(min) __min = (min);              \
+        typeof(max) __max = (max);              \
+        (void) (&__val == &__min);              \
+        (void) (&__val == &__max);              \
+        __val = __val < __min ? __min: __val;   \
+        __val > __max ? __max: __val; })
 
 /*
  * ..and if you can't take the strict
  * types, you can specify one yourself.
  *
- * Or not use min/max at all, of course.
+ * Or not use min/max/clamp at all, of course.
+ */
+#define min_t(type, x, y) ({                    \
+        type __min1 = (x);                      \
+        type __min2 = (y);                      \
+        __min1 < __min2 ? __min1: __min2; })
+
+#define max_t(type, x, y) ({                    \
+        type __max1 = (x);                      \
+        type __max2 = (y);                      \
+        __max1 > __max2 ? __max1: __max2; })
+
+/**
+ * clamp_t - return a value clamped to a given range using a given type
+ * @type: the type of variable to use
+ * @val: current value
+ * @min: minimum allowable value
+ * @max: maximum allowable value
+ *
+ * This macro does no typechecking and uses temporary variables of type
+ * 'type' to make all the comparisons.
  */
-#define min_t(type,x,y) \
-        ({ type __x = (x); type __y = (y); __x < __y ? __x: __y; })
-#define max_t(type,x,y) \
-        ({ type __x = (x); type __y = (y); __x > __y ? __x: __y; })
+#define clamp_t(type, val, min, max) ({         \
+        type __val = (val);                     \
+        type __min = (min);                     \
+        type __max = (max);                     \
+        __val = __val < __min ? __min: __val;   \
+        __val > __max ? __max: __val; })
 
+/**
+ * clamp_val - return a value clamped to a given range using val's type
+ * @val: current value
+ * @min: minimum allowable value
+ * @max: maximum allowable value
+ *
+ * This macro does no typechecking and uses temporary variables of whatever
+ * type the input argument 'val' is.  This is useful when val is an unsigned
+ * type and min and max are literals that will otherwise be assigned a signed
+ * integer type.
+ */
+#define clamp_val(val, min, max) ({             \
+        typeof(val) __val = (val);              \
+        typeof(val) __min = (min);              \
+        typeof(val) __max = (max);              \
+        __val = __val < __min ? __min: __val;   \
+        __val > __max ? __max: __val; })
 
 /**
  * container_of - cast a member of a structure out to the containing structure
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/kfifo.h b/include/linux/kfifo.h
index 404f4464cb1a..29f62e1733ff 100644
--- a/include/linux/kfifo.h
+++ b/include/linux/kfifo.h
@@ -21,8 +21,6 @@
 #ifndef _LINUX_KFIFO_H
 #define _LINUX_KFIFO_H
 
-#ifdef __KERNEL__
-
 #include <linux/kernel.h>
 #include <linux/spinlock.h>
 
@@ -151,7 +149,4 @@ static inline unsigned int kfifo_len(struct kfifo *fifo)
         return ret;
 }
 
-#else
-#warning "don't include kernel headers in userspace"
-#endif /* __KERNEL__ */
 #endif
diff --git a/include/linux/klist.h b/include/linux/klist.h
index 74071254c9d3..06c338ef7f1b 100644
--- a/include/linux/klist.h
+++ b/include/linux/klist.h
@@ -25,37 +25,47 @@ struct klist {
         void                    (*put)(struct klist_node *);
 };
 
+#define KLIST_INIT(_name, _get, _put)                                   \
+        { .k_lock       = __SPIN_LOCK_UNLOCKED(_name.k_lock),           \
+          .k_list       = LIST_HEAD_INIT(_name.k_list),                 \
+          .get          = _get,                                         \
+          .put          = _put, }
 
-extern void klist_init(struct klist * k, void (*get)(struct klist_node *),
+#define DEFINE_KLIST(_name, _get, _put)                                 \
+        struct klist _name = KLIST_INIT(_name, _get, _put)
+
+extern void klist_init(struct klist *k, void (*get)(struct klist_node *),
                        void (*put)(struct klist_node *));
 
 struct klist_node {
-        struct klist            * n_klist;
+        struct klist            *n_klist;
         struct list_head        n_node;
         struct kref             n_ref;
         struct completion       n_removed;
 };
 
-extern void klist_add_tail(struct klist_node * n, struct klist * k);
-extern void klist_add_head(struct klist_node * n, struct klist * k);
+extern void klist_add_tail(struct klist_node *n, struct klist *k);
+extern void klist_add_head(struct klist_node *n, struct klist *k);
+extern void klist_add_after(struct klist_node *n, struct klist_node *pos);
+extern void klist_add_before(struct klist_node *n, struct klist_node *pos);
 
-extern void klist_del(struct klist_node * n);
-extern void klist_remove(struct klist_node * n);
+extern void klist_del(struct klist_node *n);
+extern void klist_remove(struct klist_node *n);
 
-extern int klist_node_attached(struct klist_node * n);
+extern int klist_node_attached(struct klist_node *n);
 
 
 struct klist_iter {
-        struct klist            * i_klist;
-        struct list_head        * i_head;
-        struct klist_node       * i_cur;
+        struct klist            *i_klist;
+        struct list_head        *i_head;
+        struct klist_node       *i_cur;
 };
 
 
-extern void klist_iter_init(struct klist * k, struct klist_iter * i);
-extern void klist_iter_init_node(struct klist * k, struct klist_iter * i, 
-                                 struct klist_node * n);
-extern void klist_iter_exit(struct klist_iter * i);
-extern struct klist_node * klist_next(struct klist_iter * i);
+extern void klist_iter_init(struct klist *k, struct klist_iter *i);
+extern void klist_iter_init_node(struct klist *k, struct klist_iter *i,
+                                 struct klist_node *n);
+extern void klist_iter_exit(struct klist_iter *i);
+extern struct klist_node *klist_next(struct klist_iter *i);
 
 #endif
diff --git a/include/linux/kobj_map.h b/include/linux/kobj_map.h
index bafe178a381f..73717ed9ea79 100644
--- a/include/linux/kobj_map.h
+++ b/include/linux/kobj_map.h
@@ -1,5 +1,3 @@
-#ifdef __KERNEL__
-
 #include <linux/mutex.h>
 
 typedef struct kobject *kobj_probe_t(dev_t, int *, void *);
@@ -10,5 +8,3 @@ int kobj_map(struct kobj_map *, dev_t, unsigned long, struct module *,
 void kobj_unmap(struct kobj_map *, dev_t, unsigned long);
 struct kobject *kobj_lookup(struct kobj_map *, dev_t, int *);
 struct kobj_map *kobj_map_init(kobj_probe_t *, struct mutex *);
-
-#endif
diff --git a/include/linux/kobject.h b/include/linux/kobject.h
index caa3f411f15d..39e709f88aa0 100644
--- a/include/linux/kobject.h
+++ b/include/linux/kobject.h
@@ -16,8 +16,6 @@
 #ifndef _KOBJECT_H_
 #define _KOBJECT_H_
 
-#ifdef __KERNEL__
-
 #include <linux/types.h>
 #include <linux/list.h>
 #include <linux/sysfs.h>
@@ -224,5 +222,4 @@ static inline int kobject_action_type(const char *buf, size_t count,
 { return -EINVAL; }
 #endif
 
-#endif /* __KERNEL__ */
 #endif /* _KOBJECT_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/kref.h b/include/linux/kref.h
index 5d185635786e..0cef6badd6fb 100644
--- a/include/linux/kref.h
+++ b/include/linux/kref.h
@@ -15,8 +15,6 @@
 #ifndef _KREF_H_
 #define _KREF_H_
 
-#ifdef __KERNEL__
-
 #include <linux/types.h>
 #include <asm/atomic.h>
 
@@ -29,5 +27,4 @@ void kref_init(struct kref *kref);
 void kref_get(struct kref *kref);
 int kref_put(struct kref *kref, void (*release) (struct kref *kref));
 
-#endif /* __KERNEL__ */
 #endif /* _KREF_H_ */
diff --git a/include/linux/libata.h b/include/linux/libata.h
index 395a523d8c30..d1dfe872ee30 100644
--- a/include/linux/libata.h
+++ b/include/linux/libata.h
@@ -548,11 +548,6 @@ struct ata_device {
         u64                     n_sectors;      /* size of device, if ATA */
         unsigned int            class;          /* ATA_DEV_xxx */
 
-        union {
-                u16             id[ATA_ID_WORDS]; /* IDENTIFY xxx DEVICE data */
-                u32             gscr[SATA_PMP_GSCR_DWORDS]; /* PMP GSCR block */
-        };
-
         u8                      pio_mode;
         u8                      dma_mode;
         u8                      xfer_mode;
@@ -574,8 +569,13 @@ struct ata_device {
         u16                     sectors;        /* Number of sectors per track */
 
         /* error history */
-        struct ata_ering        ering;
         int                     spdn_cnt;
+        struct ata_ering        ering;
+
+        union {
+                u16             id[ATA_ID_WORDS]; /* IDENTIFY xxx DEVICE data */
+                u32             gscr[SATA_PMP_GSCR_DWORDS]; /* PMP GSCR block */
+        };
 };
 
 /* Offset into struct ata_device.  Fields above it are maintained
diff --git a/include/linux/list.h b/include/linux/list.h
index dac16f99c701..08cf4f651889 100644
--- a/include/linux/list.h
+++ b/include/linux/list.h
@@ -1,8 +1,6 @@
 #ifndef _LINUX_LIST_H
 #define _LINUX_LIST_H
 
-#ifdef __KERNEL__
-
 #include <linux/stddef.h>
 #include <linux/poison.h>
 #include <linux/prefetch.h>
@@ -319,7 +317,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 +345,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);
@@ -973,7 +981,4 @@ static inline void hlist_add_after_rcu(struct hlist_node *prev,
                 ({ tpos = hlist_entry(pos, typeof(*tpos), member); 1;}); \
              pos = rcu_dereference(pos->next))
 
-#else
-#warning "don't include kernel headers in userspace"
-#endif /* __KERNEL__ */
 #endif
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/math64.h b/include/linux/math64.h
new file mode 100644
index 000000000000..c1a5f81501ff
--- /dev/null
+++ b/include/linux/math64.h
@@ -0,0 +1,84 @@
+#ifndef _LINUX_MATH64_H
+#define _LINUX_MATH64_H
+
+#include <linux/types.h>
+#include <asm/div64.h>
+
+#if BITS_PER_LONG == 64
+
+/**
+ * div_u64_rem - unsigned 64bit divide with 32bit divisor with remainder
+ *
+ * This is commonly provided by 32bit archs to provide an optimized 64bit
+ * divide.
+ */
+static inline u64 div_u64_rem(u64 dividend, u32 divisor, u32 *remainder)
+{
+        *remainder = dividend % divisor;
+        return dividend / divisor;
+}
+
+/**
+ * div_s64_rem - signed 64bit divide with 32bit divisor with remainder
+ */
+static inline s64 div_s64_rem(s64 dividend, s32 divisor, s32 *remainder)
+{
+        *remainder = dividend % divisor;
+        return dividend / divisor;
+}
+
+/**
+ * div64_u64 - unsigned 64bit divide with 64bit divisor
+ */
+static inline u64 div64_u64(u64 dividend, u64 divisor)
+{
+        return dividend / divisor;
+}
+
+#elif BITS_PER_LONG == 32
+
+#ifndef div_u64_rem
+static inline u64 div_u64_rem(u64 dividend, u32 divisor, u32 *remainder)
+{
+        *remainder = do_div(dividend, divisor);
+        return dividend;
+}
+#endif
+
+#ifndef div_s64_rem
+extern s64 div_s64_rem(s64 dividend, s32 divisor, s32 *remainder);
+#endif
+
+#ifndef div64_u64
+extern u64 div64_u64(u64 dividend, u64 divisor);
+#endif
+
+#endif /* BITS_PER_LONG */
+
+/**
+ * div_u64 - unsigned 64bit divide with 32bit divisor
+ *
+ * This is the most common 64bit divide and should be used if possible,
+ * as many 32bit archs can optimize this variant better than a full 64bit
+ * divide.
+ */
+#ifndef div_u64
+static inline u64 div_u64(u64 dividend, u32 divisor)
+{
+        u32 remainder;
+        return div_u64_rem(dividend, divisor, &remainder);
+}
+#endif
+
+/**
+ * div_s64 - signed 64bit divide with 32bit divisor
+ */
+#ifndef div_s64
+static inline s64 div_s64(s64 dividend, s32 divisor)
+{
+        s32 remainder;
+        return div_s64_rem(dividend, divisor, &remainder);
+}
+#endif
+
+#endif /* _LINUX_MATH64_H */
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
-#define MPOL_PREFERRED  1
-#define MPOL_BIND       2
-#define MPOL_INTERLEAVE 3
+enum {
+        MPOL_DEFAULT,
+        MPOL_PREFERRED,
+        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.
- * All other policies don't have any external state. mpol_free() handles this.
+ * Mempolicy objects are reference counted.  A mempolicy will be freed when
+ * mpol_put() decrements the reference count to zero.
  *
- * Copying policy objects:
- * For MPOL_BIND the zonelist must be always duplicated. mpol_clone() does this.
+ * Duplicating policy objects:
+ * 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);
-static inline void mpol_free(struct mempolicy *pol)
+extern void __mpol_put(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,
-                                nodemask_t *nodes);
+void mpol_shared_policy_init(struct shared_policy *sp, struct mempolicy *mpol);
 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,
-                                        int policy, nodemask_t *nodes)
+static inline void mpol_shared_policy_init(struct shared_policy *sp,
+                                                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 |
- * with space for node: | SECTION | NODE | ZONE | ... | FLAGS |
- *   no space for node: | SECTION |     ZONE    | ... | FLAGS |
+ * No sparsemem or sparsemem vmemmap: |       NODE     | ZONE | ... | FLAGS |
+ * classic sparse with space for node:| SECTION | NODE | 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
-#error 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 > 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
-        struct mem_cgroup *mem_cgroup;
+#ifdef CONFIG_MM_OWNER
+        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..c463cd8a15a4 100644
--- a/include/linux/mmzone.h
+++ b/include/linux/mmzone.h
@@ -1,8 +1,8 @@
 #ifndef _LINUX_MMZONE_H
 #define _LINUX_MMZONE_H
 
-#ifdef __KERNEL__
 #ifndef __ASSEMBLY__
+#ifndef __GENERATING_BOUNDS_H
 
 #include <linux/spinlock.h>
 #include <linux/list.h>
@@ -15,6 +15,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>
 
@@ -95,6 +96,7 @@ enum zone_stat_item {
         NR_UNSTABLE_NFS,        /* NFS unstable pages */
         NR_BOUNCE,
         NR_VMSCAN_WRITE,
+        NR_WRITEBACK_TEMP,      /* Writeback using temporary buffers */
 #ifdef CONFIG_NUMA
         NUMA_HIT,               /* allocated in intended node */
         NUMA_MISS,              /* allocated in non intended node */
@@ -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
  */
 
-/*
- * 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
+#if MAX_NR_ZONES < 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
- * [MAZ_NR_ZONES ... MAZ_ZONELISTS -1]  : No fallback (GFP_THISNODE)
+ * [0]  : Zonelist with fallback
+ * [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;
-        return zone_idx == ZONE_HIGHMEM ||
-                (zone_idx == ZONE_MOVABLE && zone_movable_is_highmem());
+        int zone_off = (char *)zone - (char *)zone->zone_pgdat->node_zones;
+        return zone_off == ZONE_HIGHMEM * sizeof(*zone) ||
+               (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
-#include <asm/sparsemem.h>
-#endif
+static inline struct zone *zonelist_zone(struct zoneref *zoneref)
+{
+        return zoneref->zone;
+}
 
-#if BITS_PER_LONG == 32
-/*
- * with 32 bit page->flags field, we reserve 9 bits for node/zone info.
- * there are 4 zones (3 bits) and this leaves 9-3=6 bits for nodes.
+static inline int zonelist_zone_idx(struct zoneref *zoneref)
+{
+        return zoneref->zone_idx;
+}
+
+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
-/*
- * with 64 bit flags field, there's plenty of room.
+/**
+ * first_zones_zonelist - Returns the first zone at or below highest_zoneidx within the allowed nodemask in a zonelist
+ * @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,6 @@ 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/module.h b/include/linux/module.h
index 819c4e889bf1..3e03b1acbc94 100644
--- a/include/linux/module.h
+++ b/include/linux/module.h
@@ -190,7 +190,7 @@ void *__symbol_get_gpl(const char *symbol);
         extern typeof(sym) sym;                                 \
         __CRC_SYMBOL(sym, sec)                                  \
         static const char __kstrtab_##sym[]                     \
-        __attribute__((section("__ksymtab_strings")))           \
+        __attribute__((section("__ksymtab_strings"), aligned(1))) \
         = MODULE_SYMBOL_PREFIX #sym;                            \
         static const struct kernel_symbol __ksymtab_##sym       \
         __used                                                  \
@@ -229,23 +229,6 @@ enum module_state
         MODULE_STATE_GOING,
 };
 
-/* Similar stuff for section attributes. */
-struct module_sect_attr
-{
-        struct module_attribute mattr;
-        char *name;
-        unsigned long address;
-};
-
-struct module_sect_attrs
-{
-        struct attribute_group grp;
-        int nsections;
-        struct module_sect_attr attrs[0];
-};
-
-struct module_param_attrs;
-
 struct module
 {
         enum module_state state;
diff --git a/include/linux/mount.h b/include/linux/mount.h
index b4836d58f428..4374d1adeb4b 100644
--- a/include/linux/mount.h
+++ b/include/linux/mount.h
@@ -10,7 +10,6 @@
  */
 #ifndef _LINUX_MOUNT_H
 #define _LINUX_MOUNT_H
-#ifdef __KERNEL__
 
 #include <linux/types.h>
 #include <linux/list.h>
@@ -114,5 +113,4 @@ extern void mark_mounts_for_expiry(struct list_head *mounts);
 extern spinlock_t vfsmount_lock;
 extern dev_t name_to_dev_t(char *name);
 
-#endif
 #endif /* _LINUX_MOUNT_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/mtd/jedec.h b/include/linux/mtd/jedec.h
deleted file mode 100644
index 9006feb218b9..000000000000
--- a/include/linux/mtd/jedec.h
+++ /dev/null
@@ -1,66 +0,0 @@
-
-/* JEDEC Flash Interface.
- * This is an older type of interface for self programming flash. It is
- * commonly use in older AMD chips and is obsolete compared with CFI.
- * It is called JEDEC because the JEDEC association distributes the ID codes
- * for the chips.
- *
- * See the AMD flash databook for information on how to operate the interface.
- *
- * $Id: jedec.h,v 1.4 2005/11/07 11:14:54 gleixner Exp $
- */
-
-#ifndef __LINUX_MTD_JEDEC_H__
-#define __LINUX_MTD_JEDEC_H__
-
-#include <linux/types.h>
-
-#define MAX_JEDEC_CHIPS 16
-
-// Listing of all supported chips and their information
-struct JEDECTable
-{
-   __u16 jedec;
-   char *name;
-   unsigned long size;
-   unsigned long sectorsize;
-   __u32 capabilities;
-};
-
-// JEDEC being 0 is the end of the chip array
-struct jedec_flash_chip
-{
-   __u16 jedec;
-   unsigned long size;
-   unsigned long sectorsize;
-
-   // *(__u8*)(base + (adder << addrshift)) = data << datashift
-   // Address size = size << addrshift
-   unsigned long base;           // Byte 0 of the flash, will be unaligned
-   unsigned int datashift;       // Useful for 32bit/16bit accesses
-   unsigned int addrshift;
-   unsigned long offset;         // linerized start. base==offset for unbanked, uninterleaved flash
-
-   __u32 capabilities;
-
-   // These markers are filled in by the flash_chip_scan function
-   unsigned long start;
-   unsigned long length;
-};
-
-struct jedec_private
-{
-   unsigned long size;         // Total size of all the devices
-
-   /* Bank handling. If sum(bank_fill) == size then this is linear flash.
-      Otherwise the mapping has holes in it. bank_fill may be used to
-      find the holes, but in the common symetric case
-      bank_fill[0] == bank_fill[*], thus addresses may be computed
-      mathmatically. bank_fill must be powers of two */
-   unsigned is_banked;
-   unsigned long bank_fill[MAX_JEDEC_CHIPS];
-
-   struct jedec_flash_chip chips[MAX_JEDEC_CHIPS];
-};
-
-#endif
diff --git a/include/linux/mtd/mtd.h b/include/linux/mtd/mtd.h
index 0a13bb35f044..245f9098e171 100644
--- a/include/linux/mtd/mtd.h
+++ b/include/linux/mtd/mtd.h
@@ -143,10 +143,12 @@ struct mtd_info {
         int (*erase) (struct mtd_info *mtd, struct erase_info *instr);
 
         /* This stuff for eXecute-In-Place */
-        int (*point) (struct mtd_info *mtd, loff_t from, size_t len, size_t *retlen, u_char **mtdbuf);
+        /* phys is optional and may be set to NULL */
+        int (*point) (struct mtd_info *mtd, loff_t from, size_t len,
+                        size_t *retlen, void **virt, resource_size_t *phys);
 
         /* We probably shouldn't allow XIP if the unpoint isn't a NULL */
-        void (*unpoint) (struct mtd_info *mtd, u_char * addr, loff_t from, size_t len);
+        void (*unpoint) (struct mtd_info *mtd, loff_t from, size_t len);
 
 
         int (*read) (struct mtd_info *mtd, loff_t from, size_t len, size_t *retlen, u_char *buf);
diff --git a/include/linux/mtd/pmc551.h b/include/linux/mtd/pmc551.h
index a7f6d20ad407..5cc070c24d88 100644
--- a/include/linux/mtd/pmc551.h
+++ b/include/linux/mtd/pmc551.h
@@ -36,8 +36,9 @@ struct mypriv {
  * Function Prototypes
  */
 static int pmc551_erase(struct mtd_info *, struct erase_info *);
-static void pmc551_unpoint(struct mtd_info *, u_char *, loff_t, size_t);
-static int pmc551_point (struct mtd_info *mtd, loff_t from, size_t len, size_t *retlen, u_char **mtdbuf);
+static void pmc551_unpoint(struct mtd_info *, loff_t, size_t);
+static int pmc551_point(struct mtd_info *mtd, loff_t from, size_t len,
+                size_t *retlen, void **virt, resource_size_t *phys);
 static int pmc551_read(struct mtd_info *, loff_t, size_t, size_t *, u_char *);
 static int pmc551_write(struct mtd_info *, loff_t, size_t, size_t *, const u_char *);
 
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;
-}
-#ifdef __GNUC__
-        __attribute__ ((packed))
-#endif
-;
+} __attribute__ ((packed));
 
 /*
  * 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/ncp_fs_i.h b/include/linux/ncp_fs_i.h
index bdb4c8ae6924..4b0bec477846 100644
--- a/include/linux/ncp_fs_i.h
+++ b/include/linux/ncp_fs_i.h
@@ -8,8 +8,6 @@
 #ifndef _LINUX_NCP_FS_I
 #define _LINUX_NCP_FS_I
 
-#ifdef __KERNEL__
-
 /*
  * This is the ncpfs part of the inode structure. This must contain
  * all the information we need to work with an inode after creation.
@@ -28,6 +26,4 @@ struct ncp_inode_info {
         struct inode vfs_inode;
 };
 
-#endif  /* __KERNEL__ */
-
 #endif  /* _LINUX_NCP_FS_I */
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/of_device.h b/include/linux/of_device.h
index 6dc11959770c..afe338217d91 100644
--- a/include/linux/of_device.h
+++ b/include/linux/of_device.h
@@ -1,6 +1,5 @@
 #ifndef _LINUX_OF_DEVICE_H
 #define _LINUX_OF_DEVICE_H
-#ifdef __KERNEL__
 
 #include <linux/device.h>
 #include <linux/of.h>
@@ -25,5 +24,4 @@ static inline void of_device_free(struct of_device *dev)
         of_release_dev(&dev->dev);
 }
 
-#endif /* __KERNEL__ */
 #endif /* _LINUX_OF_DEVICE_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 void clear_zonelist_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, 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-FLAGS_RESERVED)
+ *  N-1           ^       0
+ *               (NR_PAGEFLAGS)
  *
- * The fields area is reserved for fields mapping zone, node and SPARSEMEM
- * section.  The boundry between these two areas is defined by
- * FLAGS_RESERVED which defines the width of the fields section
- * (see linux/mmzone.h).  New flags must _not_ overlap with this area.
+ * The fields area is reserved for fields mapping zone, node (for NUMA) and
+ * SPARSEMEM section (for variants of SPARSEMEM that require section ids like
+ * SPARSEMEM_EXTREME with !SPARSEMEM_VMEMMAP).
  */
-#define PG_locked                0      /* Page is locked. Don't touch. */
-#define PG_error                 1
-#define PG_referenced            2
-#define PG_uptodate              3
+enum pageflags {
+        PG_locked,              /* Page is locked. Don't touch. */
+        PG_error,
+        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 PG_lru                   5
-#define PG_active                6
-#define PG_slab                  7      /* slab debug (Suparna wants this) */
+#define SETPAGEFLAG(uname, lname)                                       \
+static inline void SetPage##uname(struct page *page)                    \
+                        { set_bit(PG_##lname, &page->flags); }
 
-#define PG_owner_priv_1          8      /* Owner use. If pagecache, fs may use*/
-#define PG_arch_1                9
-#define PG_reserved             10
-#define PG_private              11      /* If pagecache, has fs-private data */
+#define CLEARPAGEFLAG(uname, lname)                                     \
+static inline void ClearPage##uname(struct page *page)                  \
+                        { clear_bit(PG_##lname, &page->flags); }
 
-#define PG_writeback            12      /* Page is under writeback */
-#define PG_compound             14      /* Part of a compound page */
-#define PG_swapcache            15      /* Swap page: swp_entry_t in private */
+#define __SETPAGEFLAG(uname, lname)                                     \
+static inline void __SetPage##uname(struct page *page)                  \
+                        { __set_bit(PG_##lname, &page->flags); }
 
-#define PG_mappedtodisk         16      /* Has blocks allocated on-disk */
-#define PG_reclaim              17      /* To be reclaimed asap */
-#define PG_buddy                19      /* Page is free, on buddy lists */
+#define __CLEARPAGEFLAG(uname, lname)                                   \
+static inline void __ClearPage##uname(struct page *page)                \
+                        { __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 PG_checked              PG_owner_priv_1 /* Used by some filesystems */
-#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(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
- *
- * 32 bit  -------------------------------| FIELDS |       FLAGS         |
- * 64 bit  |           FIELDS             | ??????         FLAGS         |
- *         63                            32                              0
+ * Only test-and-set exist for PG_writeback.  The unconditional operators are
+ * risky: they bypass page accounting.
  */
-#define PG_uncached             31      /* Page has been mapped as uncached */
-#endif
+TESTPAGEFLAG(Writeback, writeback) TESTSCFLAG(Writeback, writeback)
+__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)                \
-                test_bit(PG_locked, &(page)->flags)
-#define SetPageLocked(page)             \
-                set_bit(PG_locked, &(page)->flags)
-#define TestSetPageLocked(page)         \
-                test_and_set_bit(PG_locked, &(page)->flags)
-#define ClearPageLocked(page)           \
-                clear_bit(PG_locked, &(page)->flags)
-#define TestClearPageLocked(page)       \
-                test_and_clear_bit(PG_locked, &(page)->flags)
-
-#define PageError(page)         test_bit(PG_error, &(page)->flags)
-#define SetPageError(page)      set_bit(PG_error, &(page)->flags)
-#define ClearPageError(page)    clear_bit(PG_error, &(page)->flags)
-
-#define PageReferenced(page)    test_bit(PG_referenced, &(page)->flags)
-#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)
+#define PageHighMem(__p) is_highmem(page_zone(__p))
+#else
+PAGEFLAG_FALSE(HighMem)
+#endif
+
+#ifdef CONFIG_SWAP
+PAGEFLAG(SwapCache, swapcache)
+#else
+PAGEFLAG_FALSE(SwapCache)
+#endif
+
+#ifdef CONFIG_IA64_UNCACHED_ALLOCATOR
+PAGEFLAG(Uncached, uncached)
+#else
+PAGEFLAG_FALSE(Uncached)
+#endif
 
 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)
-
-#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
+CLEARPAGEFLAG(Uptodate, uptodate)
 
-#define PageChecked(page)       test_bit(PG_checked, &(page)->flags)
-#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)
+extern void cancel_dirty_page(struct page *page, unsigned int account_size);
 
-#define PageReserved(page)      test_bit(PG_reserved, &(page)->flags)
-#define SetPageReserved(page)   set_bit(PG_reserved, &(page)->flags)
-#define ClearPageReserved(page) clear_bit(PG_reserved, &(page)->flags)
-#define __ClearPageReserved(page)       __clear_bit(PG_reserved, &(page)->flags)
+int test_clear_page_writeback(struct page *page);
+int test_set_page_writeback(struct page *page);
 
-#define SetPagePrivate(page)    set_bit(PG_private, &(page)->flags)
-#define ClearPagePrivate(page)  clear_bit(PG_private, &(page)->flags)
-#define PagePrivate(page)       test_bit(PG_private, &(page)->flags)
-#define __SetPagePrivate(page)  __set_bit(PG_private, &(page)->flags)
-#define __ClearPagePrivate(page) __clear_bit(PG_private, &(page)->flags)
+static inline void set_page_writeback(struct page *page)
+{
+        test_set_page_writeback(page);
+}
 
+#ifdef CONFIG_PAGEFLAGS_EXTENDED
 /*
- * Only test-and-set exist for PG_writeback.  The unconditional operators are
- * risky: they bypass page accounting.
+ * System with lots of page flags available. This allows separate
+ * 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)
-#define TestSetPageWriteback(page) test_and_set_bit(PG_writeback,       \
-                                                        &(page)->flags)
-#define TestClearPageWriteback(page) test_and_clear_bit(PG_writeback,   \
-                                                        &(page)->flags)
+__PAGEFLAG(Head, head)
+__PAGEFLAG(Tail, tail)
 
-#define PageBuddy(page)         test_bit(PG_buddy, &(page)->flags)
-#define __SetPageBuddy(page)    __set_bit(PG_buddy, &(page)->flags)
-#define __ClearPageBuddy(page)  __clear_bit(PG_buddy, &(page)->flags)
-
-#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)
+static inline int PageCompound(struct page *page)
+{
+        return page->flags & ((1L << PG_head) | (1L << PG_tail));
 
-#define PageCompound(page)      test_bit(PG_compound, &(page)->flags)
-#define __SetPageCompound(page) __set_bit(PG_compound, &(page)->flags)
-#define __ClearPageCompound(page) __clear_bit(PG_compound, &(page)->flags)
+}
+#else
+/*
+ * 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)    \
-                                == PG_head_tail_mask)
+static inline int PageTail(struct page *page)
+{
+        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)    \
-                                == (1L << PG_compound))
-#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 /* !PAGEFLAGS_EXTENDED */
+#endif /* !__GENERATING_BOUNDS_H */
 #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..cf6dbd759395 100644
--- a/include/linux/pci_ids.h
+++ b/include/linux/pci_ids.h
@@ -1429,6 +1429,7 @@
 #define PCI_DEVICE_ID_NEO_2DB9PRI       0x00C9
 #define PCI_DEVICE_ID_NEO_2RJ45         0x00CA
 #define PCI_DEVICE_ID_NEO_2RJ45PRI      0x00CB
+#define PCIE_DEVICE_ID_NEO_4_IBM        0x00F4
 
 #define PCI_VENDOR_ID_XIRCOM            0x115d
 #define PCI_DEVICE_ID_XIRCOM_RBM56G     0x0101
@@ -2413,6 +2414,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 PH_IOC_MAXNR            4
+#define PHN_NOT_OH              _IO(PH_IOC_MAGIC, 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/pid.h b/include/linux/pid.h
index c7980810eb09..c21c7e8124a7 100644
--- a/include/linux/pid.h
+++ b/include/linux/pid.h
@@ -60,7 +60,7 @@ struct pid
         /* lists of tasks that use this pid */
         struct hlist_head tasks[PIDTYPE_MAX];
         struct rcu_head rcu;
-        int level;
+        unsigned int level;
         struct upid numbers[1];
 };
 
@@ -89,9 +89,11 @@ extern struct pid *get_task_pid(struct task_struct *task, enum pid_type type);
  * attach_pid() and detach_pid() must be called with the tasklist_lock
  * write-held.
  */
-extern int attach_pid(struct task_struct *task, enum pid_type type,
-                      struct pid *pid);
+extern void attach_pid(struct task_struct *task, enum pid_type type,
+                        struct pid *pid);
 extern void detach_pid(struct task_struct *task, enum pid_type);
+extern void change_pid(struct task_struct *task, enum pid_type,
+                        struct pid *pid);
 extern void transfer_pid(struct task_struct *old, struct task_struct *new,
                          enum pid_type);
 
diff --git a/include/linux/pid_namespace.h b/include/linux/pid_namespace.h
index fcd61fa2c833..caff5283d15c 100644
--- a/include/linux/pid_namespace.h
+++ b/include/linux/pid_namespace.h
@@ -20,7 +20,7 @@ struct pid_namespace {
         int last_pid;
         struct task_struct *child_reaper;
         struct kmem_cache *pid_cachep;
-        int level;
+        unsigned int level;
         struct pid_namespace *parent;
 #ifdef CONFIG_PROC_FS
         struct vfsmount *proc_mnt;
diff --git a/include/linux/pm.h b/include/linux/pm.h
index 1de72cbbe0d1..39a7ee859b67 100644
--- a/include/linux/pm.h
+++ b/include/linux/pm.h
@@ -21,8 +21,6 @@
 #ifndef _LINUX_PM_H
 #define _LINUX_PM_H
 
-#ifdef __KERNEL__
-
 #include <linux/list.h>
 #include <asm/atomic.h>
 #include <asm/errno.h>
@@ -225,6 +223,4 @@ extern unsigned int	pm_flags;
 #define PM_APM  1
 #define PM_ACPI 2
 
-#endif /* __KERNEL__ */
-
 #endif /* _LINUX_PM_H */
diff --git a/include/linux/pnp.h b/include/linux/pnp.h
index b2f05c230f4b..63b128d512fb 100644
--- a/include/linux/pnp.h
+++ b/include/linux/pnp.h
@@ -6,66 +6,127 @@
 #ifndef _LINUX_PNP_H
 #define _LINUX_PNP_H
 
-#ifdef __KERNEL__
-
 #include <linux/device.h>
 #include <linux/list.h>
 #include <linux/errno.h>
 #include <linux/mod_devicetable.h>
 
-#define PNP_MAX_PORT            40
-#define PNP_MAX_MEM             24
-#define PNP_MAX_IRQ             2
-#define PNP_MAX_DMA             2
 #define PNP_NAME_LEN            50
 
 struct pnp_protocol;
 struct pnp_dev;
+struct pnp_resource_table;
 
 /*
  * Resource Management
  */
+struct resource *pnp_get_resource(struct pnp_dev *, unsigned int, unsigned int);
+
+static inline int pnp_resource_valid(struct resource *res)
+{
+        if (res && !(res->flags & IORESOURCE_UNSET))
+                return 1;
+        return 0;
+}
+
+static inline resource_size_t pnp_resource_len(struct resource *res)
+{
+        if (res->start == 0 && res->end == 0)
+                return 0;
+        return res->end - res->start + 1;
+}
+
+
+static inline resource_size_t pnp_port_start(struct pnp_dev *dev,
+                                             unsigned int bar)
+{
+        return pnp_get_resource(dev, IORESOURCE_IO, bar)->start;
+}
+
+static inline resource_size_t pnp_port_end(struct pnp_dev *dev,
+                                           unsigned int bar)
+{
+        return pnp_get_resource(dev, IORESOURCE_IO, bar)->end;
+}
+
+static inline unsigned long pnp_port_flags(struct pnp_dev *dev,
+                                           unsigned int bar)
+{
+        return pnp_get_resource(dev, IORESOURCE_IO, bar)->flags;
+}
+
+static inline int pnp_port_valid(struct pnp_dev *dev, unsigned int bar)
+{
+        return pnp_resource_valid(pnp_get_resource(dev, IORESOURCE_IO, bar));
+}
+
+static inline resource_size_t pnp_port_len(struct pnp_dev *dev,
+                                           unsigned int bar)
+{
+        return pnp_resource_len(pnp_get_resource(dev, IORESOURCE_IO, bar));
+}
+
+
+static inline resource_size_t pnp_mem_start(struct pnp_dev *dev,
+                                            unsigned int bar)
+{
+        return pnp_get_resource(dev, IORESOURCE_MEM, bar)->start;
+}
+
+static inline resource_size_t pnp_mem_end(struct pnp_dev *dev,
+                                          unsigned int bar)
+{
+        return pnp_get_resource(dev, IORESOURCE_MEM, bar)->end;
+}
+
+static inline unsigned long pnp_mem_flags(struct pnp_dev *dev, unsigned int bar)
+{
+        return pnp_get_resource(dev, IORESOURCE_MEM, bar)->flags;
+}
+
+static inline int pnp_mem_valid(struct pnp_dev *dev, unsigned int bar)
+{
+        return pnp_resource_valid(pnp_get_resource(dev, IORESOURCE_MEM, bar));
+}
+
+static inline resource_size_t pnp_mem_len(struct pnp_dev *dev,
+                                          unsigned int bar)
+{
+        return pnp_resource_len(pnp_get_resource(dev, IORESOURCE_MEM, bar));
+}
+
+
+static inline resource_size_t pnp_irq(struct pnp_dev *dev, unsigned int bar)
+{
+        return pnp_get_resource(dev, IORESOURCE_IRQ, bar)->start;
+}
+
+static inline unsigned long pnp_irq_flags(struct pnp_dev *dev, unsigned int bar)
+{
+        return pnp_get_resource(dev, IORESOURCE_IRQ, bar)->flags;
+}
+
+static inline int pnp_irq_valid(struct pnp_dev *dev, unsigned int bar)
+{
+        return pnp_resource_valid(pnp_get_resource(dev, IORESOURCE_IRQ, bar));
+}
+
+
+static inline resource_size_t pnp_dma(struct pnp_dev *dev, unsigned int bar)
+{
+        return pnp_get_resource(dev, IORESOURCE_DMA, bar)->start;
+}
+
+static inline unsigned long pnp_dma_flags(struct pnp_dev *dev, unsigned int bar)
+{
+        return pnp_get_resource(dev, IORESOURCE_DMA, bar)->flags;
+}
+
+static inline int pnp_dma_valid(struct pnp_dev *dev, unsigned int bar)
+{
+        return pnp_resource_valid(pnp_get_resource(dev, IORESOURCE_DMA, bar));
+}
 
-/* Use these instead of directly reading pnp_dev to get resource information */
-#define pnp_port_start(dev,bar)   ((dev)->res.port_resource[(bar)].start)
-#define pnp_port_end(dev,bar)     ((dev)->res.port_resource[(bar)].end)
-#define pnp_port_flags(dev,bar)   ((dev)->res.port_resource[(bar)].flags)
-#define pnp_port_valid(dev,bar) \
-        ((pnp_port_flags((dev),(bar)) & (IORESOURCE_IO | IORESOURCE_UNSET)) \
-                == IORESOURCE_IO)
-#define pnp_port_len(dev,bar) \
-        ((pnp_port_start((dev),(bar)) == 0 &&   \
-          pnp_port_end((dev),(bar)) ==          \
-          pnp_port_start((dev),(bar))) ? 0 :    \
-                                                \
-         (pnp_port_end((dev),(bar)) -           \
-          pnp_port_start((dev),(bar)) + 1))
-
-#define pnp_mem_start(dev,bar)   ((dev)->res.mem_resource[(bar)].start)
-#define pnp_mem_end(dev,bar)     ((dev)->res.mem_resource[(bar)].end)
-#define pnp_mem_flags(dev,bar)   ((dev)->res.mem_resource[(bar)].flags)
-#define pnp_mem_valid(dev,bar) \
-        ((pnp_mem_flags((dev),(bar)) & (IORESOURCE_MEM | IORESOURCE_UNSET)) \
-                == IORESOURCE_MEM)
-#define pnp_mem_len(dev,bar) \
-        ((pnp_mem_start((dev),(bar)) == 0 &&    \
-          pnp_mem_end((dev),(bar)) ==           \
-          pnp_mem_start((dev),(bar))) ? 0 :     \
-                                                \
-         (pnp_mem_end((dev),(bar)) -            \
-          pnp_mem_start((dev),(bar)) + 1))
-
-#define pnp_irq(dev,bar)         ((dev)->res.irq_resource[(bar)].start)
-#define pnp_irq_flags(dev,bar)   ((dev)->res.irq_resource[(bar)].flags)
-#define pnp_irq_valid(dev,bar) \
-        ((pnp_irq_flags((dev),(bar)) & (IORESOURCE_IRQ | IORESOURCE_UNSET)) \
-                == IORESOURCE_IRQ)
-
-#define pnp_dma(dev,bar)         ((dev)->res.dma_resource[(bar)].start)
-#define pnp_dma_flags(dev,bar)   ((dev)->res.dma_resource[(bar)].flags)
-#define pnp_dma_valid(dev,bar) \
-        ((pnp_dma_flags((dev),(bar)) & (IORESOURCE_DMA | IORESOURCE_UNSET)) \
-                == IORESOURCE_DMA)
 
 #define PNP_PORT_FLAG_16BITADDR (1<<0)
 #define PNP_PORT_FLAG_FIXED     (1<<1)
@@ -118,13 +179,6 @@ struct pnp_option {
         struct pnp_option *next;        /* used to chain dependent resources */
 };
 
-struct pnp_resource_table {
-        struct resource port_resource[PNP_MAX_PORT];
-        struct resource mem_resource[PNP_MAX_MEM];
-        struct resource dma_resource[PNP_MAX_DMA];
-        struct resource irq_resource[PNP_MAX_IRQ];
-};
-
 /*
  * Device Management
  */
@@ -194,10 +248,9 @@ struct pnp_dev {
         int capabilities;
         struct pnp_option *independent;
         struct pnp_option *dependent;
-        struct pnp_resource_table res;
+        struct pnp_resource_table *res;
 
         char name[PNP_NAME_LEN];        /* contains a human-readable name */
-        unsigned short regs;            /* ISAPnP: supported registers */
         int flags;                      /* used by protocols */
         struct proc_dir_entry *procent; /* device entry in /proc/bus/isapnp */
         void *data;
@@ -328,8 +381,8 @@ struct pnp_protocol {
         char *name;
 
         /* resource control functions */
-        int (*get) (struct pnp_dev *dev, struct pnp_resource_table *res);
-        int (*set) (struct pnp_dev *dev, struct pnp_resource_table *res);
+        int (*get) (struct pnp_dev *dev);
+        int (*set) (struct pnp_dev *dev);
         int (*disable) (struct pnp_dev *dev);
 
         /* protocol specific suspend/resume */
@@ -358,20 +411,12 @@ extern struct bus_type pnp_bus_type;
 #if defined(CONFIG_PNP)
 
 /* device management */
-int pnp_register_protocol(struct pnp_protocol *protocol);
-void pnp_unregister_protocol(struct pnp_protocol *protocol);
-int pnp_add_device(struct pnp_dev *dev);
 int pnp_device_attach(struct pnp_dev *pnp_dev);
 void pnp_device_detach(struct pnp_dev *pnp_dev);
 extern struct list_head pnp_global;
 extern int pnp_platform_devices;
 
 /* multidevice card support */
-int pnp_add_card(struct pnp_card *card);
-void pnp_remove_card(struct pnp_card *card);
-int pnp_add_card_device(struct pnp_card *card, struct pnp_dev *dev);
-void pnp_remove_card_device(struct pnp_dev *dev);
-int pnp_add_card_id(struct pnp_id *id, struct pnp_card *card);
 struct pnp_dev *pnp_request_card_device(struct pnp_card_link *clink,
                                         const char *id, struct pnp_dev *from);
 void pnp_release_card_device(struct pnp_dev *dev);
@@ -380,77 +425,42 @@ void pnp_unregister_card_driver(struct pnp_card_driver *drv);
 extern struct list_head pnp_cards;
 
 /* resource management */
-struct pnp_option *pnp_register_independent_option(struct pnp_dev *dev);
-struct pnp_option *pnp_register_dependent_option(struct pnp_dev *dev,
-                                                 int priority);
-int pnp_register_irq_resource(struct pnp_option *option, struct pnp_irq *data);
-int pnp_register_dma_resource(struct pnp_option *option, struct pnp_dma *data);
-int pnp_register_port_resource(struct pnp_option *option,
-                               struct pnp_port *data);
-int pnp_register_mem_resource(struct pnp_option *option, struct pnp_mem *data);
-void pnp_init_resource_table(struct pnp_resource_table *table);
-int pnp_manual_config_dev(struct pnp_dev *dev, struct pnp_resource_table *res,
-                          int mode);
 int pnp_auto_config_dev(struct pnp_dev *dev);
-int pnp_validate_config(struct pnp_dev *dev);
 int pnp_start_dev(struct pnp_dev *dev);
 int pnp_stop_dev(struct pnp_dev *dev);
 int pnp_activate_dev(struct pnp_dev *dev);
 int pnp_disable_dev(struct pnp_dev *dev);
-void pnp_resource_change(struct resource *resource, resource_size_t start,
-                         resource_size_t size);
 
 /* protocol helpers */
 int pnp_is_active(struct pnp_dev *dev);
 int compare_pnp_id(struct pnp_id *pos, const char *id);
-int pnp_add_id(struct pnp_id *id, struct pnp_dev *dev);
 int pnp_register_driver(struct pnp_driver *drv);
 void pnp_unregister_driver(struct pnp_driver *drv);
 
 #else
 
 /* device management */
-static inline int pnp_register_protocol(struct pnp_protocol *protocol) { return -ENODEV; }
-static inline void pnp_unregister_protocol(struct pnp_protocol *protocol) { }
-static inline int pnp_init_device(struct pnp_dev *dev) { return -ENODEV; }
-static inline int pnp_add_device(struct pnp_dev *dev) { return -ENODEV; }
 static inline int pnp_device_attach(struct pnp_dev *pnp_dev) { return -ENODEV; }
 static inline void pnp_device_detach(struct pnp_dev *pnp_dev) { }
 
 #define pnp_platform_devices 0
 
 /* multidevice card support */
-static inline int pnp_add_card(struct pnp_card *card) { return -ENODEV; }
-static inline void pnp_remove_card(struct pnp_card *card) { }
-static inline int pnp_add_card_device(struct pnp_card *card, struct pnp_dev *dev) { return -ENODEV; }
-static inline void pnp_remove_card_device(struct pnp_dev *dev) { }
-static inline int pnp_add_card_id(struct pnp_id *id, struct pnp_card *card) { return -ENODEV; }
 static inline struct pnp_dev *pnp_request_card_device(struct pnp_card_link *clink, const char *id, struct pnp_dev *from) { return NULL; }
 static inline void pnp_release_card_device(struct pnp_dev *dev) { }
 static inline int pnp_register_card_driver(struct pnp_card_driver *drv) { return -ENODEV; }
 static inline void pnp_unregister_card_driver(struct pnp_card_driver *drv) { }
 
 /* resource management */
-static inline struct pnp_option *pnp_register_independent_option(struct pnp_dev *dev) { return NULL; }
-static inline struct pnp_option *pnp_register_dependent_option(struct pnp_dev *dev, int priority) { return NULL; }
-static inline int pnp_register_irq_resource(struct pnp_option *option, struct pnp_irq *data) { return -ENODEV; }
-static inline int pnp_register_dma_resource(struct pnp_option *option, struct pnp_dma *data) { return -ENODEV; }
-static inline int pnp_register_port_resource(struct pnp_option *option, struct pnp_port *data) { return -ENODEV; }
-static inline int pnp_register_mem_resource(struct pnp_option *option, struct pnp_mem *data) { return -ENODEV; }
-static inline void pnp_init_resource_table(struct pnp_resource_table *table) { }
-static inline int pnp_manual_config_dev(struct pnp_dev *dev, struct pnp_resource_table *res, int mode) { return -ENODEV; }
 static inline int pnp_auto_config_dev(struct pnp_dev *dev) { return -ENODEV; }
-static inline int pnp_validate_config(struct pnp_dev *dev) { return -ENODEV; }
 static inline int pnp_start_dev(struct pnp_dev *dev) { return -ENODEV; }
 static inline int pnp_stop_dev(struct pnp_dev *dev) { return -ENODEV; }
 static inline int pnp_activate_dev(struct pnp_dev *dev) { return -ENODEV; }
 static inline int pnp_disable_dev(struct pnp_dev *dev) { return -ENODEV; }
-static inline void pnp_resource_change(struct resource *resource, resource_size_t start, resource_size_t size) { }
 
 /* protocol helpers */
 static inline int pnp_is_active(struct pnp_dev *dev) { return 0; }
 static inline int compare_pnp_id(struct pnp_id *pos, const char *id) { return -ENODEV; }
-static inline int pnp_add_id(struct pnp_id *id, struct pnp_dev *dev) { return -ENODEV; }
 static inline int pnp_register_driver(struct pnp_driver *drv) { return -ENODEV; }
 static inline void pnp_unregister_driver(struct pnp_driver *drv) { }
 
@@ -466,6 +476,4 @@ static inline void pnp_unregister_driver(struct pnp_driver *drv) { }
 #define pnp_dbg(format, arg...) do {} while (0)
 #endif
 
-#endif /* __KERNEL__ */
-
 #endif /* _LINUX_PNP_H */
diff --git a/include/linux/pnpbios.h b/include/linux/pnpbios.h
deleted file mode 100644
index 329192adc9dd..000000000000
--- a/include/linux/pnpbios.h
+++ /dev/null
@@ -1,151 +0,0 @@
-/*
- * Include file for the interface to a PnP BIOS
- *
- * Original BIOS code (C) 1998 Christian Schmidt (chr.schmidt@tu-bs.de)
- * PnP handler parts (c) 1998 Tom Lees <tom@lpsg.demon.co.uk>
- * Minor reorganizations by David Hinds <dahinds@users.sourceforge.net>
- *
- * This program is free software; you can redistribute it and/or modify it
- * under the terms of the GNU General Public License as published by the
- * Free Software Foundation; either version 2, or (at your option) any
- * later version.
- *
- * This program is distributed in the hope that it will be useful, but
- * WITHOUT ANY WARRANTY; without even the implied warranty of
- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
- * General Public License for more details.
- *
- * You should have received a copy of the GNU General Public License
- * along with this program; if not, write to the Free Software
- * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
- */
-
-#ifndef _LINUX_PNPBIOS_H
-#define _LINUX_PNPBIOS_H
-
-#ifdef __KERNEL__
-
-#include <linux/types.h>
-#include <linux/pnp.h>
-
-/*
- * Return codes
- */
-#define PNP_SUCCESS                     0x00
-#define PNP_NOT_SET_STATICALLY          0x7f
-#define PNP_UNKNOWN_FUNCTION            0x81
-#define PNP_FUNCTION_NOT_SUPPORTED      0x82
-#define PNP_INVALID_HANDLE              0x83
-#define PNP_BAD_PARAMETER               0x84
-#define PNP_SET_FAILED                  0x85
-#define PNP_EVENTS_NOT_PENDING          0x86
-#define PNP_SYSTEM_NOT_DOCKED           0x87
-#define PNP_NO_ISA_PNP_CARDS            0x88
-#define PNP_UNABLE_TO_DETERMINE_DOCK_CAPABILITIES 0x89
-#define PNP_CONFIG_CHANGE_FAILED_NO_BATTERY 0x8a
-#define PNP_CONFIG_CHANGE_FAILED_RESOURCE_CONFLICT 0x8b
-#define PNP_BUFFER_TOO_SMALL            0x8c
-#define PNP_USE_ESCD_SUPPORT            0x8d
-#define PNP_MESSAGE_NOT_SUPPORTED       0x8e
-#define PNP_HARDWARE_ERROR              0x8f
-
-#define ESCD_SUCCESS                    0x00
-#define ESCD_IO_ERROR_READING           0x55
-#define ESCD_INVALID                    0x56
-#define ESCD_BUFFER_TOO_SMALL           0x59
-#define ESCD_NVRAM_TOO_SMALL            0x5a
-#define ESCD_FUNCTION_NOT_SUPPORTED     0x81
-
-/*
- * Events that can be received by "get event"
- */
-#define PNPEV_ABOUT_TO_CHANGE_CONFIG    0x0001
-#define PNPEV_DOCK_CHANGED              0x0002
-#define PNPEV_SYSTEM_DEVICE_CHANGED     0x0003
-#define PNPEV_CONFIG_CHANGED_FAILED     0x0004
-#define PNPEV_UNKNOWN_SYSTEM_EVENT      0xffff
-/* 0x8000 through 0xfffe are OEM defined */
-
-/*
- * Messages that should be sent through "send message"
- */
-#define PNPMSG_OK                       0x00
-#define PNPMSG_ABORT                    0x01
-#define PNPMSG_UNDOCK_DEFAULT_ACTION    0x40
-#define PNPMSG_POWER_OFF                0x41
-#define PNPMSG_PNP_OS_ACTIVE            0x42
-#define PNPMSG_PNP_OS_INACTIVE          0x43
-
-/*
- * Plug and Play BIOS flags
- */
-#define PNPBIOS_NO_DISABLE              0x0001
-#define PNPBIOS_NO_CONFIG               0x0002
-#define PNPBIOS_OUTPUT                  0x0004
-#define PNPBIOS_INPUT                   0x0008
-#define PNPBIOS_BOOTABLE                0x0010
-#define PNPBIOS_DOCK                    0x0020
-#define PNPBIOS_REMOVABLE               0x0040
-#define pnpbios_is_static(x) (((x)->flags & 0x0100) == 0x0000)
-#define pnpbios_is_dynamic(x) ((x)->flags & 0x0080)
-
-/*
- * Function Parameters
- */
-#define PNPMODE_STATIC 1
-#define PNPMODE_DYNAMIC 0
-
-/* 0x8000 through 0xffff are OEM defined */
-
-#pragma pack(1)
-struct pnp_dev_node_info {
-        __u16 no_nodes;
-        __u16 max_node_size;
-};
-struct pnp_docking_station_info {
-        __u32 location_id;
-        __u32 serial;
-        __u16 capabilities;
-};
-struct pnp_isa_config_struc {
-        __u8 revision;
-        __u8 no_csns;
-        __u16 isa_rd_data_port;
-        __u16 reserved;
-};
-struct escd_info_struc {
-        __u16 min_escd_write_size;
-        __u16 escd_size;
-        __u32 nv_storage_base;
-};
-struct pnp_bios_node {
-        __u16 size;
-        __u8 handle;
-        __u32 eisa_id;
-        __u8 type_code[3];
-        __u16 flags;
-        __u8 data[0];
-};
-#pragma pack()
-
-#ifdef CONFIG_PNPBIOS
-
-/* non-exported */
-extern struct pnp_dev_node_info node_info;
-
-extern int pnp_bios_dev_node_info(struct pnp_dev_node_info *data);
-extern int pnp_bios_get_dev_node(u8 *nodenum, char config,
-                                 struct pnp_bios_node *data);
-extern int pnp_bios_set_dev_node(u8 nodenum, char config,
-                                 struct pnp_bios_node *data);
-extern int pnp_bios_get_stat_res(char *info);
-extern int pnp_bios_isapnp_config(struct pnp_isa_config_struc *data);
-extern int pnp_bios_escd_info(struct escd_info_struc *data);
-extern int pnp_bios_read_escd(char *data, u32 nvram_base);
-extern int pnp_bios_dock_station_info(struct pnp_docking_station_info *data);
-
-#endif /* CONFIG_PNPBIOS */
-
-#endif /* __KERNEL__ */
-
-#endif /* _LINUX_PNPBIOS_H */
diff --git a/include/linux/poison.h b/include/linux/poison.h
index a9c31be7052c..9f31683728fd 100644
--- a/include/linux/poison.h
+++ b/include/linux/poison.h
@@ -10,6 +10,13 @@
 #define LIST_POISON1  ((void *) 0x00100100)
 #define LIST_POISON2  ((void *) 0x00200200)
 
+/********** include/linux/timer.h **********/
+/*
+ * Magic number "tsta" to indicate a static timer initializer
+ * for the object debugging code.
+ */
+#define TIMER_ENTRY_STATIC      ((void *) 0x74737461)
+
 /********** mm/slab.c **********/
 /*
  * Magic nums for obj red zoning.
diff --git a/include/linux/poll.h b/include/linux/poll.h
index 16d813b364ef..ef453828877a 100644
--- a/include/linux/poll.h
+++ b/include/linux/poll.h
@@ -117,6 +117,8 @@ void zero_fd_set(unsigned long nr, unsigned long *fdset)
 extern int do_select(int n, fd_set_bits *fds, s64 *timeout);
 extern int do_sys_poll(struct pollfd __user * ufds, unsigned int nfds,
                        s64 *timeout);
+extern int core_sys_select(int n, fd_set __user *inp, fd_set __user *outp,
+                           fd_set __user *exp, s64 *timeout);
 
 #endif /* KERNEL */
 
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
-#define proc_bus NULL
+#else
 
 #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/profile.h b/include/linux/profile.h
index ff576d1db67d..05c1cc736937 100644
--- a/include/linux/profile.h
+++ b/include/linux/profile.h
@@ -1,8 +1,6 @@
 #ifndef _LINUX_PROFILE_H
 #define _LINUX_PROFILE_H
 
-#ifdef __KERNEL__
-
 #include <linux/kernel.h>
 #include <linux/init.h>
 #include <linux/cpumask.h>
@@ -118,6 +116,4 @@ static inline void unregister_timer_hook(int (*hook)(struct pt_regs *))
 
 #endif /* CONFIG_PROFILING */
 
-#endif /* __KERNEL__ */
-
 #endif /* _LINUX_PROFILE_H */
diff --git a/include/linux/proportions.h b/include/linux/proportions.h
index 2c3b3cad92be..5afc1b23346d 100644
--- a/include/linux/proportions.h
+++ b/include/linux/proportions.h
@@ -78,6 +78,19 @@ void prop_inc_percpu(struct prop_descriptor *pd, struct prop_local_percpu *pl)
 }
 
 /*
+ * Limit the time part in order to ensure there are some bits left for the
+ * cycle counter and fraction multiply.
+ */
+#define PROP_MAX_SHIFT (3*BITS_PER_LONG/4)
+
+#define PROP_FRAC_SHIFT         (BITS_PER_LONG - PROP_MAX_SHIFT - 1)
+#define PROP_FRAC_BASE          (1UL << PROP_FRAC_SHIFT)
+
+void __prop_inc_percpu_max(struct prop_descriptor *pd,
+                           struct prop_local_percpu *pl, long frac);
+
+
+/*
  * ----- SINGLE ------
  */
 
diff --git a/include/linux/ptrace.h b/include/linux/ptrace.h
index ebe0c17039cf..f98501ba557e 100644
--- a/include/linux/ptrace.h
+++ b/include/linux/ptrace.h
@@ -98,6 +98,10 @@ extern void ptrace_untrace(struct task_struct *child);
 extern int ptrace_may_attach(struct task_struct *task);
 extern int __ptrace_may_attach(struct task_struct *task);
 
+static inline int ptrace_reparented(struct task_struct *child)
+{
+        return child->real_parent != child->parent;
+}
 static inline void ptrace_link(struct task_struct *child,
                                struct task_struct *new_parent)
 {
diff --git a/include/linux/quota.h b/include/linux/quota.h
index eb560d031acd..dcddfb200947 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_off)(struct super_block *, int);
+        int (*quota_on)(struct super_block *, int, int, char *, 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,19 @@ 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))
+
+#define sb_any_quota_suspended(sb) (sb_has_quota_suspended(sb, USRQUOTA) | \
+                                  sb_has_quota_suspended(sb, GRPQUOTA))
+
 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);
-#define vfs_quota_off_mount(sb, type) vfs_quota_off(sb, type)
+extern int vfs_quota_off(struct super_block *sb, int type, int remount);
 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)
-                ret = sb->s_qcop->quota_off(sb, -1);
+        if (sb->s_qcop && sb->s_qcop->quota_off)
+                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)
-#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)
-#define DQUOT_TRANSFER(inode, iattr)            (0)
+
+static inline void DQUOT_INIT(struct inode *inode)
+{
+}
+
+static inline void DQUOT_DROP(struct inode *inode)
+{
+}
+
+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)
-#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)
-#define DQUOT_ALLOC_BLOCK(inode, nr) DQUOT_ALLOC_SPACE(inode, ((qsize_t)(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_NODIRTY(struct inode *inode, qsize_t nr)
+{
+        return DQUOT_PREALLOC_SPACE_NODIRTY(inode,
+                        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/md.h b/include/linux/raid/md.h
index 8ab630b67fcc..81a1a02d4566 100644
--- a/include/linux/raid/md.h
+++ b/include/linux/raid/md.h
@@ -94,6 +94,7 @@ extern int sync_page_io(struct block_device *bdev, sector_t sector, int size,
 extern void md_do_sync(mddev_t *mddev);
 extern void md_new_event(mddev_t *mddev);
 extern void md_allow_write(mddev_t *mddev);
+extern void md_wait_for_blocked_rdev(mdk_rdev_t *rdev, mddev_t *mddev);
 
 #endif /* CONFIG_MD */
 #endif 
diff --git a/include/linux/raid/md_k.h b/include/linux/raid/md_k.h
index 7bb6d1abf71e..812ffa590cff 100644
--- a/include/linux/raid/md_k.h
+++ b/include/linux/raid/md_k.h
@@ -84,6 +84,10 @@ struct mdk_rdev_s
 #define AllReserved     6               /* If whole device is reserved for
                                          * one array */
 #define AutoDetected    7               /* added by auto-detect */
+#define Blocked         8               /* An error occured on an externally
+                                         * managed array, don't allow writes
+                                         * until it is cleared */
+        wait_queue_head_t blocked_wait;
 
         int desc_nr;                    /* descriptor index in the superblock */
         int raid_disk;                  /* role of device in array */
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/rcuclassic.h b/include/linux/rcuclassic.h
index b3dccd68629e..b3aa05baab8a 100644
--- a/include/linux/rcuclassic.h
+++ b/include/linux/rcuclassic.h
@@ -33,8 +33,6 @@
 #ifndef __LINUX_RCUCLASSIC_H
 #define __LINUX_RCUCLASSIC_H
 
-#ifdef __KERNEL__
-
 #include <linux/cache.h>
 #include <linux/spinlock.h>
 #include <linux/threads.h>
@@ -163,5 +161,4 @@ extern long rcu_batches_completed_bh(void);
 #define rcu_enter_nohz()        do { } while (0)
 #define rcu_exit_nohz()         do { } while (0)
 
-#endif /* __KERNEL__ */
 #endif /* __LINUX_RCUCLASSIC_H */
diff --git a/include/linux/rcupdate.h b/include/linux/rcupdate.h
index 37a642c54871..8082d6587a0f 100644
--- a/include/linux/rcupdate.h
+++ b/include/linux/rcupdate.h
@@ -33,8 +33,6 @@
 #ifndef __LINUX_RCUPDATE_H
 #define __LINUX_RCUPDATE_H
 
-#ifdef __KERNEL__
-
 #include <linux/cache.h>
 #include <linux/spinlock.h>
 #include <linux/threads.h>
@@ -245,5 +243,4 @@ extern long rcu_batches_completed_bh(void);
 extern void rcu_init(void);
 extern int rcu_needs_cpu(int cpu);
 
-#endif /* __KERNEL__ */
 #endif /* __LINUX_RCUPDATE_H */
diff --git a/include/linux/rcupreempt.h b/include/linux/rcupreempt.h
index d038aa6e5ee1..8a05c7e20bc4 100644
--- a/include/linux/rcupreempt.h
+++ b/include/linux/rcupreempt.h
@@ -33,8 +33,6 @@
 #ifndef __LINUX_RCUPREEMPT_H
 #define __LINUX_RCUPREEMPT_H
 
-#ifdef __KERNEL__
-
 #include <linux/cache.h>
 #include <linux/spinlock.h>
 #include <linux/threads.h>
@@ -104,5 +102,4 @@ static inline void rcu_exit_nohz(void)
 #define rcu_exit_nohz()         do { } while (0)
 #endif /* CONFIG_NO_HZ */
 
-#endif /* __KERNEL__ */
 #endif /* __LINUX_RCUPREEMPT_H */
diff --git a/include/linux/rcupreempt_trace.h b/include/linux/rcupreempt_trace.h
index 21cd6b2a5c42..b99ae073192a 100644
--- a/include/linux/rcupreempt_trace.h
+++ b/include/linux/rcupreempt_trace.h
@@ -32,7 +32,6 @@
 #ifndef __LINUX_RCUPREEMPT_TRACE_H
 #define __LINUX_RCUPREEMPT_TRACE_H
 
-#ifdef __KERNEL__
 #include <linux/types.h>
 #include <linux/kernel.h>
 
@@ -95,5 +94,4 @@ extern void rcupreempt_trace_done_remove(struct rcupreempt_trace *trace);
 extern void rcupreempt_trace_invoke(struct rcupreempt_trace *trace);
 extern void rcupreempt_trace_next_add(struct rcupreempt_trace *trace);
 
-#endif /* __KERNEL__ */
 #endif /* __LINUX_RCUPREEMPT_TRACE_H */
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/reiserfs_fs_sb.h b/include/linux/reiserfs_fs_sb.h
index db5ef9b83c3f..336ee43ed7d8 100644
--- a/include/linux/reiserfs_fs_sb.h
+++ b/include/linux/reiserfs_fs_sb.h
@@ -177,7 +177,6 @@ struct reiserfs_journal {
         struct reiserfs_journal_cnode *j_last;  /* newest journal block */
         struct reiserfs_journal_cnode *j_first; /*  oldest journal block.  start here for traverse */
 
-        struct file *j_dev_file;
         struct block_device *j_dev_bd;
         int j_1st_reserved_block;       /* first block on s_dev of reserved area journal */
 
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..c1c99c9643d3 100644
--- a/include/linux/rio.h
+++ b/include/linux/rio.h
@@ -14,8 +14,6 @@
 #ifndef LINUX_RIO_H
 #define LINUX_RIO_H
 
-#ifdef __KERNEL__
-
 #include <linux/types.h>
 #include <linux/ioport.h>
 #include <linux/list.h>
@@ -23,7 +21,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 +36,8 @@
                                            entry is invalid (no route
                                            exists for the device ID) */
 
-#ifdef CONFIG_RAPIDIO_8_BIT_TRANSPORT
-#define RIO_MAX_ROUTE_ENTRIES   (1 << 8)
-#else
-#define RIO_MAX_ROUTE_ENTRIES   (1 << 16)
-#endif
+#define RIO_MAX_ROUTE_ENTRIES(size)     (size ? (1 << 16) : (1 << 8))
+#define RIO_ANY_DESTID(size)            (size ? 0xffff : 0xff)
 
 #define RIO_MAX_MBOX            4
 #define RIO_MAX_MSG_SIZE        0x1000
@@ -149,6 +143,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 +162,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 +177,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 +217,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 +235,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 (*lcwrite) (int index, u32 offset, int len, u32 data);
-        int (*cread) (int index, u16 destid, u8 hopcount, u32 offset, int len,
-                      u32 * data);
-        int (*cwrite) (int index, u16 destid, u8 hopcount, u32 offset, int len,
-                       u32 data);
-        int (*dsend) (int index, u16 destid, u16 data);
+        int (*lcread) (struct rio_mport *mport, int index, u32 offset, int len,
+                        u32 *data);
+        int (*lcwrite) (struct rio_mport *mport, int index, u32 offset, int len,
+                        u32 data);
+        int (*cread) (struct rio_mport *mport, int index, u16 destid,
+                        u8 hopcount, u32 offset, int len, u32 *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
@@ -321,5 +329,4 @@ extern void rio_close_inb_mbox(struct rio_mport *, int);
 extern int rio_open_outb_mbox(struct rio_mport *, void *, int, int);
 extern void rio_close_outb_mbox(struct rio_mport *, int);
 
-#endif                          /* __KERNEL__ */
 #endif                          /* LINUX_RIO_H */
diff --git a/include/linux/rio_drv.h b/include/linux/rio_drv.h
index 7adb2a1aac92..90987b7bcc1b 100644
--- a/include/linux/rio_drv.h
+++ b/include/linux/rio_drv.h
@@ -13,8 +13,6 @@
 #ifndef LINUX_RIO_DRV_H
 #define LINUX_RIO_DRV_H
 
-#ifdef __KERNEL__
-
 #include <linux/types.h>
 #include <linux/ioport.h>
 #include <linux/list.h>
@@ -465,5 +463,4 @@ extern struct rio_dev *rio_get_device(u16 vid, u16 did, struct rio_dev *from);
 extern struct rio_dev *rio_get_asm(u16 vid, u16 did, u16 asm_vid, u16 asm_did,
                                    struct rio_dev *from);
 
-#endif                          /* __KERNEL__ */
 #endif                          /* LINUX_RIO_DRV_H */
diff --git a/include/linux/rwsem.h b/include/linux/rwsem.h
index 7b524b4109a0..efd348fe8ca7 100644
--- a/include/linux/rwsem.h
+++ b/include/linux/rwsem.h
@@ -9,8 +9,6 @@
 
 #include <linux/linkage.h>
 
-#ifdef __KERNEL__
-
 #include <linux/types.h>
 #include <linux/kernel.h>
 #include <asm/system.h>
@@ -90,5 +88,4 @@ extern void up_read_non_owner(struct rw_semaphore *sem);
 # define up_read_non_owner(sem)                 up_read(sem)
 #endif
 
-#endif /* __KERNEL__ */
 #endif /* _LINUX_RWSEM_H */
diff --git a/include/linux/sched.h b/include/linux/sched.h
index 9a4f3e63e3bf..03c238088aee 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>
@@ -555,6 +554,14 @@ struct signal_struct {
 #define SIGNAL_STOP_DEQUEUED    0x00000002 /* stop signal dequeued */
 #define SIGNAL_STOP_CONTINUED   0x00000004 /* SIGCONT since WCONTINUED reap */
 #define SIGNAL_GROUP_EXIT       0x00000008 /* group exit in progress */
+/*
+ * Pending notifications to parent.
+ */
+#define SIGNAL_CLD_STOPPED      0x00000010
+#define SIGNAL_CLD_CONTINUED    0x00000020
+#define SIGNAL_CLD_MASK         (SIGNAL_CLD_STOPPED|SIGNAL_CLD_CONTINUED)
+
+#define SIGNAL_UNKILLABLE       0x00000040 /* for init: ignore fatal signals */
 
 /* If true, all threads except ->group_exit_task have pending SIGKILL */
 static inline int signal_group_exit(const struct signal_struct *sig)
@@ -1133,7 +1140,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 */
@@ -1168,7 +1175,7 @@ struct task_struct {
         struct sighand_struct *sighand;
 
         sigset_t blocked, real_blocked;
-        sigset_t saved_sigmask;         /* To be restored with TIF_RESTORE_SIGMASK */
+        sigset_t saved_sigmask; /* restored if set_restore_sigmask() was used */
         struct sigpending pending;
 
         unsigned long sas_ss_sp;
@@ -1670,7 +1677,10 @@ extern struct pid_namespace init_pid_ns;
 extern struct task_struct *find_task_by_pid_type_ns(int type, int pid,
                 struct pid_namespace *ns);
 
-extern struct task_struct *find_task_by_pid(pid_t nr);
+static inline struct task_struct *__deprecated find_task_by_pid(pid_t nr)
+{
+        return find_task_by_pid_type_ns(PIDTYPE_PID, nr, &init_pid_ns);
+}
 extern struct task_struct *find_task_by_vpid(pid_t nr);
 extern struct task_struct *find_task_by_pid_ns(pid_t nr,
                 struct pid_namespace *ns);
@@ -1746,8 +1756,7 @@ extern void zap_other_threads(struct task_struct *p);
 extern int kill_proc(pid_t, int, int);
 extern struct sigqueue *sigqueue_alloc(void);
 extern void sigqueue_free(struct sigqueue *);
-extern int send_sigqueue(int, struct sigqueue *,  struct task_struct *);
-extern int send_group_sigqueue(int, struct sigqueue *,  struct task_struct *);
+extern int send_sigqueue(struct sigqueue *,  struct task_struct *, int group);
 extern int do_sigaction(int, struct k_sigaction *, struct k_sigaction *);
 extern int do_sigaltstack(const stack_t __user *, stack_t __user *, unsigned long);
 
@@ -2149,6 +2158,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 ?       \
-                      (1 << (X)) & SECUREBITS_DEFAULT :         \
-                      (1 << (X)) & securebits )
+#define SECURE_ALL_BITS         (issecure_mask(SECURE_NOROOT) | \
+                                 issecure_mask(SECURE_NO_SETUID_FIXUP) | \
+                                 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_settime (struct timespec *ts, struct timezone *tz);
-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_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 int cap_bprm_set_security (struct linux_binprm *bprm);
-extern void cap_bprm_apply_creds (struct linux_binprm *bprm, int unsafe);
+extern int cap_capable(struct task_struct *tsk, int cap);
+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_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 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 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_removexattr(struct dentry *dentry, char *name);
+extern int cap_inode_setxattr(struct dentry *dentry, const 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 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_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_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 int cap_task_prctl(int option, unsigned long arg2, unsigned long arg3,
+                          unsigned long arg4, unsigned long arg5, long *rc_p);
+extern int cap_task_setscheduler(struct task_struct *p, int policy, struct sched_param *lp);
+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
- *      begin.  It allows a check the @bprm->security value which is set in
- *      the preceding set_security call.  The primary difference from
- *      set_security is that the argv list and envp list are reliably
- *      available in @bprm.  This hook may be called multiple times
- *      during a single execve; and in each pass set_security is called
- *      first.
- *      @bprm contains the linux_binprm structure.
+ *      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
+ *      the preceding set_security call.  The primary difference from
+ *      set_security is that the argv list and envp list are reliably
+ *      available in @bprm.  This hook may be called multiple times
+ *      during a single execve; and in each pass set_security is called
+ *      first.
+ *      @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" 
- *      is required.  The flag is passed in the auxiliary table
- *      on the initial stack to the ELF interpreter to indicate whether libc 
- *      should enable secure mode.
- *      @bprm contains the linux_binprm structure.
+ *      Return a boolean value (0 or 1) indicating whether a "secure exec"
+ *      is required.  The flag is passed in the auxiliary table
+ *      on the initial stack to the ELF interpreter to indicate whether libc
+ *      should enable secure mode.
+ *      @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
- *      @value identified by @name for @dentry.
- *      Return 0 if permission is granted.
+ *      Check permission before setting the extended attributes
+ *      @value identified by @name for @dentry.
+ *      Return 0 if permission is granted.
  * @inode_post_setxattr:
- *      Update inode security field after successful setxattr operation.
- *      @value identified by @name for @dentry.
+ *      Update inode security field after successful setxattr operation.
+ *      @value identified by @name for @dentry.
  * @inode_getxattr:
- *      Check permission before obtaining the extended attributes
- *      identified by @name for @dentry.
- *      Return 0 if permission is granted.
+ *      Check permission before obtaining the extended attributes
+ *      identified by @name for @dentry.
+ *      Return 0 if permission is granted.
  * @inode_listxattr:
- *      Check permission before obtaining the list of extended attribute 
- *      names for @dentry.
- *      Return 0 if permission is granted.
+ *      Check permission before obtaining the list of extended attribute
+ *      names for @dentry.
+ *      Return 0 if permission is granted.
  * @inode_removexattr:
- *      Check permission before removing the extended attribute
- *      identified by @name for @dentry.
- *      Return 0 if permission is granted.
+ *      Check permission before removing the extended attribute
+ *      identified by @name for @dentry.
+ *      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
- *      is being reparented to the init task.
+ *      Set the security attributes in @p->security for a kernel thread that
+ *      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
- *      security attributes, e.g. for /proc/pid inodes.
+ *      Set the security attributes for an inode based on an associated task's
+ *      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
- *      state for udp sockets on a per-packet basis to userspace via
- *      getsockopt SO_GETPEERSEC.  The application must first have indicated
- *      the IP_PASSSEC option via getsockopt.  It can then retrieve the
- *      security state returned by this hook for a packet via the SCM_SECURITY
- *      ancillary message type.
- *      @skb is the skbuff for the packet being queried
- *      @secdata is a pointer to a buffer in which to copy the security data
- *      @seclen is the maximum length for @secdata
- *      Return 0 on success, error on failure.
+ *      This hook allows the security module to provide peer socket security
+ *      state for udp sockets on a per-packet basis to userspace via
+ *      getsockopt SO_GETPEERSEC.  The application must first have indicated
+ *      the IP_PASSSEC option via getsockopt.  It can then retrieve the
+ *      security state returned by this hook for a packet via the SCM_SECURITY
+ *      ancillary message type.
+ *      @skb is the skbuff for the packet being queried
+ *      @secdata is a pointer to a buffer in which to copy the security data
+ *      @seclen is the maximum length for @secdata
+ *      Return 0 on success, error on failure.
  * @sk_alloc_security:
- *      Allocate and attach a security structure to the sk->sk_security field,
- *      which is used to copy security attributes between local stream sockets.
+ *      Allocate and attach a security structure to the sk->sk_security field,
+ *      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 
- *      process that will be receiving the message (not equal to the current 
+ *      queue, @msq.  The @target task structure contains a pointer to the
+ *      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 
- *      may be modified.
+ *      semaphore set @sma.  If the @alter flag is nonzero, the semaphore set
+ *      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.
- *      @name contains the name of the security module being stacked.
- *      @ops contains a pointer to the struct security_operations of the module to stack.
- * 
+ *      allow module stacking.
+ *      @name contains the name of the security module being stacked.
+ *      @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.
- *      @secid contains the pointer to the generated security ID.
- *      @secdata contains the security context.
+ *      Convert security context to secid.
+ *      @secid contains the pointer to the generated security ID.
+ *      @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 (*capget) (struct task_struct * target,
-                       kernel_cap_t * effective,
-                       kernel_cap_t * inheritable, kernel_cap_t * permitted);
-        int (*capset_check) (struct task_struct * target,
-                             kernel_cap_t * effective,
-                             kernel_cap_t * inheritable,
-                             kernel_cap_t * permitted);
-        void (*capset_set) (struct task_struct * target,
-                            kernel_cap_t * effective,
-                            kernel_cap_t * inheritable,
-                            kernel_cap_t * permitted);
-        int (*capable) (struct task_struct * tsk, int cap);
-        int (*acct) (struct file * file);
-        int (*sysctl) (struct ctl_table * table, int op);
-        int (*quotactl) (int cmds, int type, int id, struct super_block * sb);
-        int (*quota_on) (struct dentry * dentry);
+        int (*ptrace) (struct task_struct *parent, struct task_struct *child);
+        int (*capget) (struct task_struct *target,
+                       kernel_cap_t *effective,
+                       kernel_cap_t *inheritable, kernel_cap_t *permitted);
+        int (*capset_check) (struct task_struct *target,
+                             kernel_cap_t *effective,
+                             kernel_cap_t *inheritable,
+                             kernel_cap_t *permitted);
+        void (*capset_set) (struct task_struct *target,
+                            kernel_cap_t *effective,
+                            kernel_cap_t *inheritable,
+                            kernel_cap_t *permitted);
+        int (*capable) (struct task_struct *tsk, int cap);
+        int (*acct) (struct file *file);
+        int (*sysctl) (struct ctl_table *table, int op);
+        int (*quotactl) (int cmds, int type, int id, struct super_block *sb);
+        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);
-        void (*bprm_free_security) (struct linux_binprm * bprm);
-        void (*bprm_apply_creds) (struct linux_binprm * bprm, int unsafe);
-        void (*bprm_post_apply_creds) (struct linux_binprm * bprm);
-        int (*bprm_set_security) (struct linux_binprm * bprm);
-        int (*bprm_check_security) (struct linux_binprm * bprm);
-        int (*bprm_secureexec) (struct linux_binprm * bprm);
-
-        int (*sb_alloc_security) (struct super_block * sb);
-        void (*sb_free_security) (struct super_block * sb);
-        int (*sb_copy_data)(char *orig, char *copy);
+        int (*bprm_alloc_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_post_apply_creds) (struct linux_binprm *bprm);
+        int (*bprm_set_security) (struct linux_binprm *bprm);
+        int (*bprm_check_security) (struct linux_binprm *bprm);
+        int (*bprm_secureexec) (struct linux_binprm *bprm);
+
+        int (*sb_alloc_security) (struct super_block *sb);
+        void (*sb_free_security) (struct super_block *sb);
+        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_umount) (struct vfsmount * mnt, int flags);
-        void (*sb_umount_close) (struct vfsmount * mnt);
-        void (*sb_umount_busy) (struct vfsmount * mnt);
-        void (*sb_post_remount) (struct vfsmount * mnt,
+        int (*sb_check_sb) (struct vfsmount *mnt, struct path *path);
+        int (*sb_umount) (struct vfsmount *mnt, int flags);
+        void (*sb_umount_close) (struct vfsmount *mnt);
+        void (*sb_umount_busy) (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);
-        int (*inode_setxattr) (struct dentry *dentry, char *name, void *value,
-                               size_t size, int flags);
-        void (*inode_post_setxattr) (struct dentry *dentry, char *name, void *value,
-                                     size_t size, int flags);
-        int (*inode_getxattr) (struct dentry *dentry, char *name);
+        void (*inode_delete) (struct inode *inode);
+        int (*inode_setxattr) (struct dentry *dentry, const char *name,
+                               const void *value, size_t size, int flags);
+        void (*inode_post_setxattr) (struct dentry *dentry, const char *name,
+                                     const void *value, size_t size, int flags);
+        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_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);
-        void (*inode_getsecid)(const struct inode *inode, u32 *secid);
-
-        int (*file_permission) (struct file * file, int mask);
-        int (*file_alloc_security) (struct file * file);
-        void (*file_free_security) (struct file * file);
-        int (*file_ioctl) (struct file * file, unsigned int cmd,
+        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_listsecurity) (struct inode *inode, char *buffer, size_t buffer_size);
+        void (*inode_getsecid) (const struct inode *inode, u32 *secid);
+
+        int (*file_permission) (struct file *file, int mask);
+        int (*file_alloc_security) (struct file *file);
+        void (*file_free_security) (struct file *file);
+        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_fcntl) (struct file * file, unsigned int cmd,
+        int (*file_lock) (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_send_sigiotask) (struct task_struct * tsk,
-                                    struct fown_struct * fown, int sig);
-        int (*file_receive) (struct file * file);
-        int (*dentry_open)  (struct file *file);
+        int (*file_set_fowner) (struct file *file);
+        int (*file_send_sigiotask) (struct task_struct *tsk,
+                                    struct fown_struct *fown, int sig);
+        int (*file_receive) (struct file *file);
+        int (*dentry_open) (struct file *file);
 
         int (*task_create) (unsigned long clone_flags);
-        int (*task_alloc_security) (struct task_struct * p);
-        void (*task_free_security) (struct task_struct * p);
+        int (*task_alloc_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_getpgid) (struct task_struct * p);
-        int (*task_getsid) (struct task_struct * p);
-        void (*task_getsecid) (struct task_struct * p, u32 * secid);
+        int (*task_setpgid) (struct task_struct *p, pid_t pgid);
+        int (*task_getpgid) (struct task_struct *p);
+        int (*task_getsid) (struct task_struct *p);
+        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_setioprio) (struct task_struct * p, int ioprio);
-        int (*task_getioprio) (struct task_struct * p);
-        int (*task_setrlimit) (unsigned int resource, struct rlimit * new_rlim);
-        int (*task_setscheduler) (struct task_struct * p, int policy,
-                                  struct sched_param * lp);
-        int (*task_getscheduler) (struct task_struct * p);
-        int (*task_movememory) (struct task_struct * p);
-        int (*task_kill) (struct task_struct * p,
-                          struct siginfo * info, int sig, u32 secid);
-        int (*task_wait) (struct task_struct * p);
+        int (*task_setnice) (struct task_struct *p, int nice);
+        int (*task_setioprio) (struct task_struct *p, int ioprio);
+        int (*task_getioprio) (struct task_struct *p);
+        int (*task_setrlimit) (unsigned int resource, struct rlimit *new_rlim);
+        int (*task_setscheduler) (struct task_struct *p, int policy,
+                                  struct sched_param *lp);
+        int (*task_getscheduler) (struct task_struct *p);
+        int (*task_movememory) (struct task_struct *p);
+        int (*task_kill) (struct task_struct *p,
+                          struct siginfo *info, int sig, u32 secid);
+        int (*task_wait) (struct task_struct *p);
         int (*task_prctl) (int option, unsigned long arg2,
                            unsigned long arg3, unsigned long arg4,
-                           unsigned long arg5);
-        void (*task_reparent_to_init) (struct task_struct * p);
-        void (*task_to_inode)(struct task_struct *p, struct inode *inode);
+                           unsigned long arg5, long *rc_p);
+        void (*task_reparent_to_init) (struct task_struct *p);
+        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);
-        void (*msg_msg_free_security) (struct msg_msg * msg);
-
-        int (*msg_queue_alloc_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_msgctl) (struct msg_queue * msq, int cmd);
-        int (*msg_queue_msgsnd) (struct msg_queue * msq,
-                                 struct msg_msg * msg, int msqflg);
-        int (*msg_queue_msgrcv) (struct msg_queue * msq,
-                                 struct msg_msg * msg,
-                                 struct task_struct * target,
+        int (*msg_msg_alloc_security) (struct msg_msg *msg);
+        void (*msg_msg_free_security) (struct msg_msg *msg);
+
+        int (*msg_queue_alloc_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_msgctl) (struct msg_queue *msq, int cmd);
+        int (*msg_queue_msgsnd) (struct msg_queue *msq,
+                                 struct msg_msg *msg, int msqflg);
+        int (*msg_queue_msgrcv) (struct msg_queue *msq,
+                                 struct msg_msg *msg,
+                                 struct task_struct *target,
                                  long type, int mode);
 
-        int (*shm_alloc_security) (struct shmid_kernel * shp);
-        void (*shm_free_security) (struct shmid_kernel * shp);
-        int (*shm_associate) (struct shmid_kernel * shp, int shmflg);
-        int (*shm_shmctl) (struct shmid_kernel * shp, int cmd);
-        int (*shm_shmat) (struct shmid_kernel * shp, 
+        int (*shm_alloc_security) (struct shmid_kernel *shp);
+        void (*shm_free_security) (struct shmid_kernel *shp);
+        int (*shm_associate) (struct shmid_kernel *shp, int shmflg);
+        int (*shm_shmctl) (struct shmid_kernel *shp, int cmd);
+        int (*shm_shmat) (struct shmid_kernel *shp,
                           char __user *shmaddr, int shmflg);
 
-        int (*sem_alloc_security) (struct sem_array * sma);
-        void (*sem_free_security) (struct sem_array * sma);
-        int (*sem_associate) (struct sem_array * sma, int semflg);
-        int (*sem_semctl) (struct sem_array * sma, int cmd);
-        int (*sem_semop) (struct sem_array * sma, 
-                          struct sembuf * sops, unsigned nsops, int alter);
+        int (*sem_alloc_security) (struct sem_array *sma);
+        void (*sem_free_security) (struct sem_array *sma);
+        int (*sem_associate) (struct sem_array *sma, int semflg);
+        int (*sem_semctl) (struct sem_array *sma, int cmd);
+        int (*sem_semop) (struct sem_array *sma,
+                          struct sembuf *sops, unsigned nsops, int alter);
 
-        int (*netlink_send) (struct sock * sk, struct sk_buff * skb);
-        int (*netlink_recv) (struct sk_buff * skb, int cap);
+        int (*netlink_send) (struct sock *sk, struct sk_buff *skb);
+        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 (*setprocattr)(struct task_struct *p, char *name, void *value, size_t size);
-        int (*secid_to_secctx)(u32 secid, char **secdata, u32 *seclen);
-        int (*secctx_to_secid)(char *secdata, u32 seclen, u32 *secid);
-        void (*release_secctx)(char *secdata, u32 seclen);
+        int (*getprocattr) (struct task_struct *p, char *name, char **value);
+        int (*setprocattr) (struct task_struct *p, char *name, void *value, size_t size);
+        int (*secid_to_secctx) (u32 secid, char **secdata, u32 *seclen);
+        int (*secctx_to_secid) (const char *secdata, u32 seclen, u32 *secid);
+        void (*release_secctx) (char *secdata, u32 seclen);
 
 #ifdef CONFIG_SECURITY_NETWORK
-        int (*unix_stream_connect) (struct socket * sock,
-                                    struct socket * other, struct sock * newsk);
-        int (*unix_may_send) (struct socket * sock, struct socket * other);
+        int (*unix_stream_connect) (struct socket *sock,
+                                    struct socket *other, struct sock *newsk);
+        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,
-                            struct sockaddr * address, int addrlen);
-        int (*socket_connect) (struct socket * sock,
-                               struct sockaddr * address, int addrlen);
-        int (*socket_listen) (struct socket * sock, int backlog);
-        int (*socket_accept) (struct socket * sock, struct socket * newsock);
-        void (*socket_post_accept) (struct socket * sock,
-                                    struct socket * newsock);
-        int (*socket_sendmsg) (struct socket * sock,
-                               struct msghdr * msg, int size);
-        int (*socket_recvmsg) (struct socket * sock,
-                               struct msghdr * msg, int size, int flags);
-        int (*socket_getsockname) (struct socket * sock);
-        int (*socket_getpeername) (struct socket * sock);
-        int (*socket_getsockopt) (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_sock_rcv_skb) (struct sock * sk, struct sk_buff * skb);
+        int (*socket_bind) (struct socket *sock,
+                            struct sockaddr *address, int addrlen);
+        int (*socket_connect) (struct socket *sock,
+                               struct sockaddr *address, int addrlen);
+        int (*socket_listen) (struct socket *sock, int backlog);
+        int (*socket_accept) (struct socket *sock, struct socket *newsock);
+        void (*socket_post_accept) (struct socket *sock,
+                                    struct socket *newsock);
+        int (*socket_sendmsg) (struct socket *sock,
+                               struct msghdr *msg, int size);
+        int (*socket_recvmsg) (struct socket *sock,
+                               struct msghdr *msg, int size, int flags);
+        int (*socket_getsockname) (struct socket *sock);
+        int (*socket_getpeername) (struct socket *sock);
+        int (*socket_getsockopt) (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_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);
-        int (*inet_conn_request)(struct sock *sk, struct sk_buff *skb,
-                                        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 (*req_classify_flow)(const struct request_sock *req, struct flowi *fl);
+        void (*sock_graft) (struct sock *sk, struct socket *parent);
+        int (*inet_conn_request) (struct sock *sk, struct sk_buff *skb,
+                                  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 (*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_state_pol_flow_match)(struct xfrm_state *x,
-                        struct xfrm_policy *xp, struct flowi *fl);
-        int (*xfrm_decode_session)(struct sk_buff *skb, u32 *secid, int ckall);
+        int (*xfrm_policy_lookup) (struct xfrm_sec_ctx *ctx, u32 fl_secid, u8 dir);
+        int (*xfrm_state_pol_flow_match) (struct xfrm_state *x,
+                                          struct xfrm_policy *xp,
+                                          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);
-        void (*key_free)(struct key *key);
-        int (*key_permission)(key_ref_t key_ref,
-                              struct task_struct *context,
-                              key_perm_t perm);
-
+        int (*key_alloc) (struct key *key, struct task_struct *tsk, unsigned long flags);
+        void (*key_free) (struct key *key);
+        int (*key_permission) (key_ref_t key_ref,
+                               struct task_struct *context,
+                               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_known)(struct audit_krule *krule);
-        int (*audit_rule_match)(u32 secid, u32 field, u32 op, void *lsmrule,
-                                struct audit_context *actx);
-        void (*audit_rule_free)(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_match) (u32 secid, u32 field, u32 op, void *lsmrule,
+                                 struct audit_context *actx);
+        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 mod_reg_security     (const char *name, 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 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 *inheritable,
-                     kernel_cap_t *permitted);
+                    kernel_cap_t *effective,
+                    kernel_cap_t *inheritable,
+                    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,
-                             void *value, size_t size, int flags);
-void security_inode_post_setxattr(struct dentry *dentry, char *name,
-                                   void *value, size_t size, int flags);
-int security_inode_getxattr(struct dentry *dentry, char *name);
+int security_inode_setxattr(struct dentry *dentry, const char *name,
+                            const void *value, size_t size, int flags);
+void security_inode_post_setxattr(struct dentry *dentry, const char *name,
+                                  const void *value, size_t size, int flags);
+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,
-                                     struct super_block * sb)
+static inline int security_quotactl(int cmds, int type, int id,
+                                     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)
-{ 
-        cap_bprm_apply_creds (bprm, unsafe);
+static inline void security_bprm_apply_creds(struct linux_binprm *bprm, int 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,
-                                        struct path *path)
+static inline int security_sb_check_sb(struct vfsmount *mnt,
+                                       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,
-                                              struct path *mountpoint)
+static inline void security_sb_post_addmount(struct vfsmount *mnt,
+                                             struct path *mountpoint)
 { }
 
-static inline int security_sb_pivotroot (struct path *old_path,
-                                         struct path *new_path)
+static inline int security_sb_pivotroot(struct path *old_path,
+                                        struct path *new_path)
 {
         return 0;
 }
 
-static inline void security_sb_post_pivotroot (struct path *old_path,
-                                               struct path *new_path)
+static inline void security_sb_post_pivotroot(struct path *old_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,
-                                           void *value, size_t size, int flags)
+static inline int security_inode_setxattr(struct dentry *dentry,
+                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,
-                                                 void *value, size_t size, int flags)
+static inline void security_inode_post_setxattr(struct dentry *dentry,
+                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,
-                                       unsigned long arg)
+static inline int security_file_ioctl(struct file *file, unsigned int cmd,
+                                      unsigned long arg)
 {
         return 0;
 }
 
-static inline int security_file_mmap (struct file *file, unsigned long reqprot,
-                                      unsigned long prot,
-                                      unsigned long flags,
-                                      unsigned long addr,
-                                      unsigned long addr_only)
+static inline int security_file_mmap(struct file *file, unsigned long reqprot,
+                                     unsigned long prot,
+                                     unsigned long flags,
+                                     unsigned long addr,
+                                     unsigned long addr_only)
 {
         return 0;
 }
 
-static inline int security_file_mprotect (struct vm_area_struct *vma,
-                                          unsigned long reqprot,
-                                          unsigned long prot)
+static inline int security_file_mprotect(struct vm_area_struct *vma,
+                                         unsigned long reqprot,
+                                         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,
-                                       unsigned long arg)
+static inline int security_file_fcntl(struct file *file, unsigned int cmd,
+                                      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,
-                                                struct fown_struct *fown,
-                                                int sig)
+static inline int security_file_send_sigiotask(struct task_struct *tsk,
+                                               struct fown_struct *fown,
+                                               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,
-                                        int flags)
+static inline int security_task_setuid(uid_t id0, uid_t id1, uid_t id2,
+                                       int flags)
 {
         return 0;
 }
 
-static inline int security_task_post_setuid (uid_t old_ruid, uid_t old_euid,
-                                             uid_t old_suid, int flags)
+static inline int security_task_post_setuid(uid_t old_ruid, uid_t old_euid,
+                                            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,
-                                        int flags)
+static inline int security_task_setgid(gid_t id0, gid_t id1, gid_t id2,
+                                       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,
-                                           struct rlimit *new_rlim)
+static inline int security_task_setrlimit(unsigned int resource,
+                                          struct rlimit *new_rlim)
 {
         return 0;
 }
 
-static inline int security_task_setscheduler (struct task_struct *p,
-                                              int policy,
-                                              struct sched_param *lp)
+static inline int security_task_setscheduler(struct task_struct *p,
+                                             int policy,
+                                             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,
-                                      struct siginfo *info, int sig,
-                                      u32 secid)
+static inline int security_task_kill(struct task_struct *p,
+                                     struct siginfo *info, int sig,
+                                     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,
-                                       unsigned long arg3,
-                                       unsigned long arg4,
-                                       unsigned long arg5)
+static inline int security_task_prctl(int option, unsigned long arg2,
+                                      unsigned long arg3,
+                                      unsigned long arg4,
+                                      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,
-                                           short flag)
+static inline int security_ipc_permission(struct kern_ipc_perm *ipcp,
+                                          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, 
-                                                int msqflg)
+static inline int security_msg_queue_associate(struct msg_queue *msq,
+                                               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,
-                                             struct msg_msg * msg, int msqflg)
+static inline int security_msg_queue_msgsnd(struct msg_queue *msq,
+                                            struct msg_msg *msg, int msqflg)
 {
         return 0;
 }
 
-static inline int security_msg_queue_msgrcv (struct msg_queue * msq,
-                                             struct msg_msg * msg,
-                                             struct task_struct * target,
-                                             long type, int mode)
+static inline int security_msg_queue_msgrcv(struct msg_queue *msq,
+                                            struct msg_msg *msg,
+                                            struct task_struct *target,
+                                            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, 
-                                          int shmflg)
+static inline int security_shm_associate(struct shmid_kernel *shp,
+                                         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, 
-                                      char __user *shmaddr, int shmflg)
+static inline int security_shm_shmat(struct shmid_kernel *shp,
+                                     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, 
-                                      struct sembuf * sops, unsigned nsops, 
-                                      int alter)
+static inline int security_sem_semop(struct sem_array *sma,
+                                     struct sembuf *sops, unsigned nsops,
+                                     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,
-                                               struct socket * other,
-                                               struct sock * newsk)
+static inline int security_unix_stream_connect(struct socket *sock,
+                                               struct socket *other,
+                                               struct sock *newsk)
 {
         return 0;
 }
 
-static inline int security_unix_may_send(struct socket * sock, 
-                                         struct socket * other)
+static inline int security_unix_may_send(struct socket *sock,
+                                         struct socket *other)
 {
         return 0;
 }
 
-static inline int security_socket_create (int family, int type,
-                                          int protocol, int kern)
+static inline int security_socket_create(int family, int type,
+                                         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, 
-                                       struct sockaddr * address, 
+static inline int security_socket_bind(struct socket *sock,
+                                       struct sockaddr *address,
                                        int addrlen)
 {
         return 0;
 }
 
-static inline int security_socket_connect(struct socket * sock, 
-                                          struct sockaddr * address, 
+static inline int security_socket_connect(struct socket *sock,
+                                          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, 
-                                         struct socket * newsock)
+static inline int security_socket_accept(struct socket *sock,
+                                         struct socket *newsock)
 {
         return 0;
 }
 
-static inline void security_socket_post_accept(struct socket * sock, 
-                                               struct socket * newsock)
+static inline void security_socket_post_accept(struct socket *sock,
+                                               struct socket *newsock)
 {
 }
 
-static inline int security_socket_sendmsg(struct socket * sock, 
-                                          struct msghdr * msg, int size)
+static inline int security_socket_sendmsg(struct socket *sock,
+                                          struct msghdr *msg, int size)
 {
         return 0;
 }
 
-static inline int security_socket_recvmsg(struct socket * sock, 
-                                          struct msghdr * msg, int size, 
+static inline int security_socket_recvmsg(struct socket *sock,
+                                          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, 
-                                         struct sk_buff * skb)
+static inline int security_sock_rcv_skb(struct sock *sk,
+                                        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/seq_file.h b/include/linux/seq_file.h
index 5b5369c3c209..a66304a09955 100644
--- a/include/linux/seq_file.h
+++ b/include/linux/seq_file.h
@@ -1,6 +1,5 @@
 #ifndef _LINUX_SEQ_FILE_H
 #define _LINUX_SEQ_FILE_H
-#ifdef __KERNEL__
 
 #include <linux/types.h>
 #include <linux/string.h>
@@ -69,4 +68,3 @@ extern struct list_head *seq_list_next(void *v, struct list_head *head,
                 loff_t *ppos);
 
 #endif
-#endif
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/serial_core.h b/include/linux/serial_core.h
index 7cb094a82456..d32123ae08ad 100644
--- a/include/linux/serial_core.h
+++ b/include/linux/serial_core.h
@@ -149,13 +149,15 @@
 /* Freescale ColdFire */
 #define PORT_MCF        78
 
-#define PORT_SC26XX     79
-
+/* Blackfin SPORT */
+#define PORT_BFIN_SPORT         79
 
 /* MN10300 on-chip UART numbers */
 #define PORT_MN10300            80
 #define PORT_MN10300_CTS        81
 
+#define PORT_SC26XX     82
+
 #ifdef __KERNEL__
 
 #include <linux/compiler.h>
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 */
-        nodemask_t policy_nodes;    /* nodemask for preferred and bind */
+        struct mempolicy *mpol;     /* default memory policy for mappings */
 };
 
 static inline struct shmem_inode_info *SHMEM_I(struct inode *inode)
diff --git a/include/linux/signal.h b/include/linux/signal.h
index 42d2e0a948f4..84f997f8aa53 100644
--- a/include/linux/signal.h
+++ b/include/linux/signal.h
@@ -362,8 +362,6 @@ int unhandled_signal(struct task_struct *tsk, int sig);
 #define sig_kernel_stop(sig) \
         (((sig) < SIGRTMIN) && siginmask(sig, SIG_KERNEL_STOP_MASK))
 
-#define sig_needs_tasklist(sig) ((sig) == SIGCONT)
-
 #define sig_user_defined(t, signr) \
         (((t)->sighand->action[(signr)-1].sa.sa_handler != SIG_DFL) &&  \
          ((t)->sighand->action[(signr)-1].sa.sa_handler != SIG_IGN))
diff --git a/include/linux/slab.h b/include/linux/slab.h
index f62caaad94e0..805ed4b92f9a 100644
--- a/include/linux/slab.h
+++ b/include/linux/slab.h
@@ -9,8 +9,6 @@
 #ifndef _LINUX_SLAB_H
 #define _LINUX_SLAB_H
 
-#ifdef __KERNEL__
-
 #include <linux/gfp.h>
 #include <linux/types.h>
 
@@ -29,6 +27,13 @@
 #define SLAB_MEM_SPREAD         0x00100000UL    /* Spread some memory over cpuset */
 #define SLAB_TRACE              0x00200000UL    /* Trace allocations and frees */
 
+/* Flag to prevent checks on free */
+#ifdef CONFIG_DEBUG_OBJECTS
+# define SLAB_DEBUG_OBJECTS     0x00400000UL
+#else
+# define SLAB_DEBUG_OBJECTS     0x00000000UL
+#endif
+
 /* The following flags affect the page allocator grouping pages by mobility */
 #define SLAB_RECLAIM_ACCOUNT    0x00020000UL            /* Objects are reclaimable */
 #define SLAB_TEMPORARY          SLAB_RECLAIM_ACCOUNT    /* Objects are short-lived */
@@ -276,5 +281,4 @@ extern const struct seq_operations slabinfo_op;
 ssize_t slabinfo_write(struct file *, const char __user *, size_t, loff_t *);
 #endif
 
-#endif  /* __KERNEL__ */
 #endif  /* _LINUX_SLAB_H */
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/smb_fs_i.h b/include/linux/smb_fs_i.h
index 8516954a5141..8ccf4eca2c3d 100644
--- a/include/linux/smb_fs_i.h
+++ b/include/linux/smb_fs_i.h
@@ -9,7 +9,6 @@
 #ifndef _LINUX_SMB_FS_I
 #define _LINUX_SMB_FS_I
 
-#ifdef __KERNEL__
 #include <linux/types.h>
 #include <linux/fs.h>
 
@@ -36,4 +35,3 @@ struct smb_inode_info {
 };
 
 #endif
-#endif
diff --git a/include/linux/smb_fs_sb.h b/include/linux/smb_fs_sb.h
index 3aa97aa4277f..8a060a7040d8 100644
--- a/include/linux/smb_fs_sb.h
+++ b/include/linux/smb_fs_sb.h
@@ -9,8 +9,6 @@
 #ifndef _SMB_FS_SB
 #define _SMB_FS_SB
 
-#ifdef __KERNEL__
-
 #include <linux/types.h>
 #include <linux/smb.h>
 
@@ -96,6 +94,4 @@ smb_unlock_server(struct smb_sb_info *server)
         up(&(server->sem));
 }
 
-#endif /* __KERNEL__ */
-
 #endif
diff --git a/include/linux/string.h b/include/linux/string.h
index c5d3fcad7b57..efdc44593b52 100644
--- a/include/linux/string.h
+++ b/include/linux/string.h
@@ -109,5 +109,7 @@ extern void *kmemdup(const void *src, size_t len, gfp_t gfp);
 extern char **argv_split(gfp_t gfp, const char *str, int *argcp);
 extern void argv_free(char **argv);
 
+extern bool sysfs_streq(const char *s1, const char *s2);
+
 #endif
 #endif /* _LINUX_STRING_H_ */
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_restore_console(void) {}
+static inline void pm_set_vt_switch(int do_switch)
+{
+}
+
+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/svga.h b/include/linux/svga.h
index 13ad0b82ac28..c59a51a2b0e7 100644
--- a/include/linux/svga.h
+++ b/include/linux/svga.h
@@ -1,8 +1,6 @@
 #ifndef _LINUX_SVGA_H
 #define _LINUX_SVGA_H
 
-#ifdef __KERNEL__
-
 #include <linux/pci.h>
 #include <video/vga.h>
 
@@ -122,6 +120,5 @@ void svga_set_timings(const struct svga_timing_regs *tm, struct fb_var_screeninf
 
 int svga_match_format(const struct svga_fb_format *frm, struct fb_var_screeninfo *var, struct fb_fix_screeninfo *fix);
 
-#endif /* __KERNEL__  */
 #endif /* _LINUX_SVGA_H */
 
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,
-                                void __user *value, size_t size, int flags);
-asmlinkage long sys_lsetxattr(char __user *path, char __user *name,
-                                void __user *value, size_t size, int flags);
-asmlinkage long sys_fsetxattr(int fd, char __user *name, void __user *value,
-                                size_t size, int flags);
-asmlinkage ssize_t sys_getxattr(char __user *path, char __user *name,
+asmlinkage long sys_setxattr(const char __user *path, const char __user *name,
+                             const void __user *value, size_t size, int flags);
+asmlinkage long sys_lsetxattr(const char __user *path, const char __user *name,
+                              const void __user *value, size_t size, int flags);
+asmlinkage long sys_fsetxattr(int fd, const char __user *name,
+                              const void __user *value, size_t size, int flags);
+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_lremovexattr(char __user *path, char __user *name);
-asmlinkage long sys_fremovexattr(int fd, char __user *name);
+asmlinkage long sys_removexattr(const char __user *path,
+                                const 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/sysfs.h b/include/linux/sysfs.h
index add3c5a40827..27bad59dae79 100644
--- a/include/linux/sysfs.h
+++ b/include/linux/sysfs.h
@@ -190,6 +190,18 @@ static inline int sysfs_create_group(struct kobject *kobj,
         return 0;
 }
 
+static inline int sysfs_update_group(struct kobject *kobj,
+                                const struct attribute_group *grp)
+{
+        return 0;
+}
+
+static inline int sysfs_update_group(struct kobject *kobj,
+                                const struct attribute_group *grp)
+{
+        return 0;
+}
+
 static inline void sysfs_remove_group(struct kobject *kobj,
                                       const struct attribute_group *grp)
 {
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)))
-#else
->> I want to scream! <<
-#endif
+#define __packed2__     __attribute__((packed, aligned(2)))
 
 
 #ifndef __KERNEL__
diff --git a/include/linux/textsearch.h b/include/linux/textsearch.h
index 004808a6df1d..6f371f24160b 100644
--- a/include/linux/textsearch.h
+++ b/include/linux/textsearch.h
@@ -1,8 +1,6 @@
 #ifndef __LINUX_TEXTSEARCH_H
 #define __LINUX_TEXTSEARCH_H
 
-#ifdef __KERNEL__
-
 #include <linux/types.h>
 #include <linux/list.h>
 #include <linux/kernel.h>
@@ -177,6 +175,4 @@ static inline void *ts_config_priv(struct ts_config *conf)
         return ((u8 *) conf + TS_PRIV_ALIGN(sizeof(struct ts_config)));
 }
 
-#endif /* __KERNEL__ */
-
 #endif
diff --git a/include/linux/thermal.h b/include/linux/thermal.h
index 90c1c191ea69..06d3e6eb9ca8 100644
--- a/include/linux/thermal.h
+++ b/include/linux/thermal.h
@@ -41,6 +41,7 @@ struct thermal_zone_device_ops {
         int (*set_mode) (struct thermal_zone_device *, const char *);
         int (*get_trip_type) (struct thermal_zone_device *, int, char *);
         int (*get_trip_temp) (struct thermal_zone_device *, int, char *);
+        int (*get_crit_temp) (struct thermal_zone_device *, unsigned long *);
 };
 
 struct thermal_cooling_device_ops {
@@ -65,6 +66,23 @@ struct thermal_cooling_device {
                                 ((long)t-2732+5)/10 : ((long)t-2732-5)/10)
 #define CELSIUS_TO_KELVIN(t)    ((t)*10+2732)
 
+#if defined(CONFIG_HWMON) ||    \
+        (defined(CONFIG_HWMON_MODULE) && defined(CONFIG_THERMAL_MODULE))
+/* thermal zone devices with the same type share one hwmon device */
+struct thermal_hwmon_device {
+        char type[THERMAL_NAME_LENGTH];
+        struct device *device;
+        int count;
+        struct list_head tz_list;
+        struct list_head node;
+};
+
+struct thermal_hwmon_attr {
+        struct device_attribute attr;
+        char name[16];
+};
+#endif
+
 struct thermal_zone_device {
         int id;
         char type[THERMAL_NAME_LENGTH];
@@ -76,6 +94,13 @@ struct thermal_zone_device {
         struct idr idr;
         struct mutex lock;      /* protect cooling devices list */
         struct list_head node;
+#if defined(CONFIG_HWMON) ||    \
+        (defined(CONFIG_HWMON_MODULE) && defined(CONFIG_THERMAL_MODULE))
+        struct list_head hwmon_node;
+        struct thermal_hwmon_device *hwmon;
+        struct thermal_hwmon_attr temp_input;   /* hwmon sys attr */
+        struct thermal_hwmon_attr temp_crit;    /* hwmon sys attr */
+#endif
 };
 
 struct thermal_zone_device *thermal_zone_device_register(char *, int, void *,
@@ -88,24 +113,10 @@ int thermal_zone_bind_cooling_device(struct thermal_zone_device *, int,
                                      struct thermal_cooling_device *);
 int thermal_zone_unbind_cooling_device(struct thermal_zone_device *, int,
                                        struct thermal_cooling_device *);
-
-#ifdef  CONFIG_THERMAL
 struct thermal_cooling_device *thermal_cooling_device_register(char *, void *,
                                                                struct
                                                                thermal_cooling_device_ops
                                                                *);
 void thermal_cooling_device_unregister(struct thermal_cooling_device *);
-#else
-static inline struct thermal_cooling_device
-*thermal_cooling_device_register(char *c, void *v,
-                                 struct thermal_cooling_device_ops *t)
-{
-        return NULL;
-}
-static inline
-    void thermal_cooling_device_unregister(struct thermal_cooling_device *t)
-{
-};
-#endif
 
 #endif /* __THERMAL_H__ */
diff --git a/include/linux/thread_info.h b/include/linux/thread_info.h
index accd7bad35b0..38a56477f27a 100644
--- a/include/linux/thread_info.h
+++ b/include/linux/thread_info.h
@@ -92,6 +92,31 @@ static inline int test_ti_thread_flag(struct thread_info *ti, int flag)
 #define set_need_resched()      set_thread_flag(TIF_NEED_RESCHED)
 #define clear_need_resched()    clear_thread_flag(TIF_NEED_RESCHED)
 
-#endif
+#if defined TIF_RESTORE_SIGMASK && !defined HAVE_SET_RESTORE_SIGMASK
+/*
+ * An arch can define its own version of set_restore_sigmask() to get the
+ * job done however works, with or without TIF_RESTORE_SIGMASK.
+ */
+#define HAVE_SET_RESTORE_SIGMASK        1
+
+/**
+ * set_restore_sigmask() - make sure saved_sigmask processing gets done
+ *
+ * This sets TIF_RESTORE_SIGMASK and ensures that the arch signal code
+ * will run before returning to user mode, to process the flag.  For
+ * all callers, TIF_SIGPENDING is already set or it's no harm to set
+ * it.  TIF_RESTORE_SIGMASK need not be in the set of bits that the
+ * arch code will notice on return to user mode, in case those bits
+ * are scarce.  We set TIF_SIGPENDING here to ensure that the arch
+ * signal code always gets run when TIF_RESTORE_SIGMASK is set.
+ */
+static inline void set_restore_sigmask(void)
+{
+        set_thread_flag(TIF_RESTORE_SIGMASK);
+        set_thread_flag(TIF_SIGPENDING);
+}
+#endif  /* TIF_RESTORE_SIGMASK && !HAVE_SET_RESTORE_SIGMASK */
+
+#endif  /* __KERNEL__ */
 
 #endif /* _LINUX_THREAD_INFO_H */
diff --git a/include/linux/timer.h b/include/linux/timer.h
index 979fefdeb862..d4ba79248a27 100644
--- a/include/linux/timer.h
+++ b/include/linux/timer.h
@@ -4,6 +4,7 @@
 #include <linux/list.h>
 #include <linux/ktime.h>
 #include <linux/stddef.h>
+#include <linux/debugobjects.h>
 
 struct tvec_base;
 
@@ -25,6 +26,7 @@ struct timer_list {
 extern struct tvec_base boot_tvec_bases;
 
 #define TIMER_INITIALIZER(_function, _expires, _data) {         \
+                .entry = { .prev = TIMER_ENTRY_STATIC },        \
                 .function = (_function),                        \
                 .expires = (_expires),                          \
                 .data = (_data),                                \
@@ -38,6 +40,17 @@ extern struct tvec_base boot_tvec_bases;
 void init_timer(struct timer_list *timer);
 void init_timer_deferrable(struct timer_list *timer);
 
+#ifdef CONFIG_DEBUG_OBJECTS_TIMERS
+extern void init_timer_on_stack(struct timer_list *timer);
+extern void destroy_timer_on_stack(struct timer_list *timer);
+#else
+static inline void destroy_timer_on_stack(struct timer_list *timer) { }
+static inline void init_timer_on_stack(struct timer_list *timer)
+{
+        init_timer(timer);
+}
+#endif
+
 static inline void setup_timer(struct timer_list * timer,
                                 void (*function)(unsigned long),
                                 unsigned long data)
@@ -47,6 +60,15 @@ static inline void setup_timer(struct timer_list * timer,
         init_timer(timer);
 }
 
+static inline void setup_timer_on_stack(struct timer_list *timer,
+                                        void (*function)(unsigned long),
+                                        unsigned long data)
+{
+        timer->function = function;
+        timer->data = data;
+        init_timer_on_stack(timer);
+}
+
 /**
  * timer_pending - is a timer pending?
  * @timer: the timer in question
@@ -164,5 +186,4 @@ unsigned long __round_jiffies_relative(unsigned long j, int cpu);
 unsigned long round_jiffies(unsigned long j);
 unsigned long round_jiffies_relative(unsigned long j);
 
-
 #endif
diff --git a/include/linux/timex.h b/include/linux/timex.h
index 8ea3e71ba7fa..fc6035d29d56 100644
--- a/include/linux/timex.h
+++ b/include/linux/timex.h
@@ -58,6 +58,8 @@
 
 #include <asm/param.h>
 
+#define NTP_API         4       /* NTP API version */
+
 /*
  * SHIFT_KG and SHIFT_KF establish the damping of the PLL and are chosen
  * for a slightly underdamped convergence characteristic. SHIFT_KH
@@ -74,24 +76,22 @@
 #define MAXTC           10      /* maximum time constant (shift) */
 
 /*
- * The SHIFT_UPDATE define establishes the decimal point of the
- * time_offset variable which represents the current offset with
- * respect to standard time.
- *
  * SHIFT_USEC defines the scaling (shift) of the time_freq and
  * time_tolerance variables, which represent the current frequency
  * offset and maximum frequency tolerance.
  */
-#define SHIFT_UPDATE (SHIFT_HZ + 1) /* time offset scale (shift) */
 #define SHIFT_USEC 16           /* frequency offset scale (shift) */
-#define SHIFT_NSEC 12           /* kernel frequency offset scale */
-
-#define MAXPHASE 512000L        /* max phase error (us) */
-#define MAXFREQ (512L << SHIFT_USEC)  /* max frequency error (ppm) */
-#define MAXFREQ_NSEC (512000L << SHIFT_NSEC) /* max frequency error (ppb) */
+#define PPM_SCALE (NSEC_PER_USEC << (NTP_SCALE_SHIFT - SHIFT_USEC))
+#define PPM_SCALE_INV_SHIFT 20
+#define PPM_SCALE_INV ((1ll << (PPM_SCALE_INV_SHIFT + NTP_SCALE_SHIFT)) / \
+                       PPM_SCALE + 1)
+
+#define MAXPHASE 500000000l     /* max phase error (ns) */
+#define MAXFREQ 500000          /* max frequency error (ns/s) */
+#define MAXFREQ_SCALED ((s64)MAXFREQ << NTP_SCALE_SHIFT)
 #define MINSEC 256              /* min interval between updates (s) */
 #define MAXSEC 2048             /* max interval between updates (s) */
-#define NTP_PHASE_LIMIT (MAXPHASE << 5) /* beyond max. dispersion */
+#define NTP_PHASE_LIMIT ((MAXPHASE / NSEC_PER_USEC) << 5) /* beyond max. dispersion */
 
 /*
  * syscall interface - used (mainly by NTP daemon)
@@ -121,9 +121,11 @@ struct timex {
         long errcnt;            /* calibration errors (ro) */
         long stbcnt;            /* stability limit exceeded (ro) */
 
+        int tai;                /* TAI offset (ro) */
+
         int  :32; int  :32; int  :32; int  :32;
         int  :32; int  :32; int  :32; int  :32;
-        int  :32; int  :32; int  :32; int  :32;
+        int  :32; int  :32; int  :32;
 };
 
 /*
@@ -135,6 +137,9 @@ struct timex {
 #define ADJ_ESTERROR            0x0008  /* estimated time error */
 #define ADJ_STATUS              0x0010  /* clock status */
 #define ADJ_TIMECONST           0x0020  /* pll time constant */
+#define ADJ_TAI                 0x0080  /* set TAI offset */
+#define ADJ_MICRO               0x1000  /* select microsecond resolution */
+#define ADJ_NANO                0x2000  /* select nanosecond resolution */
 #define ADJ_TICK                0x4000  /* tick value */
 #define ADJ_OFFSET_SINGLESHOT   0x8001  /* old-fashioned adjtime */
 #define ADJ_OFFSET_SS_READ      0xa001  /* read-only adjtime */
@@ -146,8 +151,6 @@ struct timex {
 #define MOD_ESTERROR    ADJ_ESTERROR
 #define MOD_STATUS      ADJ_STATUS
 #define MOD_TIMECONST   ADJ_TIMECONST
-#define MOD_CLKB        ADJ_TICK
-#define MOD_CLKA        ADJ_OFFSET_SINGLESHOT /* 0x8000 in original */
 
 
 /*
@@ -169,9 +172,13 @@ struct timex {
 #define STA_PPSERROR    0x0800  /* PPS signal calibration error (ro) */
 
 #define STA_CLOCKERR    0x1000  /* clock hardware fault (ro) */
+#define STA_NANO        0x2000  /* resolution (0 = us, 1 = ns) (ro) */
+#define STA_MODE        0x4000  /* mode (0 = PLL, 1 = FLL) (ro) */
+#define STA_CLK         0x8000  /* clock source (0 = A, 1 = B) (ro) */
 
+/* read-only bits */
 #define STA_RONLY (STA_PPSSIGNAL | STA_PPSJITTER | STA_PPSWANDER | \
-    STA_PPSERROR | STA_CLOCKERR) /* read-only bits */
+        STA_PPSERROR | STA_CLOCKERR | STA_NANO | STA_MODE | STA_CLK)
 
 /*
  * Clock states (time_state)
@@ -203,10 +210,9 @@ extern int time_status;		/* clock synchronization status bits */
 extern long time_maxerror;      /* maximum error */
 extern long time_esterror;      /* estimated error */
 
-extern long time_freq;          /* frequency offset (scaled ppm) */
-
 extern long time_adjust;        /* The amount of adjtime left */
 
+extern void ntp_init(void);
 extern void ntp_clear(void);
 
 /**
@@ -225,7 +231,7 @@ static inline int ntp_synced(void)
         __x < 0 ? -(-__x >> __s) : __x >> __s;  \
 })
 
-#define TICK_LENGTH_SHIFT       32
+#define NTP_SCALE_SHIFT         32
 
 #ifdef CONFIG_NO_HZ
 #define NTP_INTERVAL_FREQ  (2)
@@ -234,8 +240,8 @@ static inline int ntp_synced(void)
 #endif
 #define NTP_INTERVAL_LENGTH (NSEC_PER_SEC/NTP_INTERVAL_FREQ)
 
-/* Returns how long ticks are at present, in ns / 2^(SHIFT_SCALE-10). */
-extern u64 current_tick_length(void);
+/* Returns how long ticks are at present, in ns / 2^NTP_SCALE_SHIFT. */
+extern u64 tick_length;
 
 extern void second_overflow(void);
 extern void update_ntp_one_tick(void);
diff --git a/include/linux/tty.h b/include/linux/tty.h
index dd8e08fe8855..7f7121f9c968 100644
--- a/include/linux/tty.h
+++ b/include/linux/tty.h
@@ -177,27 +177,33 @@ struct signal_struct;
  * size each time the window is created or resized anyway.
  *                                              - TYT, 9/14/92
  */
+
+struct tty_operations;
+
 struct tty_struct {
         int     magic;
         struct tty_driver *driver;
+        const struct tty_operations *ops;
         int index;
         struct tty_ldisc ldisc;
         struct mutex termios_mutex;
+        spinlock_t ctrl_lock;
+        /* Termios values are protected by the termios mutex */
         struct ktermios *termios, *termios_locked;
         char name[64];
-        struct pid *pgrp;
+        struct pid *pgrp;               /* Protected by ctrl lock */
         struct pid *session;
         unsigned long flags;
         int count;
-        struct winsize winsize;
+        struct winsize winsize;         /* termios mutex */
         unsigned char stopped:1, hw_stopped:1, flow_stopped:1, packet:1;
         unsigned char low_latency:1, warned:1;
-        unsigned char ctrl_status;
+        unsigned char ctrl_status;      /* ctrl_lock */
         unsigned int receive_room;      /* Bytes free for queue */
 
         struct tty_struct *link;
         struct fasync_struct *fasync;
-        struct tty_bufhead buf;
+        struct tty_bufhead buf;         /* Locked internally */
         int alt_speed;          /* For magic substitution of 38400 bps */
         wait_queue_head_t write_wait;
         wait_queue_head_t read_wait;
@@ -211,6 +217,7 @@ struct tty_struct {
         /*
          * The following is data for the N_TTY line discipline.  For
          * historical reasons, this is included in the tty structure.
+         * Mostly locked by the BKL.
          */
         unsigned int column;
         unsigned char lnext:1, erasing:1, raw:1, real_raw:1, icanon:1;
@@ -292,15 +299,21 @@ extern void tty_unregister_device(struct tty_driver *driver, unsigned index);
 extern int tty_read_raw_data(struct tty_struct *tty, unsigned char *bufp,
                              int buflen);
 extern void tty_write_message(struct tty_struct *tty, char *msg);
+extern int tty_put_char(struct tty_struct *tty, unsigned char c);
+extern int tty_chars_in_buffer(struct tty_struct *tty);
+extern int tty_write_room(struct tty_struct *tty);
+extern void tty_driver_flush_buffer(struct tty_struct *tty);
+extern void tty_throttle(struct tty_struct *tty);
+extern void tty_unthrottle(struct tty_struct *tty);
 
 extern int is_current_pgrp_orphaned(void);
+extern struct pid *tty_get_pgrp(struct tty_struct *tty);
 extern int is_ignored(int sig);
 extern int tty_signal(int sig, struct tty_struct *tty);
 extern void tty_hangup(struct tty_struct * tty);
 extern void tty_vhangup(struct tty_struct * tty);
 extern void tty_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);
@@ -324,8 +337,7 @@ extern void tty_ldisc_put(int);
 extern void tty_wakeup(struct tty_struct *tty);
 extern void tty_ldisc_flush(struct tty_struct *tty);
 
-extern int tty_ioctl(struct inode *inode, struct file *file, unsigned int cmd,
-                     unsigned long arg);
+extern long tty_ioctl(struct file *file, unsigned int cmd, unsigned long arg);
 extern int tty_mode_ioctl(struct tty_struct *tty, struct file *file,
                         unsigned int cmd, unsigned long arg);
 extern int tty_perform_flush(struct tty_struct *tty, unsigned long arg);
@@ -351,8 +363,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_opening(void);
+extern void tty_audit_push_task(struct task_struct *tsk, uid_t loginuid, u32 sessionid);
 #else
 static inline void tty_audit_add_data(struct tty_struct *tty,
                                       unsigned char *data, size_t size)
@@ -367,10 +378,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_opening(void)
+static inline void tty_audit_push_task(struct task_struct *tsk, uid_t loginuid, u32 sessionid)
 {
 }
 #endif
diff --git a/include/linux/tty_driver.h b/include/linux/tty_driver.h
index 21f69aca4505..59f1c0bd8f9c 100644
--- a/include/linux/tty_driver.h
+++ b/include/linux/tty_driver.h
@@ -12,11 +12,15 @@
  *      This routine is called when a particular tty device is opened.
  *      This routine is mandatory; if this routine is not filled in,
  *      the attempted open will fail with ENODEV.
+ *
+ *      Required method.
  *     
  * void (*close)(struct tty_struct * tty, struct file * filp);
  *
  *      This routine is called when a particular tty device is closed.
  *
+ *      Required method.
+ *
  * int (*write)(struct tty_struct * tty,
  *               const unsigned char *buf, int count);
  *
@@ -26,7 +30,9 @@
  *      number of characters actually accepted for writing.  This
  *      routine is mandatory.
  *
- * void (*put_char)(struct tty_struct *tty, unsigned char ch);
+ *      Optional: Required for writable devices.
+ *
+ * int (*put_char)(struct tty_struct *tty, unsigned char ch);
  *
  *      This routine is called by the kernel to write a single
  *      character to the tty device.  If the kernel uses this routine,
@@ -34,10 +40,18 @@
  *      done stuffing characters into the driver.  If there is no room
  *      in the queue, the character is ignored.
  *
+ *      Optional: Kernel will use the write method if not provided.
+ *
+ *      Note: Do not call this function directly, call tty_put_char
+ *
  * void (*flush_chars)(struct tty_struct *tty);
  *
  *      This routine is called by the kernel after it has written a
  *      series of characters to the tty device using put_char().  
+ *
+ *      Optional:
+ *
+ *      Note: Do not call this function directly, call tty_driver_flush_chars
  * 
  * int  (*write_room)(struct tty_struct *tty);
  *
@@ -45,6 +59,10 @@
  *      will accept for queuing to be written.  This number is subject
  *      to change as output buffers get emptied, or if the output flow
  *      control is acted.
+ *
+ *      Required if write method is provided else not needed.
+ *
+ *      Note: Do not call this function directly, call tty_write_room
  * 
  * int  (*ioctl)(struct tty_struct *tty, struct file * file,
  *          unsigned int cmd, unsigned long arg);
@@ -53,28 +71,37 @@
  *      device-specific ioctl's.  If the ioctl number passed in cmd
  *      is not recognized by the driver, it should return ENOIOCTLCMD.
  *
+ *      Optional
+ *
  * long (*compat_ioctl)(struct tty_struct *tty, struct file * file,
  *                      unsigned int cmd, unsigned long arg);
  *
  *      implement ioctl processing for 32 bit process on 64 bit system
+ *
+ *      Optional
  * 
  * void (*set_termios)(struct tty_struct *tty, struct ktermios * old);
  *
  *      This routine allows the tty driver to be notified when
- *      device's termios settings have changed.  Note that a
- *      well-designed tty driver should be prepared to accept the case
- *      where old == NULL, and try to do something rational.
+ *      device's termios settings have changed.
+ *
+ *      Optional: Called under the termios lock
+ *
  *
  * void (*set_ldisc)(struct tty_struct *tty);
  *
  *      This routine allows the tty driver to be notified when the
  *      device's termios settings have changed.
+ *
+ *      Optional: Called under BKL (currently)
  * 
  * void (*throttle)(struct tty_struct * tty);
  *
  *      This routine notifies the tty driver that input buffers for
  *      the line discipline are close to full, and it should somehow
  *      signal that no more characters should be sent to the tty.
+ *
+ *      Optional: Always invoke via tty_throttle();
  * 
  * void (*unthrottle)(struct tty_struct * tty);
  *
@@ -82,21 +109,33 @@
  *      that characters can now be sent to the tty without fear of
  *      overrunning the input buffers of the line disciplines.
  * 
+ *      Optional: Always invoke via tty_unthrottle();
+ *
  * void (*stop)(struct tty_struct *tty);
  *
  *      This routine notifies the tty driver that it should stop
  *      outputting characters to the tty device.  
+ *
+ *      Optional:
+ *
+ *      Note: Call stop_tty not this method.
  * 
  * void (*start)(struct tty_struct *tty);
  *
  *      This routine notifies the tty driver that it resume sending
  *      characters to the tty device.
+ *
+ *      Optional:
+ *
+ *      Note: Call start_tty not this method.
  * 
  * void (*hangup)(struct tty_struct *tty);
  *
  *      This routine notifies the tty driver that it should hangup the
  *      tty device.
  *
+ *      Required:
+ *
  * void (*break_ctl)(struct tty_stuct *tty, int state);
  *
  *      This optional routine requests the tty driver to turn on or
@@ -106,18 +145,26 @@
  *
  *      If this routine is implemented, the high-level tty driver will
  *      handle the following ioctls: TCSBRK, TCSBRKP, TIOCSBRK,
- *      TIOCCBRK.  Otherwise, these ioctls will be passed down to the
- *      driver to handle.
+ *      TIOCCBRK.
+ *
+ *      Optional: Required for TCSBRK/BRKP/etc handling.
  *
  * void (*wait_until_sent)(struct tty_struct *tty, int timeout);
  * 
  *      This routine waits until the device has written out all of the
  *      characters in its transmitter FIFO.
  *
+ *      Optional: If not provided the device is assumed to have no FIFO
+ *
+ *      Note: Usually correct to call tty_wait_until_sent
+ *
  * void (*send_xchar)(struct tty_struct *tty, char ch);
  *
  *      This routine is used to send a high-priority XON/XOFF
  *      character to the device.
+ *
+ *      Optional: If not provided then the write method is called under
+ *      the atomic write lock to keep it serialized with the ldisc.
  */
 
 #include <linux/fs.h>
@@ -132,7 +179,7 @@ struct tty_operations {
         void (*close)(struct tty_struct * tty, struct file * filp);
         int  (*write)(struct tty_struct * tty,
                       const unsigned char *buf, int count);
-        void (*put_char)(struct tty_struct *tty, unsigned char ch);
+        int  (*put_char)(struct tty_struct *tty, unsigned char ch);
         void (*flush_chars)(struct tty_struct *tty);
         int  (*write_room)(struct tty_struct *tty);
         int  (*chars_in_buffer)(struct tty_struct *tty);
@@ -153,8 +200,6 @@ struct tty_operations {
         void (*send_xchar)(struct tty_struct *tty, char ch);
         int (*read_proc)(char *page, char **start, off_t off,
                           int count, int *eof, void *data);
-        int (*write_proc)(struct file *file, const char __user *buffer,
-                          unsigned long count, void *data);
         int (*tiocmget)(struct tty_struct *tty, struct file *file);
         int (*tiocmset)(struct tty_struct *tty, struct file *file,
                         unsigned int set, unsigned int clear);
@@ -190,48 +235,13 @@ struct tty_driver {
         struct tty_struct **ttys;
         struct ktermios **termios;
         struct ktermios **termios_locked;
-        void *driver_state;     /* only used for the PTY driver */
-        
+        void *driver_state;
+
         /*
-         * Interface routines from the upper tty layer to the tty
-         * driver.      Will be replaced with struct tty_operations.
+         * Driver methods
          */
-        int  (*open)(struct tty_struct * tty, struct file * filp);
-        void (*close)(struct tty_struct * tty, struct file * filp);
-        int  (*write)(struct tty_struct * tty,
-                      const unsigned char *buf, int count);
-        void (*put_char)(struct tty_struct *tty, unsigned char ch);
-        void (*flush_chars)(struct tty_struct *tty);
-        int  (*write_room)(struct tty_struct *tty);
-        int  (*chars_in_buffer)(struct tty_struct *tty);
-        int  (*ioctl)(struct tty_struct *tty, struct file * file,
-                    unsigned int cmd, unsigned long arg);
-        long (*compat_ioctl)(struct tty_struct *tty, struct file * file,
-                             unsigned int cmd, unsigned long arg);
-        void (*set_termios)(struct tty_struct *tty, struct ktermios * old);
-        void (*throttle)(struct tty_struct * tty);
-        void (*unthrottle)(struct tty_struct * tty);
-        void (*stop)(struct tty_struct *tty);
-        void (*start)(struct tty_struct *tty);
-        void (*hangup)(struct tty_struct *tty);
-        void (*break_ctl)(struct tty_struct *tty, int state);
-        void (*flush_buffer)(struct tty_struct *tty);
-        void (*set_ldisc)(struct tty_struct *tty);
-        void (*wait_until_sent)(struct tty_struct *tty, int timeout);
-        void (*send_xchar)(struct tty_struct *tty, char ch);
-        int (*read_proc)(char *page, char **start, off_t off,
-                          int count, int *eof, void *data);
-        int (*write_proc)(struct file *file, const char __user *buffer,
-                          unsigned long count, void *data);
-        int (*tiocmget)(struct tty_struct *tty, struct file *file);
-        int (*tiocmset)(struct tty_struct *tty, struct file *file,
-                        unsigned int set, unsigned int clear);
-#ifdef CONFIG_CONSOLE_POLL
-        int (*poll_init)(struct tty_driver *driver, int line, char *options);
-        int (*poll_get_char)(struct tty_driver *driver, int line);
-        void (*poll_put_char)(struct tty_driver *driver, int line, char ch);
-#endif
 
+        const struct tty_operations *ops;
         struct list_head tty_drivers;
 };
 
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/usb/c67x00.h b/include/linux/usb/c67x00.h
new file mode 100644
index 000000000000..83c6b45470ca
--- /dev/null
+++ b/include/linux/usb/c67x00.h
@@ -0,0 +1,48 @@
+/*
+ * usb_c67x00.h: platform definitions for the Cypress C67X00 USB chip
+ *
+ * Copyright (C) 2006-2008 Barco N.V.
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; either version 2 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston,
+ * MA  02110-1301  USA.
+ */
+
+#ifndef _LINUX_USB_C67X00_H
+#define _LINUX_USB_C67X00_H
+
+/* SIE configuration */
+#define C67X00_SIE_UNUSED       0
+#define C67X00_SIE_HOST         1
+#define C67X00_SIE_PERIPHERAL_A 2       /* peripheral on A port */
+#define C67X00_SIE_PERIPHERAL_B 3       /* peripheral on B port */
+
+#define c67x00_sie_config(config, n)  (((config)>>(4*(n)))&0x3)
+
+#define C67X00_SIE1_UNUSED              (C67X00_SIE_UNUSED              << 0)
+#define C67X00_SIE1_HOST                (C67X00_SIE_HOST                << 0)
+#define C67X00_SIE1_PERIPHERAL_A        (C67X00_SIE_PERIPHERAL_A        << 0)
+#define C67X00_SIE1_PERIPHERAL_B        (C67X00_SIE_PERIPHERAL_B        << 0)
+
+#define C67X00_SIE2_UNUSED              (C67X00_SIE_UNUSED              << 4)
+#define C67X00_SIE2_HOST                (C67X00_SIE_HOST                << 4)
+#define C67X00_SIE2_PERIPHERAL_A        (C67X00_SIE_PERIPHERAL_A        << 4)
+#define C67X00_SIE2_PERIPHERAL_B        (C67X00_SIE_PERIPHERAL_B        << 4)
+
+struct c67x00_platform_data {
+        int sie_config;                 /* SIEs config (C67X00_SIEx_*) */
+        unsigned long hpi_regstep;      /* Step between HPI registers  */
+};
+
+#endif /* _LINUX_USB_C67X00_H */
diff --git a/include/linux/usb/ch9.h b/include/linux/usb/ch9.h
index 7e0d3084f76c..73a2f4eb1f7a 100644
--- a/include/linux/usb/ch9.h
+++ b/include/linux/usb/ch9.h
@@ -455,7 +455,7 @@ struct usb_encryption_descriptor {
 
 /*-------------------------------------------------------------------------*/
 
-/* USB_DT_BOS:  group of wireless capabilities */
+/* USB_DT_BOS:  group of device-level capabilities */
 struct usb_bos_descriptor {
         __u8  bLength;
         __u8  bDescriptorType;
@@ -501,6 +501,16 @@ struct usb_wireless_cap_descriptor {	/* Ultra Wide Band */
         __u8  bReserved;
 } __attribute__((packed));
 
+#define USB_CAP_TYPE_EXT                2
+
+struct usb_ext_cap_descriptor {         /* Link Power Management */
+        __u8  bLength;
+        __u8  bDescriptorType;
+        __u8  bDevCapabilityType;
+        __u8  bmAttributes;
+#define USB_LPM_SUPPORT                 (1 << 1)        /* supports LPM */
+} __attribute__((packed));
+
 /*-------------------------------------------------------------------------*/
 
 /* USB_DT_WIRELESS_ENDPOINT_COMP:  companion descriptor associated with
diff --git a/include/linux/usb/gadget.h b/include/linux/usb/gadget.h
index d8128f7102c9..cf468fbdbf8e 100644
--- a/include/linux/usb/gadget.h
+++ b/include/linux/usb/gadget.h
@@ -114,6 +114,8 @@ struct usb_ep_ops {
         int (*dequeue) (struct usb_ep *ep, struct usb_request *req);
 
         int (*set_halt) (struct usb_ep *ep, int value);
+        int (*set_wedge) (struct usb_ep *ep);
+
         int (*fifo_status) (struct usb_ep *ep);
         void (*fifo_flush) (struct usb_ep *ep);
 };
@@ -349,6 +351,25 @@ static inline int usb_ep_clear_halt(struct usb_ep *ep)
 }
 
 /**
+ * usb_ep_set_wedge - sets the halt feature and ignores clear requests
+ * @ep: the endpoint being wedged
+ *
+ * Use this to stall an endpoint and ignore CLEAR_FEATURE(HALT_ENDPOINT)
+ * requests. If the gadget driver clears the halt status, it will
+ * automatically unwedge the endpoint.
+ *
+ * Returns zero on success, else negative errno.
+ */
+static inline int
+usb_ep_set_wedge(struct usb_ep *ep)
+{
+        if (ep->ops->set_wedge)
+                return ep->ops->set_wedge(ep);
+        else
+                return ep->ops->set_halt(ep, 1);
+}
+
+/**
  * usb_ep_fifo_status - returns number of bytes in fifo, or error
  * @ep: the endpoint whose fifo status is being checked.
  *
diff --git a/include/linux/virtio.h b/include/linux/virtio.h
index e7d10845b3c1..06005fa9e982 100644
--- a/include/linux/virtio.h
+++ b/include/linux/virtio.h
@@ -76,6 +76,7 @@ struct virtqueue_ops {
  * @dev: underlying device.
  * @id: the device type identification (used to match it with a driver).
  * @config: the configuration ops for this device.
+ * @features: the features supported by both driver and device.
  * @priv: private pointer for the driver's use.
  */
 struct virtio_device
@@ -84,6 +85,8 @@ struct virtio_device
         struct device dev;
         struct virtio_device_id id;
         struct virtio_config_ops *config;
+        /* Note that this is a Linux set_bit-style bitmap. */
+        unsigned long features[1];
         void *priv;
 };
 
@@ -94,6 +97,8 @@ void unregister_virtio_device(struct virtio_device *dev);
  * virtio_driver - operations for a virtio I/O driver
  * @driver: underlying device driver (populate name and owner).
  * @id_table: the ids serviced by this driver.
+ * @feature_table: an array of feature numbers supported by this device.
+ * @feature_table_size: number of entries in the feature table array.
  * @probe: the function to call when a device is found.  Returns a token for
  *    remove, or PTR_ERR().
  * @remove: the function when a device is removed.
@@ -103,6 +108,8 @@ void unregister_virtio_device(struct virtio_device *dev);
 struct virtio_driver {
         struct device_driver driver;
         const struct virtio_device_id *id_table;
+        const unsigned int *feature_table;
+        unsigned int feature_table_size;
         int (*probe)(struct virtio_device *dev);
         void (*remove)(struct virtio_device *dev);
         void (*config_changed)(struct virtio_device *dev);
diff --git a/include/linux/virtio_blk.h b/include/linux/virtio_blk.h
index bca0b10d7947..d4695a3356d0 100644
--- a/include/linux/virtio_blk.h
+++ b/include/linux/virtio_blk.h
@@ -9,6 +9,7 @@
 #define VIRTIO_BLK_F_BARRIER    0       /* Does host support barriers? */
 #define VIRTIO_BLK_F_SIZE_MAX   1       /* Indicates maximum segment size */
 #define VIRTIO_BLK_F_SEG_MAX    2       /* Indicates maximum # of segments */
+#define VIRTIO_BLK_F_GEOMETRY   4       /* Legacy geometry available  */
 
 struct virtio_blk_config
 {
@@ -18,6 +19,12 @@ struct virtio_blk_config
         __le32 size_max;
         /* The maximum number of segments (if VIRTIO_BLK_F_SEG_MAX) */
         __le32 seg_max;
+        /* geometry the device (if VIRTIO_BLK_F_GEOMETRY) */
+        struct virtio_blk_geometry {
+                __le16 cylinders;
+                __u8 heads;
+                __u8 sectors;
+        } geometry;
 } __attribute__((packed));
 
 /* These two define direction. */
@@ -41,13 +48,8 @@ struct virtio_blk_outhdr
         __u64 sector;
 };
 
+/* And this is the final byte of the write scatter-gather list. */
 #define VIRTIO_BLK_S_OK         0
 #define VIRTIO_BLK_S_IOERR      1
 #define VIRTIO_BLK_S_UNSUPP     2
-
-/* This is the first element of the write scatter-gather list */
-struct virtio_blk_inhdr
-{
-        unsigned char status;
-};
 #endif /* _LINUX_VIRTIO_BLK_H */
diff --git a/include/linux/virtio_config.h b/include/linux/virtio_config.h
index d581b2914b34..50db245c81ad 100644
--- a/include/linux/virtio_config.h
+++ b/include/linux/virtio_config.h
@@ -16,27 +16,20 @@
 #define VIRTIO_CONFIG_S_FAILED          0x80
 
 #ifdef __KERNEL__
-struct virtio_device;
+#include <linux/virtio.h>
 
 /**
  * virtio_config_ops - operations for configuring a virtio device
- * @feature: search for a feature in this config
- *      vdev: the virtio_device
- *      bit: the feature bit
- *      Returns true if the feature is supported.  Acknowledges the feature
- *      so the host can see it.
  * @get: read the value of a configuration field
  *      vdev: the virtio_device
  *      offset: the offset of the configuration field
  *      buf: the buffer to write the field value into.
  *      len: the length of the buffer
- *      Note that contents are conventionally little-endian.
  * @set: write the value of a configuration field
  *      vdev: the virtio_device
  *      offset: the offset of the configuration field
  *      buf: the buffer to read the field value from.
  *      len: the length of the buffer
- *      Note that contents are conventionally little-endian.
  * @get_status: read the status byte
  *      vdev: the virtio_device
  *      Returns the status byte
@@ -52,10 +45,15 @@ struct virtio_device;
  *      callback: the virqtueue callback
  *      Returns the new virtqueue or ERR_PTR() (eg. -ENOENT).
  * @del_vq: free a virtqueue found by find_vq().
+ * @get_features: get the array of feature bits for this device.
+ *      vdev: the virtio_device
+ *      Returns the first 32 feature bits (all we currently need).
+ * @set_features: confirm what device features we'll be using.
+ *      vdev: the virtio_device
+ *      feature: the first 32 feature bits
  */
 struct virtio_config_ops
 {
-        bool (*feature)(struct virtio_device *vdev, unsigned bit);
         void (*get)(struct virtio_device *vdev, unsigned offset,
                     void *buf, unsigned len);
         void (*set)(struct virtio_device *vdev, unsigned offset,
@@ -67,43 +65,52 @@ struct virtio_config_ops
                                      unsigned index,
                                      void (*callback)(struct virtqueue *));
         void (*del_vq)(struct virtqueue *vq);
+        u32 (*get_features)(struct virtio_device *vdev);
+        void (*set_features)(struct virtio_device *vdev, u32 features);
 };
 
+/* If driver didn't advertise the feature, it will never appear. */
+void virtio_check_driver_offered_feature(const struct virtio_device *vdev,
+                                         unsigned int fbit);
+
 /**
- * virtio_config_val - look for a feature and get a single virtio config.
- * @vdev: the virtio device
+ * virtio_has_feature - helper to determine if this device has this feature.
+ * @vdev: the device
  * @fbit: the feature bit
- * @offset: the type to search for.
- * @val: a pointer to the value to fill in.
- *
- * The return value is -ENOENT if the feature doesn't exist.  Otherwise
- * the value is endian-corrected and returned in v. */
-#define virtio_config_val(vdev, fbit, offset, v) ({                     \
-        int _err;                                                       \
-        if ((vdev)->config->feature((vdev), (fbit))) {                  \
-                __virtio_config_val((vdev), (offset), (v));             \
-                _err = 0;                                               \
-        } else                                                          \
-                _err = -ENOENT;                                         \
-        _err;                                                           \
-})
+ */
+static inline bool virtio_has_feature(const struct virtio_device *vdev,
+                                      unsigned int fbit)
+{
+        /* Did you forget to fix assumptions on max features? */
+        if (__builtin_constant_p(fbit))
+                BUILD_BUG_ON(fbit >= 32);
+
+        virtio_check_driver_offered_feature(vdev, fbit);
+        return test_bit(fbit, vdev->features);
+}
 
 /**
- * __virtio_config_val - get a single virtio config without feature check.
+ * virtio_config_val - look for a feature and get a virtio config entry.
  * @vdev: the virtio device
+ * @fbit: the feature bit
  * @offset: the type to search for.
  * @val: a pointer to the value to fill in.
  *
- * The value is endian-corrected and returned in v. */
-#define __virtio_config_val(vdev, offset, v) do {                       \
-        BUILD_BUG_ON(sizeof(*(v)) != 1 && sizeof(*(v)) != 2             \
-                     && sizeof(*(v)) != 4 && sizeof(*(v)) != 8);        \
-        (vdev)->config->get((vdev), (offset), (v), sizeof(*(v)));       \
-        switch (sizeof(*(v))) {                                         \
-        case 2: le16_to_cpus((__u16 *) v); break;                       \
-        case 4: le32_to_cpus((__u32 *) v); break;                       \
-        case 8: le64_to_cpus((__u64 *) v); break;                       \
-        }                                                               \
-} while(0)
+ * The return value is -ENOENT if the feature doesn't exist.  Otherwise
+ * the config value is copied into whatever is pointed to by v. */
+#define virtio_config_val(vdev, fbit, offset, v) \
+        virtio_config_buf((vdev), (fbit), (offset), (v), sizeof(v))
+
+static inline int virtio_config_buf(struct virtio_device *vdev,
+                                    unsigned int fbit,
+                                    unsigned int offset,
+                                    void *buf, unsigned len)
+{
+        if (!virtio_has_feature(vdev, fbit))
+                return -ENOENT;
+
+        vdev->config->get(vdev, offset, buf, len);
+        return 0;
+}
 #endif /* __KERNEL__ */
 #endif /* _LINUX_VIRTIO_CONFIG_H */
diff --git a/include/linux/virtio_net.h b/include/linux/virtio_net.h
index 1ea3351df609..9405aa6cdf26 100644
--- a/include/linux/virtio_net.h
+++ b/include/linux/virtio_net.h
@@ -6,9 +6,18 @@
 #define VIRTIO_ID_NET   1
 
 /* The feature bitmap for virtio net */
-#define VIRTIO_NET_F_CSUM       0       /* Can handle pkts w/ partial csum */
+#define VIRTIO_NET_F_CSUM       0       /* Host handles pkts w/ partial csum */
+#define VIRTIO_NET_F_GUEST_CSUM 1       /* Guest handles pkts w/ partial csum */
 #define VIRTIO_NET_F_MAC        5       /* Host has given MAC address. */
-#define VIRTIO_NET_F_GSO        6       /* Can handle pkts w/ any GSO type */
+#define VIRTIO_NET_F_GSO        6       /* Host handles pkts w/ any GSO type */
+#define VIRTIO_NET_F_GUEST_TSO4 7       /* Guest can handle TSOv4 in. */
+#define VIRTIO_NET_F_GUEST_TSO6 8       /* Guest can handle TSOv6 in. */
+#define VIRTIO_NET_F_GUEST_ECN  9       /* Guest can handle TSO[6] w/ ECN in. */
+#define VIRTIO_NET_F_GUEST_UFO  10      /* Guest can handle UFO in. */
+#define VIRTIO_NET_F_HOST_TSO4  11      /* Host can handle TSOv4 in. */
+#define VIRTIO_NET_F_HOST_TSO6  12      /* Host can handle TSOv6 in. */
+#define VIRTIO_NET_F_HOST_ECN   13      /* Host can handle TSO[6] w/ ECN in. */
+#define VIRTIO_NET_F_HOST_UFO   14      /* Host can handle UFO in. */
 
 struct virtio_net_config
 {
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/writeback.h b/include/linux/writeback.h
index b7b3362f7717..f462439cc288 100644
--- a/include/linux/writeback.h
+++ b/include/linux/writeback.h
@@ -114,6 +114,9 @@ struct file;
 int dirty_writeback_centisecs_handler(struct ctl_table *, int, struct file *,
                                       void __user *, size_t *, loff_t *);
 
+void get_dirty_limits(long *pbackground, long *pdirty, long *pbdi_dirty,
+                 struct backing_dev_info *bdi);
+
 void page_writeback_init(void);
 void balance_dirty_pages_ratelimited_nr(struct address_space *mapping,
                                         unsigned long nr_pages_dirtied);
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_removexattr(struct dentry *, char *);
+int vfs_setxattr(struct dentry *, const char *, const void *, size_t, int);
+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);