Merge branch 'akpm' (Andrew's patch-bomb)

Merge misc patches from Andrew Morton:
 "Incoming:

   - lots of misc stuff

   - backlight tree updates

   - lib/ updates

   - Oleg's percpu-rwsem changes

   - checkpatch

   - rtc

   - aoe

   - more checkpoint/restart support

  I still have a pile of MM stuff pending - Pekka should be merging
  later today after which that is good to go.  A number of other things
  are twiddling thumbs awaiting maintainer merges."

* emailed patches from Andrew Morton <akpm@linux-foundation.org>: (180 commits)
  scatterlist: don't BUG when we can trivially return a proper error.
  docs: update documentation about /proc/<pid>/fdinfo/<fd> fanotify output
  fs, fanotify: add @mflags field to fanotify output
  docs: add documentation about /proc/<pid>/fdinfo/<fd> output
  fs, notify: add procfs fdinfo helper
  fs, exportfs: add exportfs_encode_inode_fh() helper
  fs, exportfs: escape nil dereference if no s_export_op present
  fs, epoll: add procfs fdinfo helper
  fs, eventfd: add procfs fdinfo helper
  procfs: add ability to plug in auxiliary fdinfo providers
  tools/testing/selftests/kcmp/kcmp_test.c: print reason for failure in kcmp_test
  breakpoint selftests: print failure status instead of cause make error
  kcmp selftests: print fail status instead of cause make error
  kcmp selftests: make run_tests fix
  mem-hotplug selftests: print failure status instead of cause make error
  cpu-hotplug selftests: print failure status instead of cause make error
  mqueue selftests: print failure status instead of cause make error
  vm selftests: print failure status instead of cause make error
  ubifs: use prandom_bytes
  mtd: nandsim: use prandom_bytes
  ...

19 files changed, 145 insertions, 129 deletions

diff --git a/include/asm-generic/io.h b/include/asm-generic/io.h
index 9e0ebe051243..d1e93284d72a 100644
--- a/include/asm-generic/io.h
+++ b/include/asm-generic/io.h
@@ -154,7 +154,7 @@ static inline void insb(unsigned long addr, void *buffer, int count)
         if (count) {
                 u8 *buf = buffer;
                 do {
-                        u8 x = inb(addr);
+                        u8 x = __raw_readb(addr + PCI_IOBASE);
                         *buf++ = x;
                 } while (--count);
         }
@@ -167,7 +167,7 @@ static inline void insw(unsigned long addr, void *buffer, int count)
         if (count) {
                 u16 *buf = buffer;
                 do {
-                        u16 x = inw(addr);
+                        u16 x = __raw_readw(addr + PCI_IOBASE);
                         *buf++ = x;
                 } while (--count);
         }
@@ -180,7 +180,7 @@ static inline void insl(unsigned long addr, void *buffer, int count)
         if (count) {
                 u32 *buf = buffer;
                 do {
-                        u32 x = inl(addr);
+                        u32 x = __raw_readl(addr + PCI_IOBASE);
                         *buf++ = x;
                 } while (--count);
         }
@@ -193,7 +193,7 @@ static inline void outsb(unsigned long addr, const void *buffer, int count)
         if (count) {
                 const u8 *buf = buffer;
                 do {
-                        outb(*buf++, addr);
+                        __raw_writeb(*buf++, addr + PCI_IOBASE);
                 } while (--count);
         }
 }
@@ -205,7 +205,7 @@ static inline void outsw(unsigned long addr, const void *buffer, int count)
         if (count) {
                 const u16 *buf = buffer;
                 do {
-                        outw(*buf++, addr);
+                        __raw_writew(*buf++, addr + PCI_IOBASE);
                 } while (--count);
         }
 }
@@ -217,7 +217,7 @@ static inline void outsl(unsigned long addr, const void *buffer, int count)
         if (count) {
                 const u32 *buf = buffer;
                 do {
-                        outl(*buf++, addr);
+                        __raw_writel(*buf++, addr + PCI_IOBASE);
                 } while (--count);
         }
 }
diff --git a/include/linux/backlight.h b/include/linux/backlight.h
index 5ffc6dda4675..da9a0825e007 100644
--- a/include/linux/backlight.h
+++ b/include/linux/backlight.h
@@ -134,4 +134,14 @@ struct generic_bl_info {
         void (*kick_battery)(void);
 };
 
+#ifdef CONFIG_OF
+struct backlight_device *of_find_backlight_by_node(struct device_node *node);
+#else
+static inline struct backlight_device *
+of_find_backlight_by_node(struct device_node *node)
+{
+        return NULL;
+}
+#endif
+
 #endif
diff --git a/include/linux/binfmts.h b/include/linux/binfmts.h
index 2630c9b41a86..a4c2b565c835 100644
--- a/include/linux/binfmts.h
+++ b/include/linux/binfmts.h
@@ -54,8 +54,6 @@ struct linux_binprm {
 #define BINPRM_FLAGS_EXECFD_BIT 1
 #define BINPRM_FLAGS_EXECFD (1 << BINPRM_FLAGS_EXECFD_BIT)
 
-#define BINPRM_MAX_RECURSION 4
-
 /* Function parameter for binfmt->coredump */
 struct coredump_params {
         siginfo_t *siginfo;
diff --git a/include/linux/compat.h b/include/linux/compat.h
index 784ebfe63c48..e4920bd58a47 100644
--- a/include/linux/compat.h
+++ b/include/linux/compat.h
@@ -588,6 +588,9 @@ asmlinkage ssize_t compat_sys_process_vm_writev(compat_pid_t pid,
 asmlinkage long compat_sys_sendfile(int out_fd, int in_fd,
                                     compat_off_t __user *offset, compat_size_t count);
 
+asmlinkage long compat_sys_sched_rr_get_interval(compat_pid_t pid,
+                                                 struct compat_timespec __user *interval);
+
 #else
 
 #define is_compat_task() (0)
diff --git a/include/linux/compiler.h b/include/linux/compiler.h
index f430e4162f41..b121554f1fe2 100644
--- a/include/linux/compiler.h
+++ b/include/linux/compiler.h
@@ -10,6 +10,7 @@
 # define __force        __attribute__((force))
 # define __nocast       __attribute__((nocast))
 # define __iomem        __attribute__((noderef, address_space(2)))
+# define __must_hold(x) __attribute__((context(x,1,1)))
 # define __acquires(x)  __attribute__((context(x,0,1)))
 # define __releases(x)  __attribute__((context(x,1,0)))
 # define __acquire(x)   __context__(x,1)
@@ -33,6 +34,7 @@ extern void __chk_io_ptr(const volatile void __iomem *);
 # define __chk_user_ptr(x) (void)0
 # define __chk_io_ptr(x) (void)0
 # define __builtin_warning(x, y...) (1)
+# define __must_hold(x)
 # define __acquires(x)
 # define __releases(x)
 # define __acquire(x) (void)0
diff --git a/include/linux/exportfs.h b/include/linux/exportfs.h
index 12291a7ee275..c7e6b6392ab8 100644
--- a/include/linux/exportfs.h
+++ b/include/linux/exportfs.h
@@ -177,6 +177,8 @@ struct export_operations {
         int (*commit_metadata)(struct inode *inode);
 };
 
+extern int exportfs_encode_inode_fh(struct inode *inode, struct fid *fid,
+                                    int *max_len, struct inode *parent);
 extern int exportfs_encode_fh(struct dentry *dentry, struct fid *fid,
         int *max_len, int connectable);
 extern struct dentry *exportfs_decode_fh(struct vfsmount *mnt, struct fid *fid,
diff --git a/include/linux/fs.h b/include/linux/fs.h
index 035521b46528..a823d4be38e7 100644
--- a/include/linux/fs.h
+++ b/include/linux/fs.h
@@ -44,6 +44,7 @@ struct vm_area_struct;
 struct vfsmount;
 struct cred;
 struct swap_info_struct;
+struct seq_file;
 
 extern void __init inode_init(void);
 extern void __init inode_init_early(void);
@@ -1543,6 +1544,7 @@ struct file_operations {
         int (*setlease)(struct file *, long, struct file_lock **);
         long (*fallocate)(struct file *file, int mode, loff_t offset,
                           loff_t len);
+        int (*show_fdinfo)(struct seq_file *m, struct file *f);
 };
 
 struct inode_operations {
@@ -1578,8 +1580,6 @@ struct inode_operations {
                            umode_t create_mode, int *opened);
 } ____cacheline_aligned;
 
-struct seq_file;
-
 ssize_t rw_copy_check_uvector(int type, const struct iovec __user * uvector,
                               unsigned long nr_segs, unsigned long fast_segs,
                               struct iovec *fast_pointer,
@@ -2288,9 +2288,9 @@ extern ino_t find_inode_number(struct dentry *, struct qstr *);
 #include <linux/err.h>
 
 /* needed for stackable file system support */
-extern loff_t default_llseek(struct file *file, loff_t offset, int origin);
+extern loff_t default_llseek(struct file *file, loff_t offset, int whence);
 
-extern loff_t vfs_llseek(struct file *file, loff_t offset, int origin);
+extern loff_t vfs_llseek(struct file *file, loff_t offset, int whence);
 
 extern int inode_init_always(struct super_block *, struct inode *);
 extern void inode_init_once(struct inode *);
@@ -2398,11 +2398,11 @@ extern long do_splice_direct(struct file *in, loff_t *ppos, struct file *out,
 
 extern void
 file_ra_state_init(struct file_ra_state *ra, struct address_space *mapping);
-extern loff_t noop_llseek(struct file *file, loff_t offset, int origin);
-extern loff_t no_llseek(struct file *file, loff_t offset, int origin);
-extern loff_t generic_file_llseek(struct file *file, loff_t offset, int origin);
+extern loff_t noop_llseek(struct file *file, loff_t offset, int whence);
+extern loff_t no_llseek(struct file *file, loff_t offset, int whence);
+extern loff_t generic_file_llseek(struct file *file, loff_t offset, int whence);
 extern loff_t generic_file_llseek_size(struct file *file, loff_t offset,
-                int origin, loff_t maxsize, loff_t eof);
+                int whence, loff_t maxsize, loff_t eof);
 extern int generic_file_open(struct inode * inode, struct file * filp);
 extern int nonseekable_open(struct inode * inode, struct file * filp);
 
diff --git a/include/linux/ftrace.h b/include/linux/ftrace.h
index a52f2f4fe030..92691d85c320 100644
--- a/include/linux/ftrace.h
+++ b/include/linux/ftrace.h
@@ -394,7 +394,7 @@ ssize_t ftrace_filter_write(struct file *file, const char __user *ubuf,
                             size_t cnt, loff_t *ppos);
 ssize_t ftrace_notrace_write(struct file *file, const char __user *ubuf,
                              size_t cnt, loff_t *ppos);
-loff_t ftrace_regex_lseek(struct file *file, loff_t offset, int origin);
+loff_t ftrace_regex_lseek(struct file *file, loff_t offset, int whence);
 int ftrace_regex_release(struct inode *inode, struct file *file);
 
 void __init
@@ -559,7 +559,7 @@ static inline ssize_t ftrace_filter_write(struct file *file, const char __user *
                             size_t cnt, loff_t *ppos) { return -ENODEV; }
 static inline ssize_t ftrace_notrace_write(struct file *file, const char __user *ubuf,
                              size_t cnt, loff_t *ppos) { return -ENODEV; }
-static inline loff_t ftrace_regex_lseek(struct file *file, loff_t offset, int origin)
+static inline loff_t ftrace_regex_lseek(struct file *file, loff_t offset, int whence)
 {
         return -ENODEV;
 }
diff --git a/include/linux/init.h b/include/linux/init.h
index f63692d6902e..a799273714ac 100644
--- a/include/linux/init.h
+++ b/include/linux/init.h
@@ -182,16 +182,16 @@ extern bool initcall_debug;
  * can point at the same handler without causing duplicate-symbol build errors.
  */
 
-#define __define_initcall(level,fn,id) \
+#define __define_initcall(fn, id) \
         static initcall_t __initcall_##fn##id __used \
-        __attribute__((__section__(".initcall" level ".init"))) = fn
+        __attribute__((__section__(".initcall" #id ".init"))) = fn
 
 /*
  * Early initcalls run before initializing SMP.
  *
  * Only for built-in code, not modules.
  */
-#define early_initcall(fn)              __define_initcall("early",fn,early)
+#define early_initcall(fn)              __define_initcall(fn, early)
 
 /*
  * A "pure" initcall has no dependencies on anything else, and purely
@@ -200,23 +200,23 @@ extern bool initcall_debug;
  * This only exists for built-in code, not for modules.
  * Keep main.c:initcall_level_names[] in sync.
  */
-#define pure_initcall(fn)               __define_initcall("0",fn,0)
-
-#define core_initcall(fn)               __define_initcall("1",fn,1)
-#define core_initcall_sync(fn)          __define_initcall("1s",fn,1s)
-#define postcore_initcall(fn)           __define_initcall("2",fn,2)
-#define postcore_initcall_sync(fn)      __define_initcall("2s",fn,2s)
-#define arch_initcall(fn)               __define_initcall("3",fn,3)
-#define arch_initcall_sync(fn)          __define_initcall("3s",fn,3s)
-#define subsys_initcall(fn)             __define_initcall("4",fn,4)
-#define subsys_initcall_sync(fn)        __define_initcall("4s",fn,4s)
-#define fs_initcall(fn)                 __define_initcall("5",fn,5)
-#define fs_initcall_sync(fn)            __define_initcall("5s",fn,5s)
-#define rootfs_initcall(fn)             __define_initcall("rootfs",fn,rootfs)
-#define device_initcall(fn)             __define_initcall("6",fn,6)
-#define device_initcall_sync(fn)        __define_initcall("6s",fn,6s)
-#define late_initcall(fn)               __define_initcall("7",fn,7)
-#define late_initcall_sync(fn)          __define_initcall("7s",fn,7s)
+#define pure_initcall(fn)               __define_initcall(fn, 0)
+
+#define core_initcall(fn)               __define_initcall(fn, 1)
+#define core_initcall_sync(fn)          __define_initcall(fn, 1s)
+#define postcore_initcall(fn)           __define_initcall(fn, 2)
+#define postcore_initcall_sync(fn)      __define_initcall(fn, 2s)
+#define arch_initcall(fn)               __define_initcall(fn, 3)
+#define arch_initcall_sync(fn)          __define_initcall(fn, 3s)
+#define subsys_initcall(fn)             __define_initcall(fn, 4)
+#define subsys_initcall_sync(fn)        __define_initcall(fn, 4s)
+#define fs_initcall(fn)                 __define_initcall(fn, 5)
+#define fs_initcall_sync(fn)            __define_initcall(fn, 5s)
+#define rootfs_initcall(fn)             __define_initcall(fn, rootfs)
+#define device_initcall(fn)             __define_initcall(fn, 6)
+#define device_initcall_sync(fn)        __define_initcall(fn, 6s)
+#define late_initcall(fn)               __define_initcall(fn, 7)
+#define late_initcall_sync(fn)          __define_initcall(fn, 7s)
 
 #define __initcall(fn) device_initcall(fn)
 
diff --git a/include/linux/kernel.h b/include/linux/kernel.h
index d97ed5897447..d140e8fb075f 100644
--- a/include/linux/kernel.h
+++ b/include/linux/kernel.h
@@ -220,6 +220,23 @@ int __must_check _kstrtol(const char *s, unsigned int base, long *res);
 
 int __must_check kstrtoull(const char *s, unsigned int base, unsigned long long *res);
 int __must_check kstrtoll(const char *s, unsigned int base, long long *res);
+
+/**
+ * kstrtoul - convert a string to an unsigned long
+ * @s: The start of the string. The string must be null-terminated, and may also
+ *  include a single newline before its terminating null. The first character
+ *  may also be a plus sign, but not a minus sign.
+ * @base: The number base to use. The maximum supported base is 16. If base is
+ *  given as 0, then the base of the string is automatically detected with the
+ *  conventional semantics - If it begins with 0x the number will be parsed as a
+ *  hexadecimal (case insensitive), if it otherwise begins with 0, it will be
+ *  parsed as an octal number. Otherwise it will be parsed as a decimal.
+ * @res: Where to write the result of the conversion on success.
+ *
+ * Returns 0 on success, -ERANGE on overflow and -EINVAL on parsing error.
+ * Used as a replacement for the obsolete simple_strtoull. Return code must
+ * be checked.
+*/
 static inline int __must_check kstrtoul(const char *s, unsigned int base, unsigned long *res)
 {
         /*
@@ -233,6 +250,22 @@ static inline int __must_check kstrtoul(const char *s, unsigned int base, unsign
                 return _kstrtoul(s, base, res);
 }
 
+/**
+ * kstrtol - convert a string to a long
+ * @s: The start of the string. The string must be null-terminated, and may also
+ *  include a single newline before its terminating null. The first character
+ *  may also be a plus sign or a minus sign.
+ * @base: The number base to use. The maximum supported base is 16. If base is
+ *  given as 0, then the base of the string is automatically detected with the
+ *  conventional semantics - If it begins with 0x the number will be parsed as a
+ *  hexadecimal (case insensitive), if it otherwise begins with 0, it will be
+ *  parsed as an octal number. Otherwise it will be parsed as a decimal.
+ * @res: Where to write the result of the conversion on success.
+ *
+ * Returns 0 on success, -ERANGE on overflow and -EINVAL on parsing error.
+ * Used as a replacement for the obsolete simple_strtoull. Return code must
+ * be checked.
+ */
 static inline int __must_check kstrtol(const char *s, unsigned int base, long *res)
 {
         /*
diff --git a/include/linux/percpu-rwsem.h b/include/linux/percpu-rwsem.h
index bd1e86071e57..3e88c9a7d57f 100644
--- a/include/linux/percpu-rwsem.h
+++ b/include/linux/percpu-rwsem.h
@@ -1,83 +1,34 @@
 #ifndef _LINUX_PERCPU_RWSEM_H
 #define _LINUX_PERCPU_RWSEM_H
 
-#include <linux/mutex.h>
+#include <linux/atomic.h>
+#include <linux/rwsem.h>
 #include <linux/percpu.h>
-#include <linux/rcupdate.h>
-#include <linux/delay.h>
+#include <linux/wait.h>
+#include <linux/lockdep.h>
 
 struct percpu_rw_semaphore {
-        unsigned __percpu *counters;
-        bool locked;
-        struct mutex mtx;
+        unsigned int __percpu   *fast_read_ctr;
+        atomic_t                write_ctr;
+        struct rw_semaphore     rw_sem;
+        atomic_t                slow_read_ctr;
+        wait_queue_head_t       write_waitq;
 };
 
-#define light_mb()      barrier()
-#define heavy_mb()      synchronize_sched_expedited()
+extern void percpu_down_read(struct percpu_rw_semaphore *);
+extern void percpu_up_read(struct percpu_rw_semaphore *);
 
-static inline void percpu_down_read(struct percpu_rw_semaphore *p)
-{
-        rcu_read_lock_sched();
-        if (unlikely(p->locked)) {
-                rcu_read_unlock_sched();
-                mutex_lock(&p->mtx);
-                this_cpu_inc(*p->counters);
-                mutex_unlock(&p->mtx);
-                return;
-        }
-        this_cpu_inc(*p->counters);
-        rcu_read_unlock_sched();
-        light_mb(); /* A, between read of p->locked and read of data, paired with D */
-}
+extern void percpu_down_write(struct percpu_rw_semaphore *);
+extern void percpu_up_write(struct percpu_rw_semaphore *);
 
-static inline void percpu_up_read(struct percpu_rw_semaphore *p)
-{
-        light_mb(); /* B, between read of the data and write to p->counter, paired with C */
-        this_cpu_dec(*p->counters);
-}
+extern int __percpu_init_rwsem(struct percpu_rw_semaphore *,
+                                const char *, struct lock_class_key *);
+extern void percpu_free_rwsem(struct percpu_rw_semaphore *);
 
-static inline unsigned __percpu_count(unsigned __percpu *counters)
-{
-        unsigned total = 0;
-        int cpu;
-
-        for_each_possible_cpu(cpu)
-                total += ACCESS_ONCE(*per_cpu_ptr(counters, cpu));
-
-        return total;
-}
-
-static inline void percpu_down_write(struct percpu_rw_semaphore *p)
-{
-        mutex_lock(&p->mtx);
-        p->locked = true;
-        synchronize_sched_expedited(); /* make sure that all readers exit the rcu_read_lock_sched region */
-        while (__percpu_count(p->counters))
-                msleep(1);
-        heavy_mb(); /* C, between read of p->counter and write to data, paired with B */
-}
-
-static inline void percpu_up_write(struct percpu_rw_semaphore *p)
-{
-        heavy_mb(); /* D, between write to data and write to p->locked, paired with A */
-        p->locked = false;
-        mutex_unlock(&p->mtx);
-}
-
-static inline int percpu_init_rwsem(struct percpu_rw_semaphore *p)
-{
-        p->counters = alloc_percpu(unsigned);
-        if (unlikely(!p->counters))
-                return -ENOMEM;
-        p->locked = false;
-        mutex_init(&p->mtx);
-        return 0;
-}
-
-static inline void percpu_free_rwsem(struct percpu_rw_semaphore *p)
-{
-        free_percpu(p->counters);
-        p->counters = NULL; /* catch use after free bugs */
-}
+#define percpu_init_rwsem(brw)  \
+({                                                              \
+        static struct lock_class_key rwsem_key;                 \
+        __percpu_init_rwsem(brw, #brw, &rwsem_key);             \
+})
 
 #endif
diff --git a/include/linux/platform_data/lp855x.h b/include/linux/platform_data/lp855x.h
index 761f31752367..e81f62d24ee2 100644
--- a/include/linux/platform_data/lp855x.h
+++ b/include/linux/platform_data/lp855x.h
@@ -89,11 +89,6 @@ enum lp8556_brightness_source {
         LP8556_COMBINED2,       /* pwm + i2c after the shaper block */
 };
 
-struct lp855x_pwm_data {
-        void (*pwm_set_intensity) (int brightness, int max_brightness);
-        int (*pwm_get_intensity) (int max_brightness);
-};
-
 struct lp855x_rom_data {
         u8 addr;
         u8 val;
@@ -105,7 +100,7 @@ struct lp855x_rom_data {
  * @mode : brightness control by pwm or lp855x register
  * @device_control : value of DEVICE CONTROL register
  * @initial_brightness : initial value of backlight brightness
- * @pwm_data : platform specific pwm generation functions.
+ * @period_ns : platform specific pwm period value. unit is nano.
                 Only valid when mode is PWM_BASED.
  * @load_new_rom_data :
         0 : use default configuration data
@@ -118,7 +113,7 @@ struct lp855x_platform_data {
         enum lp855x_brightness_ctrl_mode mode;
         u8 device_control;
         int initial_brightness;
-        struct lp855x_pwm_data pwm_data;
+        unsigned int period_ns;
         u8 load_new_rom_data;
         int size_program;
         struct lp855x_rom_data *rom_data;
diff --git a/include/linux/proc_fs.h b/include/linux/proc_fs.h
index 2e24018b7cec..32676b35d2f5 100644
--- a/include/linux/proc_fs.h
+++ b/include/linux/proc_fs.h
@@ -314,4 +314,7 @@ static inline struct net *PDE_NET(struct proc_dir_entry *pde)
         return pde->parent->data;
 }
 
+#include <linux/signal.h>
+
+void render_sigset_t(struct seq_file *m, const char *header, sigset_t *set);
 #endif /* _LINUX_PROC_FS_H */
diff --git a/include/linux/ptrace.h b/include/linux/ptrace.h
index a89ff04bddd9..addfbe7c180e 100644
--- a/include/linux/ptrace.h
+++ b/include/linux/ptrace.h
@@ -32,6 +32,8 @@
 #define PT_TRACE_EXIT           PT_EVENT_FLAG(PTRACE_EVENT_EXIT)
 #define PT_TRACE_SECCOMP        PT_EVENT_FLAG(PTRACE_EVENT_SECCOMP)
 
+#define PT_EXITKILL             (PTRACE_O_EXITKILL << PT_OPT_FLAG_SHIFT)
+
 /* single stepping state bits (used on ARM and PA-RISC) */
 #define PT_SINGLESTEP_BIT       31
 #define PT_SINGLESTEP           (1<<PT_SINGLESTEP_BIT)
diff --git a/include/linux/random.h b/include/linux/random.h
index 6330ed47b38b..d9846088c2c5 100644
--- a/include/linux/random.h
+++ b/include/linux/random.h
@@ -25,10 +25,19 @@ extern const struct file_operations random_fops, urandom_fops;
 unsigned int get_random_int(void);
 unsigned long randomize_range(unsigned long start, unsigned long end, unsigned long len);
 
-u32 random32(void);
-void srandom32(u32 seed);
+u32 prandom_u32(void);
+void prandom_bytes(void *buf, int nbytes);
+void prandom_seed(u32 seed);
 
-u32 prandom32(struct rnd_state *);
+/*
+ * These macros are preserved for backward compatibility and should be
+ * removed as soon as a transition is finished.
+ */
+#define random32() prandom_u32()
+#define srandom32(seed) prandom_seed(seed)
+
+u32 prandom_u32_state(struct rnd_state *);
+void prandom_bytes_state(struct rnd_state *state, void *buf, int nbytes);
 
 /*
  * Handle minimum values for seeds
@@ -39,11 +48,11 @@ static inline u32 __seed(u32 x, u32 m)
 }
 
 /**
- * prandom32_seed - set seed for prandom32().
+ * prandom_seed_state - set seed for prandom_u32_state().
  * @state: pointer to state structure to receive the seed.
  * @seed: arbitrary 64-bit value to use as a seed.
  */
-static inline void prandom32_seed(struct rnd_state *state, u64 seed)
+static inline void prandom_seed_state(struct rnd_state *state, u64 seed)
 {
         u32 i = (seed >> 32) ^ (seed << 10) ^ seed;
 
diff --git a/include/linux/sched.h b/include/linux/sched.h
index b089c92c609b..9914c662ed7b 100644
--- a/include/linux/sched.h
+++ b/include/linux/sched.h
@@ -1778,12 +1778,6 @@ static inline int is_global_init(struct task_struct *tsk)
         return tsk->pid == 1;
 }
 
-/*
- * is_container_init:
- * check whether in the task is init in its own pid namespace.
- */
-extern int is_container_init(struct task_struct *tsk);
-
 extern struct pid *cad_pid;
 
 extern void free_task(struct task_struct *tsk);
diff --git a/include/linux/string.h b/include/linux/string.h
index 630125818ca8..ac889c5ea11b 100644
--- a/include/linux/string.h
+++ b/include/linux/string.h
@@ -143,4 +143,15 @@ static inline bool strstarts(const char *str, const char *prefix)
 
 extern size_t memweight(const void *ptr, size_t bytes);
 
+/**
+ * kbasename - return the last part of a pathname.
+ *
+ * @path: path to extract the filename from.
+ */
+static inline const char *kbasename(const char *path)
+{
+        const char *tail = strrchr(path, '/');
+        return tail ? tail + 1 : path;
+}
+
 #endif /* _LINUX_STRING_H_ */
diff --git a/include/linux/syscalls.h b/include/linux/syscalls.h
index 91835e7f364d..36c3b07c5119 100644
--- a/include/linux/syscalls.h
+++ b/include/linux/syscalls.h
@@ -560,10 +560,10 @@ asmlinkage long sys_utime(char __user *filename,
 asmlinkage long sys_utimes(char __user *filename,
                                 struct timeval __user *utimes);
 asmlinkage long sys_lseek(unsigned int fd, off_t offset,
-                          unsigned int origin);
+                          unsigned int whence);
 asmlinkage long sys_llseek(unsigned int fd, unsigned long offset_high,
                         unsigned long offset_low, loff_t __user *result,
-                        unsigned int origin);
+                        unsigned int whence);
 asmlinkage long sys_read(unsigned int fd, char __user *buf, size_t count);
 asmlinkage long sys_readahead(int fd, loff_t offset, size_t count);
 asmlinkage long sys_readv(unsigned long fd,
diff --git a/include/uapi/linux/ptrace.h b/include/uapi/linux/ptrace.h
index 1ef6c056a9e4..022ab186a812 100644
--- a/include/uapi/linux/ptrace.h
+++ b/include/uapi/linux/ptrace.h
@@ -73,7 +73,10 @@
 #define PTRACE_O_TRACEEXIT      (1 << PTRACE_EVENT_EXIT)
 #define PTRACE_O_TRACESECCOMP   (1 << PTRACE_EVENT_SECCOMP)
 
-#define PTRACE_O_MASK           0x000000ff
+/* eventless options */
+#define PTRACE_O_EXITKILL       (1 << 20)
+
+#define PTRACE_O_MASK           (0x000000ff | PTRACE_O_EXITKILL)
 
 #include <asm/ptrace.h>