sync to Linus v4.13-rc2 for subsystem developers to work against

163 files changed, 11323 insertions, 7595 deletions

diff --git a/kernel/Makefile b/kernel/Makefile
index 72aa080f91f0..4cb8e8b23c6e 100644
--- a/kernel/Makefile
+++ b/kernel/Makefile
@@ -82,7 +82,7 @@ obj-$(CONFIG_KPROBES) += kprobes.o
 obj-$(CONFIG_KGDB) += debug/
 obj-$(CONFIG_DETECT_HUNG_TASK) += hung_task.o
 obj-$(CONFIG_LOCKUP_DETECTOR) += watchdog.o
-obj-$(CONFIG_HARDLOCKUP_DETECTOR) += watchdog_hld.o
+obj-$(CONFIG_HARDLOCKUP_DETECTOR_PERF) += watchdog_hld.o
 obj-$(CONFIG_SECCOMP) += seccomp.o
 obj-$(CONFIG_RELAY) += relay.o
 obj-$(CONFIG_SYSCTL) += utsname_sysctl.o
diff --git a/kernel/async.c b/kernel/async.c
index d2edd6efec56..2cbd3dd5940d 100644
--- a/kernel/async.c
+++ b/kernel/async.c
@@ -114,14 +114,14 @@ static void async_run_entry_fn(struct work_struct *work)
         ktime_t uninitialized_var(calltime), delta, rettime;
 
         /* 1) run (and print duration) */
-        if (initcall_debug && system_state == SYSTEM_BOOTING) {
+        if (initcall_debug && system_state < SYSTEM_RUNNING) {
                 pr_debug("calling  %lli_%pF @ %i\n",
                         (long long)entry->cookie,
                         entry->func, task_pid_nr(current));
                 calltime = ktime_get();
         }
         entry->func(entry->data, entry->cookie);
-        if (initcall_debug && system_state == SYSTEM_BOOTING) {
+        if (initcall_debug && system_state < SYSTEM_RUNNING) {
                 rettime = ktime_get();
                 delta = ktime_sub(rettime, calltime);
                 pr_debug("initcall %lli_%pF returned 0 after %lld usecs\n",
@@ -284,14 +284,14 @@ void async_synchronize_cookie_domain(async_cookie_t cookie, struct async_domain
 {
         ktime_t uninitialized_var(starttime), delta, endtime;
 
-        if (initcall_debug && system_state == SYSTEM_BOOTING) {
+        if (initcall_debug && system_state < SYSTEM_RUNNING) {
                 pr_debug("async_waiting @ %i\n", task_pid_nr(current));
                 starttime = ktime_get();
         }
 
         wait_event(async_done, lowest_in_progress(domain) >= cookie);
 
-        if (initcall_debug && system_state == SYSTEM_BOOTING) {
+        if (initcall_debug && system_state < SYSTEM_RUNNING) {
                 endtime = ktime_get();
                 delta = ktime_sub(endtime, starttime);
 
diff --git a/kernel/audit.c b/kernel/audit.c
index 4b7d49868ce1..6dd556931739 100644
--- a/kernel/audit.c
+++ b/kernel/audit.c
@@ -575,12 +575,16 @@ static void kauditd_retry_skb(struct sk_buff *skb)
 
 /**
  * auditd_reset - Disconnect the auditd connection
+ * @ac: auditd connection state
  *
  * Description:
  * Break the auditd/kauditd connection and move all the queued records into the
- * hold queue in case auditd reconnects.
+ * hold queue in case auditd reconnects.  It is important to note that the @ac
+ * pointer should never be dereferenced inside this function as it may be NULL
+ * or invalid, you can only compare the memory address!  If @ac is NULL then
+ * the connection will always be reset.
  */
-static void auditd_reset(void)
+static void auditd_reset(const struct auditd_connection *ac)
 {
         unsigned long flags;
         struct sk_buff *skb;
@@ -590,17 +594,21 @@ static void auditd_reset(void)
         spin_lock_irqsave(&auditd_conn_lock, flags);
         ac_old = rcu_dereference_protected(auditd_conn,
                                            lockdep_is_held(&auditd_conn_lock));
+        if (ac && ac != ac_old) {
+                /* someone already registered a new auditd connection */
+                spin_unlock_irqrestore(&auditd_conn_lock, flags);
+                return;
+        }
         rcu_assign_pointer(auditd_conn, NULL);
         spin_unlock_irqrestore(&auditd_conn_lock, flags);
 
         if (ac_old)
                 call_rcu(&ac_old->rcu, auditd_conn_free);
 
-        /* flush all of the main and retry queues to the hold queue */
+        /* flush the retry queue to the hold queue, but don't touch the main
+         * queue since we need to process that normally for multicast */
         while ((skb = skb_dequeue(&audit_retry_queue)))
                 kauditd_hold_skb(skb);
-        while ((skb = skb_dequeue(&audit_queue)))
-                kauditd_hold_skb(skb);
 }
 
 /**
@@ -633,6 +641,7 @@ static int auditd_send_unicast_skb(struct sk_buff *skb)
         ac = rcu_dereference(auditd_conn);
         if (!ac) {
                 rcu_read_unlock();
+                kfree_skb(skb);
                 rc = -ECONNREFUSED;
                 goto err;
         }
@@ -649,8 +658,8 @@ static int auditd_send_unicast_skb(struct sk_buff *skb)
         return rc;
 
 err:
-        if (rc == -ECONNREFUSED)
-                auditd_reset();
+        if (ac && rc == -ECONNREFUSED)
+                auditd_reset(ac);
         return rc;
 }
 
@@ -795,9 +804,9 @@ static int kauditd_thread(void *dummy)
                 rc = kauditd_send_queue(sk, portid,
                                         &audit_hold_queue, UNICAST_RETRIES,
                                         NULL, kauditd_rehold_skb);
-                if (rc < 0) {
+                if (ac && rc < 0) {
                         sk = NULL;
-                        auditd_reset();
+                        auditd_reset(ac);
                         goto main_queue;
                 }
 
@@ -805,9 +814,9 @@ static int kauditd_thread(void *dummy)
                 rc = kauditd_send_queue(sk, portid,
                                         &audit_retry_queue, UNICAST_RETRIES,
                                         NULL, kauditd_hold_skb);
-                if (rc < 0) {
+                if (ac && rc < 0) {
                         sk = NULL;
-                        auditd_reset();
+                        auditd_reset(ac);
                         goto main_queue;
                 }
 
@@ -815,12 +824,13 @@ main_queue:
                 /* process the main queue - do the multicast send and attempt
                  * unicast, dump failed record sends to the retry queue; if
                  * sk == NULL due to previous failures we will just do the
-                 * multicast send and move the record to the retry queue */
+                 * multicast send and move the record to the hold queue */
                 rc = kauditd_send_queue(sk, portid, &audit_queue, 1,
                                         kauditd_send_multicast_skb,
-                                        kauditd_retry_skb);
-                if (sk == NULL || rc < 0)
-                        auditd_reset();
+                                        (sk ?
+                                         kauditd_retry_skb : kauditd_hold_skb));
+                if (ac && rc < 0)
+                        auditd_reset(ac);
                 sk = NULL;
 
                 /* drop our netns reference, no auditd sends past this line */
@@ -1230,7 +1240,7 @@ static int audit_receive_msg(struct sk_buff *skb, struct nlmsghdr *nlh)
                                                                 auditd_pid, 1);
 
                                 /* unregister the auditd connection */
-                                auditd_reset();
+                                auditd_reset(NULL);
                         }
                 }
                 if (s.mask & AUDIT_STATUS_RATE_LIMIT) {
@@ -1999,22 +2009,10 @@ void audit_log_cap(struct audit_buffer *ab, char *prefix, kernel_cap_t *cap)
 
 static void audit_log_fcaps(struct audit_buffer *ab, struct audit_names *name)
 {
-        kernel_cap_t *perm = &name->fcap.permitted;
-        kernel_cap_t *inh = &name->fcap.inheritable;
-        int log = 0;
-
-        if (!cap_isclear(*perm)) {
-                audit_log_cap(ab, "cap_fp", perm);
-                log = 1;
-        }
-        if (!cap_isclear(*inh)) {
-                audit_log_cap(ab, "cap_fi", inh);
-                log = 1;
-        }
-
-        if (log)
-                audit_log_format(ab, " cap_fe=%d cap_fver=%x",
-                                 name->fcap.fE, name->fcap_ver);
+        audit_log_cap(ab, "cap_fp", &name->fcap.permitted);
+        audit_log_cap(ab, "cap_fi", &name->fcap.inheritable);
+        audit_log_format(ab, " cap_fe=%d cap_fver=%x",
+                         name->fcap.fE, name->fcap_ver);
 }
 
 static inline int audit_copy_fcaps(struct audit_names *name,
diff --git a/kernel/audit.h b/kernel/audit.h
index ddfce2ea4891..b331d9b83f63 100644
--- a/kernel/audit.h
+++ b/kernel/audit.h
@@ -68,6 +68,7 @@ struct audit_cap_data {
                 unsigned int    fE;             /* effective bit of file cap */
                 kernel_cap_t    effective;      /* effective set of process */
         };
+        kernel_cap_t            ambient;
 };
 
 /* When fs/namei.c:getname() is called, we store the pointer in name and bump
@@ -247,13 +248,13 @@ struct audit_netlink_list {
         struct sk_buff_head q;
 };
 
-int audit_send_list(void *);
+int audit_send_list(void *_dest);
 
 extern int selinux_audit_rule_update(void);
 
 extern struct mutex audit_filter_mutex;
-extern int audit_del_rule(struct audit_entry *);
-extern void audit_free_rule_rcu(struct rcu_head *);
+extern int audit_del_rule(struct audit_entry *entry);
+extern void audit_free_rule_rcu(struct rcu_head *head);
 extern struct list_head audit_filter_list[];
 
 extern struct audit_entry *audit_dupe_rule(struct audit_krule *old);
@@ -301,17 +302,17 @@ extern int audit_exe_compare(struct task_struct *tsk, struct audit_fsnotify_mark
 #endif /* CONFIG_AUDIT_WATCH */
 
 #ifdef CONFIG_AUDIT_TREE
-extern struct audit_chunk *audit_tree_lookup(const struct inode *);
-extern void audit_put_chunk(struct audit_chunk *);
-extern bool audit_tree_match(struct audit_chunk *, struct audit_tree *);
-extern int audit_make_tree(struct audit_krule *, char *, u32);
-extern int audit_add_tree_rule(struct audit_krule *);
-extern int audit_remove_tree_rule(struct audit_krule *);
+extern struct audit_chunk *audit_tree_lookup(const struct inode *inode);
+extern void audit_put_chunk(struct audit_chunk *chunk);
+extern bool audit_tree_match(struct audit_chunk *chunk, struct audit_tree *tree);
+extern int audit_make_tree(struct audit_krule *rule, char *pathname, u32 op);
+extern int audit_add_tree_rule(struct audit_krule *rule);
+extern int audit_remove_tree_rule(struct audit_krule *rule);
 extern void audit_trim_trees(void);
 extern int audit_tag_tree(char *old, char *new);
-extern const char *audit_tree_path(struct audit_tree *);
-extern void audit_put_tree(struct audit_tree *);
-extern void audit_kill_trees(struct list_head *);
+extern const char *audit_tree_path(struct audit_tree *tree);
+extern void audit_put_tree(struct audit_tree *tree);
+extern void audit_kill_trees(struct list_head *list);
 #else
 #define audit_remove_tree_rule(rule) BUG()
 #define audit_add_tree_rule(rule) -EINVAL
@@ -323,7 +324,7 @@ extern void audit_kill_trees(struct list_head *);
 #define audit_kill_trees(list) BUG()
 #endif
 
-extern char *audit_unpack_string(void **, size_t *, size_t);
+extern char *audit_unpack_string(void **bufp, size_t *remain, size_t len);
 
 extern pid_t audit_sig_pid;
 extern kuid_t audit_sig_uid;
@@ -333,7 +334,7 @@ extern int audit_filter(int msgtype, unsigned int listtype);
 
 #ifdef CONFIG_AUDITSYSCALL
 extern int audit_signal_info(int sig, struct task_struct *t);
-extern void audit_filter_inodes(struct task_struct *, struct audit_context *);
+extern void audit_filter_inodes(struct task_struct *tsk, struct audit_context *ctx);
 extern struct list_head *audit_killed_trees(void);
 #else
 #define audit_signal_info(s,t) AUDIT_DISABLED
diff --git a/kernel/auditsc.c b/kernel/auditsc.c
index bb724baa7ac9..3260ba2312a9 100644
--- a/kernel/auditsc.c
+++ b/kernel/auditsc.c
@@ -1261,6 +1261,7 @@ static void show_special(struct audit_context *context, int *call_panic)
                 audit_log_cap(ab, "cap_pi", &context->capset.cap.inheritable);
                 audit_log_cap(ab, "cap_pp", &context->capset.cap.permitted);
                 audit_log_cap(ab, "cap_pe", &context->capset.cap.effective);
+                audit_log_cap(ab, "cap_pa", &context->capset.cap.ambient);
                 break;
         case AUDIT_MMAP:
                 audit_log_format(ab, "fd=%d flags=0x%x", context->mmap.fd,
@@ -1382,9 +1383,11 @@ static void audit_log_exit(struct audit_context *context, struct task_struct *ts
                         audit_log_cap(ab, "old_pp", &axs->old_pcap.permitted);
                         audit_log_cap(ab, "old_pi", &axs->old_pcap.inheritable);
                         audit_log_cap(ab, "old_pe", &axs->old_pcap.effective);
-                        audit_log_cap(ab, "new_pp", &axs->new_pcap.permitted);
-                        audit_log_cap(ab, "new_pi", &axs->new_pcap.inheritable);
-                        audit_log_cap(ab, "new_pe", &axs->new_pcap.effective);
+                        audit_log_cap(ab, "old_pa", &axs->old_pcap.ambient);
+                        audit_log_cap(ab, "pp", &axs->new_pcap.permitted);
+                        audit_log_cap(ab, "pi", &axs->new_pcap.inheritable);
+                        audit_log_cap(ab, "pe", &axs->new_pcap.effective);
+                        audit_log_cap(ab, "pa", &axs->new_pcap.ambient);
                         break; }
 
                 }
@@ -2342,10 +2345,12 @@ int __audit_log_bprm_fcaps(struct linux_binprm *bprm,
         ax->old_pcap.permitted   = old->cap_permitted;
         ax->old_pcap.inheritable = old->cap_inheritable;
         ax->old_pcap.effective   = old->cap_effective;
+        ax->old_pcap.ambient     = old->cap_ambient;
 
         ax->new_pcap.permitted   = new->cap_permitted;
         ax->new_pcap.inheritable = new->cap_inheritable;
         ax->new_pcap.effective   = new->cap_effective;
+        ax->new_pcap.ambient     = new->cap_ambient;
         return 0;
 }
 
@@ -2364,6 +2369,7 @@ void __audit_log_capset(const struct cred *new, const struct cred *old)
         context->capset.cap.effective   = new->cap_effective;
         context->capset.cap.inheritable = new->cap_effective;
         context->capset.cap.permitted   = new->cap_permitted;
+        context->capset.cap.ambient     = new->cap_ambient;
         context->type = AUDIT_CAPSET;
 }
 
diff --git a/kernel/bpf/arraymap.c b/kernel/bpf/arraymap.c
index 5e00b2333c26..d771a3872500 100644
--- a/kernel/bpf/arraymap.c
+++ b/kernel/bpf/arraymap.c
@@ -86,6 +86,7 @@ static struct bpf_map *array_map_alloc(union bpf_attr *attr)
         array->map.key_size = attr->key_size;
         array->map.value_size = attr->value_size;
         array->map.max_entries = attr->max_entries;
+        array->map.map_flags = attr->map_flags;
         array->elem_size = elem_size;
 
         if (!percpu)
@@ -334,6 +335,26 @@ static void *fd_array_map_lookup_elem(struct bpf_map *map, void *key)
 }
 
 /* only called from syscall */
+int bpf_fd_array_map_lookup_elem(struct bpf_map *map, void *key, u32 *value)
+{
+        void **elem, *ptr;
+        int ret =  0;
+
+        if (!map->ops->map_fd_sys_lookup_elem)
+                return -ENOTSUPP;
+
+        rcu_read_lock();
+        elem = array_map_lookup_elem(map, key);
+        if (elem && (ptr = READ_ONCE(*elem)))
+                *value = map->ops->map_fd_sys_lookup_elem(ptr);
+        else
+                ret = -ENOENT;
+        rcu_read_unlock();
+
+        return ret;
+}
+
+/* only called from syscall */
 int bpf_fd_array_map_update_elem(struct bpf_map *map, struct file *map_file,
                                  void *key, void *value, u64 map_flags)
 {
@@ -399,6 +420,11 @@ static void prog_fd_array_put_ptr(void *ptr)
         bpf_prog_put(ptr);
 }
 
+static u32 prog_fd_array_sys_lookup_elem(void *ptr)
+{
+        return ((struct bpf_prog *)ptr)->aux->id;
+}
+
 /* decrement refcnt of all bpf_progs that are stored in this map */
 void bpf_fd_array_map_clear(struct bpf_map *map)
 {
@@ -417,6 +443,7 @@ const struct bpf_map_ops prog_array_map_ops = {
         .map_delete_elem = fd_array_map_delete_elem,
         .map_fd_get_ptr = prog_fd_array_get_ptr,
         .map_fd_put_ptr = prog_fd_array_put_ptr,
+        .map_fd_sys_lookup_elem = prog_fd_array_sys_lookup_elem,
 };
 
 static struct bpf_event_entry *bpf_event_entry_gen(struct file *perf_file,
@@ -451,38 +478,24 @@ static void bpf_event_entry_free_rcu(struct bpf_event_entry *ee)
 static void *perf_event_fd_array_get_ptr(struct bpf_map *map,
                                          struct file *map_file, int fd)
 {
-        const struct perf_event_attr *attr;
         struct bpf_event_entry *ee;
         struct perf_event *event;
         struct file *perf_file;
+        u64 value;
 
         perf_file = perf_event_get(fd);
         if (IS_ERR(perf_file))
                 return perf_file;
 
+        ee = ERR_PTR(-EOPNOTSUPP);
         event = perf_file->private_data;
-        ee = ERR_PTR(-EINVAL);
-
-        attr = perf_event_attrs(event);
-        if (IS_ERR(attr) || attr->inherit)
+        if (perf_event_read_local(event, &value) == -EOPNOTSUPP)
                 goto err_out;
 
-        switch (attr->type) {
-        case PERF_TYPE_SOFTWARE:
-                if (attr->config != PERF_COUNT_SW_BPF_OUTPUT)
-                        goto err_out;
-                /* fall-through */
-        case PERF_TYPE_RAW:
-        case PERF_TYPE_HARDWARE:
-                ee = bpf_event_entry_gen(perf_file, map_file);
-                if (ee)
-                        return ee;
-                ee = ERR_PTR(-ENOMEM);
-                /* fall-through */
-        default:
-                break;
-        }
-
+        ee = bpf_event_entry_gen(perf_file, map_file);
+        if (ee)
+                return ee;
+        ee = ERR_PTR(-ENOMEM);
 err_out:
         fput(perf_file);
         return ee;
@@ -598,4 +611,5 @@ const struct bpf_map_ops array_of_maps_map_ops = {
         .map_delete_elem = fd_array_map_delete_elem,
         .map_fd_get_ptr = bpf_map_fd_get_ptr,
         .map_fd_put_ptr = bpf_map_fd_put_ptr,
+        .map_fd_sys_lookup_elem = bpf_map_fd_sys_lookup_elem,
 };
diff --git a/kernel/bpf/cgroup.c b/kernel/bpf/cgroup.c
index ea6033cba947..546113430049 100644
--- a/kernel/bpf/cgroup.c
+++ b/kernel/bpf/cgroup.c
@@ -236,3 +236,40 @@ int __cgroup_bpf_run_filter_sk(struct sock *sk,
         return ret;
 }
 EXPORT_SYMBOL(__cgroup_bpf_run_filter_sk);
+
+/**
+ * __cgroup_bpf_run_filter_sock_ops() - Run a program on a sock
+ * @sk: socket to get cgroup from
+ * @sock_ops: bpf_sock_ops_kern struct to pass to program. Contains
+ * sk with connection information (IP addresses, etc.) May not contain
+ * cgroup info if it is a req sock.
+ * @type: The type of program to be exectuted
+ *
+ * socket passed is expected to be of type INET or INET6.
+ *
+ * The program type passed in via @type must be suitable for sock_ops
+ * filtering. No further check is performed to assert that.
+ *
+ * This function will return %-EPERM if any if an attached program was found
+ * and if it returned != 1 during execution. In all other cases, 0 is returned.
+ */
+int __cgroup_bpf_run_filter_sock_ops(struct sock *sk,
+                                     struct bpf_sock_ops_kern *sock_ops,
+                                     enum bpf_attach_type type)
+{
+        struct cgroup *cgrp = sock_cgroup_ptr(&sk->sk_cgrp_data);
+        struct bpf_prog *prog;
+        int ret = 0;
+
+
+        rcu_read_lock();
+
+        prog = rcu_dereference(cgrp->bpf.effective[type]);
+        if (prog)
+                ret = BPF_PROG_RUN(prog, sock_ops) == 1 ? 0 : -EPERM;
+
+        rcu_read_unlock();
+
+        return ret;
+}
+EXPORT_SYMBOL(__cgroup_bpf_run_filter_sock_ops);
diff --git a/kernel/bpf/core.c b/kernel/bpf/core.c
index dedf367f59bb..ad5f55922a13 100644
--- a/kernel/bpf/core.c
+++ b/kernel/bpf/core.c
@@ -763,10 +763,10 @@ EXPORT_SYMBOL_GPL(__bpf_call_base);
  *
  * Decode and execute eBPF instructions.
  */
-static unsigned int __bpf_prog_run(void *ctx, const struct bpf_insn *insn)
+static unsigned int ___bpf_prog_run(u64 *regs, const struct bpf_insn *insn,
+                                    u64 *stack)
 {
-        u64 stack[MAX_BPF_STACK / sizeof(u64)];
-        u64 regs[MAX_BPF_REG], tmp;
+        u64 tmp;
         static const void *jumptable[256] = {
                 [0 ... 255] = &&default_label,
                 /* Now overwrite non-defaults ... */
@@ -824,7 +824,7 @@ static unsigned int __bpf_prog_run(void *ctx, const struct bpf_insn *insn)
                 [BPF_ALU64 | BPF_NEG] = &&ALU64_NEG,
                 /* Call instruction */
                 [BPF_JMP | BPF_CALL] = &&JMP_CALL,
-                [BPF_JMP | BPF_CALL | BPF_X] = &&JMP_TAIL_CALL,
+                [BPF_JMP | BPF_TAIL_CALL] = &&JMP_TAIL_CALL,
                 /* Jumps */
                 [BPF_JMP | BPF_JA] = &&JMP_JA,
                 [BPF_JMP | BPF_JEQ | BPF_X] = &&JMP_JEQ_X,
@@ -874,9 +874,6 @@ static unsigned int __bpf_prog_run(void *ctx, const struct bpf_insn *insn)
 #define CONT     ({ insn++; goto select_insn; })
 #define CONT_JMP ({ insn++; goto select_insn; })
 
-        FP = (u64) (unsigned long) &stack[ARRAY_SIZE(stack)];
-        ARG1 = (u64) (unsigned long) ctx;
-
 select_insn:
         goto *jumptable[insn->code];
 
@@ -1219,7 +1216,39 @@ load_byte:
                 WARN_RATELIMIT(1, "unknown opcode %02x\n", insn->code);
                 return 0;
 }
-STACK_FRAME_NON_STANDARD(__bpf_prog_run); /* jump table */
+STACK_FRAME_NON_STANDARD(___bpf_prog_run); /* jump table */
+
+#define PROG_NAME(stack_size) __bpf_prog_run##stack_size
+#define DEFINE_BPF_PROG_RUN(stack_size) \
+static unsigned int PROG_NAME(stack_size)(const void *ctx, const struct bpf_insn *insn) \
+{ \
+        u64 stack[stack_size / sizeof(u64)]; \
+        u64 regs[MAX_BPF_REG]; \
+\
+        FP = (u64) (unsigned long) &stack[ARRAY_SIZE(stack)]; \
+        ARG1 = (u64) (unsigned long) ctx; \
+        return ___bpf_prog_run(regs, insn, stack); \
+}
+
+#define EVAL1(FN, X) FN(X)
+#define EVAL2(FN, X, Y...) FN(X) EVAL1(FN, Y)
+#define EVAL3(FN, X, Y...) FN(X) EVAL2(FN, Y)
+#define EVAL4(FN, X, Y...) FN(X) EVAL3(FN, Y)
+#define EVAL5(FN, X, Y...) FN(X) EVAL4(FN, Y)
+#define EVAL6(FN, X, Y...) FN(X) EVAL5(FN, Y)
+
+EVAL6(DEFINE_BPF_PROG_RUN, 32, 64, 96, 128, 160, 192);
+EVAL6(DEFINE_BPF_PROG_RUN, 224, 256, 288, 320, 352, 384);
+EVAL4(DEFINE_BPF_PROG_RUN, 416, 448, 480, 512);
+
+#define PROG_NAME_LIST(stack_size) PROG_NAME(stack_size),
+
+static unsigned int (*interpreters[])(const void *ctx,
+                                      const struct bpf_insn *insn) = {
+EVAL6(PROG_NAME_LIST, 32, 64, 96, 128, 160, 192)
+EVAL6(PROG_NAME_LIST, 224, 256, 288, 320, 352, 384)
+EVAL4(PROG_NAME_LIST, 416, 448, 480, 512)
+};
 
 bool bpf_prog_array_compatible(struct bpf_array *array,
                                const struct bpf_prog *fp)
@@ -1268,7 +1297,9 @@ static int bpf_check_tail_call(const struct bpf_prog *fp)
  */
 struct bpf_prog *bpf_prog_select_runtime(struct bpf_prog *fp, int *err)
 {
-        fp->bpf_func = (void *) __bpf_prog_run;
+        u32 stack_depth = max_t(u32, fp->aux->stack_depth, 1);
+
+        fp->bpf_func = interpreters[(round_up(stack_depth, 32) / 32) - 1];
 
         /* eBPF JITs can rewrite the program in case constant
          * blinding is active. However, in case of error during
diff --git a/kernel/bpf/hashtab.c b/kernel/bpf/hashtab.c
index 004334ea13ba..4fb463172aa8 100644
--- a/kernel/bpf/hashtab.c
+++ b/kernel/bpf/hashtab.c
@@ -1244,6 +1244,26 @@ static void fd_htab_map_free(struct bpf_map *map)
 }
 
 /* only called from syscall */
+int bpf_fd_htab_map_lookup_elem(struct bpf_map *map, void *key, u32 *value)
+{
+        void **ptr;
+        int ret = 0;
+
+        if (!map->ops->map_fd_sys_lookup_elem)
+                return -ENOTSUPP;
+
+        rcu_read_lock();
+        ptr = htab_map_lookup_elem(map, key);
+        if (ptr)
+                *value = map->ops->map_fd_sys_lookup_elem(READ_ONCE(*ptr));
+        else
+                ret = -ENOENT;
+        rcu_read_unlock();
+
+        return ret;
+}
+
+/* only called from syscall */
 int bpf_fd_htab_map_update_elem(struct bpf_map *map, struct file *map_file,
                                 void *key, void *value, u64 map_flags)
 {
@@ -1305,4 +1325,5 @@ const struct bpf_map_ops htab_of_maps_map_ops = {
         .map_delete_elem = htab_map_delete_elem,
         .map_fd_get_ptr = bpf_map_fd_get_ptr,
         .map_fd_put_ptr = bpf_map_fd_put_ptr,
+        .map_fd_sys_lookup_elem = bpf_map_fd_sys_lookup_elem,
 };
diff --git a/kernel/bpf/inode.c b/kernel/bpf/inode.c
index 9bbd33497d3d..e833ed914358 100644
--- a/kernel/bpf/inode.c
+++ b/kernel/bpf/inode.c
@@ -377,10 +377,22 @@ static void bpf_evict_inode(struct inode *inode)
                 bpf_any_put(inode->i_private, type);
 }
 
+/*
+ * Display the mount options in /proc/mounts.
+ */
+static int bpf_show_options(struct seq_file *m, struct dentry *root)
+{
+        umode_t mode = d_inode(root)->i_mode & S_IALLUGO & ~S_ISVTX;
+
+        if (mode != S_IRWXUGO)
+                seq_printf(m, ",mode=%o", mode);
+        return 0;
+}
+
 static const struct super_operations bpf_super_ops = {
         .statfs         = simple_statfs,
         .drop_inode     = generic_delete_inode,
-        .show_options   = generic_show_options,
+        .show_options   = bpf_show_options,
         .evict_inode    = bpf_evict_inode,
 };
 
@@ -434,8 +446,6 @@ static int bpf_fill_super(struct super_block *sb, void *data, int silent)
         struct inode *inode;
         int ret;
 
-        save_mount_options(sb, data);
-
         ret = bpf_parse_options(data, &opts);
         if (ret)
                 return ret;
diff --git a/kernel/bpf/lpm_trie.c b/kernel/bpf/lpm_trie.c
index 39cfafd895b8..b09185f0f17d 100644
--- a/kernel/bpf/lpm_trie.c
+++ b/kernel/bpf/lpm_trie.c
@@ -432,6 +432,7 @@ static struct bpf_map *trie_alloc(union bpf_attr *attr)
         trie->map.key_size = attr->key_size;
         trie->map.value_size = attr->value_size;
         trie->map.max_entries = attr->max_entries;
+        trie->map.map_flags = attr->map_flags;
         trie->data_size = attr->key_size -
                           offsetof(struct bpf_lpm_trie_key, data);
         trie->max_prefixlen = trie->data_size * 8;
diff --git a/kernel/bpf/map_in_map.c b/kernel/bpf/map_in_map.c
index 59bcdf821ae4..1da574612bea 100644
--- a/kernel/bpf/map_in_map.c
+++ b/kernel/bpf/map_in_map.c
@@ -95,3 +95,8 @@ void bpf_map_fd_put_ptr(void *ptr)
          */
         bpf_map_put(ptr);
 }
+
+u32 bpf_map_fd_sys_lookup_elem(void *ptr)
+{
+        return ((struct bpf_map *)ptr)->id;
+}
diff --git a/kernel/bpf/map_in_map.h b/kernel/bpf/map_in_map.h
index 177fadb689dc..6183db9ec08c 100644
--- a/kernel/bpf/map_in_map.h
+++ b/kernel/bpf/map_in_map.h
@@ -19,5 +19,6 @@ bool bpf_map_meta_equal(const struct bpf_map *meta0,
 void *bpf_map_fd_get_ptr(struct bpf_map *map, struct file *map_file,
                          int ufd);
 void bpf_map_fd_put_ptr(void *ptr);
+u32 bpf_map_fd_sys_lookup_elem(void *ptr);
 
 #endif
diff --git a/kernel/bpf/stackmap.c b/kernel/bpf/stackmap.c
index 4dfd6f2ec2f9..31147d730abf 100644
--- a/kernel/bpf/stackmap.c
+++ b/kernel/bpf/stackmap.c
@@ -88,6 +88,7 @@ static struct bpf_map *stack_map_alloc(union bpf_attr *attr)
         smap->map.key_size = attr->key_size;
         smap->map.value_size = value_size;
         smap->map.max_entries = attr->max_entries;
+        smap->map.map_flags = attr->map_flags;
         smap->n_buckets = n_buckets;
         smap->map.pages = round_up(cost, PAGE_SIZE) >> PAGE_SHIFT;
 
diff --git a/kernel/bpf/syscall.c b/kernel/bpf/syscall.c
index 265a0d854e33..045646da97cc 100644
--- a/kernel/bpf/syscall.c
+++ b/kernel/bpf/syscall.c
@@ -22,8 +22,20 @@
 #include <linux/filter.h>
 #include <linux/version.h>
 #include <linux/kernel.h>
+#include <linux/idr.h>
+
+#define IS_FD_ARRAY(map) ((map)->map_type == BPF_MAP_TYPE_PROG_ARRAY || \
+                           (map)->map_type == BPF_MAP_TYPE_PERF_EVENT_ARRAY || \
+                           (map)->map_type == BPF_MAP_TYPE_CGROUP_ARRAY || \
+                           (map)->map_type == BPF_MAP_TYPE_ARRAY_OF_MAPS)
+#define IS_FD_HASH(map) ((map)->map_type == BPF_MAP_TYPE_HASH_OF_MAPS)
+#define IS_FD_MAP(map) (IS_FD_ARRAY(map) || IS_FD_HASH(map))
 
 DEFINE_PER_CPU(int, bpf_prog_active);
+static DEFINE_IDR(prog_idr);
+static DEFINE_SPINLOCK(prog_idr_lock);
+static DEFINE_IDR(map_idr);
+static DEFINE_SPINLOCK(map_idr_lock);
 
 int sysctl_unprivileged_bpf_disabled __read_mostly;
 
@@ -114,6 +126,37 @@ static void bpf_map_uncharge_memlock(struct bpf_map *map)
         free_uid(user);
 }
 
+static int bpf_map_alloc_id(struct bpf_map *map)
+{
+        int id;
+
+        spin_lock_bh(&map_idr_lock);
+        id = idr_alloc_cyclic(&map_idr, map, 1, INT_MAX, GFP_ATOMIC);
+        if (id > 0)
+                map->id = id;
+        spin_unlock_bh(&map_idr_lock);
+
+        if (WARN_ON_ONCE(!id))
+                return -ENOSPC;
+
+        return id > 0 ? 0 : id;
+}
+
+static void bpf_map_free_id(struct bpf_map *map, bool do_idr_lock)
+{
+        if (do_idr_lock)
+                spin_lock_bh(&map_idr_lock);
+        else
+                __acquire(&map_idr_lock);
+
+        idr_remove(&map_idr, map->id);
+
+        if (do_idr_lock)
+                spin_unlock_bh(&map_idr_lock);
+        else
+                __release(&map_idr_lock);
+}
+
 /* called from workqueue */
 static void bpf_map_free_deferred(struct work_struct *work)
 {
@@ -135,14 +178,21 @@ static void bpf_map_put_uref(struct bpf_map *map)
 /* decrement map refcnt and schedule it for freeing via workqueue
  * (unrelying map implementation ops->map_free() might sleep)
  */
-void bpf_map_put(struct bpf_map *map)
+static void __bpf_map_put(struct bpf_map *map, bool do_idr_lock)
 {
         if (atomic_dec_and_test(&map->refcnt)) {
+                /* bpf_map_free_id() must be called first */
+                bpf_map_free_id(map, do_idr_lock);
                 INIT_WORK(&map->work, bpf_map_free_deferred);
                 schedule_work(&map->work);
         }
 }
 
+void bpf_map_put(struct bpf_map *map)
+{
+        __bpf_map_put(map, true);
+}
+
 void bpf_map_put_with_uref(struct bpf_map *map)
 {
         bpf_map_put_uref(map);
@@ -166,10 +216,12 @@ static void bpf_map_show_fdinfo(struct seq_file *m, struct file *filp)
         const struct bpf_map *map = filp->private_data;
         const struct bpf_array *array;
         u32 owner_prog_type = 0;
+        u32 owner_jited = 0;
 
         if (map->map_type == BPF_MAP_TYPE_PROG_ARRAY) {
                 array = container_of(map, struct bpf_array, map);
                 owner_prog_type = array->owner_prog_type;
+                owner_jited = array->owner_jited;
         }
 
         seq_printf(m,
@@ -186,9 +238,12 @@ static void bpf_map_show_fdinfo(struct seq_file *m, struct file *filp)
                    map->map_flags,
                    map->pages * 1ULL << PAGE_SHIFT);
 
-        if (owner_prog_type)
+        if (owner_prog_type) {
                 seq_printf(m, "owner_prog_type:\t%u\n",
                            owner_prog_type);
+                seq_printf(m, "owner_jited:\t%u\n",
+                           owner_jited);
+        }
 }
 #endif
 
@@ -236,11 +291,22 @@ static int map_create(union bpf_attr *attr)
         if (err)
                 goto free_map_nouncharge;
 
-        err = bpf_map_new_fd(map);
-        if (err < 0)
-                /* failed to allocate fd */
+        err = bpf_map_alloc_id(map);
+        if (err)
                 goto free_map;
 
+        err = bpf_map_new_fd(map);
+        if (err < 0) {
+                /* failed to allocate fd.
+                 * bpf_map_put() is needed because the above
+                 * bpf_map_alloc_id() has published the map
+                 * to the userspace and the userspace may
+                 * have refcnt-ed it through BPF_MAP_GET_FD_BY_ID.
+                 */
+                bpf_map_put(map);
+                return err;
+        }
+
         trace_bpf_map_create(map, err);
         return err;
 
@@ -295,6 +361,28 @@ struct bpf_map *bpf_map_get_with_uref(u32 ufd)
         return map;
 }
 
+/* map_idr_lock should have been held */
+static struct bpf_map *bpf_map_inc_not_zero(struct bpf_map *map,
+                                            bool uref)
+{
+        int refold;
+
+        refold = __atomic_add_unless(&map->refcnt, 1, 0);
+
+        if (refold >= BPF_MAX_REFCNT) {
+                __bpf_map_put(map, false);
+                return ERR_PTR(-EBUSY);
+        }
+
+        if (!refold)
+                return ERR_PTR(-ENOENT);
+
+        if (uref)
+                atomic_inc(&map->usercnt);
+
+        return map;
+}
+
 int __weak bpf_stackmap_copy(struct bpf_map *map, void *key, void *value)
 {
         return -ENOTSUPP;
@@ -322,19 +410,18 @@ static int map_lookup_elem(union bpf_attr *attr)
         if (IS_ERR(map))
                 return PTR_ERR(map);
 
-        err = -ENOMEM;
-        key = kmalloc(map->key_size, GFP_USER);
-        if (!key)
+        key = memdup_user(ukey, map->key_size);
+        if (IS_ERR(key)) {
+                err = PTR_ERR(key);
                 goto err_put;
-
-        err = -EFAULT;
-        if (copy_from_user(key, ukey, map->key_size) != 0)
-                goto free_key;
+        }
 
         if (map->map_type == BPF_MAP_TYPE_PERCPU_HASH ||
             map->map_type == BPF_MAP_TYPE_LRU_PERCPU_HASH ||
             map->map_type == BPF_MAP_TYPE_PERCPU_ARRAY)
                 value_size = round_up(map->value_size, 8) * num_possible_cpus();
+        else if (IS_FD_MAP(map))
+                value_size = sizeof(u32);
         else
                 value_size = map->value_size;
 
@@ -350,9 +437,10 @@ static int map_lookup_elem(union bpf_attr *attr)
                 err = bpf_percpu_array_copy(map, key, value);
         } else if (map->map_type == BPF_MAP_TYPE_STACK_TRACE) {
                 err = bpf_stackmap_copy(map, key, value);
-        } else if (map->map_type == BPF_MAP_TYPE_ARRAY_OF_MAPS ||
-                   map->map_type == BPF_MAP_TYPE_HASH_OF_MAPS) {
-                err = -ENOTSUPP;
+        } else if (IS_FD_ARRAY(map)) {
+                err = bpf_fd_array_map_lookup_elem(map, key, value);
+        } else if (IS_FD_HASH(map)) {
+                err = bpf_fd_htab_map_lookup_elem(map, key, value);
         } else {
                 rcu_read_lock();
                 ptr = map->ops->map_lookup_elem(map, key);
@@ -402,14 +490,11 @@ static int map_update_elem(union bpf_attr *attr)
         if (IS_ERR(map))
                 return PTR_ERR(map);
 
-        err = -ENOMEM;
-        key = kmalloc(map->key_size, GFP_USER);
-        if (!key)
+        key = memdup_user(ukey, map->key_size);
+        if (IS_ERR(key)) {
+                err = PTR_ERR(key);
                 goto err_put;
-
-        err = -EFAULT;
-        if (copy_from_user(key, ukey, map->key_size) != 0)
-                goto free_key;
+        }
 
         if (map->map_type == BPF_MAP_TYPE_PERCPU_HASH ||
             map->map_type == BPF_MAP_TYPE_LRU_PERCPU_HASH ||
@@ -488,14 +573,11 @@ static int map_delete_elem(union bpf_attr *attr)
         if (IS_ERR(map))
                 return PTR_ERR(map);
 
-        err = -ENOMEM;
-        key = kmalloc(map->key_size, GFP_USER);
-        if (!key)
+        key = memdup_user(ukey, map->key_size);
+        if (IS_ERR(key)) {
+                err = PTR_ERR(key);
                 goto err_put;
-
-        err = -EFAULT;
-        if (copy_from_user(key, ukey, map->key_size) != 0)
-                goto free_key;
+        }
 
         preempt_disable();
         __this_cpu_inc(bpf_prog_active);
@@ -507,7 +589,6 @@ static int map_delete_elem(union bpf_attr *attr)
 
         if (!err)
                 trace_bpf_map_delete_elem(map, ufd, key);
-free_key:
         kfree(key);
 err_put:
         fdput(f);
@@ -536,14 +617,11 @@ static int map_get_next_key(union bpf_attr *attr)
                 return PTR_ERR(map);
 
         if (ukey) {
-                err = -ENOMEM;
-                key = kmalloc(map->key_size, GFP_USER);
-                if (!key)
+                key = memdup_user(ukey, map->key_size);
+                if (IS_ERR(key)) {
+                        err = PTR_ERR(key);
                         goto err_put;
-
-                err = -EFAULT;
-                if (copy_from_user(key, ukey, map->key_size) != 0)
-                        goto free_key;
+                }
         } else {
                 key = NULL;
         }
@@ -650,6 +728,42 @@ static void bpf_prog_uncharge_memlock(struct bpf_prog *prog)
         free_uid(user);
 }
 
+static int bpf_prog_alloc_id(struct bpf_prog *prog)
+{
+        int id;
+
+        spin_lock_bh(&prog_idr_lock);
+        id = idr_alloc_cyclic(&prog_idr, prog, 1, INT_MAX, GFP_ATOMIC);
+        if (id > 0)
+                prog->aux->id = id;
+        spin_unlock_bh(&prog_idr_lock);
+
+        /* id is in [1, INT_MAX) */
+        if (WARN_ON_ONCE(!id))
+                return -ENOSPC;
+
+        return id > 0 ? 0 : id;
+}
+
+static void bpf_prog_free_id(struct bpf_prog *prog, bool do_idr_lock)
+{
+        /* cBPF to eBPF migrations are currently not in the idr store. */
+        if (!prog->aux->id)
+                return;
+
+        if (do_idr_lock)
+                spin_lock_bh(&prog_idr_lock);
+        else
+                __acquire(&prog_idr_lock);
+
+        idr_remove(&prog_idr, prog->aux->id);
+
+        if (do_idr_lock)
+                spin_unlock_bh(&prog_idr_lock);
+        else
+                __release(&prog_idr_lock);
+}
+
 static void __bpf_prog_put_rcu(struct rcu_head *rcu)
 {
         struct bpf_prog_aux *aux = container_of(rcu, struct bpf_prog_aux, rcu);
@@ -659,14 +773,21 @@ static void __bpf_prog_put_rcu(struct rcu_head *rcu)
         bpf_prog_free(aux->prog);
 }
 
-void bpf_prog_put(struct bpf_prog *prog)
+static void __bpf_prog_put(struct bpf_prog *prog, bool do_idr_lock)
 {
         if (atomic_dec_and_test(&prog->aux->refcnt)) {
                 trace_bpf_prog_put_rcu(prog);
+                /* bpf_prog_free_id() must be called first */
+                bpf_prog_free_id(prog, do_idr_lock);
                 bpf_prog_kallsyms_del(prog);
                 call_rcu(&prog->aux->rcu, __bpf_prog_put_rcu);
         }
 }
+
+void bpf_prog_put(struct bpf_prog *prog)
+{
+        __bpf_prog_put(prog, true);
+}
 EXPORT_SYMBOL_GPL(bpf_prog_put);
 
 static int bpf_prog_release(struct inode *inode, struct file *filp)
@@ -748,6 +869,24 @@ struct bpf_prog *bpf_prog_inc(struct bpf_prog *prog)
 }
 EXPORT_SYMBOL_GPL(bpf_prog_inc);
 
+/* prog_idr_lock should have been held */
+static struct bpf_prog *bpf_prog_inc_not_zero(struct bpf_prog *prog)
+{
+        int refold;
+
+        refold = __atomic_add_unless(&prog->aux->refcnt, 1, 0);
+
+        if (refold >= BPF_MAX_REFCNT) {
+                __bpf_prog_put(prog, false);
+                return ERR_PTR(-EBUSY);
+        }
+
+        if (!refold)
+                return ERR_PTR(-ENOENT);
+
+        return prog;
+}
+
 static struct bpf_prog *__bpf_prog_get(u32 ufd, enum bpf_prog_type *type)
 {
         struct fd f = fdget(ufd);
@@ -815,7 +954,9 @@ static int bpf_prog_load(union bpf_attr *attr)
             attr->kern_version != LINUX_VERSION_CODE)
                 return -EINVAL;
 
-        if (type != BPF_PROG_TYPE_SOCKET_FILTER && !capable(CAP_SYS_ADMIN))
+        if (type != BPF_PROG_TYPE_SOCKET_FILTER &&
+            type != BPF_PROG_TYPE_CGROUP_SKB &&
+            !capable(CAP_SYS_ADMIN))
                 return -EPERM;
 
         /* plain bpf_prog allocation */
@@ -855,11 +996,22 @@ static int bpf_prog_load(union bpf_attr *attr)
         if (err < 0)
                 goto free_used_maps;
 
-        err = bpf_prog_new_fd(prog);
-        if (err < 0)
-                /* failed to allocate fd */
+        err = bpf_prog_alloc_id(prog);
+        if (err)
                 goto free_used_maps;
 
+        err = bpf_prog_new_fd(prog);
+        if (err < 0) {
+                /* failed to allocate fd.
+                 * bpf_prog_put() is needed because the above
+                 * bpf_prog_alloc_id() has published the prog
+                 * to the userspace and the userspace may
+                 * have refcnt-ed it through BPF_PROG_GET_FD_BY_ID.
+                 */
+                bpf_prog_put(prog);
+                return err;
+        }
+
         bpf_prog_kallsyms_add(prog);
         trace_bpf_prog_load(prog, err);
         return err;
@@ -919,6 +1071,9 @@ static int bpf_prog_attach(const union bpf_attr *attr)
         case BPF_CGROUP_INET_SOCK_CREATE:
                 ptype = BPF_PROG_TYPE_CGROUP_SOCK;
                 break;
+        case BPF_CGROUP_SOCK_OPS:
+                ptype = BPF_PROG_TYPE_SOCK_OPS;
+                break;
         default:
                 return -EINVAL;
         }
@@ -959,6 +1114,7 @@ static int bpf_prog_detach(const union bpf_attr *attr)
         case BPF_CGROUP_INET_INGRESS:
         case BPF_CGROUP_INET_EGRESS:
         case BPF_CGROUP_INET_SOCK_CREATE:
+        case BPF_CGROUP_SOCK_OPS:
                 cgrp = cgroup_get_from_fd(attr->target_fd);
                 if (IS_ERR(cgrp))
                         return PTR_ERR(cgrp);
@@ -973,6 +1129,7 @@ static int bpf_prog_detach(const union bpf_attr *attr)
 
         return ret;
 }
+
 #endif /* CONFIG_CGROUP_BPF */
 
 #define BPF_PROG_TEST_RUN_LAST_FIELD test.duration
@@ -997,6 +1154,237 @@ static int bpf_prog_test_run(const union bpf_attr *attr,
         return ret;
 }
 
+#define BPF_OBJ_GET_NEXT_ID_LAST_FIELD next_id
+
+static int bpf_obj_get_next_id(const union bpf_attr *attr,
+                               union bpf_attr __user *uattr,
+                               struct idr *idr,
+                               spinlock_t *lock)
+{
+        u32 next_id = attr->start_id;
+        int err = 0;
+
+        if (CHECK_ATTR(BPF_OBJ_GET_NEXT_ID) || next_id >= INT_MAX)
+                return -EINVAL;
+
+        if (!capable(CAP_SYS_ADMIN))
+                return -EPERM;
+
+        next_id++;
+        spin_lock_bh(lock);
+        if (!idr_get_next(idr, &next_id))
+                err = -ENOENT;
+        spin_unlock_bh(lock);
+
+        if (!err)
+                err = put_user(next_id, &uattr->next_id);
+
+        return err;
+}
+
+#define BPF_PROG_GET_FD_BY_ID_LAST_FIELD prog_id
+
+static int bpf_prog_get_fd_by_id(const union bpf_attr *attr)
+{
+        struct bpf_prog *prog;
+        u32 id = attr->prog_id;
+        int fd;
+
+        if (CHECK_ATTR(BPF_PROG_GET_FD_BY_ID))
+                return -EINVAL;
+
+        if (!capable(CAP_SYS_ADMIN))
+                return -EPERM;
+
+        spin_lock_bh(&prog_idr_lock);
+        prog = idr_find(&prog_idr, id);
+        if (prog)
+                prog = bpf_prog_inc_not_zero(prog);
+        else
+                prog = ERR_PTR(-ENOENT);
+        spin_unlock_bh(&prog_idr_lock);
+
+        if (IS_ERR(prog))
+                return PTR_ERR(prog);
+
+        fd = bpf_prog_new_fd(prog);
+        if (fd < 0)
+                bpf_prog_put(prog);
+
+        return fd;
+}
+
+#define BPF_MAP_GET_FD_BY_ID_LAST_FIELD map_id
+
+static int bpf_map_get_fd_by_id(const union bpf_attr *attr)
+{
+        struct bpf_map *map;
+        u32 id = attr->map_id;
+        int fd;
+
+        if (CHECK_ATTR(BPF_MAP_GET_FD_BY_ID))
+                return -EINVAL;
+
+        if (!capable(CAP_SYS_ADMIN))
+                return -EPERM;
+
+        spin_lock_bh(&map_idr_lock);
+        map = idr_find(&map_idr, id);
+        if (map)
+                map = bpf_map_inc_not_zero(map, true);
+        else
+                map = ERR_PTR(-ENOENT);
+        spin_unlock_bh(&map_idr_lock);
+
+        if (IS_ERR(map))
+                return PTR_ERR(map);
+
+        fd = bpf_map_new_fd(map);
+        if (fd < 0)
+                bpf_map_put(map);
+
+        return fd;
+}
+
+static int check_uarg_tail_zero(void __user *uaddr,
+                                size_t expected_size,
+                                size_t actual_size)
+{
+        unsigned char __user *addr;
+        unsigned char __user *end;
+        unsigned char val;
+        int err;
+
+        if (actual_size <= expected_size)
+                return 0;
+
+        addr = uaddr + expected_size;
+        end  = uaddr + actual_size;
+
+        for (; addr < end; addr++) {
+                err = get_user(val, addr);
+                if (err)
+                        return err;
+                if (val)
+                        return -E2BIG;
+        }
+
+        return 0;
+}
+
+static int bpf_prog_get_info_by_fd(struct bpf_prog *prog,
+                                   const union bpf_attr *attr,
+                                   union bpf_attr __user *uattr)
+{
+        struct bpf_prog_info __user *uinfo = u64_to_user_ptr(attr->info.info);
+        struct bpf_prog_info info = {};
+        u32 info_len = attr->info.info_len;
+        char __user *uinsns;
+        u32 ulen;
+        int err;
+
+        err = check_uarg_tail_zero(uinfo, sizeof(info), info_len);
+        if (err)
+                return err;
+        info_len = min_t(u32, sizeof(info), info_len);
+
+        if (copy_from_user(&info, uinfo, info_len))
+                return err;
+
+        info.type = prog->type;
+        info.id = prog->aux->id;
+
+        memcpy(info.tag, prog->tag, sizeof(prog->tag));
+
+        if (!capable(CAP_SYS_ADMIN)) {
+                info.jited_prog_len = 0;
+                info.xlated_prog_len = 0;
+                goto done;
+        }
+
+        ulen = info.jited_prog_len;
+        info.jited_prog_len = prog->jited_len;
+        if (info.jited_prog_len && ulen) {
+                uinsns = u64_to_user_ptr(info.jited_prog_insns);
+                ulen = min_t(u32, info.jited_prog_len, ulen);
+                if (copy_to_user(uinsns, prog->bpf_func, ulen))
+                        return -EFAULT;
+        }
+
+        ulen = info.xlated_prog_len;
+        info.xlated_prog_len = bpf_prog_size(prog->len);
+        if (info.xlated_prog_len && ulen) {
+                uinsns = u64_to_user_ptr(info.xlated_prog_insns);
+                ulen = min_t(u32, info.xlated_prog_len, ulen);
+                if (copy_to_user(uinsns, prog->insnsi, ulen))
+                        return -EFAULT;
+        }
+
+done:
+        if (copy_to_user(uinfo, &info, info_len) ||
+            put_user(info_len, &uattr->info.info_len))
+                return -EFAULT;
+
+        return 0;
+}
+
+static int bpf_map_get_info_by_fd(struct bpf_map *map,
+                                  const union bpf_attr *attr,
+                                  union bpf_attr __user *uattr)
+{
+        struct bpf_map_info __user *uinfo = u64_to_user_ptr(attr->info.info);
+        struct bpf_map_info info = {};
+        u32 info_len = attr->info.info_len;
+        int err;
+
+        err = check_uarg_tail_zero(uinfo, sizeof(info), info_len);
+        if (err)
+                return err;
+        info_len = min_t(u32, sizeof(info), info_len);
+
+        info.type = map->map_type;
+        info.id = map->id;
+        info.key_size = map->key_size;
+        info.value_size = map->value_size;
+        info.max_entries = map->max_entries;
+        info.map_flags = map->map_flags;
+
+        if (copy_to_user(uinfo, &info, info_len) ||
+            put_user(info_len, &uattr->info.info_len))
+                return -EFAULT;
+
+        return 0;
+}
+
+#define BPF_OBJ_GET_INFO_BY_FD_LAST_FIELD info.info
+
+static int bpf_obj_get_info_by_fd(const union bpf_attr *attr,
+                                  union bpf_attr __user *uattr)
+{
+        int ufd = attr->info.bpf_fd;
+        struct fd f;
+        int err;
+
+        if (CHECK_ATTR(BPF_OBJ_GET_INFO_BY_FD))
+                return -EINVAL;
+
+        f = fdget(ufd);
+        if (!f.file)
+                return -EBADFD;
+
+        if (f.file->f_op == &bpf_prog_fops)
+                err = bpf_prog_get_info_by_fd(f.file->private_data, attr,
+                                              uattr);
+        else if (f.file->f_op == &bpf_map_fops)
+                err = bpf_map_get_info_by_fd(f.file->private_data, attr,
+                                             uattr);
+        else
+                err = -EINVAL;
+
+        fdput(f);
+        return err;
+}
+
 SYSCALL_DEFINE3(bpf, int, cmd, union bpf_attr __user *, uattr, unsigned int, size)
 {
         union bpf_attr attr = {};
@@ -1016,23 +1404,10 @@ SYSCALL_DEFINE3(bpf, int, cmd, union bpf_attr __user *, uattr, unsigned int, siz
          * user-space does not rely on any kernel feature
          * extensions we dont know about yet.
          */
-        if (size > sizeof(attr)) {
-                unsigned char __user *addr;
-                unsigned char __user *end;
-                unsigned char val;
-
-                addr = (void __user *)uattr + sizeof(attr);
-                end  = (void __user *)uattr + size;
-
-                for (; addr < end; addr++) {
-                        err = get_user(val, addr);
-                        if (err)
-                                return err;
-                        if (val)
-                                return -E2BIG;
-                }
-                size = sizeof(attr);
-        }
+        err = check_uarg_tail_zero(uattr, sizeof(attr), size);
+        if (err)
+                return err;
+        size = min_t(u32, size, sizeof(attr));
 
         /* copy attributes from user space, may be less than sizeof(bpf_attr) */
         if (copy_from_user(&attr, uattr, size) != 0)
@@ -1074,6 +1449,23 @@ SYSCALL_DEFINE3(bpf, int, cmd, union bpf_attr __user *, uattr, unsigned int, siz
         case BPF_PROG_TEST_RUN:
                 err = bpf_prog_test_run(&attr, uattr);
                 break;
+        case BPF_PROG_GET_NEXT_ID:
+                err = bpf_obj_get_next_id(&attr, uattr,
+                                          &prog_idr, &prog_idr_lock);
+                break;
+        case BPF_MAP_GET_NEXT_ID:
+                err = bpf_obj_get_next_id(&attr, uattr,
+                                          &map_idr, &map_idr_lock);
+                break;
+        case BPF_PROG_GET_FD_BY_ID:
+                err = bpf_prog_get_fd_by_id(&attr);
+                break;
+        case BPF_MAP_GET_FD_BY_ID:
+                err = bpf_map_get_fd_by_id(&attr);
+                break;
+        case BPF_OBJ_GET_INFO_BY_FD:
+                err = bpf_obj_get_info_by_fd(&attr, uattr);
+                break;
         default:
                 err = -EINVAL;
                 break;
diff --git a/kernel/bpf/verifier.c b/kernel/bpf/verifier.c
index 1eddb713b815..af9e84a4944e 100644
--- a/kernel/bpf/verifier.c
+++ b/kernel/bpf/verifier.c
@@ -463,19 +463,22 @@ static const int caller_saved[CALLER_SAVED_REGS] = {
         BPF_REG_0, BPF_REG_1, BPF_REG_2, BPF_REG_3, BPF_REG_4, BPF_REG_5
 };
 
+static void mark_reg_not_init(struct bpf_reg_state *regs, u32 regno)
+{
+        BUG_ON(regno >= MAX_BPF_REG);
+
+        memset(&regs[regno], 0, sizeof(regs[regno]));
+        regs[regno].type = NOT_INIT;
+        regs[regno].min_value = BPF_REGISTER_MIN_RANGE;
+        regs[regno].max_value = BPF_REGISTER_MAX_RANGE;
+}
+
 static void init_reg_state(struct bpf_reg_state *regs)
 {
         int i;
 
-        for (i = 0; i < MAX_BPF_REG; i++) {
-                regs[i].type = NOT_INIT;
-                regs[i].imm = 0;
-                regs[i].min_value = BPF_REGISTER_MIN_RANGE;
-                regs[i].max_value = BPF_REGISTER_MAX_RANGE;
-                regs[i].min_align = 0;
-                regs[i].aux_off = 0;
-                regs[i].aux_off_align = 0;
-        }
+        for (i = 0; i < MAX_BPF_REG; i++)
+                mark_reg_not_init(regs, i);
 
         /* frame pointer */
         regs[BPF_REG_FP].type = FRAME_PTR;
@@ -501,6 +504,7 @@ static void reset_reg_range_values(struct bpf_reg_state *regs, u32 regno)
 {
         regs[regno].min_value = BPF_REGISTER_MIN_RANGE;
         regs[regno].max_value = BPF_REGISTER_MAX_RANGE;
+        regs[regno].value_from_signed = false;
         regs[regno].min_align = 0;
 }
 
@@ -543,20 +547,6 @@ static int check_reg_arg(struct bpf_reg_state *regs, u32 regno,
         return 0;
 }
 
-static int bpf_size_to_bytes(int bpf_size)
-{
-        if (bpf_size == BPF_W)
-                return 4;
-        else if (bpf_size == BPF_H)
-                return 2;
-        else if (bpf_size == BPF_B)
-                return 1;
-        else if (bpf_size == BPF_DW)
-                return 8;
-        else
-                return -EINVAL;
-}
-
 static bool is_spillable_regtype(enum bpf_reg_type type)
 {
         switch (type) {
@@ -755,15 +745,29 @@ static int check_packet_access(struct bpf_verifier_env *env, u32 regno, int off,
 }
 
 /* check access to 'struct bpf_context' fields */
-static int check_ctx_access(struct bpf_verifier_env *env, int off, int size,
+static int check_ctx_access(struct bpf_verifier_env *env, int insn_idx, int off, int size,
                             enum bpf_access_type t, enum bpf_reg_type *reg_type)
 {
+        struct bpf_insn_access_aux info = {
+                .reg_type = *reg_type,
+        };
+
         /* for analyzer ctx accesses are already validated and converted */
         if (env->analyzer_ops)
                 return 0;
 
         if (env->prog->aux->ops->is_valid_access &&
-            env->prog->aux->ops->is_valid_access(off, size, t, reg_type)) {
+            env->prog->aux->ops->is_valid_access(off, size, t, &info)) {
+                /* A non zero info.ctx_field_size indicates that this field is a
+                 * candidate for later verifier transformation to load the whole
+                 * field and then apply a mask when accessed with a narrower
+                 * access than actual ctx access size. A zero info.ctx_field_size
+                 * will only allow for whole field access and rejects any other
+                 * type of narrower access.
+                 */
+                env->insn_aux_data[insn_idx].ctx_field_size = info.ctx_field_size;
+                *reg_type = info.reg_type;
+
                 /* remember the offset of last byte accessed in ctx */
                 if (env->prog->aux->max_ctx_offset < off + size)
                         env->prog->aux->max_ctx_offset = off + size;
@@ -774,12 +778,13 @@ static int check_ctx_access(struct bpf_verifier_env *env, int off, int size,
         return -EACCES;
 }
 
-static bool is_pointer_value(struct bpf_verifier_env *env, int regno)
+static bool __is_pointer_value(bool allow_ptr_leaks,
+                               const struct bpf_reg_state *reg)
 {
-        if (env->allow_ptr_leaks)
+        if (allow_ptr_leaks)
                 return false;
 
-        switch (env->cur_state.regs[regno].type) {
+        switch (reg->type) {
         case UNKNOWN_VALUE:
         case CONST_IMM:
                 return false;
@@ -788,6 +793,11 @@ static bool is_pointer_value(struct bpf_verifier_env *env, int regno)
         }
 }
 
+static bool is_pointer_value(struct bpf_verifier_env *env, int regno)
+{
+        return __is_pointer_value(env->allow_ptr_leaks, &env->cur_state.regs[regno]);
+}
+
 static int check_pkt_ptr_alignment(const struct bpf_reg_state *reg,
                                    int off, int size, bool strict)
 {
@@ -808,11 +818,15 @@ static int check_pkt_ptr_alignment(const struct bpf_reg_state *reg,
                 reg_off += reg->aux_off;
         }
 
-        /* skb->data is NET_IP_ALIGN-ed, but for strict alignment checking
-         * we force this to 2 which is universally what architectures use
-         * when they don't set CONFIG_HAVE_EFFICIENT_UNALIGNED_ACCESS.
+        /* For platforms that do not have a Kconfig enabling
+         * CONFIG_HAVE_EFFICIENT_UNALIGNED_ACCESS the value of
+         * NET_IP_ALIGN is universally set to '2'.  And on platforms
+         * that do set CONFIG_HAVE_EFFICIENT_UNALIGNED_ACCESS, we get
+         * to this code only in strict mode where we want to emulate
+         * the NET_IP_ALIGN==2 checking.  Therefore use an
+         * unconditional IP align value of '2'.
          */
-        ip_align = strict ? 2 : NET_IP_ALIGN;
+        ip_align = 2;
         if ((ip_align + reg_off + off) % size != 0) {
                 verbose("misaligned packet access off %d+%d+%d size %d\n",
                         ip_align, reg_off, off, size);
@@ -839,9 +853,6 @@ static int check_ptr_alignment(struct bpf_verifier_env *env,
 {
         bool strict = env->strict_alignment;
 
-        if (!IS_ENABLED(CONFIG_HAVE_EFFICIENT_UNALIGNED_ACCESS))
-                strict = true;
-
         switch (reg->type) {
         case PTR_TO_PACKET:
                 return check_pkt_ptr_alignment(reg, off, size, strict);
@@ -864,7 +875,7 @@ static int check_ptr_alignment(struct bpf_verifier_env *env,
  * if t==write && value_regno==-1, some unknown value is stored into memory
  * if t==read && value_regno==-1, don't care what we read from memory
  */
-static int check_mem_access(struct bpf_verifier_env *env, u32 regno, int off,
+static int check_mem_access(struct bpf_verifier_env *env, int insn_idx, u32 regno, int off,
                             int bpf_size, enum bpf_access_type t,
                             int value_regno)
 {
@@ -907,7 +918,7 @@ static int check_mem_access(struct bpf_verifier_env *env, u32 regno, int off,
                         verbose("R%d leaks addr into ctx\n", value_regno);
                         return -EACCES;
                 }
-                err = check_ctx_access(env, off, size, t, &reg_type);
+                err = check_ctx_access(env, insn_idx, off, size, t, &reg_type);
                 if (!err && t == BPF_READ && value_regno >= 0) {
                         mark_reg_unknown_value_and_range(state->regs,
                                                          value_regno);
@@ -922,6 +933,10 @@ static int check_mem_access(struct bpf_verifier_env *env, u32 regno, int off,
                         verbose("invalid stack off=%d size=%d\n", off, size);
                         return -EACCES;
                 }
+
+                if (env->prog->aux->stack_depth < -off)
+                        env->prog->aux->stack_depth = -off;
+
                 if (t == BPF_WRITE) {
                         if (!env->allow_ptr_leaks &&
                             state->stack_slot_type[MAX_BPF_STACK + off] == STACK_SPILL &&
@@ -964,7 +979,7 @@ static int check_mem_access(struct bpf_verifier_env *env, u32 regno, int off,
         return err;
 }
 
-static int check_xadd(struct bpf_verifier_env *env, struct bpf_insn *insn)
+static int check_xadd(struct bpf_verifier_env *env, int insn_idx, struct bpf_insn *insn)
 {
         struct bpf_reg_state *regs = env->cur_state.regs;
         int err;
@@ -985,14 +1000,19 @@ static int check_xadd(struct bpf_verifier_env *env, struct bpf_insn *insn)
         if (err)
                 return err;
 
+        if (is_pointer_value(env, insn->src_reg)) {
+                verbose("R%d leaks addr into mem\n", insn->src_reg);
+                return -EACCES;
+        }
+
         /* check whether atomic_add can read the memory */
-        err = check_mem_access(env, insn->dst_reg, insn->off,
+        err = check_mem_access(env, insn_idx, insn->dst_reg, insn->off,
                                BPF_SIZE(insn->code), BPF_READ, -1);
         if (err)
                 return err;
 
         /* check whether atomic_add can write into the same memory */
-        return check_mem_access(env, insn->dst_reg, insn->off,
+        return check_mem_access(env, insn_idx, insn->dst_reg, insn->off,
                                 BPF_SIZE(insn->code), BPF_WRITE, -1);
 }
 
@@ -1028,6 +1048,9 @@ static int check_stack_boundary(struct bpf_verifier_env *env, int regno,
                 return -EACCES;
         }
 
+        if (env->prog->aux->stack_depth < -off)
+                env->prog->aux->stack_depth = -off;
+
         if (meta && meta->raw_mode) {
                 meta->access_size = access_size;
                 meta->regno = regno;
@@ -1335,8 +1358,8 @@ static void clear_all_pkt_pointers(struct bpf_verifier_env *env)
                 if (reg->type != PTR_TO_PACKET &&
                     reg->type != PTR_TO_PACKET_END)
                         continue;
-                reg->type = UNKNOWN_VALUE;
-                reg->imm = 0;
+                __mark_reg_unknown_value(state->spilled_regs,
+                                         i / BPF_REG_SIZE);
         }
 }
 
@@ -1345,7 +1368,6 @@ static int check_call(struct bpf_verifier_env *env, int func_id, int insn_idx)
         struct bpf_verifier_state *state = &env->cur_state;
         const struct bpf_func_proto *fn = NULL;
         struct bpf_reg_state *regs = state->regs;
-        struct bpf_reg_state *reg;
         struct bpf_call_arg_meta meta;
         bool changes_data;
         int i, err;
@@ -1406,17 +1428,14 @@ static int check_call(struct bpf_verifier_env *env, int func_id, int insn_idx)
          * is inferred from register state.
          */
         for (i = 0; i < meta.access_size; i++) {
-                err = check_mem_access(env, meta.regno, i, BPF_B, BPF_WRITE, -1);
+                err = check_mem_access(env, insn_idx, meta.regno, i, BPF_B, BPF_WRITE, -1);
                 if (err)
                         return err;
         }
 
         /* reset caller saved regs */
-        for (i = 0; i < CALLER_SAVED_REGS; i++) {
-                reg = regs + caller_saved[i];
-                reg->type = NOT_INIT;
-                reg->imm = 0;
-        }
+        for (i = 0; i < CALLER_SAVED_REGS; i++)
+                mark_reg_not_init(regs, caller_saved[i]);
 
         /* update return register */
         if (fn->ret_type == RET_INTEGER) {
@@ -1645,6 +1664,65 @@ static int evaluate_reg_alu(struct bpf_verifier_env *env, struct bpf_insn *insn)
         return 0;
 }
 
+static int evaluate_reg_imm_alu_unknown(struct bpf_verifier_env *env,
+                                        struct bpf_insn *insn)
+{
+        struct bpf_reg_state *regs = env->cur_state.regs;
+        struct bpf_reg_state *dst_reg = &regs[insn->dst_reg];
+        struct bpf_reg_state *src_reg = &regs[insn->src_reg];
+        u8 opcode = BPF_OP(insn->code);
+        s64 imm_log2 = __ilog2_u64((long long)dst_reg->imm);
+
+        /* BPF_X code with src_reg->type UNKNOWN_VALUE here. */
+        if (src_reg->imm > 0 && dst_reg->imm) {
+                switch (opcode) {
+                case BPF_ADD:
+                        /* dreg += sreg
+                         * where both have zero upper bits. Adding them
+                         * can only result making one more bit non-zero
+                         * in the larger value.
+                         * Ex. 0xffff (imm=48) + 1 (imm=63) = 0x10000 (imm=47)
+                         *     0xffff (imm=48) + 0xffff = 0x1fffe (imm=47)
+                         */
+                        dst_reg->imm = min(src_reg->imm, 63 - imm_log2);
+                        dst_reg->imm--;
+                        break;
+                case BPF_AND:
+                        /* dreg &= sreg
+                         * AND can not extend zero bits only shrink
+                         * Ex.  0x00..00ffffff
+                         *    & 0x0f..ffffffff
+                         *     ----------------
+                         *      0x00..00ffffff
+                         */
+                        dst_reg->imm = max(src_reg->imm, 63 - imm_log2);
+                        break;
+                case BPF_OR:
+                        /* dreg |= sreg
+                         * OR can only extend zero bits
+                         * Ex.  0x00..00ffffff
+                         *    | 0x0f..ffffffff
+                         *     ----------------
+                         *      0x0f..00ffffff
+                         */
+                        dst_reg->imm = min(src_reg->imm, 63 - imm_log2);
+                        break;
+                case BPF_SUB:
+                case BPF_MUL:
+                case BPF_RSH:
+                case BPF_LSH:
+                        /* These may be flushed out later */
+                default:
+                        mark_reg_unknown_value(regs, insn->dst_reg);
+                }
+        } else {
+                mark_reg_unknown_value(regs, insn->dst_reg);
+        }
+
+        dst_reg->type = UNKNOWN_VALUE;
+        return 0;
+}
+
 static int evaluate_reg_imm_alu(struct bpf_verifier_env *env,
                                 struct bpf_insn *insn)
 {
@@ -1654,6 +1732,9 @@ static int evaluate_reg_imm_alu(struct bpf_verifier_env *env,
         u8 opcode = BPF_OP(insn->code);
         u64 dst_imm = dst_reg->imm;
 
+        if (BPF_SRC(insn->code) == BPF_X && src_reg->type == UNKNOWN_VALUE)
+                return evaluate_reg_imm_alu_unknown(env, insn);
+
         /* dst_reg->type == CONST_IMM here. Simulate execution of insns
          * containing ALU ops. Don't care about overflow or negative
          * values, just add/sub/... them; registers are in u64.
@@ -1758,10 +1839,24 @@ static void adjust_reg_min_max_vals(struct bpf_verifier_env *env,
         dst_align = dst_reg->min_align;
 
         /* We don't know anything about what was done to this register, mark it
-         * as unknown.
+         * as unknown. Also, if both derived bounds came from signed/unsigned
+         * mixed compares and one side is unbounded, we cannot really do anything
+         * with them as boundaries cannot be trusted. Thus, arithmetic of two
+         * regs of such kind will get invalidated bounds on the dst side.
          */
-        if (min_val == BPF_REGISTER_MIN_RANGE &&
-            max_val == BPF_REGISTER_MAX_RANGE) {
+        if ((min_val == BPF_REGISTER_MIN_RANGE &&
+             max_val == BPF_REGISTER_MAX_RANGE) ||
+            (BPF_SRC(insn->code) == BPF_X &&
+             ((min_val != BPF_REGISTER_MIN_RANGE &&
+               max_val == BPF_REGISTER_MAX_RANGE) ||
+              (min_val == BPF_REGISTER_MIN_RANGE &&
+               max_val != BPF_REGISTER_MAX_RANGE) ||
+              (dst_reg->min_value != BPF_REGISTER_MIN_RANGE &&
+               dst_reg->max_value == BPF_REGISTER_MAX_RANGE) ||
+              (dst_reg->min_value == BPF_REGISTER_MIN_RANGE &&
+               dst_reg->max_value != BPF_REGISTER_MAX_RANGE)) &&
+             regs[insn->dst_reg].value_from_signed !=
+             regs[insn->src_reg].value_from_signed)) {
                 reset_reg_range_values(regs, insn->dst_reg);
                 return;
         }
@@ -1945,9 +2040,11 @@ static int check_alu_op(struct bpf_verifier_env *env, struct bpf_insn *insn)
                          */
                         regs[insn->dst_reg].type = CONST_IMM;
                         regs[insn->dst_reg].imm = insn->imm;
+                        regs[insn->dst_reg].id = 0;
                         regs[insn->dst_reg].max_value = insn->imm;
                         regs[insn->dst_reg].min_value = insn->imm;
                         regs[insn->dst_reg].min_align = calc_align(insn->imm);
+                        regs[insn->dst_reg].value_from_signed = false;
                 }
 
         } else if (opcode > BPF_END) {
@@ -2123,40 +2220,63 @@ static void reg_set_min_max(struct bpf_reg_state *true_reg,
                             struct bpf_reg_state *false_reg, u64 val,
                             u8 opcode)
 {
+        bool value_from_signed = true;
+        bool is_range = true;
+
         switch (opcode) {
         case BPF_JEQ:
                 /* If this is false then we know nothing Jon Snow, but if it is
                  * true then we know for sure.
                  */
                 true_reg->max_value = true_reg->min_value = val;
+                is_range = false;
                 break;
         case BPF_JNE:
                 /* If this is true we know nothing Jon Snow, but if it is false
                  * we know the value for sure;
                  */
                 false_reg->max_value = false_reg->min_value = val;
+                is_range = false;
                 break;
         case BPF_JGT:
-                /* Unsigned comparison, the minimum value is 0. */
-                false_reg->min_value = 0;
+                value_from_signed = false;
                 /* fallthrough */
         case BPF_JSGT:
+                if (true_reg->value_from_signed != value_from_signed)
+                        reset_reg_range_values(true_reg, 0);
+                if (false_reg->value_from_signed != value_from_signed)
+                        reset_reg_range_values(false_reg, 0);
+                if (opcode == BPF_JGT) {
+                        /* Unsigned comparison, the minimum value is 0. */
+                        false_reg->min_value = 0;
+                }
                 /* If this is false then we know the maximum val is val,
                  * otherwise we know the min val is val+1.
                  */
                 false_reg->max_value = val;
+                false_reg->value_from_signed = value_from_signed;
                 true_reg->min_value = val + 1;
+                true_reg->value_from_signed = value_from_signed;
                 break;
         case BPF_JGE:
-                /* Unsigned comparison, the minimum value is 0. */
-                false_reg->min_value = 0;
+                value_from_signed = false;
                 /* fallthrough */
         case BPF_JSGE:
+                if (true_reg->value_from_signed != value_from_signed)
+                        reset_reg_range_values(true_reg, 0);
+                if (false_reg->value_from_signed != value_from_signed)
+                        reset_reg_range_values(false_reg, 0);
+                if (opcode == BPF_JGE) {
+                        /* Unsigned comparison, the minimum value is 0. */
+                        false_reg->min_value = 0;
+                }
                 /* If this is false then we know the maximum value is val - 1,
                  * otherwise we know the mimimum value is val.
                  */
                 false_reg->max_value = val - 1;
+                false_reg->value_from_signed = value_from_signed;
                 true_reg->min_value = val;
+                true_reg->value_from_signed = value_from_signed;
                 break;
         default:
                 break;
@@ -2164,6 +2284,12 @@ static void reg_set_min_max(struct bpf_reg_state *true_reg,
 
         check_reg_overflow(false_reg);
         check_reg_overflow(true_reg);
+        if (is_range) {
+                if (__is_pointer_value(false, false_reg))
+                        reset_reg_range_values(false_reg, 0);
+                if (__is_pointer_value(false, true_reg))
+                        reset_reg_range_values(true_reg, 0);
+        }
 }
 
 /* Same as above, but for the case that dst_reg is a CONST_IMM reg and src_reg
@@ -2173,41 +2299,64 @@ static void reg_set_min_max_inv(struct bpf_reg_state *true_reg,
                                 struct bpf_reg_state *false_reg, u64 val,
                                 u8 opcode)
 {
+        bool value_from_signed = true;
+        bool is_range = true;
+
         switch (opcode) {
         case BPF_JEQ:
                 /* If this is false then we know nothing Jon Snow, but if it is
                  * true then we know for sure.
                  */
                 true_reg->max_value = true_reg->min_value = val;
+                is_range = false;
                 break;
         case BPF_JNE:
                 /* If this is true we know nothing Jon Snow, but if it is false
                  * we know the value for sure;
                  */
                 false_reg->max_value = false_reg->min_value = val;
+                is_range = false;
                 break;
         case BPF_JGT:
-                /* Unsigned comparison, the minimum value is 0. */
-                true_reg->min_value = 0;
+                value_from_signed = false;
                 /* fallthrough */
         case BPF_JSGT:
+                if (true_reg->value_from_signed != value_from_signed)
+                        reset_reg_range_values(true_reg, 0);
+                if (false_reg->value_from_signed != value_from_signed)
+                        reset_reg_range_values(false_reg, 0);
+                if (opcode == BPF_JGT) {
+                        /* Unsigned comparison, the minimum value is 0. */
+                        true_reg->min_value = 0;
+                }
                 /*
                  * If this is false, then the val is <= the register, if it is
                  * true the register <= to the val.
                  */
                 false_reg->min_value = val;
+                false_reg->value_from_signed = value_from_signed;
                 true_reg->max_value = val - 1;
+                true_reg->value_from_signed = value_from_signed;
                 break;
         case BPF_JGE:
-                /* Unsigned comparison, the minimum value is 0. */
-                true_reg->min_value = 0;
+                value_from_signed = false;
                 /* fallthrough */
         case BPF_JSGE:
+                if (true_reg->value_from_signed != value_from_signed)
+                        reset_reg_range_values(true_reg, 0);
+                if (false_reg->value_from_signed != value_from_signed)
+                        reset_reg_range_values(false_reg, 0);
+                if (opcode == BPF_JGE) {
+                        /* Unsigned comparison, the minimum value is 0. */
+                        true_reg->min_value = 0;
+                }
                 /* If this is false then constant < register, if it is true then
                  * the register < constant.
                  */
                 false_reg->min_value = val + 1;
+                false_reg->value_from_signed = value_from_signed;
                 true_reg->max_value = val;
+                true_reg->value_from_signed = value_from_signed;
                 break;
         default:
                 break;
@@ -2215,6 +2364,12 @@ static void reg_set_min_max_inv(struct bpf_reg_state *true_reg,
 
         check_reg_overflow(false_reg);
         check_reg_overflow(true_reg);
+        if (is_range) {
+                if (__is_pointer_value(false, false_reg))
+                        reset_reg_range_values(false_reg, 0);
+                if (__is_pointer_value(false, true_reg))
+                        reset_reg_range_values(true_reg, 0);
+        }
 }
 
 static void mark_map_reg(struct bpf_reg_state *regs, u32 regno, u32 id,
@@ -2402,6 +2557,7 @@ static int check_ld_imm(struct bpf_verifier_env *env, struct bpf_insn *insn)
 
                 regs[insn->dst_reg].type = CONST_IMM;
                 regs[insn->dst_reg].imm = imm;
+                regs[insn->dst_reg].id = 0;
                 return 0;
         }
 
@@ -2444,7 +2600,6 @@ static int check_ld_abs(struct bpf_verifier_env *env, struct bpf_insn *insn)
 {
         struct bpf_reg_state *regs = env->cur_state.regs;
         u8 mode = BPF_MODE(insn->code);
-        struct bpf_reg_state *reg;
         int i, err;
 
         if (!may_access_skb(env->prog->type)) {
@@ -2477,11 +2632,8 @@ static int check_ld_abs(struct bpf_verifier_env *env, struct bpf_insn *insn)
         }
 
         /* reset caller saved regs to unreadable */
-        for (i = 0; i < CALLER_SAVED_REGS; i++) {
-                reg = regs + caller_saved[i];
-                reg->type = NOT_INIT;
-                reg->imm = 0;
-        }
+        for (i = 0; i < CALLER_SAVED_REGS; i++)
+                mark_reg_not_init(regs, caller_saved[i]);
 
         /* mark destination R0 register as readable, since it contains
          * the value fetched from the packet
@@ -2692,7 +2844,8 @@ err_free:
 /* the following conditions reduce the number of explored insns
  * from ~140k to ~80k for ultra large programs that use a lot of ptr_to_packet
  */
-static bool compare_ptrs_to_packet(struct bpf_reg_state *old,
+static bool compare_ptrs_to_packet(struct bpf_verifier_env *env,
+                                   struct bpf_reg_state *old,
                                    struct bpf_reg_state *cur)
 {
         if (old->id != cur->id)
@@ -2735,7 +2888,7 @@ static bool compare_ptrs_to_packet(struct bpf_reg_state *old,
          * 'if (R4 > data_end)' and all further insn were already good with r=20,
          * so they will be good with r=30 and we can prune the search.
          */
-        if (old->off <= cur->off &&
+        if (!env->strict_alignment && old->off <= cur->off &&
             old->off >= old->range && cur->off >= cur->range)
                 return true;
 
@@ -2806,7 +2959,7 @@ static bool states_equal(struct bpf_verifier_env *env,
                         continue;
 
                 if (rold->type == PTR_TO_PACKET && rcur->type == PTR_TO_PACKET &&
-                    compare_ptrs_to_packet(rold, rcur))
+                    compare_ptrs_to_packet(env, rold, rcur))
                         continue;
 
                 return false;
@@ -2824,6 +2977,8 @@ static bool states_equal(struct bpf_verifier_env *env,
                         return false;
                 if (i % BPF_REG_SIZE)
                         continue;
+                if (old->stack_slot_type[i] != STACK_SPILL)
+                        continue;
                 if (memcmp(&old->spilled_regs[i / BPF_REG_SIZE],
                            &cur->spilled_regs[i / BPF_REG_SIZE],
                            sizeof(old->spilled_regs[0])))
@@ -2985,18 +3140,12 @@ static int do_check(struct bpf_verifier_env *env)
                         /* check that memory (src_reg + off) is readable,
                          * the state of dst_reg will be updated by this func
                          */
-                        err = check_mem_access(env, insn->src_reg, insn->off,
+                        err = check_mem_access(env, insn_idx, insn->src_reg, insn->off,
                                                BPF_SIZE(insn->code), BPF_READ,
                                                insn->dst_reg);
                         if (err)
                                 return err;
 
-                        if (BPF_SIZE(insn->code) != BPF_W &&
-                            BPF_SIZE(insn->code) != BPF_DW) {
-                                insn_idx++;
-                                continue;
-                        }
-
                         prev_src_type = &env->insn_aux_data[insn_idx].ptr_type;
 
                         if (*prev_src_type == NOT_INIT) {
@@ -3024,7 +3173,7 @@ static int do_check(struct bpf_verifier_env *env)
                         enum bpf_reg_type *prev_dst_type, dst_reg_type;
 
                         if (BPF_MODE(insn->code) == BPF_XADD) {
-                                err = check_xadd(env, insn);
+                                err = check_xadd(env, insn_idx, insn);
                                 if (err)
                                         return err;
                                 insn_idx++;
@@ -3043,7 +3192,7 @@ static int do_check(struct bpf_verifier_env *env)
                         dst_reg_type = regs[insn->dst_reg].type;
 
                         /* check that memory (dst_reg + off) is writeable */
-                        err = check_mem_access(env, insn->dst_reg, insn->off,
+                        err = check_mem_access(env, insn_idx, insn->dst_reg, insn->off,
                                                BPF_SIZE(insn->code), BPF_WRITE,
                                                insn->src_reg);
                         if (err)
@@ -3072,7 +3221,7 @@ static int do_check(struct bpf_verifier_env *env)
                                 return err;
 
                         /* check that memory (dst_reg + off) is writeable */
-                        err = check_mem_access(env, insn->dst_reg, insn->off,
+                        err = check_mem_access(env, insn_idx, insn->dst_reg, insn->off,
                                                BPF_SIZE(insn->code), BPF_WRITE,
                                                -1);
                         if (err)
@@ -3170,7 +3319,8 @@ process_bpf_exit:
                 insn_idx++;
         }
 
-        verbose("processed %d insns\n", insn_processed);
+        verbose("processed %d insns, stack depth %d\n",
+                insn_processed, env->prog->aux->stack_depth);
         return 0;
 }
 
@@ -3370,11 +3520,13 @@ static struct bpf_prog *bpf_patch_insn_data(struct bpf_verifier_env *env, u32 of
 static int convert_ctx_accesses(struct bpf_verifier_env *env)
 {
         const struct bpf_verifier_ops *ops = env->prog->aux->ops;
+        int i, cnt, size, ctx_field_size, delta = 0;
         const int insn_cnt = env->prog->len;
         struct bpf_insn insn_buf[16], *insn;
         struct bpf_prog *new_prog;
         enum bpf_access_type type;
-        int i, cnt, delta = 0;
+        bool is_narrower_load;
+        u32 target_size;
 
         if (ops->gen_prologue) {
                 cnt = ops->gen_prologue(insn_buf, env->seen_direct_write,
@@ -3414,12 +3566,52 @@ static int convert_ctx_accesses(struct bpf_verifier_env *env)
                 if (env->insn_aux_data[i + delta].ptr_type != PTR_TO_CTX)
                         continue;
 
-                cnt = ops->convert_ctx_access(type, insn, insn_buf, env->prog);
-                if (cnt == 0 || cnt >= ARRAY_SIZE(insn_buf)) {
+                ctx_field_size = env->insn_aux_data[i + delta].ctx_field_size;
+                size = BPF_LDST_BYTES(insn);
+
+                /* If the read access is a narrower load of the field,
+                 * convert to a 4/8-byte load, to minimum program type specific
+                 * convert_ctx_access changes. If conversion is successful,
+                 * we will apply proper mask to the result.
+                 */
+                is_narrower_load = size < ctx_field_size;
+                if (is_narrower_load) {
+                        u32 off = insn->off;
+                        u8 size_code;
+
+                        if (type == BPF_WRITE) {
+                                verbose("bpf verifier narrow ctx access misconfigured\n");
+                                return -EINVAL;
+                        }
+
+                        size_code = BPF_H;
+                        if (ctx_field_size == 4)
+                                size_code = BPF_W;
+                        else if (ctx_field_size == 8)
+                                size_code = BPF_DW;
+
+                        insn->off = off & ~(ctx_field_size - 1);
+                        insn->code = BPF_LDX | BPF_MEM | size_code;
+                }
+
+                target_size = 0;
+                cnt = ops->convert_ctx_access(type, insn, insn_buf, env->prog,
+                                              &target_size);
+                if (cnt == 0 || cnt >= ARRAY_SIZE(insn_buf) ||
+                    (ctx_field_size && !target_size)) {
                         verbose("bpf verifier is misconfigured\n");
                         return -EINVAL;
                 }
 
+                if (is_narrower_load && size < target_size) {
+                        if (ctx_field_size <= 4)
+                                insn_buf[cnt++] = BPF_ALU32_IMM(BPF_AND, insn->dst_reg,
+                                                                (1 << size * 8) - 1);
+                        else
+                                insn_buf[cnt++] = BPF_ALU64_IMM(BPF_AND, insn->dst_reg,
+                                                                (1 << size * 8) - 1);
+                }
+
                 new_prog = bpf_patch_insn_data(env, i + delta, insn_buf, cnt);
                 if (!new_prog)
                         return -ENOMEM;
@@ -3465,6 +3657,7 @@ static int fixup_bpf_calls(struct bpf_verifier_env *env)
                          * the program array.
                          */
                         prog->cb_access = 1;
+                        env->prog->aux->stack_depth = MAX_BPF_STACK;
 
                         /* mark bpf_tail_call as different opcode to avoid
                          * conditional branch in the interpeter for every normal
@@ -3472,7 +3665,7 @@ static int fixup_bpf_calls(struct bpf_verifier_env *env)
                          * that doesn't support bpf_tail_call yet
                          */
                         insn->imm = 0;
-                        insn->code |= BPF_X;
+                        insn->code = BPF_JMP | BPF_TAIL_CALL;
                         continue;
                 }
 
@@ -3584,10 +3777,10 @@ int bpf_check(struct bpf_prog **prog, union bpf_attr *attr)
         } else {
                 log_level = 0;
         }
-        if (attr->prog_flags & BPF_F_STRICT_ALIGNMENT)
+
+        env->strict_alignment = !!(attr->prog_flags & BPF_F_STRICT_ALIGNMENT);
+        if (!IS_ENABLED(CONFIG_HAVE_EFFICIENT_UNALIGNED_ACCESS))
                 env->strict_alignment = true;
-        else
-                env->strict_alignment = false;
 
         ret = replace_map_fd_with_map_ptr(env);
         if (ret < 0)
@@ -3693,7 +3886,10 @@ int bpf_analyzer(struct bpf_prog *prog, const struct bpf_ext_analyzer_ops *ops,
         mutex_lock(&bpf_verifier_lock);
 
         log_level = 0;
+
         env->strict_alignment = false;
+        if (!IS_ENABLED(CONFIG_HAVE_EFFICIENT_UNALIGNED_ACCESS))
+                env->strict_alignment = true;
 
         env->explored_states = kcalloc(env->prog->len,
                                        sizeof(struct bpf_verifier_state_list *),
diff --git a/kernel/cgroup/Makefile b/kernel/cgroup/Makefile
index 387348a40c64..ce693ccb8c58 100644
--- a/kernel/cgroup/Makefile
+++ b/kernel/cgroup/Makefile
@@ -4,3 +4,4 @@ obj-$(CONFIG_CGROUP_FREEZER) += freezer.o
 obj-$(CONFIG_CGROUP_PIDS) += pids.o
 obj-$(CONFIG_CGROUP_RDMA) += rdma.o
 obj-$(CONFIG_CPUSETS) += cpuset.o
+obj-$(CONFIG_CGROUP_DEBUG) += debug.o
diff --git a/kernel/cgroup/cgroup-internal.h b/kernel/cgroup/cgroup-internal.h
index 00f4d6bf048f..793565c05742 100644
--- a/kernel/cgroup/cgroup-internal.h
+++ b/kernel/cgroup/cgroup-internal.h
@@ -192,6 +192,8 @@ int cgroup_rmdir(struct kernfs_node *kn);
 int cgroup_show_path(struct seq_file *sf, struct kernfs_node *kf_node,
                      struct kernfs_root *kf_root);
 
+int cgroup_task_count(const struct cgroup *cgrp);
+
 /*
  * namespace.c
  */
diff --git a/kernel/cgroup/cgroup-v1.c b/kernel/cgroup/cgroup-v1.c
index 85d75152402d..7bf4b1533f34 100644
--- a/kernel/cgroup/cgroup-v1.c
+++ b/kernel/cgroup/cgroup-v1.c
@@ -334,19 +334,15 @@ static struct cgroup_pidlist *cgroup_pidlist_find_create(struct cgroup *cgrp,
 /**
  * cgroup_task_count - count the number of tasks in a cgroup.
  * @cgrp: the cgroup in question
- *
- * Return the number of tasks in the cgroup.  The returned number can be
- * higher than the actual number of tasks due to css_set references from
- * namespace roots and temporary usages.
  */
-static int cgroup_task_count(const struct cgroup *cgrp)
+int cgroup_task_count(const struct cgroup *cgrp)
 {
         int count = 0;
         struct cgrp_cset_link *link;
 
         spin_lock_irq(&css_set_lock);
         list_for_each_entry(link, &cgrp->cset_links, cset_link)
-                count += refcount_read(&link->cset->refcount);
+                count += link->cset->nr_tasks;
         spin_unlock_irq(&css_set_lock);
         return count;
 }
@@ -1263,150 +1259,3 @@ static int __init cgroup_no_v1(char *str)
         return 1;
 }
 __setup("cgroup_no_v1=", cgroup_no_v1);
-
-
-#ifdef CONFIG_CGROUP_DEBUG
-static struct cgroup_subsys_state *
-debug_css_alloc(struct cgroup_subsys_state *parent_css)
-{
-        struct cgroup_subsys_state *css = kzalloc(sizeof(*css), GFP_KERNEL);
-
-        if (!css)
-                return ERR_PTR(-ENOMEM);
-
-        return css;
-}
-
-static void debug_css_free(struct cgroup_subsys_state *css)
-{
-        kfree(css);
-}
-
-static u64 debug_taskcount_read(struct cgroup_subsys_state *css,
-                                struct cftype *cft)
-{
-        return cgroup_task_count(css->cgroup);
-}
-
-static u64 current_css_set_read(struct cgroup_subsys_state *css,
-                                struct cftype *cft)
-{
-        return (u64)(unsigned long)current->cgroups;
-}
-
-static u64 current_css_set_refcount_read(struct cgroup_subsys_state *css,
-                                         struct cftype *cft)
-{
-        u64 count;
-
-        rcu_read_lock();
-        count = refcount_read(&task_css_set(current)->refcount);
-        rcu_read_unlock();
-        return count;
-}
-
-static int current_css_set_cg_links_read(struct seq_file *seq, void *v)
-{
-        struct cgrp_cset_link *link;
-        struct css_set *cset;
-        char *name_buf;
-
-        name_buf = kmalloc(NAME_MAX + 1, GFP_KERNEL);
-        if (!name_buf)
-                return -ENOMEM;
-
-        spin_lock_irq(&css_set_lock);
-        rcu_read_lock();
-        cset = rcu_dereference(current->cgroups);
-        list_for_each_entry(link, &cset->cgrp_links, cgrp_link) {
-                struct cgroup *c = link->cgrp;
-
-                cgroup_name(c, name_buf, NAME_MAX + 1);
-                seq_printf(seq, "Root %d group %s\n",
-                           c->root->hierarchy_id, name_buf);
-        }
-        rcu_read_unlock();
-        spin_unlock_irq(&css_set_lock);
-        kfree(name_buf);
-        return 0;
-}
-
-#define MAX_TASKS_SHOWN_PER_CSS 25
-static int cgroup_css_links_read(struct seq_file *seq, void *v)
-{
-        struct cgroup_subsys_state *css = seq_css(seq);
-        struct cgrp_cset_link *link;
-
-        spin_lock_irq(&css_set_lock);
-        list_for_each_entry(link, &css->cgroup->cset_links, cset_link) {
-                struct css_set *cset = link->cset;
-                struct task_struct *task;
-                int count = 0;
-
-                seq_printf(seq, "css_set %pK\n", cset);
-
-                list_for_each_entry(task, &cset->tasks, cg_list) {
-                        if (count++ > MAX_TASKS_SHOWN_PER_CSS)
-                                goto overflow;
-                        seq_printf(seq, "  task %d\n", task_pid_vnr(task));
-                }
-
-                list_for_each_entry(task, &cset->mg_tasks, cg_list) {
-                        if (count++ > MAX_TASKS_SHOWN_PER_CSS)
-                                goto overflow;
-                        seq_printf(seq, "  task %d\n", task_pid_vnr(task));
-                }
-                continue;
-        overflow:
-                seq_puts(seq, "  ...\n");
-        }
-        spin_unlock_irq(&css_set_lock);
-        return 0;
-}
-
-static u64 releasable_read(struct cgroup_subsys_state *css, struct cftype *cft)
-{
-        return (!cgroup_is_populated(css->cgroup) &&
-                !css_has_online_children(&css->cgroup->self));
-}
-
-static struct cftype debug_files[] =  {
-        {
-                .name = "taskcount",
-                .read_u64 = debug_taskcount_read,
-        },
-
-        {
-                .name = "current_css_set",
-                .read_u64 = current_css_set_read,
-        },
-
-        {
-                .name = "current_css_set_refcount",
-                .read_u64 = current_css_set_refcount_read,
-        },
-
-        {
-                .name = "current_css_set_cg_links",
-                .seq_show = current_css_set_cg_links_read,
-        },
-
-        {
-                .name = "cgroup_css_links",
-                .seq_show = cgroup_css_links_read,
-        },
-
-        {
-                .name = "releasable",
-                .read_u64 = releasable_read,
-        },
-
-        { }     /* terminate */
-};
-
-struct cgroup_subsys debug_cgrp_subsys = {
-        .css_alloc = debug_css_alloc,
-        .css_free = debug_css_free,
-        .legacy_cftypes = debug_files,
-};
-#endif /* CONFIG_CGROUP_DEBUG */
diff --git a/kernel/cgroup/cgroup.c b/kernel/cgroup/cgroup.c
index c3c9a0e1b3c9..620794a20a33 100644
--- a/kernel/cgroup/cgroup.c
+++ b/kernel/cgroup/cgroup.c
@@ -573,6 +573,11 @@ static int css_set_count	= 1;	/* 1 for init_css_set */
 /**
  * css_set_populated - does a css_set contain any tasks?
  * @cset: target css_set
+ *
+ * css_set_populated() should be the same as !!cset->nr_tasks at steady
+ * state. However, css_set_populated() can be called while a task is being
+ * added to or removed from the linked list before the nr_tasks is
+ * properly updated. Hence, we can't just look at ->nr_tasks here.
  */
 static bool css_set_populated(struct css_set *cset)
 {
@@ -1542,10 +1547,56 @@ int cgroup_show_path(struct seq_file *sf, struct kernfs_node *kf_node,
         return len;
 }
 
+static int parse_cgroup_root_flags(char *data, unsigned int *root_flags)
+{
+        char *token;
+
+        *root_flags = 0;
+
+        if (!data)
+                return 0;
+
+        while ((token = strsep(&data, ",")) != NULL) {
+                if (!strcmp(token, "nsdelegate")) {
+                        *root_flags |= CGRP_ROOT_NS_DELEGATE;
+                        continue;
+                }
+
+                pr_err("cgroup2: unknown option \"%s\"\n", token);
+                return -EINVAL;
+        }
+
+        return 0;
+}
+
+static void apply_cgroup_root_flags(unsigned int root_flags)
+{
+        if (current->nsproxy->cgroup_ns == &init_cgroup_ns) {
+                if (root_flags & CGRP_ROOT_NS_DELEGATE)
+                        cgrp_dfl_root.flags |= CGRP_ROOT_NS_DELEGATE;
+                else
+                        cgrp_dfl_root.flags &= ~CGRP_ROOT_NS_DELEGATE;
+        }
+}
+
+static int cgroup_show_options(struct seq_file *seq, struct kernfs_root *kf_root)
+{
+        if (cgrp_dfl_root.flags & CGRP_ROOT_NS_DELEGATE)
+                seq_puts(seq, ",nsdelegate");
+        return 0;
+}
+
 static int cgroup_remount(struct kernfs_root *kf_root, int *flags, char *data)
 {
-        pr_err("remount is not allowed\n");
-        return -EINVAL;
+        unsigned int root_flags;
+        int ret;
+
+        ret = parse_cgroup_root_flags(data, &root_flags);
+        if (ret)
+                return ret;
+
+        apply_cgroup_root_flags(root_flags);
+        return 0;
 }
 
 /*
@@ -1598,6 +1649,7 @@ static void cgroup_enable_task_cg_lists(void)
                                 css_set_update_populated(cset, true);
                         list_add_tail(&p->cg_list, &cset->tasks);
                         get_css_set(cset);
+                        cset->nr_tasks++;
                 }
                 spin_unlock(&p->sighand->siglock);
         } while_each_thread(g, p);
@@ -1784,6 +1836,7 @@ static struct dentry *cgroup_mount(struct file_system_type *fs_type,
 {
         struct cgroup_namespace *ns = current->nsproxy->cgroup_ns;
         struct dentry *dentry;
+        int ret;
 
         get_cgroup_ns(ns);
 
@@ -1801,16 +1854,21 @@ static struct dentry *cgroup_mount(struct file_system_type *fs_type,
                 cgroup_enable_task_cg_lists();
 
         if (fs_type == &cgroup2_fs_type) {
-                if (data) {
-                        pr_err("cgroup2: unknown option \"%s\"\n", (char *)data);
+                unsigned int root_flags;
+
+                ret = parse_cgroup_root_flags(data, &root_flags);
+                if (ret) {
                         put_cgroup_ns(ns);
-                        return ERR_PTR(-EINVAL);
+                        return ERR_PTR(ret);
                 }
+
                 cgrp_dfl_visible = true;
                 cgroup_get_live(&cgrp_dfl_root.cgrp);
 
                 dentry = cgroup_do_mount(&cgroup2_fs_type, flags, &cgrp_dfl_root,
                                          CGROUP2_SUPER_MAGIC, ns);
+                if (!IS_ERR(dentry))
+                        apply_cgroup_root_flags(root_flags);
         } else {
                 dentry = cgroup1_mount(&cgroup_fs_type, flags, data,
                                        CGROUP_SUPER_MAGIC, ns);
@@ -2064,8 +2122,10 @@ static int cgroup_migrate_execute(struct cgroup_mgctx *mgctx)
                         struct css_set *to_cset = cset->mg_dst_cset;
 
                         get_css_set(to_cset);
+                        to_cset->nr_tasks++;
                         css_set_move_task(task, from_cset, to_cset, true);
                         put_css_set_locked(from_cset);
+                        from_cset->nr_tasks--;
                 }
         }
         spin_unlock_irq(&css_set_lock);
@@ -2355,27 +2415,14 @@ static int cgroup_procs_write_permission(struct task_struct *task,
                                          struct cgroup *dst_cgrp,
                                          struct kernfs_open_file *of)
 {
-        int ret = 0;
-
-        if (cgroup_on_dfl(dst_cgrp)) {
-                struct super_block *sb = of->file->f_path.dentry->d_sb;
-                struct cgroup *cgrp;
-                struct inode *inode;
-
-                spin_lock_irq(&css_set_lock);
-                cgrp = task_cgroup_from_root(task, &cgrp_dfl_root);
-                spin_unlock_irq(&css_set_lock);
-
-                while (!cgroup_is_descendant(dst_cgrp, cgrp))
-                        cgrp = cgroup_parent(cgrp);
+        struct super_block *sb = of->file->f_path.dentry->d_sb;
+        struct cgroup_namespace *ns = current->nsproxy->cgroup_ns;
+        struct cgroup *root_cgrp = ns->root_cset->dfl_cgrp;
+        struct cgroup *src_cgrp, *com_cgrp;
+        struct inode *inode;
+        int ret;
 
-                ret = -ENOMEM;
-                inode = kernfs_get_inode(sb, cgrp->procs_file.kn);
-                if (inode) {
-                        ret = inode_permission(inode, MAY_WRITE);
-                        iput(inode);
-                }
-        } else {
+        if (!cgroup_on_dfl(dst_cgrp)) {
                 const struct cred *cred = current_cred();
                 const struct cred *tcred = get_task_cred(task);
 
@@ -2383,14 +2430,47 @@ static int cgroup_procs_write_permission(struct task_struct *task,
                  * even if we're attaching all tasks in the thread group,
                  * we only need to check permissions on one of them.
                  */
-                if (!uid_eq(cred->euid, GLOBAL_ROOT_UID) &&
-                    !uid_eq(cred->euid, tcred->uid) &&
-                    !uid_eq(cred->euid, tcred->suid))
+                if (uid_eq(cred->euid, GLOBAL_ROOT_UID) ||
+                    uid_eq(cred->euid, tcred->uid) ||
+                    uid_eq(cred->euid, tcred->suid))
+                        ret = 0;
+                else
                         ret = -EACCES;
+
                 put_cred(tcred);
+                return ret;
         }
 
-        return ret;
+        /* find the source cgroup */
+        spin_lock_irq(&css_set_lock);
+        src_cgrp = task_cgroup_from_root(task, &cgrp_dfl_root);
+        spin_unlock_irq(&css_set_lock);
+
+        /* and the common ancestor */
+        com_cgrp = src_cgrp;
+        while (!cgroup_is_descendant(dst_cgrp, com_cgrp))
+                com_cgrp = cgroup_parent(com_cgrp);
+
+        /* %current should be authorized to migrate to the common ancestor */
+        inode = kernfs_get_inode(sb, com_cgrp->procs_file.kn);
+        if (!inode)
+                return -ENOMEM;
+
+        ret = inode_permission(inode, MAY_WRITE);
+        iput(inode);
+        if (ret)
+                return ret;
+
+        /*
+         * If namespaces are delegation boundaries, %current must be able
+         * to see both source and destination cgroups from its namespace.
+         */
+        if ((cgrp_dfl_root.flags & CGRP_ROOT_NS_DELEGATE) &&
+            (!cgroup_is_descendant(src_cgrp, root_cgrp) ||
+             !cgroup_is_descendant(dst_cgrp, root_cgrp)))
+                return -ENOENT;
+
+        return 0;
 }
 
 /*
@@ -2954,11 +3034,23 @@ static void cgroup_file_release(struct kernfs_open_file *of)
 static ssize_t cgroup_file_write(struct kernfs_open_file *of, char *buf,
                                  size_t nbytes, loff_t off)
 {
+        struct cgroup_namespace *ns = current->nsproxy->cgroup_ns;
         struct cgroup *cgrp = of->kn->parent->priv;
         struct cftype *cft = of->kn->priv;
         struct cgroup_subsys_state *css;
         int ret;
 
+        /*
+         * If namespaces are delegation boundaries, disallow writes to
+         * files in an non-init namespace root from inside the namespace
+         * except for the files explicitly marked delegatable -
+         * cgroup.procs and cgroup.subtree_control.
+         */
+        if ((cgrp->root->flags & CGRP_ROOT_NS_DELEGATE) &&
+            !(cft->flags & CFTYPE_NS_DELEGATABLE) &&
+            ns != &init_cgroup_ns && ns->root_cset->dfl_cgrp == cgrp)
+                return -EPERM;
+
         if (cft->write)
                 return cft->write(of, buf, nbytes, off);
 
@@ -3792,6 +3884,7 @@ static int cgroup_procs_show(struct seq_file *s, void *v)
 static struct cftype cgroup_base_files[] = {
         {
                 .name = "cgroup.procs",
+                .flags = CFTYPE_NS_DELEGATABLE,
                 .file_offset = offsetof(struct cgroup, procs_file),
                 .release = cgroup_procs_release,
                 .seq_start = cgroup_procs_start,
@@ -3805,6 +3898,7 @@ static struct cftype cgroup_base_files[] = {
         },
         {
                 .name = "cgroup.subtree_control",
+                .flags = CFTYPE_NS_DELEGATABLE,
                 .seq_show = cgroup_subtree_control_show,
                 .write = cgroup_subtree_control_write,
         },
@@ -4265,6 +4359,11 @@ static void kill_css(struct cgroup_subsys_state *css)
 {
         lockdep_assert_held(&cgroup_mutex);
 
+        if (css->flags & CSS_DYING)
+                return;
+
+        css->flags |= CSS_DYING;
+
         /*
          * This must happen before css is disassociated with its cgroup.
          * See seq_css() for details.
@@ -4388,6 +4487,7 @@ int cgroup_rmdir(struct kernfs_node *kn)
 }
 
 static struct kernfs_syscall_ops cgroup_kf_syscall_ops = {
+        .show_options           = cgroup_show_options,
         .remount_fs             = cgroup_remount,
         .mkdir                  = cgroup_mkdir,
         .rmdir                  = cgroup_rmdir,
@@ -4784,6 +4884,7 @@ void cgroup_post_fork(struct task_struct *child)
                 cset = task_css_set(current);
                 if (list_empty(&child->cg_list)) {
                         get_css_set(cset);
+                        cset->nr_tasks++;
                         css_set_move_task(child, NULL, cset, false);
                 }
                 spin_unlock_irq(&css_set_lock);
@@ -4833,6 +4934,7 @@ void cgroup_exit(struct task_struct *tsk)
         if (!list_empty(&tsk->cg_list)) {
                 spin_lock_irq(&css_set_lock);
                 css_set_move_task(tsk, cset, NULL, false);
+                cset->nr_tasks--;
                 spin_unlock_irq(&css_set_lock);
         } else {
                 get_css_set(cset);
diff --git a/kernel/cgroup/cpuset.c b/kernel/cgroup/cpuset.c
index f6501f4f6040..ca8376e5008c 100644
--- a/kernel/cgroup/cpuset.c
+++ b/kernel/cgroup/cpuset.c
@@ -176,9 +176,9 @@ typedef enum {
 } cpuset_flagbits_t;
 
 /* convenient tests for these bits */
-static inline bool is_cpuset_online(const struct cpuset *cs)
+static inline bool is_cpuset_online(struct cpuset *cs)
 {
-        return test_bit(CS_ONLINE, &cs->flags);
+        return test_bit(CS_ONLINE, &cs->flags) && !css_is_dying(&cs->css);
 }
 
 static inline int is_cpu_exclusive(const struct cpuset *cs)
@@ -1038,40 +1038,25 @@ static void cpuset_post_attach(void)
  * @tsk: the task to change
  * @newmems: new nodes that the task will be set
  *
- * In order to avoid seeing no nodes if the old and new nodes are disjoint,
- * we structure updates as setting all new allowed nodes, then clearing newly
- * disallowed ones.
+ * We use the mems_allowed_seq seqlock to safely update both tsk->mems_allowed
+ * and rebind an eventual tasks' mempolicy. If the task is allocating in
+ * parallel, it might temporarily see an empty intersection, which results in
+ * a seqlock check and retry before OOM or allocation failure.
  */
 static void cpuset_change_task_nodemask(struct task_struct *tsk,
                                         nodemask_t *newmems)
 {
-        bool need_loop;
-
         task_lock(tsk);
-        /*
-         * Determine if a loop is necessary if another thread is doing
-         * read_mems_allowed_begin().  If at least one node remains unchanged and
-         * tsk does not have a mempolicy, then an empty nodemask will not be
-         * possible when mems_allowed is larger than a word.
-         */
-        need_loop = task_has_mempolicy(tsk) ||
-                        !nodes_intersects(*newmems, tsk->mems_allowed);
 
-        if (need_loop) {
-                local_irq_disable();
-                write_seqcount_begin(&tsk->mems_allowed_seq);
-        }
+        local_irq_disable();
+        write_seqcount_begin(&tsk->mems_allowed_seq);
 
         nodes_or(tsk->mems_allowed, tsk->mems_allowed, *newmems);
-        mpol_rebind_task(tsk, newmems, MPOL_REBIND_STEP1);
-
-        mpol_rebind_task(tsk, newmems, MPOL_REBIND_STEP2);
+        mpol_rebind_task(tsk, newmems);
         tsk->mems_allowed = *newmems;
 
-        if (need_loop) {
-                write_seqcount_end(&tsk->mems_allowed_seq);
-                local_irq_enable();
-        }
+        write_seqcount_end(&tsk->mems_allowed_seq);
+        local_irq_enable();
 
         task_unlock(tsk);
 }
diff --git a/kernel/cgroup/debug.c b/kernel/cgroup/debug.c
new file mode 100644
index 000000000000..dac46af22782
--- /dev/null
+++ b/kernel/cgroup/debug.c
@@ -0,0 +1,357 @@
+/*
+ * Debug controller
+ *
+ * WARNING: This controller is for cgroup core debugging only.
+ * Its interfaces are unstable and subject to changes at any time.
+ */
+#include <linux/ctype.h>
+#include <linux/mm.h>
+#include <linux/slab.h>
+
+#include "cgroup-internal.h"
+
+static struct cgroup_subsys_state *
+debug_css_alloc(struct cgroup_subsys_state *parent_css)
+{
+        struct cgroup_subsys_state *css = kzalloc(sizeof(*css), GFP_KERNEL);
+
+        if (!css)
+                return ERR_PTR(-ENOMEM);
+
+        return css;
+}
+
+static void debug_css_free(struct cgroup_subsys_state *css)
+{
+        kfree(css);
+}
+
+/*
+ * debug_taskcount_read - return the number of tasks in a cgroup.
+ * @cgrp: the cgroup in question
+ */
+static u64 debug_taskcount_read(struct cgroup_subsys_state *css,
+                                struct cftype *cft)
+{
+        return cgroup_task_count(css->cgroup);
+}
+
+static int current_css_set_read(struct seq_file *seq, void *v)
+{
+        struct kernfs_open_file *of = seq->private;
+        struct css_set *cset;
+        struct cgroup_subsys *ss;
+        struct cgroup_subsys_state *css;
+        int i, refcnt;
+
+        if (!cgroup_kn_lock_live(of->kn, false))
+                return -ENODEV;
+
+        spin_lock_irq(&css_set_lock);
+        rcu_read_lock();
+        cset = rcu_dereference(current->cgroups);
+        refcnt = refcount_read(&cset->refcount);
+        seq_printf(seq, "css_set %pK %d", cset, refcnt);
+        if (refcnt > cset->nr_tasks)
+                seq_printf(seq, " +%d", refcnt - cset->nr_tasks);
+        seq_puts(seq, "\n");
+
+        /*
+         * Print the css'es stored in the current css_set.
+         */
+        for_each_subsys(ss, i) {
+                css = cset->subsys[ss->id];
+                if (!css)
+                        continue;
+                seq_printf(seq, "%2d: %-4s\t- %lx[%d]\n", ss->id, ss->name,
+                          (unsigned long)css, css->id);
+        }
+        rcu_read_unlock();
+        spin_unlock_irq(&css_set_lock);
+        cgroup_kn_unlock(of->kn);
+        return 0;
+}
+
+static u64 current_css_set_refcount_read(struct cgroup_subsys_state *css,
+                                         struct cftype *cft)
+{
+        u64 count;
+
+        rcu_read_lock();
+        count = refcount_read(&task_css_set(current)->refcount);
+        rcu_read_unlock();
+        return count;
+}
+
+static int current_css_set_cg_links_read(struct seq_file *seq, void *v)
+{
+        struct cgrp_cset_link *link;
+        struct css_set *cset;
+        char *name_buf;
+
+        name_buf = kmalloc(NAME_MAX + 1, GFP_KERNEL);
+        if (!name_buf)
+                return -ENOMEM;
+
+        spin_lock_irq(&css_set_lock);
+        rcu_read_lock();
+        cset = rcu_dereference(current->cgroups);
+        list_for_each_entry(link, &cset->cgrp_links, cgrp_link) {
+                struct cgroup *c = link->cgrp;
+
+                cgroup_name(c, name_buf, NAME_MAX + 1);
+                seq_printf(seq, "Root %d group %s\n",
+                           c->root->hierarchy_id, name_buf);
+        }
+        rcu_read_unlock();
+        spin_unlock_irq(&css_set_lock);
+        kfree(name_buf);
+        return 0;
+}
+
+#define MAX_TASKS_SHOWN_PER_CSS 25
+static int cgroup_css_links_read(struct seq_file *seq, void *v)
+{
+        struct cgroup_subsys_state *css = seq_css(seq);
+        struct cgrp_cset_link *link;
+        int dead_cnt = 0, extra_refs = 0;
+
+        spin_lock_irq(&css_set_lock);
+        list_for_each_entry(link, &css->cgroup->cset_links, cset_link) {
+                struct css_set *cset = link->cset;
+                struct task_struct *task;
+                int count = 0;
+                int refcnt = refcount_read(&cset->refcount);
+
+                seq_printf(seq, " %d", refcnt);
+                if (refcnt - cset->nr_tasks > 0) {
+                        int extra = refcnt - cset->nr_tasks;
+
+                        seq_printf(seq, " +%d", extra);
+                        /*
+                         * Take out the one additional reference in
+                         * init_css_set.
+                         */
+                        if (cset == &init_css_set)
+                                extra--;
+                        extra_refs += extra;
+                }
+                seq_puts(seq, "\n");
+
+                list_for_each_entry(task, &cset->tasks, cg_list) {
+                        if (count++ <= MAX_TASKS_SHOWN_PER_CSS)
+                                seq_printf(seq, "  task %d\n",
+                                           task_pid_vnr(task));
+                }
+
+                list_for_each_entry(task, &cset->mg_tasks, cg_list) {
+                        if (count++ <= MAX_TASKS_SHOWN_PER_CSS)
+                                seq_printf(seq, "  task %d\n",
+                                           task_pid_vnr(task));
+                }
+                /* show # of overflowed tasks */
+                if (count > MAX_TASKS_SHOWN_PER_CSS)
+                        seq_printf(seq, "  ... (%d)\n",
+                                   count - MAX_TASKS_SHOWN_PER_CSS);
+
+                if (cset->dead) {
+                        seq_puts(seq, "    [dead]\n");
+                        dead_cnt++;
+                }
+
+                WARN_ON(count != cset->nr_tasks);
+        }
+        spin_unlock_irq(&css_set_lock);
+
+        if (!dead_cnt && !extra_refs)
+                return 0;
+
+        seq_puts(seq, "\n");
+        if (extra_refs)
+                seq_printf(seq, "extra references = %d\n", extra_refs);
+        if (dead_cnt)
+                seq_printf(seq, "dead css_sets = %d\n", dead_cnt);
+
+        return 0;
+}
+
+static int cgroup_subsys_states_read(struct seq_file *seq, void *v)
+{
+        struct kernfs_open_file *of = seq->private;
+        struct cgroup *cgrp;
+        struct cgroup_subsys *ss;
+        struct cgroup_subsys_state *css;
+        char pbuf[16];
+        int i;
+
+        cgrp = cgroup_kn_lock_live(of->kn, false);
+        if (!cgrp)
+                return -ENODEV;
+
+        for_each_subsys(ss, i) {
+                css = rcu_dereference_check(cgrp->subsys[ss->id], true);
+                if (!css)
+                        continue;
+
+                pbuf[0] = '\0';
+
+                /* Show the parent CSS if applicable*/
+                if (css->parent)
+                        snprintf(pbuf, sizeof(pbuf) - 1, " P=%d",
+                                 css->parent->id);
+                seq_printf(seq, "%2d: %-4s\t- %lx[%d] %d%s\n", ss->id, ss->name,
+                          (unsigned long)css, css->id,
+                          atomic_read(&css->online_cnt), pbuf);
+        }
+
+        cgroup_kn_unlock(of->kn);
+        return 0;
+}
+
+static void cgroup_masks_read_one(struct seq_file *seq, const char *name,
+                                  u16 mask)
+{
+        struct cgroup_subsys *ss;
+        int ssid;
+        bool first = true;
+
+        seq_printf(seq, "%-17s: ", name);
+        for_each_subsys(ss, ssid) {
+                if (!(mask & (1 << ssid)))
+                        continue;
+                if (!first)
+                        seq_puts(seq, ", ");
+                seq_puts(seq, ss->name);
+                first = false;
+        }
+        seq_putc(seq, '\n');
+}
+
+static int cgroup_masks_read(struct seq_file *seq, void *v)
+{
+        struct kernfs_open_file *of = seq->private;
+        struct cgroup *cgrp;
+
+        cgrp = cgroup_kn_lock_live(of->kn, false);
+        if (!cgrp)
+                return -ENODEV;
+
+        cgroup_masks_read_one(seq, "subtree_control", cgrp->subtree_control);
+        cgroup_masks_read_one(seq, "subtree_ss_mask", cgrp->subtree_ss_mask);
+
+        cgroup_kn_unlock(of->kn);
+        return 0;
+}
+
+static u64 releasable_read(struct cgroup_subsys_state *css, struct cftype *cft)
+{
+        return (!cgroup_is_populated(css->cgroup) &&
+                !css_has_online_children(&css->cgroup->self));
+}
+
+static struct cftype debug_legacy_files[] =  {
+        {
+                .name = "taskcount",
+                .read_u64 = debug_taskcount_read,
+        },
+
+        {
+                .name = "current_css_set",
+                .seq_show = current_css_set_read,
+                .flags = CFTYPE_ONLY_ON_ROOT,
+        },
+
+        {
+                .name = "current_css_set_refcount",
+                .read_u64 = current_css_set_refcount_read,
+                .flags = CFTYPE_ONLY_ON_ROOT,
+        },
+
+        {
+                .name = "current_css_set_cg_links",
+                .seq_show = current_css_set_cg_links_read,
+                .flags = CFTYPE_ONLY_ON_ROOT,
+        },
+
+        {
+                .name = "cgroup_css_links",
+                .seq_show = cgroup_css_links_read,
+        },
+
+        {
+                .name = "cgroup_subsys_states",
+                .seq_show = cgroup_subsys_states_read,
+        },
+
+        {
+                .name = "cgroup_masks",
+                .seq_show = cgroup_masks_read,
+        },
+
+        {
+                .name = "releasable",
+                .read_u64 = releasable_read,
+        },
+
+        { }     /* terminate */
+};
+
+static struct cftype debug_files[] =  {
+        {
+                .name = "taskcount",
+                .read_u64 = debug_taskcount_read,
+        },
+
+        {
+                .name = "current_css_set",
+                .seq_show = current_css_set_read,
+                .flags = CFTYPE_ONLY_ON_ROOT,
+        },
+
+        {
+                .name = "current_css_set_refcount",
+                .read_u64 = current_css_set_refcount_read,
+                .flags = CFTYPE_ONLY_ON_ROOT,
+        },
+
+        {
+                .name = "current_css_set_cg_links",
+                .seq_show = current_css_set_cg_links_read,
+                .flags = CFTYPE_ONLY_ON_ROOT,
+        },
+
+        {
+                .name = "css_links",
+                .seq_show = cgroup_css_links_read,
+        },
+
+        {
+                .name = "csses",
+                .seq_show = cgroup_subsys_states_read,
+        },
+
+        {
+                .name = "masks",
+                .seq_show = cgroup_masks_read,
+        },
+
+        { }     /* terminate */
+};
+
+struct cgroup_subsys debug_cgrp_subsys = {
+        .css_alloc      = debug_css_alloc,
+        .css_free       = debug_css_free,
+        .legacy_cftypes = debug_legacy_files,
+};
+
+/*
+ * On v2, debug is an implicit controller enabled by "cgroup_debug" boot
+ * parameter.
+ */
+static int __init enable_cgroup_debug(char *str)
+{
+        debug_cgrp_subsys.dfl_cftypes = debug_files;
+        debug_cgrp_subsys.implicit_on_dfl = true;
+        return 1;
+}
+__setup("cgroup_debug", enable_cgroup_debug);
diff --git a/kernel/compat.c b/kernel/compat.c
index 933bcb31ae10..6f0a0e723a06 100644
--- a/kernel/compat.c
+++ b/kernel/compat.c
@@ -30,100 +30,66 @@
 
 #include <linux/uaccess.h>
 
-static int compat_get_timex(struct timex *txc, struct compat_timex __user *utp)
+int compat_get_timex(struct timex *txc, const struct compat_timex __user *utp)
 {
-        memset(txc, 0, sizeof(struct timex));
-
-        if (!access_ok(VERIFY_READ, utp, sizeof(struct compat_timex)) ||
-                        __get_user(txc->modes, &utp->modes) ||
-                        __get_user(txc->offset, &utp->offset) ||
-                        __get_user(txc->freq, &utp->freq) ||
-                        __get_user(txc->maxerror, &utp->maxerror) ||
-                        __get_user(txc->esterror, &utp->esterror) ||
-                        __get_user(txc->status, &utp->status) ||
-                        __get_user(txc->constant, &utp->constant) ||
-                        __get_user(txc->precision, &utp->precision) ||
-                        __get_user(txc->tolerance, &utp->tolerance) ||
-                        __get_user(txc->time.tv_sec, &utp->time.tv_sec) ||
-                        __get_user(txc->time.tv_usec, &utp->time.tv_usec) ||
-                        __get_user(txc->tick, &utp->tick) ||
-                        __get_user(txc->ppsfreq, &utp->ppsfreq) ||
-                        __get_user(txc->jitter, &utp->jitter) ||
-                        __get_user(txc->shift, &utp->shift) ||
-                        __get_user(txc->stabil, &utp->stabil) ||
-                        __get_user(txc->jitcnt, &utp->jitcnt) ||
-                        __get_user(txc->calcnt, &utp->calcnt) ||
-                        __get_user(txc->errcnt, &utp->errcnt) ||
-                        __get_user(txc->stbcnt, &utp->stbcnt))
-                return -EFAULT;
+        struct compat_timex tx32;
 
-        return 0;
-}
-
-static int compat_put_timex(struct compat_timex __user *utp, struct timex *txc)
-{
-        if (!access_ok(VERIFY_WRITE, utp, sizeof(struct compat_timex)) ||
-                        __put_user(txc->modes, &utp->modes) ||
-                        __put_user(txc->offset, &utp->offset) ||
-                        __put_user(txc->freq, &utp->freq) ||
-                        __put_user(txc->maxerror, &utp->maxerror) ||
-                        __put_user(txc->esterror, &utp->esterror) ||
-                        __put_user(txc->status, &utp->status) ||
-                        __put_user(txc->constant, &utp->constant) ||
-                        __put_user(txc->precision, &utp->precision) ||
-                        __put_user(txc->tolerance, &utp->tolerance) ||
-                        __put_user(txc->time.tv_sec, &utp->time.tv_sec) ||
-                        __put_user(txc->time.tv_usec, &utp->time.tv_usec) ||
-                        __put_user(txc->tick, &utp->tick) ||
-                        __put_user(txc->ppsfreq, &utp->ppsfreq) ||
-                        __put_user(txc->jitter, &utp->jitter) ||
-                        __put_user(txc->shift, &utp->shift) ||
-                        __put_user(txc->stabil, &utp->stabil) ||
-                        __put_user(txc->jitcnt, &utp->jitcnt) ||
-                        __put_user(txc->calcnt, &utp->calcnt) ||
-                        __put_user(txc->errcnt, &utp->errcnt) ||
-                        __put_user(txc->stbcnt, &utp->stbcnt) ||
-                        __put_user(txc->tai, &utp->tai))
+        if (copy_from_user(&tx32, utp, sizeof(struct compat_timex)))
                 return -EFAULT;
-        return 0;
-}
 
-COMPAT_SYSCALL_DEFINE2(gettimeofday, struct compat_timeval __user *, tv,
-                       struct timezone __user *, tz)
-{
-        if (tv) {
-                struct timeval ktv;
-                do_gettimeofday(&ktv);
-                if (compat_put_timeval(&ktv, tv))
-                        return -EFAULT;
-        }
-        if (tz) {
-                if (copy_to_user(tz, &sys_tz, sizeof(sys_tz)))
-                        return -EFAULT;
-        }
+        txc->modes = tx32.modes;
+        txc->offset = tx32.offset;
+        txc->freq = tx32.freq;
+        txc->maxerror = tx32.maxerror;
+        txc->esterror = tx32.esterror;
+        txc->status = tx32.status;
+        txc->constant = tx32.constant;
+        txc->precision = tx32.precision;
+        txc->tolerance = tx32.tolerance;
+        txc->time.tv_sec = tx32.time.tv_sec;
+        txc->time.tv_usec = tx32.time.tv_usec;
+        txc->tick = tx32.tick;
+        txc->ppsfreq = tx32.ppsfreq;
+        txc->jitter = tx32.jitter;
+        txc->shift = tx32.shift;
+        txc->stabil = tx32.stabil;
+        txc->jitcnt = tx32.jitcnt;
+        txc->calcnt = tx32.calcnt;
+        txc->errcnt = tx32.errcnt;
+        txc->stbcnt = tx32.stbcnt;
 
         return 0;
 }
 
-COMPAT_SYSCALL_DEFINE2(settimeofday, struct compat_timeval __user *, tv,
-                       struct timezone __user *, tz)
-{
-        struct timespec64 new_ts;
-        struct timeval user_tv;
-        struct timezone new_tz;
-
-        if (tv) {
-                if (compat_get_timeval(&user_tv, tv))
-                        return -EFAULT;
-                new_ts.tv_sec = user_tv.tv_sec;
-                new_ts.tv_nsec = user_tv.tv_usec * NSEC_PER_USEC;
-        }
-        if (tz) {
-                if (copy_from_user(&new_tz, tz, sizeof(*tz)))
-                        return -EFAULT;
-        }
-
-        return do_sys_settimeofday64(tv ? &new_ts : NULL, tz ? &new_tz : NULL);
+int compat_put_timex(struct compat_timex __user *utp, const struct timex *txc)
+{
+        struct compat_timex tx32;
+
+        memset(&tx32, 0, sizeof(struct compat_timex));
+        tx32.modes = txc->modes;
+        tx32.offset = txc->offset;
+        tx32.freq = txc->freq;
+        tx32.maxerror = txc->maxerror;
+        tx32.esterror = txc->esterror;
+        tx32.status = txc->status;
+        tx32.constant = txc->constant;
+        tx32.precision = txc->precision;
+        tx32.tolerance = txc->tolerance;
+        tx32.time.tv_sec = txc->time.tv_sec;
+        tx32.time.tv_usec = txc->time.tv_usec;
+        tx32.tick = txc->tick;
+        tx32.ppsfreq = txc->ppsfreq;
+        tx32.jitter = txc->jitter;
+        tx32.shift = txc->shift;
+        tx32.stabil = txc->stabil;
+        tx32.jitcnt = txc->jitcnt;
+        tx32.calcnt = txc->calcnt;
+        tx32.errcnt = txc->errcnt;
+        tx32.stbcnt = txc->stbcnt;
+        tx32.tai = txc->tai;
+        if (copy_to_user(utp, &tx32, sizeof(struct compat_timex)))
+                return -EFAULT;
+        return 0;
 }
 
 static int __compat_get_timeval(struct timeval *tv, const struct compat_timeval __user *ctv)
@@ -154,6 +120,50 @@ static int __compat_put_timespec(const struct timespec *ts, struct compat_timesp
                         __put_user(ts->tv_nsec, &cts->tv_nsec)) ? -EFAULT : 0;
 }
 
+static int __compat_get_timespec64(struct timespec64 *ts64,
+                                   const struct compat_timespec __user *cts)
+{
+        struct compat_timespec ts;
+        int ret;
+
+        ret = copy_from_user(&ts, cts, sizeof(ts));
+        if (ret)
+                return -EFAULT;
+
+        ts64->tv_sec = ts.tv_sec;
+        ts64->tv_nsec = ts.tv_nsec;
+
+        return 0;
+}
+
+static int __compat_put_timespec64(const struct timespec64 *ts64,
+                                   struct compat_timespec __user *cts)
+{
+        struct compat_timespec ts = {
+                .tv_sec = ts64->tv_sec,
+                .tv_nsec = ts64->tv_nsec
+        };
+        return copy_to_user(cts, &ts, sizeof(ts)) ? -EFAULT : 0;
+}
+
+int compat_get_timespec64(struct timespec64 *ts, const void __user *uts)
+{
+        if (COMPAT_USE_64BIT_TIME)
+                return copy_from_user(ts, uts, sizeof(*ts)) ? -EFAULT : 0;
+        else
+                return __compat_get_timespec64(ts, uts);
+}
+EXPORT_SYMBOL_GPL(compat_get_timespec64);
+
+int compat_put_timespec64(const struct timespec64 *ts, void __user *uts)
+{
+        if (COMPAT_USE_64BIT_TIME)
+                return copy_to_user(uts, ts, sizeof(*ts)) ? -EFAULT : 0;
+        else
+                return __compat_put_timespec64(ts, uts);
+}
+EXPORT_SYMBOL_GPL(compat_put_timespec64);
+
 int compat_get_timeval(struct timeval *tv, const void __user *utv)
 {
         if (COMPAT_USE_64BIT_TIME)
@@ -213,190 +223,30 @@ int compat_convert_timespec(struct timespec __user **kts,
         return 0;
 }
 
-static long compat_nanosleep_restart(struct restart_block *restart)
-{
-        struct compat_timespec __user *rmtp;
-        struct timespec rmt;
-        mm_segment_t oldfs;
-        long ret;
-
-        restart->nanosleep.rmtp = (struct timespec __user *) &rmt;
-        oldfs = get_fs();
-        set_fs(KERNEL_DS);
-        ret = hrtimer_nanosleep_restart(restart);
-        set_fs(oldfs);
-
-        if (ret == -ERESTART_RESTARTBLOCK) {
-                rmtp = restart->nanosleep.compat_rmtp;
-
-                if (rmtp && compat_put_timespec(&rmt, rmtp))
-                        return -EFAULT;
-        }
-
-        return ret;
-}
-
-COMPAT_SYSCALL_DEFINE2(nanosleep, struct compat_timespec __user *, rqtp,
-                       struct compat_timespec __user *, rmtp)
-{
-        struct timespec tu, rmt;
-        struct timespec64 tu64;
-        mm_segment_t oldfs;
-        long ret;
-
-        if (compat_get_timespec(&tu, rqtp))
-                return -EFAULT;
-
-        tu64 = timespec_to_timespec64(tu);
-        if (!timespec64_valid(&tu64))
-                return -EINVAL;
-
-        oldfs = get_fs();
-        set_fs(KERNEL_DS);
-        ret = hrtimer_nanosleep(&tu64,
-                                rmtp ? (struct timespec __user *)&rmt : NULL,
-                                HRTIMER_MODE_REL, CLOCK_MONOTONIC);
-        set_fs(oldfs);
-
-        /*
-         * hrtimer_nanosleep() can only return 0 or
-         * -ERESTART_RESTARTBLOCK here because:
-         *
-         * - we call it with HRTIMER_MODE_REL and therefor exclude the
-         *   -ERESTARTNOHAND return path.
-         *
-         * - we supply the rmtp argument from the task stack (due to
-         *   the necessary compat conversion. So the update cannot
-         *   fail, which excludes the -EFAULT return path as well. If
-         *   it fails nevertheless we have a bigger problem and wont
-         *   reach this place anymore.
-         *
-         * - if the return value is 0, we do not have to update rmtp
-         *    because there is no remaining time.
-         *
-         * We check for -ERESTART_RESTARTBLOCK nevertheless if the
-         * core implementation decides to return random nonsense.
-         */
-        if (ret == -ERESTART_RESTARTBLOCK) {
-                struct restart_block *restart = &current->restart_block;
-
-                restart->fn = compat_nanosleep_restart;
-                restart->nanosleep.compat_rmtp = rmtp;
-
-                if (rmtp && compat_put_timespec(&rmt, rmtp))
-                        return -EFAULT;
-        }
-        return ret;
-}
-
-static inline long get_compat_itimerval(struct itimerval *o,
-                struct compat_itimerval __user *i)
+int get_compat_itimerval(struct itimerval *o, const struct compat_itimerval __user *i)
 {
-        return (!access_ok(VERIFY_READ, i, sizeof(*i)) ||
-                (__get_user(o->it_interval.tv_sec, &i->it_interval.tv_sec) |
-                 __get_user(o->it_interval.tv_usec, &i->it_interval.tv_usec) |
-                 __get_user(o->it_value.tv_sec, &i->it_value.tv_sec) |
-                 __get_user(o->it_value.tv_usec, &i->it_value.tv_usec)));
-}
-
-static inline long put_compat_itimerval(struct compat_itimerval __user *o,
-                struct itimerval *i)
-{
-        return (!access_ok(VERIFY_WRITE, o, sizeof(*o)) ||
-                (__put_user(i->it_interval.tv_sec, &o->it_interval.tv_sec) |
-                 __put_user(i->it_interval.tv_usec, &o->it_interval.tv_usec) |
-                 __put_user(i->it_value.tv_sec, &o->it_value.tv_sec) |
-                 __put_user(i->it_value.tv_usec, &o->it_value.tv_usec)));
-}
-
-asmlinkage long sys_ni_posix_timers(void);
+        struct compat_itimerval v32;
 
-COMPAT_SYSCALL_DEFINE2(getitimer, int, which,
-                struct compat_itimerval __user *, it)
-{
-        struct itimerval kit;
-        int error;
-
-        if (!IS_ENABLED(CONFIG_POSIX_TIMERS))
-                return sys_ni_posix_timers();
-
-        error = do_getitimer(which, &kit);
-        if (!error && put_compat_itimerval(it, &kit))
-                error = -EFAULT;
-        return error;
-}
-
-COMPAT_SYSCALL_DEFINE3(setitimer, int, which,
-                struct compat_itimerval __user *, in,
-                struct compat_itimerval __user *, out)
-{
-        struct itimerval kin, kout;
-        int error;
-
-        if (!IS_ENABLED(CONFIG_POSIX_TIMERS))
-                return sys_ni_posix_timers();
-
-        if (in) {
-                if (get_compat_itimerval(&kin, in))
-                        return -EFAULT;
-        } else
-                memset(&kin, 0, sizeof(kin));
-
-        error = do_setitimer(which, &kin, out ? &kout : NULL);
-        if (error || !out)
-                return error;
-        if (put_compat_itimerval(out, &kout))
+        if (copy_from_user(&v32, i, sizeof(struct compat_itimerval)))
                 return -EFAULT;
+        o->it_interval.tv_sec = v32.it_interval.tv_sec;
+        o->it_interval.tv_usec = v32.it_interval.tv_usec;
+        o->it_value.tv_sec = v32.it_value.tv_sec;
+        o->it_value.tv_usec = v32.it_value.tv_usec;
         return 0;
 }
 
-static compat_clock_t clock_t_to_compat_clock_t(clock_t x)
-{
-        return compat_jiffies_to_clock_t(clock_t_to_jiffies(x));
-}
-
-COMPAT_SYSCALL_DEFINE1(times, struct compat_tms __user *, tbuf)
+int put_compat_itimerval(struct compat_itimerval __user *o, const struct itimerval *i)
 {
-        if (tbuf) {
-                struct tms tms;
-                struct compat_tms tmp;
-
-                do_sys_times(&tms);
-                /* Convert our struct tms to the compat version. */
-                tmp.tms_utime = clock_t_to_compat_clock_t(tms.tms_utime);
-                tmp.tms_stime = clock_t_to_compat_clock_t(tms.tms_stime);
-                tmp.tms_cutime = clock_t_to_compat_clock_t(tms.tms_cutime);
-                tmp.tms_cstime = clock_t_to_compat_clock_t(tms.tms_cstime);
-                if (copy_to_user(tbuf, &tmp, sizeof(tmp)))
-                        return -EFAULT;
-        }
-        force_successful_syscall_return();
-        return compat_jiffies_to_clock_t(jiffies);
-}
-
-#ifdef __ARCH_WANT_SYS_SIGPENDING
+        struct compat_itimerval v32;
 
-/*
- * Assumption: old_sigset_t and compat_old_sigset_t are both
- * types that can be passed to put_user()/get_user().
- */
-
-COMPAT_SYSCALL_DEFINE1(sigpending, compat_old_sigset_t __user *, set)
-{
-        old_sigset_t s;
-        long ret;
-        mm_segment_t old_fs = get_fs();
-
-        set_fs(KERNEL_DS);
-        ret = sys_sigpending((old_sigset_t __user *) &s);
-        set_fs(old_fs);
-        if (ret == 0)
-                ret = put_user(s, set);
-        return ret;
+        v32.it_interval.tv_sec = i->it_interval.tv_sec;
+        v32.it_interval.tv_usec = i->it_interval.tv_usec;
+        v32.it_value.tv_sec = i->it_value.tv_sec;
+        v32.it_value.tv_usec = i->it_value.tv_usec;
+        return copy_to_user(o, &v32, sizeof(struct compat_itimerval)) ? -EFAULT : 0;
 }
 
-#endif
-
 #ifdef __ARCH_WANT_SYS_SIGPROCMASK
 
 /*
@@ -451,164 +301,33 @@ COMPAT_SYSCALL_DEFINE3(sigprocmask, int, how,
 
 #endif
 
-COMPAT_SYSCALL_DEFINE2(setrlimit, unsigned int, resource,
-                       struct compat_rlimit __user *, rlim)
-{
-        struct rlimit r;
-
-        if (!access_ok(VERIFY_READ, rlim, sizeof(*rlim)) ||
-            __get_user(r.rlim_cur, &rlim->rlim_cur) ||
-            __get_user(r.rlim_max, &rlim->rlim_max))
-                return -EFAULT;
-
-        if (r.rlim_cur == COMPAT_RLIM_INFINITY)
-                r.rlim_cur = RLIM_INFINITY;
-        if (r.rlim_max == COMPAT_RLIM_INFINITY)
-                r.rlim_max = RLIM_INFINITY;
-        return do_prlimit(current, resource, &r, NULL);
-}
-
-#ifdef COMPAT_RLIM_OLD_INFINITY
-
-COMPAT_SYSCALL_DEFINE2(old_getrlimit, unsigned int, resource,
-                       struct compat_rlimit __user *, rlim)
-{
-        struct rlimit r;
-        int ret;
-        mm_segment_t old_fs = get_fs();
-
-        set_fs(KERNEL_DS);
-        ret = sys_old_getrlimit(resource, (struct rlimit __user *)&r);
-        set_fs(old_fs);
-
-        if (!ret) {
-                if (r.rlim_cur > COMPAT_RLIM_OLD_INFINITY)
-                        r.rlim_cur = COMPAT_RLIM_INFINITY;
-                if (r.rlim_max > COMPAT_RLIM_OLD_INFINITY)
-                        r.rlim_max = COMPAT_RLIM_INFINITY;
-
-                if (!access_ok(VERIFY_WRITE, rlim, sizeof(*rlim)) ||
-                    __put_user(r.rlim_cur, &rlim->rlim_cur) ||
-                    __put_user(r.rlim_max, &rlim->rlim_max))
-                        return -EFAULT;
-        }
-        return ret;
-}
-
-#endif
-
-COMPAT_SYSCALL_DEFINE2(getrlimit, unsigned int, resource,
-                       struct compat_rlimit __user *, rlim)
-{
-        struct rlimit r;
-        int ret;
-
-        ret = do_prlimit(current, resource, NULL, &r);
-        if (!ret) {
-                if (r.rlim_cur > COMPAT_RLIM_INFINITY)
-                        r.rlim_cur = COMPAT_RLIM_INFINITY;
-                if (r.rlim_max > COMPAT_RLIM_INFINITY)
-                        r.rlim_max = COMPAT_RLIM_INFINITY;
-
-                if (!access_ok(VERIFY_WRITE, rlim, sizeof(*rlim)) ||
-                    __put_user(r.rlim_cur, &rlim->rlim_cur) ||
-                    __put_user(r.rlim_max, &rlim->rlim_max))
-                        return -EFAULT;
-        }
-        return ret;
-}
-
 int put_compat_rusage(const struct rusage *r, struct compat_rusage __user *ru)
 {
-        if (!access_ok(VERIFY_WRITE, ru, sizeof(*ru)) ||
-            __put_user(r->ru_utime.tv_sec, &ru->ru_utime.tv_sec) ||
-            __put_user(r->ru_utime.tv_usec, &ru->ru_utime.tv_usec) ||
-            __put_user(r->ru_stime.tv_sec, &ru->ru_stime.tv_sec) ||
-            __put_user(r->ru_stime.tv_usec, &ru->ru_stime.tv_usec) ||
-            __put_user(r->ru_maxrss, &ru->ru_maxrss) ||
-            __put_user(r->ru_ixrss, &ru->ru_ixrss) ||
-            __put_user(r->ru_idrss, &ru->ru_idrss) ||
-            __put_user(r->ru_isrss, &ru->ru_isrss) ||
-            __put_user(r->ru_minflt, &ru->ru_minflt) ||
-            __put_user(r->ru_majflt, &ru->ru_majflt) ||
-            __put_user(r->ru_nswap, &ru->ru_nswap) ||
-            __put_user(r->ru_inblock, &ru->ru_inblock) ||
-            __put_user(r->ru_oublock, &ru->ru_oublock) ||
-            __put_user(r->ru_msgsnd, &ru->ru_msgsnd) ||
-            __put_user(r->ru_msgrcv, &ru->ru_msgrcv) ||
-            __put_user(r->ru_nsignals, &ru->ru_nsignals) ||
-            __put_user(r->ru_nvcsw, &ru->ru_nvcsw) ||
-            __put_user(r->ru_nivcsw, &ru->ru_nivcsw))
+        struct compat_rusage r32;
+        memset(&r32, 0, sizeof(r32));
+        r32.ru_utime.tv_sec = r->ru_utime.tv_sec;
+        r32.ru_utime.tv_usec = r->ru_utime.tv_usec;
+        r32.ru_stime.tv_sec = r->ru_stime.tv_sec;
+        r32.ru_stime.tv_usec = r->ru_stime.tv_usec;
+        r32.ru_maxrss = r->ru_maxrss;
+        r32.ru_ixrss = r->ru_ixrss;
+        r32.ru_idrss = r->ru_idrss;
+        r32.ru_isrss = r->ru_isrss;
+        r32.ru_minflt = r->ru_minflt;
+        r32.ru_majflt = r->ru_majflt;
+        r32.ru_nswap = r->ru_nswap;
+        r32.ru_inblock = r->ru_inblock;
+        r32.ru_oublock = r->ru_oublock;
+        r32.ru_msgsnd = r->ru_msgsnd;
+        r32.ru_msgrcv = r->ru_msgrcv;
+        r32.ru_nsignals = r->ru_nsignals;
+        r32.ru_nvcsw = r->ru_nvcsw;
+        r32.ru_nivcsw = r->ru_nivcsw;
+        if (copy_to_user(ru, &r32, sizeof(r32)))
                 return -EFAULT;
         return 0;
 }
 
-COMPAT_SYSCALL_DEFINE4(wait4,
-        compat_pid_t, pid,
-        compat_uint_t __user *, stat_addr,
-        int, options,
-        struct compat_rusage __user *, ru)
-{
-        if (!ru) {
-                return sys_wait4(pid, stat_addr, options, NULL);
-        } else {
-                struct rusage r;
-                int ret;
-                unsigned int status;
-                mm_segment_t old_fs = get_fs();
-
-                set_fs (KERNEL_DS);
-                ret = sys_wait4(pid,
-                                (stat_addr ?
-                                 (unsigned int __user *) &status : NULL),
-                                options, (struct rusage __user *) &r);
-                set_fs (old_fs);
-
-                if (ret > 0) {
-                        if (put_compat_rusage(&r, ru))
-                                return -EFAULT;
-                        if (stat_addr && put_user(status, stat_addr))
-                                return -EFAULT;
-                }
-                return ret;
-        }
-}
-
-COMPAT_SYSCALL_DEFINE5(waitid,
-                int, which, compat_pid_t, pid,
-                struct compat_siginfo __user *, uinfo, int, options,
-                struct compat_rusage __user *, uru)
-{
-        siginfo_t info;
-        struct rusage ru;
-        long ret;
-        mm_segment_t old_fs = get_fs();
-
-        memset(&info, 0, sizeof(info));
-
-        set_fs(KERNEL_DS);
-        ret = sys_waitid(which, pid, (siginfo_t __user *)&info, options,
-                         uru ? (struct rusage __user *)&ru : NULL);
-        set_fs(old_fs);
-
-        if ((ret < 0) || (info.si_signo == 0))
-                return ret;
-
-        if (uru) {
-                /* sys_waitid() overwrites everything in ru */
-                if (COMPAT_USE_64BIT_TIME)
-                        ret = copy_to_user(uru, &ru, sizeof(ru));
-                else
-                        ret = put_compat_rusage(&ru, uru);
-                if (ret)
-                        return -EFAULT;
-        }
-
-        BUG_ON(info.si_code & __SI_MASK);
-        info.si_code |= __SI_CHLD;
-        return copy_siginfo_to_user32(uinfo, &info);
-}
-
 static int compat_get_user_cpu_mask(compat_ulong_t __user *user_mask_ptr,
                                     unsigned len, struct cpumask *new_mask)
 {
@@ -689,192 +408,26 @@ int put_compat_itimerspec(struct compat_itimerspec __user *dst,
         return 0;
 }
 
-COMPAT_SYSCALL_DEFINE3(timer_create, clockid_t, which_clock,
-                       struct compat_sigevent __user *, timer_event_spec,
-                       timer_t __user *, created_timer_id)
-{
-        struct sigevent __user *event = NULL;
-
-        if (timer_event_spec) {
-                struct sigevent kevent;
-
-                event = compat_alloc_user_space(sizeof(*event));
-                if (get_compat_sigevent(&kevent, timer_event_spec) ||
-                    copy_to_user(event, &kevent, sizeof(*event)))
-                        return -EFAULT;
-        }
-
-        return sys_timer_create(which_clock, event, created_timer_id);
-}
-
-COMPAT_SYSCALL_DEFINE4(timer_settime, timer_t, timer_id, int, flags,
-                       struct compat_itimerspec __user *, new,
-                       struct compat_itimerspec __user *, old)
-{
-        long err;
-        mm_segment_t oldfs;
-        struct itimerspec newts, oldts;
-
-        if (!new)
-                return -EINVAL;
-        if (get_compat_itimerspec(&newts, new))
-                return -EFAULT;
-        oldfs = get_fs();
-        set_fs(KERNEL_DS);
-        err = sys_timer_settime(timer_id, flags,
-                                (struct itimerspec __user *) &newts,
-                                (struct itimerspec __user *) &oldts);
-        set_fs(oldfs);
-        if (!err && old && put_compat_itimerspec(old, &oldts))
-                return -EFAULT;
-        return err;
-}
-
-COMPAT_SYSCALL_DEFINE2(timer_gettime, timer_t, timer_id,
-                       struct compat_itimerspec __user *, setting)
-{
-        long err;
-        mm_segment_t oldfs;
-        struct itimerspec ts;
-
-        oldfs = get_fs();
-        set_fs(KERNEL_DS);
-        err = sys_timer_gettime(timer_id,
-                                (struct itimerspec __user *) &ts);
-        set_fs(oldfs);
-        if (!err && put_compat_itimerspec(setting, &ts))
-                return -EFAULT;
-        return err;
-}
-
-COMPAT_SYSCALL_DEFINE2(clock_settime, clockid_t, which_clock,
-                       struct compat_timespec __user *, tp)
-{
-        long err;
-        mm_segment_t oldfs;
-        struct timespec ts;
-
-        if (compat_get_timespec(&ts, tp))
-                return -EFAULT;
-        oldfs = get_fs();
-        set_fs(KERNEL_DS);
-        err = sys_clock_settime(which_clock,
-                                (struct timespec __user *) &ts);
-        set_fs(oldfs);
-        return err;
-}
-
-COMPAT_SYSCALL_DEFINE2(clock_gettime, clockid_t, which_clock,
-                       struct compat_timespec __user *, tp)
-{
-        long err;
-        mm_segment_t oldfs;
-        struct timespec ts;
-
-        oldfs = get_fs();
-        set_fs(KERNEL_DS);
-        err = sys_clock_gettime(which_clock,
-                                (struct timespec __user *) &ts);
-        set_fs(oldfs);
-        if (!err && compat_put_timespec(&ts, tp))
-                return -EFAULT;
-        return err;
-}
-
-COMPAT_SYSCALL_DEFINE2(clock_adjtime, clockid_t, which_clock,
-                       struct compat_timex __user *, utp)
+int get_compat_itimerspec64(struct itimerspec64 *its,
+                        const struct compat_itimerspec __user *uits)
 {
-        struct timex txc;
-        mm_segment_t oldfs;
-        int err, ret;
 
-        err = compat_get_timex(&txc, utp);
-        if (err)
-                return err;
-
-        oldfs = get_fs();
-        set_fs(KERNEL_DS);
-        ret = sys_clock_adjtime(which_clock, (struct timex __user *) &txc);
-        set_fs(oldfs);
-
-        err = compat_put_timex(utp, &txc);
-        if (err)
-                return err;
-
-        return ret;
-}
-
-COMPAT_SYSCALL_DEFINE2(clock_getres, clockid_t, which_clock,
-                       struct compat_timespec __user *, tp)
-{
-        long err;
-        mm_segment_t oldfs;
-        struct timespec ts;
-
-        oldfs = get_fs();
-        set_fs(KERNEL_DS);
-        err = sys_clock_getres(which_clock,
-                               (struct timespec __user *) &ts);
-        set_fs(oldfs);
-        if (!err && tp && compat_put_timespec(&ts, tp))
+        if (__compat_get_timespec64(&its->it_interval, &uits->it_interval) ||
+            __compat_get_timespec64(&its->it_value, &uits->it_value))
                 return -EFAULT;
-        return err;
-}
-
-static long compat_clock_nanosleep_restart(struct restart_block *restart)
-{
-        long err;
-        mm_segment_t oldfs;
-        struct timespec tu;
-        struct compat_timespec __user *rmtp = restart->nanosleep.compat_rmtp;
-
-        restart->nanosleep.rmtp = (struct timespec __user *) &tu;
-        oldfs = get_fs();
-        set_fs(KERNEL_DS);
-        err = clock_nanosleep_restart(restart);
-        set_fs(oldfs);
-
-        if ((err == -ERESTART_RESTARTBLOCK) && rmtp &&
-            compat_put_timespec(&tu, rmtp))
-                return -EFAULT;
-
-        if (err == -ERESTART_RESTARTBLOCK) {
-                restart->fn = compat_clock_nanosleep_restart;
-                restart->nanosleep.compat_rmtp = rmtp;
-        }
-        return err;
+        return 0;
 }
+EXPORT_SYMBOL_GPL(get_compat_itimerspec64);
 
-COMPAT_SYSCALL_DEFINE4(clock_nanosleep, clockid_t, which_clock, int, flags,
-                       struct compat_timespec __user *, rqtp,
-                       struct compat_timespec __user *, rmtp)
+int put_compat_itimerspec64(const struct itimerspec64 *its,
+                        struct compat_itimerspec __user *uits)
 {
-        long err;
-        mm_segment_t oldfs;
-        struct timespec in, out;
-        struct restart_block *restart;
-
-        if (compat_get_timespec(&in, rqtp))
-                return -EFAULT;
-
-        oldfs = get_fs();
-        set_fs(KERNEL_DS);
-        err = sys_clock_nanosleep(which_clock, flags,
-                                  (struct timespec __user *) &in,
-                                  (struct timespec __user *) &out);
-        set_fs(oldfs);
-
-        if ((err == -ERESTART_RESTARTBLOCK) && rmtp &&
-            compat_put_timespec(&out, rmtp))
+        if (__compat_put_timespec64(&its->it_interval, &uits->it_interval) ||
+            __compat_put_timespec64(&its->it_value, &uits->it_value))
                 return -EFAULT;
-
-        if (err == -ERESTART_RESTARTBLOCK) {
-                restart = &current->restart_block;
-                restart->fn = compat_clock_nanosleep_restart;
-                restart->nanosleep.compat_rmtp = rmtp;
-        }
-        return err;
+        return 0;
 }
+EXPORT_SYMBOL_GPL(put_compat_itimerspec64);
 
 /*
  * We currently only need the following fields from the sigevent
@@ -900,84 +453,59 @@ int get_compat_sigevent(struct sigevent *event,
 long compat_get_bitmap(unsigned long *mask, const compat_ulong_t __user *umask,
                        unsigned long bitmap_size)
 {
-        int i, j;
-        unsigned long m;
-        compat_ulong_t um;
         unsigned long nr_compat_longs;
 
         /* align bitmap up to nearest compat_long_t boundary */
         bitmap_size = ALIGN(bitmap_size, BITS_PER_COMPAT_LONG);
+        nr_compat_longs = BITS_TO_COMPAT_LONGS(bitmap_size);
 
         if (!access_ok(VERIFY_READ, umask, bitmap_size / 8))
                 return -EFAULT;
 
-        nr_compat_longs = BITS_TO_COMPAT_LONGS(bitmap_size);
-
-        for (i = 0; i < BITS_TO_LONGS(bitmap_size); i++) {
-                m = 0;
-
-                for (j = 0; j < sizeof(m)/sizeof(um); j++) {
-                        /*
-                         * We dont want to read past the end of the userspace
-                         * bitmap. We must however ensure the end of the
-                         * kernel bitmap is zeroed.
-                         */
-                        if (nr_compat_longs) {
-                                nr_compat_longs--;
-                                if (__get_user(um, umask))
-                                        return -EFAULT;
-                        } else {
-                                um = 0;
-                        }
-
-                        umask++;
-                        m |= (long)um << (j * BITS_PER_COMPAT_LONG);
-                }
-                *mask++ = m;
+        user_access_begin();
+        while (nr_compat_longs > 1) {
+                compat_ulong_t l1, l2;
+                unsafe_get_user(l1, umask++, Efault);
+                unsafe_get_user(l2, umask++, Efault);
+                *mask++ = ((unsigned long)l2 << BITS_PER_COMPAT_LONG) | l1;
+                nr_compat_longs -= 2;
         }
-
+        if (nr_compat_longs)
+                unsafe_get_user(*mask, umask++, Efault);
+        user_access_end();
         return 0;
+
+Efault:
+        user_access_end();
+        return -EFAULT;
 }
 
 long compat_put_bitmap(compat_ulong_t __user *umask, unsigned long *mask,
                        unsigned long bitmap_size)
 {
-        int i, j;
-        unsigned long m;
-        compat_ulong_t um;
         unsigned long nr_compat_longs;
 
         /* align bitmap up to nearest compat_long_t boundary */
         bitmap_size = ALIGN(bitmap_size, BITS_PER_COMPAT_LONG);
+        nr_compat_longs = BITS_TO_COMPAT_LONGS(bitmap_size);
 
         if (!access_ok(VERIFY_WRITE, umask, bitmap_size / 8))
                 return -EFAULT;
 
-        nr_compat_longs = BITS_TO_COMPAT_LONGS(bitmap_size);
-
-        for (i = 0; i < BITS_TO_LONGS(bitmap_size); i++) {
-                m = *mask++;
-
-                for (j = 0; j < sizeof(m)/sizeof(um); j++) {
-                        um = m;
-
-                        /*
-                         * We dont want to write past the end of the userspace
-                         * bitmap.
-                         */
-                        if (nr_compat_longs) {
-                                nr_compat_longs--;
-                                if (__put_user(um, umask))
-                                        return -EFAULT;
-                        }
-
-                        umask++;
-                        m >>= 4*sizeof(um);
-                        m >>= 4*sizeof(um);
-                }
+        user_access_begin();
+        while (nr_compat_longs > 1) {
+                unsigned long m = *mask++;
+                unsafe_put_user((compat_ulong_t)m, umask++, Efault);
+                unsafe_put_user(m >> BITS_PER_COMPAT_LONG, umask++, Efault);
+                nr_compat_longs -= 2;
         }
-
+        if (nr_compat_longs)
+                unsafe_put_user((compat_ulong_t)*mask, umask++, Efault);
+        user_access_end();
         return 0;
+Efault:
+        user_access_end();
+        return -EFAULT;
 }
 
 void
@@ -1003,96 +531,6 @@ sigset_to_compat(compat_sigset_t *compat, const sigset_t *set)
         }
 }
 
-COMPAT_SYSCALL_DEFINE4(rt_sigtimedwait, compat_sigset_t __user *, uthese,
-                struct compat_siginfo __user *, uinfo,
-                struct compat_timespec __user *, uts, compat_size_t, sigsetsize)
-{
-        compat_sigset_t s32;
-        sigset_t s;
-        struct timespec t;
-        siginfo_t info;
-        long ret;
-
-        if (sigsetsize != sizeof(sigset_t))
-                return -EINVAL;
-
-        if (copy_from_user(&s32, uthese, sizeof(compat_sigset_t)))
-                return -EFAULT;
-        sigset_from_compat(&s, &s32);
-
-        if (uts) {
-                if (compat_get_timespec(&t, uts))
-                        return -EFAULT;
-        }
-
-        ret = do_sigtimedwait(&s, &info, uts ? &t : NULL);
-
-        if (ret > 0 && uinfo) {
-                if (copy_siginfo_to_user32(uinfo, &info))
-                        ret = -EFAULT;
-        }
-
-        return ret;
-}
-
-#ifdef __ARCH_WANT_COMPAT_SYS_TIME
-
-/* compat_time_t is a 32 bit "long" and needs to get converted. */
-
-COMPAT_SYSCALL_DEFINE1(time, compat_time_t __user *, tloc)
-{
-        compat_time_t i;
-        struct timeval tv;
-
-        do_gettimeofday(&tv);
-        i = tv.tv_sec;
-
-        if (tloc) {
-                if (put_user(i,tloc))
-                        return -EFAULT;
-        }
-        force_successful_syscall_return();
-        return i;
-}
-
-COMPAT_SYSCALL_DEFINE1(stime, compat_time_t __user *, tptr)
-{
-        struct timespec tv;
-        int err;
-
-        if (get_user(tv.tv_sec, tptr))
-                return -EFAULT;
-
-        tv.tv_nsec = 0;
-
-        err = security_settime(&tv, NULL);
-        if (err)
-                return err;
-
-        do_settimeofday(&tv);
-        return 0;
-}
-
-#endif /* __ARCH_WANT_COMPAT_SYS_TIME */
-
-COMPAT_SYSCALL_DEFINE1(adjtimex, struct compat_timex __user *, utp)
-{
-        struct timex txc;
-        int err, ret;
-
-        err = compat_get_timex(&txc, utp);
-        if (err)
-                return err;
-
-        ret = do_adjtimex(&txc);
-
-        err = compat_put_timex(utp, &txc);
-        if (err)
-                return err;
-
-        return ret;
-}
-
 #ifdef CONFIG_NUMA
 COMPAT_SYSCALL_DEFINE6(move_pages, pid_t, pid, compat_ulong_t, nr_pages,
                        compat_uptr_t __user *, pages32,
diff --git a/kernel/configs/android-base.config b/kernel/configs/android-base.config
index 26a06e09a5bd..d70829033bb7 100644
--- a/kernel/configs/android-base.config
+++ b/kernel/configs/android-base.config
@@ -1,10 +1,13 @@
 #  KEEP ALPHABETICALLY SORTED
 # CONFIG_DEVKMEM is not set
 # CONFIG_DEVMEM is not set
+# CONFIG_FHANDLE is not set
 # CONFIG_INET_LRO is not set
-# CONFIG_MODULES is not set
+# CONFIG_NFSD is not set
+# CONFIG_NFS_FS is not set
 # CONFIG_OABI_COMPAT is not set
 # CONFIG_SYSVIPC is not set
+# CONFIG_USELIB is not set
 CONFIG_ANDROID=y
 CONFIG_ANDROID_BINDER_IPC=y
 CONFIG_ANDROID_LOW_MEMORY_KILLER=y
@@ -13,6 +16,7 @@ CONFIG_ASHMEM=y
 CONFIG_AUDIT=y
 CONFIG_BLK_DEV_INITRD=y
 CONFIG_CGROUPS=y
+CONFIG_CGROUP_BPF=y
 CONFIG_CGROUP_CPUACCT=y
 CONFIG_CGROUP_DEBUG=y
 CONFIG_CGROUP_FREEZER=y
@@ -23,6 +27,8 @@ CONFIG_EMBEDDED=y
 CONFIG_FB=y
 CONFIG_HARDENED_USERCOPY=y
 CONFIG_HIGH_RES_TIMERS=y
+CONFIG_IKCONFIG=y
+CONFIG_IKCONFIG_PROC=y
 CONFIG_INET6_AH=y
 CONFIG_INET6_ESP=y
 CONFIG_INET6_IPCOMP=y
@@ -60,6 +66,9 @@ CONFIG_IP_NF_TARGET_MASQUERADE=y
 CONFIG_IP_NF_TARGET_NETMAP=y
 CONFIG_IP_NF_TARGET_REDIRECT=y
 CONFIG_IP_NF_TARGET_REJECT=y
+CONFIG_MODULES=y
+CONFIG_MODULE_UNLOAD=y
+CONFIG_MODVERSIONS=y
 CONFIG_NET=y
 CONFIG_NETDEVICES=y
 CONFIG_NETFILTER=y
diff --git a/kernel/configs/android-recommended.config b/kernel/configs/android-recommended.config
index 28ee064b6744..946fb92418f7 100644
--- a/kernel/configs/android-recommended.config
+++ b/kernel/configs/android-recommended.config
@@ -6,13 +6,15 @@
 # CONFIG_NF_CONNTRACK_SIP is not set
 # CONFIG_PM_WAKELOCKS_GC is not set
 # CONFIG_VT is not set
+CONFIG_ARM64_SW_TTBR0_PAN=y
 CONFIG_BACKLIGHT_LCD_SUPPORT=y
 CONFIG_BLK_DEV_DM=y
 CONFIG_BLK_DEV_LOOP=y
 CONFIG_BLK_DEV_RAM=y
 CONFIG_BLK_DEV_RAM_SIZE=8192
+CONFIG_CC_STACKPROTECTOR_STRONG=y
 CONFIG_COMPACTION=y
-CONFIG_STRICT_KERNEL_RWX=y
+CONFIG_CPU_SW_DOMAIN_PAN=y
 CONFIG_DM_CRYPT=y
 CONFIG_DM_UEVENT=y
 CONFIG_DM_VERITY=y
@@ -105,6 +107,7 @@ CONFIG_SCHEDSTATS=y
 CONFIG_SMARTJOYPLUS_FF=y
 CONFIG_SND=y
 CONFIG_SOUND=y
+CONFIG_STRICT_KERNEL_RWX=y
 CONFIG_SUSPEND_TIME=y
 CONFIG_TABLET_USB_ACECAD=y
 CONFIG_TABLET_USB_AIPTEK=y
diff --git a/kernel/cpu.c b/kernel/cpu.c
index 9ae6fbe5b5cf..eee033134262 100644
--- a/kernel/cpu.c
+++ b/kernel/cpu.c
@@ -27,6 +27,7 @@
 #include <linux/smpboot.h>
 #include <linux/relay.h>
 #include <linux/slab.h>
+#include <linux/percpu-rwsem.h>
 
 #include <trace/events/power.h>
 #define CREATE_TRACE_POINTS
@@ -65,6 +66,12 @@ struct cpuhp_cpu_state {
 
 static DEFINE_PER_CPU(struct cpuhp_cpu_state, cpuhp_state);
 
+#if defined(CONFIG_LOCKDEP) && defined(CONFIG_SMP)
+static struct lock_class_key cpuhp_state_key;
+static struct lockdep_map cpuhp_state_lock_map =
+        STATIC_LOCKDEP_MAP_INIT("cpuhp_state", &cpuhp_state_key);
+#endif
+
 /**
  * cpuhp_step - Hotplug state machine step
  * @name:       Name of the step
@@ -196,121 +203,41 @@ void cpu_maps_update_done(void)
         mutex_unlock(&cpu_add_remove_lock);
 }
 
-/* If set, cpu_up and cpu_down will return -EBUSY and do nothing.
+/*
+ * If set, cpu_up and cpu_down will return -EBUSY and do nothing.
  * Should always be manipulated under cpu_add_remove_lock
  */
 static int cpu_hotplug_disabled;
 
 #ifdef CONFIG_HOTPLUG_CPU
 
-static struct {
-        struct task_struct *active_writer;
-        /* wait queue to wake up the active_writer */
-        wait_queue_head_t wq;
-        /* verifies that no writer will get active while readers are active */
-        struct mutex lock;
-        /*
-         * Also blocks the new readers during
-         * an ongoing cpu hotplug operation.
-         */
-        atomic_t refcount;
-
-#ifdef CONFIG_DEBUG_LOCK_ALLOC
-        struct lockdep_map dep_map;
-#endif
-} cpu_hotplug = {
-        .active_writer = NULL,
-        .wq = __WAIT_QUEUE_HEAD_INITIALIZER(cpu_hotplug.wq),
-        .lock = __MUTEX_INITIALIZER(cpu_hotplug.lock),
-#ifdef CONFIG_DEBUG_LOCK_ALLOC
-        .dep_map = STATIC_LOCKDEP_MAP_INIT("cpu_hotplug.dep_map", &cpu_hotplug.dep_map),
-#endif
-};
+DEFINE_STATIC_PERCPU_RWSEM(cpu_hotplug_lock);
 
-/* Lockdep annotations for get/put_online_cpus() and cpu_hotplug_begin/end() */
-#define cpuhp_lock_acquire_read() lock_map_acquire_read(&cpu_hotplug.dep_map)
-#define cpuhp_lock_acquire_tryread() \
-                                  lock_map_acquire_tryread(&cpu_hotplug.dep_map)
-#define cpuhp_lock_acquire()      lock_map_acquire(&cpu_hotplug.dep_map)
-#define cpuhp_lock_release()      lock_map_release(&cpu_hotplug.dep_map)
-
-
-void get_online_cpus(void)
+void cpus_read_lock(void)
 {
-        might_sleep();
-        if (cpu_hotplug.active_writer == current)
-                return;
-        cpuhp_lock_acquire_read();
-        mutex_lock(&cpu_hotplug.lock);
-        atomic_inc(&cpu_hotplug.refcount);
-        mutex_unlock(&cpu_hotplug.lock);
+        percpu_down_read(&cpu_hotplug_lock);
 }
-EXPORT_SYMBOL_GPL(get_online_cpus);
+EXPORT_SYMBOL_GPL(cpus_read_lock);
 
-void put_online_cpus(void)
+void cpus_read_unlock(void)
 {
-        int refcount;
-
-        if (cpu_hotplug.active_writer == current)
-                return;
-
-        refcount = atomic_dec_return(&cpu_hotplug.refcount);
-        if (WARN_ON(refcount < 0)) /* try to fix things up */
-                atomic_inc(&cpu_hotplug.refcount);
-
-        if (refcount <= 0 && waitqueue_active(&cpu_hotplug.wq))
-                wake_up(&cpu_hotplug.wq);
-
-        cpuhp_lock_release();
-
+        percpu_up_read(&cpu_hotplug_lock);
 }
-EXPORT_SYMBOL_GPL(put_online_cpus);
+EXPORT_SYMBOL_GPL(cpus_read_unlock);
 
-/*
- * This ensures that the hotplug operation can begin only when the
- * refcount goes to zero.
- *
- * Note that during a cpu-hotplug operation, the new readers, if any,
- * will be blocked by the cpu_hotplug.lock
- *
- * Since cpu_hotplug_begin() is always called after invoking
- * cpu_maps_update_begin(), we can be sure that only one writer is active.
- *
- * Note that theoretically, there is a possibility of a livelock:
- * - Refcount goes to zero, last reader wakes up the sleeping
- *   writer.
- * - Last reader unlocks the cpu_hotplug.lock.
- * - A new reader arrives at this moment, bumps up the refcount.
- * - The writer acquires the cpu_hotplug.lock finds the refcount
- *   non zero and goes to sleep again.
- *
- * However, this is very difficult to achieve in practice since
- * get_online_cpus() not an api which is called all that often.
- *
- */
-void cpu_hotplug_begin(void)
+void cpus_write_lock(void)
 {
-        DEFINE_WAIT(wait);
-
-        cpu_hotplug.active_writer = current;
-        cpuhp_lock_acquire();
+        percpu_down_write(&cpu_hotplug_lock);
+}
 
-        for (;;) {
-                mutex_lock(&cpu_hotplug.lock);
-                prepare_to_wait(&cpu_hotplug.wq, &wait, TASK_UNINTERRUPTIBLE);
-                if (likely(!atomic_read(&cpu_hotplug.refcount)))
-                                break;
-                mutex_unlock(&cpu_hotplug.lock);
-                schedule();
-        }
-        finish_wait(&cpu_hotplug.wq, &wait);
+void cpus_write_unlock(void)
+{
+        percpu_up_write(&cpu_hotplug_lock);
 }
 
-void cpu_hotplug_done(void)
+void lockdep_assert_cpus_held(void)
 {
-        cpu_hotplug.active_writer = NULL;
-        mutex_unlock(&cpu_hotplug.lock);
-        cpuhp_lock_release();
+        percpu_rwsem_assert_held(&cpu_hotplug_lock);
 }
 
 /*
@@ -344,13 +271,26 @@ void cpu_hotplug_enable(void)
 EXPORT_SYMBOL_GPL(cpu_hotplug_enable);
 #endif  /* CONFIG_HOTPLUG_CPU */
 
-/* Notifier wrappers for transitioning to state machine */
+static void __cpuhp_kick_ap_work(struct cpuhp_cpu_state *st);
 
 static int bringup_wait_for_ap(unsigned int cpu)
 {
         struct cpuhp_cpu_state *st = per_cpu_ptr(&cpuhp_state, cpu);
 
+        /* Wait for the CPU to reach CPUHP_AP_ONLINE_IDLE */
         wait_for_completion(&st->done);
+        if (WARN_ON_ONCE((!cpu_online(cpu))))
+                return -ECANCELED;
+
+        /* Unpark the stopper thread and the hotplug thread of the target cpu */
+        stop_machine_unpark(cpu);
+        kthread_unpark(st->thread);
+
+        /* Should we go further up ? */
+        if (st->target > CPUHP_AP_ONLINE_IDLE) {
+                __cpuhp_kick_ap_work(st);
+                wait_for_completion(&st->done);
+        }
         return st->result;
 }
 
@@ -371,9 +311,7 @@ static int bringup_cpu(unsigned int cpu)
         irq_unlock_sparse();
         if (ret)
                 return ret;
-        ret = bringup_wait_for_ap(cpu);
-        BUG_ON(!cpu_online(cpu));
-        return ret;
+        return bringup_wait_for_ap(cpu);
 }
 
 /*
@@ -484,6 +422,7 @@ static void cpuhp_thread_fun(unsigned int cpu)
 
         st->should_run = false;
 
+        lock_map_acquire(&cpuhp_state_lock_map);
         /* Single callback invocation for [un]install ? */
         if (st->single) {
                 if (st->cb_state < CPUHP_AP_ONLINE) {
@@ -510,6 +449,7 @@ static void cpuhp_thread_fun(unsigned int cpu)
                 else if (st->state > st->target)
                         ret = cpuhp_ap_offline(cpu, st);
         }
+        lock_map_release(&cpuhp_state_lock_map);
         st->result = ret;
         complete(&st->done);
 }
@@ -524,6 +464,9 @@ cpuhp_invoke_ap_callback(int cpu, enum cpuhp_state state, bool bringup,
         if (!cpu_online(cpu))
                 return 0;
 
+        lock_map_acquire(&cpuhp_state_lock_map);
+        lock_map_release(&cpuhp_state_lock_map);
+
         /*
          * If we are up and running, use the hotplug thread. For early calls
          * we invoke the thread function directly.
@@ -567,6 +510,8 @@ static int cpuhp_kick_ap_work(unsigned int cpu)
         enum cpuhp_state state = st->state;
 
         trace_cpuhp_enter(cpu, st->target, state, cpuhp_kick_ap_work);
+        lock_map_acquire(&cpuhp_state_lock_map);
+        lock_map_release(&cpuhp_state_lock_map);
         __cpuhp_kick_ap_work(st);
         wait_for_completion(&st->done);
         trace_cpuhp_exit(cpu, st->state, state, st->result);
@@ -630,30 +575,6 @@ void clear_tasks_mm_cpumask(int cpu)
         rcu_read_unlock();
 }
 
-static inline void check_for_tasks(int dead_cpu)
-{
-        struct task_struct *g, *p;
-
-        read_lock(&tasklist_lock);
-        for_each_process_thread(g, p) {
-                if (!p->on_rq)
-                        continue;
-                /*
-                 * We do the check with unlocked task_rq(p)->lock.
-                 * Order the reading to do not warn about a task,
-                 * which was running on this cpu in the past, and
-                 * it's just been woken on another cpu.
-                 */
-                rmb();
-                if (task_cpu(p) != dead_cpu)
-                        continue;
-
-                pr_warn("Task %s (pid=%d) is on cpu %d (state=%ld, flags=%x)\n",
-                        p->comm, task_pid_nr(p), dead_cpu, p->state, p->flags);
-        }
-        read_unlock(&tasklist_lock);
-}
-
 /* Take this CPU down. */
 static int take_cpu_down(void *_param)
 {
@@ -701,7 +622,7 @@ static int takedown_cpu(unsigned int cpu)
         /*
          * So now all preempt/rcu users must observe !cpu_active().
          */
-        err = stop_machine(take_cpu_down, NULL, cpumask_of(cpu));
+        err = stop_machine_cpuslocked(take_cpu_down, NULL, cpumask_of(cpu));
         if (err) {
                 /* CPU refused to die */
                 irq_unlock_sparse();
@@ -773,7 +694,7 @@ static int __ref _cpu_down(unsigned int cpu, int tasks_frozen,
         if (!cpu_present(cpu))
                 return -EINVAL;
 
-        cpu_hotplug_begin();
+        cpus_write_lock();
 
         cpuhp_tasks_frozen = tasks_frozen;
 
@@ -811,7 +732,7 @@ static int __ref _cpu_down(unsigned int cpu, int tasks_frozen,
         }
 
 out:
-        cpu_hotplug_done();
+        cpus_write_unlock();
         return ret;
 }
 
@@ -859,31 +780,20 @@ void notify_cpu_starting(unsigned int cpu)
 }
 
 /*
- * Called from the idle task. We need to set active here, so we can kick off
- * the stopper thread and unpark the smpboot threads. If the target state is
- * beyond CPUHP_AP_ONLINE_IDLE we kick cpuhp thread and let it bring up the
- * cpu further.
+ * Called from the idle task. Wake up the controlling task which brings the
+ * stopper and the hotplug thread of the upcoming CPU up and then delegates
+ * the rest of the online bringup to the hotplug thread.
  */
 void cpuhp_online_idle(enum cpuhp_state state)
 {
         struct cpuhp_cpu_state *st = this_cpu_ptr(&cpuhp_state);
-        unsigned int cpu = smp_processor_id();
 
         /* Happens for the boot cpu */
         if (state != CPUHP_AP_ONLINE_IDLE)
                 return;
 
         st->state = CPUHP_AP_ONLINE_IDLE;
-
-        /* Unpark the stopper thread and the hotplug thread of this cpu */
-        stop_machine_unpark(cpu);
-        kthread_unpark(st->thread);
-
-        /* Should we go further up ? */
-        if (st->target > CPUHP_AP_ONLINE_IDLE)
-                __cpuhp_kick_ap_work(st);
-        else
-                complete(&st->done);
+        complete(&st->done);
 }
 
 /* Requires cpu_add_remove_lock to be held */
@@ -893,7 +803,7 @@ static int _cpu_up(unsigned int cpu, int tasks_frozen, enum cpuhp_state target)
         struct task_struct *idle;
         int ret = 0;
 
-        cpu_hotplug_begin();
+        cpus_write_lock();
 
         if (!cpu_present(cpu)) {
                 ret = -EINVAL;
@@ -941,7 +851,7 @@ static int _cpu_up(unsigned int cpu, int tasks_frozen, enum cpuhp_state target)
         target = min((int)target, CPUHP_BRINGUP_CPU);
         ret = cpuhp_up_callbacks(cpu, st, target);
 out:
-        cpu_hotplug_done();
+        cpus_write_unlock();
         return ret;
 }
 
@@ -1252,6 +1162,11 @@ static struct cpuhp_step cpuhp_ap_states[] = {
                 .startup.single         = smpboot_unpark_threads,
                 .teardown.single        = NULL,
         },
+        [CPUHP_AP_IRQ_AFFINITY_ONLINE] = {
+                .name                   = "irq/affinity:online",
+                .startup.single         = irq_affinity_online_cpu,
+                .teardown.single        = NULL,
+        },
         [CPUHP_AP_PERF_ONLINE] = {
                 .name                   = "perf:online",
                 .startup.single         = perf_event_init_cpu,
@@ -1413,18 +1328,20 @@ static void cpuhp_rollback_install(int failedcpu, enum cpuhp_state state,
         }
 }
 
-int __cpuhp_state_add_instance(enum cpuhp_state state, struct hlist_node *node,
-                               bool invoke)
+int __cpuhp_state_add_instance_cpuslocked(enum cpuhp_state state,
+                                          struct hlist_node *node,
+                                          bool invoke)
 {
         struct cpuhp_step *sp;
         int cpu;
         int ret;
 
+        lockdep_assert_cpus_held();
+
         sp = cpuhp_get_step(state);
         if (sp->multi_instance == false)
                 return -EINVAL;
 
-        get_online_cpus();
         mutex_lock(&cpuhp_state_mutex);
 
         if (!invoke || !sp->startup.multi)
@@ -1453,13 +1370,23 @@ add_node:
         hlist_add_head(node, &sp->list);
 unlock:
         mutex_unlock(&cpuhp_state_mutex);
-        put_online_cpus();
+        return ret;
+}
+
+int __cpuhp_state_add_instance(enum cpuhp_state state, struct hlist_node *node,
+                               bool invoke)
+{
+        int ret;
+
+        cpus_read_lock();
+        ret = __cpuhp_state_add_instance_cpuslocked(state, node, invoke);
+        cpus_read_unlock();
         return ret;
 }
 EXPORT_SYMBOL_GPL(__cpuhp_state_add_instance);
 
 /**
- * __cpuhp_setup_state - Setup the callbacks for an hotplug machine state
+ * __cpuhp_setup_state_cpuslocked - Setup the callbacks for an hotplug machine state
  * @state:              The state to setup
  * @invoke:             If true, the startup function is invoked for cpus where
  *                      cpu state >= @state
@@ -1468,25 +1395,27 @@ EXPORT_SYMBOL_GPL(__cpuhp_state_add_instance);
  * @multi_instance:     State is set up for multiple instances which get
  *                      added afterwards.
  *
+ * The caller needs to hold cpus read locked while calling this function.
  * Returns:
  *   On success:
  *      Positive state number if @state is CPUHP_AP_ONLINE_DYN
  *      0 for all other states
  *   On failure: proper (negative) error code
  */
-int __cpuhp_setup_state(enum cpuhp_state state,
-                        const char *name, bool invoke,
-                        int (*startup)(unsigned int cpu),
-                        int (*teardown)(unsigned int cpu),
-                        bool multi_instance)
+int __cpuhp_setup_state_cpuslocked(enum cpuhp_state state,
+                                   const char *name, bool invoke,
+                                   int (*startup)(unsigned int cpu),
+                                   int (*teardown)(unsigned int cpu),
+                                   bool multi_instance)
 {
         int cpu, ret = 0;
         bool dynstate;
 
+        lockdep_assert_cpus_held();
+
         if (cpuhp_cb_check(state) || !name)
                 return -EINVAL;
 
-        get_online_cpus();
         mutex_lock(&cpuhp_state_mutex);
 
         ret = cpuhp_store_callbacks(state, name, startup, teardown,
@@ -1522,7 +1451,6 @@ int __cpuhp_setup_state(enum cpuhp_state state,
         }
 out:
         mutex_unlock(&cpuhp_state_mutex);
-        put_online_cpus();
         /*
          * If the requested state is CPUHP_AP_ONLINE_DYN, return the
          * dynamically allocated state in case of success.
@@ -1531,6 +1459,22 @@ out:
                 return state;
         return ret;
 }
+EXPORT_SYMBOL(__cpuhp_setup_state_cpuslocked);
+
+int __cpuhp_setup_state(enum cpuhp_state state,
+                        const char *name, bool invoke,
+                        int (*startup)(unsigned int cpu),
+                        int (*teardown)(unsigned int cpu),
+                        bool multi_instance)
+{
+        int ret;
+
+        cpus_read_lock();
+        ret = __cpuhp_setup_state_cpuslocked(state, name, invoke, startup,
+                                             teardown, multi_instance);
+        cpus_read_unlock();
+        return ret;
+}
 EXPORT_SYMBOL(__cpuhp_setup_state);
 
 int __cpuhp_state_remove_instance(enum cpuhp_state state,
@@ -1544,7 +1488,7 @@ int __cpuhp_state_remove_instance(enum cpuhp_state state,
         if (!sp->multi_instance)
                 return -EINVAL;
 
-        get_online_cpus();
+        cpus_read_lock();
         mutex_lock(&cpuhp_state_mutex);
 
         if (!invoke || !cpuhp_get_teardown_cb(state))
@@ -1565,29 +1509,30 @@ int __cpuhp_state_remove_instance(enum cpuhp_state state,
 remove:
         hlist_del(node);
         mutex_unlock(&cpuhp_state_mutex);
-        put_online_cpus();
+        cpus_read_unlock();
 
         return 0;
 }
 EXPORT_SYMBOL_GPL(__cpuhp_state_remove_instance);
 
 /**
- * __cpuhp_remove_state - Remove the callbacks for an hotplug machine state
+ * __cpuhp_remove_state_cpuslocked - Remove the callbacks for an hotplug machine state
  * @state:      The state to remove
  * @invoke:     If true, the teardown function is invoked for cpus where
  *              cpu state >= @state
  *
+ * The caller needs to hold cpus read locked while calling this function.
  * The teardown callback is currently not allowed to fail. Think
  * about module removal!
  */
-void __cpuhp_remove_state(enum cpuhp_state state, bool invoke)
+void __cpuhp_remove_state_cpuslocked(enum cpuhp_state state, bool invoke)
 {
         struct cpuhp_step *sp = cpuhp_get_step(state);
         int cpu;
 
         BUG_ON(cpuhp_cb_check(state));
 
-        get_online_cpus();
+        lockdep_assert_cpus_held();
 
         mutex_lock(&cpuhp_state_mutex);
         if (sp->multi_instance) {
@@ -1615,7 +1560,14 @@ void __cpuhp_remove_state(enum cpuhp_state state, bool invoke)
 remove:
         cpuhp_store_callbacks(state, NULL, NULL, NULL, false);
         mutex_unlock(&cpuhp_state_mutex);
-        put_online_cpus();
+}
+EXPORT_SYMBOL(__cpuhp_remove_state_cpuslocked);
+
+void __cpuhp_remove_state(enum cpuhp_state state, bool invoke)
+{
+        cpus_read_lock();
+        __cpuhp_remove_state_cpuslocked(state, invoke);
+        cpus_read_unlock();
 }
 EXPORT_SYMBOL(__cpuhp_remove_state);
 
@@ -1658,13 +1610,13 @@ static ssize_t write_cpuhp_target(struct device *dev,
         ret = !sp->name || sp->cant_stop ? -EINVAL : 0;
         mutex_unlock(&cpuhp_state_mutex);
         if (ret)
-                return ret;
+                goto out;
 
         if (st->state < target)
                 ret = do_cpu_up(dev->id, target);
         else
                 ret = do_cpu_down(dev->id, target);
-
+out:
         unlock_device_hotplug();
         return ret ? ret : count;
 }
@@ -1684,7 +1636,7 @@ static struct attribute *cpuhp_cpu_attrs[] = {
         NULL
 };
 
-static struct attribute_group cpuhp_cpu_attr_group = {
+static const struct attribute_group cpuhp_cpu_attr_group = {
         .attrs = cpuhp_cpu_attrs,
         .name = "hotplug",
         NULL
@@ -1716,7 +1668,7 @@ static struct attribute *cpuhp_cpu_root_attrs[] = {
         NULL
 };
 
-static struct attribute_group cpuhp_cpu_root_attr_group = {
+static const struct attribute_group cpuhp_cpu_root_attr_group = {
         .attrs = cpuhp_cpu_root_attrs,
         .name = "hotplug",
         NULL
diff --git a/kernel/crash_core.c b/kernel/crash_core.c
index fcbd568f1e95..6db80fc0810b 100644
--- a/kernel/crash_core.c
+++ b/kernel/crash_core.c
@@ -14,10 +14,12 @@
 #include <asm/sections.h>
 
 /* vmcoreinfo stuff */
-static unsigned char vmcoreinfo_data[VMCOREINFO_BYTES];
-u32 vmcoreinfo_note[VMCOREINFO_NOTE_SIZE/4];
-size_t vmcoreinfo_size;
-size_t vmcoreinfo_max_size = sizeof(vmcoreinfo_data);
+static unsigned char *vmcoreinfo_data;
+static size_t vmcoreinfo_size;
+u32 *vmcoreinfo_note;
+
+/* trusted vmcoreinfo, e.g. we can make a copy in the crash memory */
+static unsigned char *vmcoreinfo_data_safecopy;
 
 /*
  * parsing the "crashkernel" commandline
@@ -324,8 +326,23 @@ static void update_vmcoreinfo_note(void)
         final_note(buf);
 }
 
+void crash_update_vmcoreinfo_safecopy(void *ptr)
+{
+        if (ptr)
+                memcpy(ptr, vmcoreinfo_data, vmcoreinfo_size);
+
+        vmcoreinfo_data_safecopy = ptr;
+}
+
 void crash_save_vmcoreinfo(void)
 {
+        if (!vmcoreinfo_note)
+                return;
+
+        /* Use the safe copy to generate vmcoreinfo note if have */
+        if (vmcoreinfo_data_safecopy)
+                vmcoreinfo_data = vmcoreinfo_data_safecopy;
+
         vmcoreinfo_append_str("CRASHTIME=%ld\n", get_seconds());
         update_vmcoreinfo_note();
 }
@@ -340,7 +357,7 @@ void vmcoreinfo_append_str(const char *fmt, ...)
         r = vscnprintf(buf, sizeof(buf), fmt, args);
         va_end(args);
 
-        r = min(r, vmcoreinfo_max_size - vmcoreinfo_size);
+        r = min(r, (size_t)VMCOREINFO_BYTES - vmcoreinfo_size);
 
         memcpy(&vmcoreinfo_data[vmcoreinfo_size], buf, r);
 
@@ -356,11 +373,26 @@ void __weak arch_crash_save_vmcoreinfo(void)
 
 phys_addr_t __weak paddr_vmcoreinfo_note(void)
 {
-        return __pa_symbol((unsigned long)(char *)&vmcoreinfo_note);
+        return __pa(vmcoreinfo_note);
 }
 
 static int __init crash_save_vmcoreinfo_init(void)
 {
+        vmcoreinfo_data = (unsigned char *)get_zeroed_page(GFP_KERNEL);
+        if (!vmcoreinfo_data) {
+                pr_warn("Memory allocation for vmcoreinfo_data failed\n");
+                return -ENOMEM;
+        }
+
+        vmcoreinfo_note = alloc_pages_exact(VMCOREINFO_NOTE_SIZE,
+                                                GFP_KERNEL | __GFP_ZERO);
+        if (!vmcoreinfo_note) {
+                free_page((unsigned long)vmcoreinfo_data);
+                vmcoreinfo_data = NULL;
+                pr_warn("Memory allocation for vmcoreinfo_note failed\n");
+                return -ENOMEM;
+        }
+
         VMCOREINFO_OSRELEASE(init_uts_ns.name.release);
         VMCOREINFO_PAGESIZE(PAGE_SIZE);
 
diff --git a/kernel/cred.c b/kernel/cred.c
index 2bc66075740f..ecf03657e71c 100644
--- a/kernel/cred.c
+++ b/kernel/cred.c
@@ -1,4 +1,4 @@
-/* Task credentials management - see Documentation/security/credentials.txt
+/* Task credentials management - see Documentation/security/credentials.rst
  *
  * Copyright (C) 2008 Red Hat, Inc. All Rights Reserved.
  * Written by David Howells (dhowells@redhat.com)
diff --git a/kernel/events/core.c b/kernel/events/core.c
index 6e75a5c9412d..426c2ffba16d 100644
--- a/kernel/events/core.c
+++ b/kernel/events/core.c
@@ -389,6 +389,7 @@ static atomic_t nr_switch_events __read_mostly;
 static LIST_HEAD(pmus);
 static DEFINE_MUTEX(pmus_lock);
 static struct srcu_struct pmus_srcu;
+static cpumask_var_t perf_online_mask;
 
 /*
  * perf event paranoia level:
@@ -925,11 +926,6 @@ static inline int is_cgroup_event(struct perf_event *event)
         return 0;
 }
 
-static inline u64 perf_cgroup_event_cgrp_time(struct perf_event *event)
-{
-        return 0;
-}
-
 static inline void update_cgrp_time_from_event(struct perf_event *event)
 {
 }
@@ -1456,6 +1452,13 @@ static enum event_type_t get_event_type(struct perf_event *event)
 
         lockdep_assert_held(&ctx->lock);
 
+        /*
+         * It's 'group type', really, because if our group leader is
+         * pinned, so are we.
+         */
+        if (event->group_leader != event)
+                event = event->group_leader;
+
         event_type = event->attr.pinned ? EVENT_PINNED : EVENT_FLEXIBLE;
         if (!ctx->task)
                 event_type |= EVENT_CPU;
@@ -3636,10 +3639,10 @@ static inline u64 perf_event_count(struct perf_event *event)
  *     will not be local and we cannot read them atomically
  *   - must not have a pmu::count method
  */
-u64 perf_event_read_local(struct perf_event *event)
+int perf_event_read_local(struct perf_event *event, u64 *value)
 {
         unsigned long flags;
-        u64 val;
+        int ret = 0;
 
         /*
          * Disabling interrupts avoids all counter scheduling (context
@@ -3647,25 +3650,37 @@ u64 perf_event_read_local(struct perf_event *event)
          */
         local_irq_save(flags);
 
-        /* If this is a per-task event, it must be for current */
-        WARN_ON_ONCE((event->attach_state & PERF_ATTACH_TASK) &&
-                     event->hw.target != current);
-
-        /* If this is a per-CPU event, it must be for this CPU */
-        WARN_ON_ONCE(!(event->attach_state & PERF_ATTACH_TASK) &&
-                     event->cpu != smp_processor_id());
-
         /*
          * It must not be an event with inherit set, we cannot read
          * all child counters from atomic context.
          */
-        WARN_ON_ONCE(event->attr.inherit);
+        if (event->attr.inherit) {
+                ret = -EOPNOTSUPP;
+                goto out;
+        }
 
         /*
          * It must not have a pmu::count method, those are not
          * NMI safe.
          */
-        WARN_ON_ONCE(event->pmu->count);
+        if (event->pmu->count) {
+                ret = -EOPNOTSUPP;
+                goto out;
+        }
+
+        /* If this is a per-task event, it must be for current */
+        if ((event->attach_state & PERF_ATTACH_TASK) &&
+            event->hw.target != current) {
+                ret = -EINVAL;
+                goto out;
+        }
+
+        /* If this is a per-CPU event, it must be for this CPU */
+        if (!(event->attach_state & PERF_ATTACH_TASK) &&
+            event->cpu != smp_processor_id()) {
+                ret = -EINVAL;
+                goto out;
+        }
 
         /*
          * If the event is currently on this CPU, its either a per-task event,
@@ -3675,10 +3690,11 @@ u64 perf_event_read_local(struct perf_event *event)
         if (event->oncpu == smp_processor_id())
                 event->pmu->read(event);
 
-        val = local64_read(&event->count);
+        *value = local64_read(&event->count);
+out:
         local_irq_restore(flags);
 
-        return val;
+        return ret;
 }
 
 static int perf_event_read(struct perf_event *event, bool group)
@@ -3812,14 +3828,6 @@ find_get_context(struct pmu *pmu, struct task_struct *task,
                 if (perf_paranoid_cpu() && !capable(CAP_SYS_ADMIN))
                         return ERR_PTR(-EACCES);
 
-                /*
-                 * We could be clever and allow to attach a event to an
-                 * offline CPU and activate it when the CPU comes up, but
-                 * that's for later.
-                 */
-                if (!cpu_online(cpu))
-                        return ERR_PTR(-ENODEV);
-
                 cpuctx = per_cpu_ptr(pmu->pmu_cpu_context, cpu);
                 ctx = &cpuctx->ctx;
                 get_ctx(ctx);
@@ -4377,7 +4385,9 @@ EXPORT_SYMBOL_GPL(perf_event_read_value);
 static int __perf_read_group_add(struct perf_event *leader,
                                         u64 read_format, u64 *values)
 {
+        struct perf_event_context *ctx = leader->ctx;
         struct perf_event *sub;
+        unsigned long flags;
         int n = 1; /* skip @nr */
         int ret;
 
@@ -4407,12 +4417,15 @@ static int __perf_read_group_add(struct perf_event *leader,
         if (read_format & PERF_FORMAT_ID)
                 values[n++] = primary_event_id(leader);
 
+        raw_spin_lock_irqsave(&ctx->lock, flags);
+
         list_for_each_entry(sub, &leader->sibling_list, group_entry) {
                 values[n++] += perf_event_count(sub);
                 if (read_format & PERF_FORMAT_ID)
                         values[n++] = primary_event_id(sub);
         }
 
+        raw_spin_unlock_irqrestore(&ctx->lock, flags);
         return 0;
 }
 
@@ -5729,9 +5742,6 @@ static void perf_output_read_one(struct perf_output_handle *handle,
         __output_copy(handle, values, n * sizeof(u64));
 }
 
-/*
- * XXX PERF_FORMAT_GROUP vs inherited events seems difficult.
- */
 static void perf_output_read_group(struct perf_output_handle *handle,
                             struct perf_event *event,
                             u64 enabled, u64 running)
@@ -5776,6 +5786,13 @@ static void perf_output_read_group(struct perf_output_handle *handle,
 #define PERF_FORMAT_TOTAL_TIMES (PERF_FORMAT_TOTAL_TIME_ENABLED|\
                                  PERF_FORMAT_TOTAL_TIME_RUNNING)
 
+/*
+ * XXX PERF_SAMPLE_READ vs inherited events seems difficult.
+ *
+ * The problem is that its both hard and excessively expensive to iterate the
+ * child list, not to mention that its impossible to IPI the children running
+ * on another CPU, from interrupt/NMI context.
+ */
 static void perf_output_read(struct perf_output_handle *handle,
                              struct perf_event *event)
 {
@@ -7703,7 +7720,8 @@ static int swevent_hlist_get_cpu(int cpu)
         int err = 0;
 
         mutex_lock(&swhash->hlist_mutex);
-        if (!swevent_hlist_deref(swhash) && cpu_online(cpu)) {
+        if (!swevent_hlist_deref(swhash) &&
+            cpumask_test_cpu(cpu, perf_online_mask)) {
                 struct swevent_hlist *hlist;
 
                 hlist = kzalloc(sizeof(*hlist), GFP_KERNEL);
@@ -7724,7 +7742,7 @@ static int swevent_hlist_get(void)
 {
         int err, cpu, failed_cpu;
 
-        get_online_cpus();
+        mutex_lock(&pmus_lock);
         for_each_possible_cpu(cpu) {
                 err = swevent_hlist_get_cpu(cpu);
                 if (err) {
@@ -7732,8 +7750,7 @@ static int swevent_hlist_get(void)
                         goto fail;
                 }
         }
-        put_online_cpus();
-
+        mutex_unlock(&pmus_lock);
         return 0;
 fail:
         for_each_possible_cpu(cpu) {
@@ -7741,8 +7758,7 @@ fail:
                         break;
                 swevent_hlist_put_cpu(cpu);
         }
-
-        put_online_cpus();
+        mutex_unlock(&pmus_lock);
         return err;
 }
 
@@ -8037,12 +8053,8 @@ static int perf_event_set_bpf_prog(struct perf_event *event, u32 prog_fd)
         bool is_kprobe, is_tracepoint;
         struct bpf_prog *prog;
 
-        if (event->attr.type == PERF_TYPE_HARDWARE ||
-            event->attr.type == PERF_TYPE_SOFTWARE)
-                return perf_event_set_bpf_handler(event, prog_fd);
-
         if (event->attr.type != PERF_TYPE_TRACEPOINT)
-                return -EINVAL;
+                return perf_event_set_bpf_handler(event, prog_fd);
 
         if (event->tp_event->prog)
                 return -EEXIST;
@@ -8920,7 +8932,7 @@ perf_event_mux_interval_ms_store(struct device *dev,
         pmu->hrtimer_interval_ms = timer;
 
         /* update all cpuctx for this PMU */
-        get_online_cpus();
+        cpus_read_lock();
         for_each_online_cpu(cpu) {
                 struct perf_cpu_context *cpuctx;
                 cpuctx = per_cpu_ptr(pmu->pmu_cpu_context, cpu);
@@ -8929,7 +8941,7 @@ perf_event_mux_interval_ms_store(struct device *dev,
                 cpu_function_call(cpu,
                         (remote_function_f)perf_mux_hrtimer_restart, cpuctx);
         }
-        put_online_cpus();
+        cpus_read_unlock();
         mutex_unlock(&mux_interval_mutex);
 
         return count;
@@ -9059,6 +9071,7 @@ skip_type:
                 lockdep_set_class(&cpuctx->ctx.mutex, &cpuctx_mutex);
                 lockdep_set_class(&cpuctx->ctx.lock, &cpuctx_lock);
                 cpuctx->ctx.pmu = pmu;
+                cpuctx->online = cpumask_test_cpu(cpu, perf_online_mask);
 
                 __perf_mux_hrtimer_init(cpuctx, cpu);
         }
@@ -9172,7 +9185,7 @@ static int perf_try_init_event(struct pmu *pmu, struct perf_event *event)
 
 static struct pmu *perf_init_event(struct perf_event *event)
 {
-        struct pmu *pmu = NULL;
+        struct pmu *pmu;
         int idx;
         int ret;
 
@@ -9441,9 +9454,10 @@ perf_event_alloc(struct perf_event_attr *attr, int cpu,
         local64_set(&hwc->period_left, hwc->sample_period);
 
         /*
-         * we currently do not support PERF_FORMAT_GROUP on inherited events
+         * We currently do not support PERF_SAMPLE_READ on inherited events.
+         * See perf_output_read().
          */
-        if (attr->inherit && (attr->read_format & PERF_FORMAT_GROUP))
+        if (attr->inherit && (attr->sample_type & PERF_SAMPLE_READ))
                 goto err_ns;
 
         if (!has_branch_stack(event))
@@ -9456,9 +9470,7 @@ perf_event_alloc(struct perf_event_attr *attr, int cpu,
         }
 
         pmu = perf_init_event(event);
-        if (!pmu)
-                goto err_ns;
-        else if (IS_ERR(pmu)) {
+        if (IS_ERR(pmu)) {
                 err = PTR_ERR(pmu);
                 goto err_ns;
         }
@@ -9471,8 +9483,10 @@ perf_event_alloc(struct perf_event_attr *attr, int cpu,
                 event->addr_filters_offs = kcalloc(pmu->nr_addr_filters,
                                                    sizeof(unsigned long),
                                                    GFP_KERNEL);
-                if (!event->addr_filters_offs)
+                if (!event->addr_filters_offs) {
+                        err = -ENOMEM;
                         goto err_per_task;
+                }
 
                 /* force hw sync on the address filters */
                 event->addr_filters_gen = 1;
@@ -9882,12 +9896,10 @@ SYSCALL_DEFINE5(perf_event_open,
                 goto err_task;
         }
 
-        get_online_cpus();
-
         if (task) {
                 err = mutex_lock_interruptible(&task->signal->cred_guard_mutex);
                 if (err)
-                        goto err_cpus;
+                        goto err_task;
 
                 /*
                  * Reuse ptrace permission checks for now.
@@ -10073,6 +10085,23 @@ SYSCALL_DEFINE5(perf_event_open,
                 goto err_locked;
         }
 
+        if (!task) {
+                /*
+                 * Check if the @cpu we're creating an event for is online.
+                 *
+                 * We use the perf_cpu_context::ctx::mutex to serialize against
+                 * the hotplug notifiers. See perf_event_{init,exit}_cpu().
+                 */
+                struct perf_cpu_context *cpuctx =
+                        container_of(ctx, struct perf_cpu_context, ctx);
+
+                if (!cpuctx->online) {
+                        err = -ENODEV;
+                        goto err_locked;
+                }
+        }
+
+
         /*
          * Must be under the same ctx::mutex as perf_install_in_context(),
          * because we need to serialize with concurrent event creation.
@@ -10162,8 +10191,6 @@ SYSCALL_DEFINE5(perf_event_open,
                 put_task_struct(task);
         }
 
-        put_online_cpus();
-
         mutex_lock(&current->perf_event_mutex);
         list_add_tail(&event->owner_entry, &current->perf_event_list);
         mutex_unlock(&current->perf_event_mutex);
@@ -10197,8 +10224,6 @@ err_alloc:
 err_cred:
         if (task)
                 mutex_unlock(&task->signal->cred_guard_mutex);
-err_cpus:
-        put_online_cpus();
 err_task:
         if (task)
                 put_task_struct(task);
@@ -10253,6 +10278,21 @@ perf_event_create_kernel_counter(struct perf_event_attr *attr, int cpu,
                 goto err_unlock;
         }
 
+        if (!task) {
+                /*
+                 * Check if the @cpu we're creating an event for is online.
+                 *
+                 * We use the perf_cpu_context::ctx::mutex to serialize against
+                 * the hotplug notifiers. See perf_event_{init,exit}_cpu().
+                 */
+                struct perf_cpu_context *cpuctx =
+                        container_of(ctx, struct perf_cpu_context, ctx);
+                if (!cpuctx->online) {
+                        err = -ENODEV;
+                        goto err_unlock;
+                }
+        }
+
         if (!exclusive_event_installable(event, ctx)) {
                 err = -EBUSY;
                 goto err_unlock;
@@ -10920,6 +10960,8 @@ static void __init perf_event_init_all_cpus(void)
         struct swevent_htable *swhash;
         int cpu;
 
+        zalloc_cpumask_var(&perf_online_mask, GFP_KERNEL);
+
         for_each_possible_cpu(cpu) {
                 swhash = &per_cpu(swevent_htable, cpu);
                 mutex_init(&swhash->hlist_mutex);
@@ -10935,7 +10977,7 @@ static void __init perf_event_init_all_cpus(void)
         }
 }
 
-int perf_event_init_cpu(unsigned int cpu)
+void perf_swevent_init_cpu(unsigned int cpu)
 {
         struct swevent_htable *swhash = &per_cpu(swevent_htable, cpu);
 
@@ -10948,7 +10990,6 @@ int perf_event_init_cpu(unsigned int cpu)
                 rcu_assign_pointer(swhash->swevent_hlist, hlist);
         }
         mutex_unlock(&swhash->hlist_mutex);
-        return 0;
 }
 
 #if defined CONFIG_HOTPLUG_CPU || defined CONFIG_KEXEC_CORE
@@ -10966,19 +11007,22 @@ static void __perf_event_exit_context(void *__info)
 
 static void perf_event_exit_cpu_context(int cpu)
 {
+        struct perf_cpu_context *cpuctx;
         struct perf_event_context *ctx;
         struct pmu *pmu;
-        int idx;
 
-        idx = srcu_read_lock(&pmus_srcu);
-        list_for_each_entry_rcu(pmu, &pmus, entry) {
-                ctx = &per_cpu_ptr(pmu->pmu_cpu_context, cpu)->ctx;
+        mutex_lock(&pmus_lock);
+        list_for_each_entry(pmu, &pmus, entry) {
+                cpuctx = per_cpu_ptr(pmu->pmu_cpu_context, cpu);
+                ctx = &cpuctx->ctx;
 
                 mutex_lock(&ctx->mutex);
                 smp_call_function_single(cpu, __perf_event_exit_context, ctx, 1);
+                cpuctx->online = 0;
                 mutex_unlock(&ctx->mutex);
         }
-        srcu_read_unlock(&pmus_srcu, idx);
+        cpumask_clear_cpu(cpu, perf_online_mask);
+        mutex_unlock(&pmus_lock);
 }
 #else
 
@@ -10986,6 +11030,29 @@ static void perf_event_exit_cpu_context(int cpu) { }
 
 #endif
 
+int perf_event_init_cpu(unsigned int cpu)
+{
+        struct perf_cpu_context *cpuctx;
+        struct perf_event_context *ctx;
+        struct pmu *pmu;
+
+        perf_swevent_init_cpu(cpu);
+
+        mutex_lock(&pmus_lock);
+        cpumask_set_cpu(cpu, perf_online_mask);
+        list_for_each_entry(pmu, &pmus, entry) {
+                cpuctx = per_cpu_ptr(pmu->pmu_cpu_context, cpu);
+                ctx = &cpuctx->ctx;
+
+                mutex_lock(&ctx->mutex);
+                cpuctx->online = 1;
+                mutex_unlock(&ctx->mutex);
+        }
+        mutex_unlock(&pmus_lock);
+
+        return 0;
+}
+
 int perf_event_exit_cpu(unsigned int cpu)
 {
         perf_event_exit_cpu_context(cpu);
diff --git a/kernel/events/ring_buffer.c b/kernel/events/ring_buffer.c
index 2831480c63a2..ee97196bb151 100644
--- a/kernel/events/ring_buffer.c
+++ b/kernel/events/ring_buffer.c
@@ -580,7 +580,7 @@ int rb_alloc_aux(struct ring_buffer *rb, struct perf_event *event,
         int ret = -ENOMEM, max_order = 0;
 
         if (!has_aux(event))
-                return -ENOTSUPP;
+                return -EOPNOTSUPP;
 
         if (event->pmu->capabilities & PERF_PMU_CAP_AUX_NO_SG) {
                 /*
diff --git a/kernel/exit.c b/kernel/exit.c
index 516acdb0e0ec..c5548faa9f37 100644
--- a/kernel/exit.c
+++ b/kernel/exit.c
@@ -51,7 +51,6 @@
 #include <linux/task_io_accounting_ops.h>
 #include <linux/tracehook.h>
 #include <linux/fs_struct.h>
-#include <linux/userfaultfd_k.h>
 #include <linux/init_task.h>
 #include <linux/perf_event.h>
 #include <trace/events/sched.h>
@@ -62,6 +61,7 @@
 #include <linux/kcov.h>
 #include <linux/random.h>
 #include <linux/rcuwait.h>
+#include <linux/compat.h>
 
 #include <linux/uaccess.h>
 #include <asm/unistd.h>
@@ -318,19 +318,6 @@ void rcuwait_wake_up(struct rcuwait *w)
         rcu_read_unlock();
 }
 
-struct task_struct *try_get_task_struct(struct task_struct **ptask)
-{
-        struct task_struct *task;
-
-        rcu_read_lock();
-        task = task_rcu_dereference(ptask);
-        if (task)
-                get_task_struct(task);
-        rcu_read_unlock();
-
-        return task;
-}
-
 /*
  * Determine if a process group is "orphaned", according to the POSIX
  * definition in 2.2.2.52.  Orphaned process groups are not to be affected
@@ -995,16 +982,23 @@ SYSCALL_DEFINE1(exit_group, int, error_code)
         return 0;
 }
 
+struct waitid_info {
+        pid_t pid;
+        uid_t uid;
+        int status;
+        int cause;
+};
+
 struct wait_opts {
         enum pid_type           wo_type;
         int                     wo_flags;
         struct pid              *wo_pid;
 
-        struct siginfo __user   *wo_info;
-        int __user              *wo_stat;
-        struct rusage __user    *wo_rusage;
+        struct waitid_info      *wo_info;
+        int                     wo_stat;
+        struct rusage           *wo_rusage;
 
-        wait_queue_t            child_wait;
+        wait_queue_entry_t              child_wait;
         int                     notask_error;
 };
 
@@ -1049,34 +1043,6 @@ eligible_child(struct wait_opts *wo, bool ptrace, struct task_struct *p)
         return 1;
 }
 
-static int wait_noreap_copyout(struct wait_opts *wo, struct task_struct *p,
-                                pid_t pid, uid_t uid, int why, int status)
-{
-        struct siginfo __user *infop;
-        int retval = wo->wo_rusage
-                ? getrusage(p, RUSAGE_BOTH, wo->wo_rusage) : 0;
-
-        put_task_struct(p);
-        infop = wo->wo_info;
-        if (infop) {
-                if (!retval)
-                        retval = put_user(SIGCHLD, &infop->si_signo);
-                if (!retval)
-                        retval = put_user(0, &infop->si_errno);
-                if (!retval)
-                        retval = put_user((short)why, &infop->si_code);
-                if (!retval)
-                        retval = put_user(pid, &infop->si_pid);
-                if (!retval)
-                        retval = put_user(uid, &infop->si_uid);
-                if (!retval)
-                        retval = put_user(status, &infop->si_status);
-        }
-        if (!retval)
-                retval = pid;
-        return retval;
-}
-
 /*
  * Handle sys_wait4 work for one task in state EXIT_ZOMBIE.  We hold
  * read_lock(&tasklist_lock) on entry.  If we return zero, we still hold
@@ -1085,30 +1051,23 @@ static int wait_noreap_copyout(struct wait_opts *wo, struct task_struct *p,
  */
 static int wait_task_zombie(struct wait_opts *wo, struct task_struct *p)
 {
-        int state, retval, status;
+        int state, status;
         pid_t pid = task_pid_vnr(p);
         uid_t uid = from_kuid_munged(current_user_ns(), task_uid(p));
-        struct siginfo __user *infop;
+        struct waitid_info *infop;
 
         if (!likely(wo->wo_flags & WEXITED))
                 return 0;
 
         if (unlikely(wo->wo_flags & WNOWAIT)) {
-                int exit_code = p->exit_code;
-                int why;
-
+                status = p->exit_code;
                 get_task_struct(p);
                 read_unlock(&tasklist_lock);
                 sched_annotate_sleep();
-
-                if ((exit_code & 0x7f) == 0) {
-                        why = CLD_EXITED;
-                        status = exit_code >> 8;
-                } else {
-                        why = (exit_code & 0x80) ? CLD_DUMPED : CLD_KILLED;
-                        status = exit_code & 0x7f;
-                }
-                return wait_noreap_copyout(wo, p, pid, uid, why, status);
+                if (wo->wo_rusage)
+                        getrusage(p, RUSAGE_BOTH, wo->wo_rusage);
+                put_task_struct(p);
+                goto out_info;
         }
         /*
          * Move the task's state to DEAD/TRACE, only one thread can do this.
@@ -1181,38 +1140,11 @@ static int wait_task_zombie(struct wait_opts *wo, struct task_struct *p)
                 spin_unlock_irq(&current->sighand->siglock);
         }
 
-        retval = wo->wo_rusage
-                ? getrusage(p, RUSAGE_BOTH, wo->wo_rusage) : 0;
+        if (wo->wo_rusage)
+                getrusage(p, RUSAGE_BOTH, wo->wo_rusage);
         status = (p->signal->flags & SIGNAL_GROUP_EXIT)
                 ? p->signal->group_exit_code : p->exit_code;
-        if (!retval && wo->wo_stat)
-                retval = put_user(status, wo->wo_stat);
-
-        infop = wo->wo_info;
-        if (!retval && infop)
-                retval = put_user(SIGCHLD, &infop->si_signo);
-        if (!retval && infop)
-                retval = put_user(0, &infop->si_errno);
-        if (!retval && infop) {
-                int why;
-
-                if ((status & 0x7f) == 0) {
-                        why = CLD_EXITED;
-                        status >>= 8;
-                } else {
-                        why = (status & 0x80) ? CLD_DUMPED : CLD_KILLED;
-                        status &= 0x7f;
-                }
-                retval = put_user((short)why, &infop->si_code);
-                if (!retval)
-                        retval = put_user(status, &infop->si_status);
-        }
-        if (!retval && infop)
-                retval = put_user(pid, &infop->si_pid);
-        if (!retval && infop)
-                retval = put_user(uid, &infop->si_uid);
-        if (!retval)
-                retval = pid;
+        wo->wo_stat = status;
 
         if (state == EXIT_TRACE) {
                 write_lock_irq(&tasklist_lock);
@@ -1229,7 +1161,21 @@ static int wait_task_zombie(struct wait_opts *wo, struct task_struct *p)
         if (state == EXIT_DEAD)
                 release_task(p);
 
-        return retval;
+out_info:
+        infop = wo->wo_info;
+        if (infop) {
+                if ((status & 0x7f) == 0) {
+                        infop->cause = CLD_EXITED;
+                        infop->status = status >> 8;
+                } else {
+                        infop->cause = (status & 0x80) ? CLD_DUMPED : CLD_KILLED;
+                        infop->status = status & 0x7f;
+                }
+                infop->pid = pid;
+                infop->uid = uid;
+        }
+
+        return pid;
 }
 
 static int *task_stopped_code(struct task_struct *p, bool ptrace)
@@ -1265,8 +1211,8 @@ static int *task_stopped_code(struct task_struct *p, bool ptrace)
 static int wait_task_stopped(struct wait_opts *wo,
                                 int ptrace, struct task_struct *p)
 {
-        struct siginfo __user *infop;
-        int retval, exit_code, *p_code, why;
+        struct waitid_info *infop;
+        int exit_code, *p_code, why;
         uid_t uid = 0; /* unneeded, required by compiler */
         pid_t pid;
 
@@ -1311,34 +1257,21 @@ unlock_sig:
         why = ptrace ? CLD_TRAPPED : CLD_STOPPED;
         read_unlock(&tasklist_lock);
         sched_annotate_sleep();
+        if (wo->wo_rusage)
+                getrusage(p, RUSAGE_BOTH, wo->wo_rusage);
+        put_task_struct(p);
 
-        if (unlikely(wo->wo_flags & WNOWAIT))
-                return wait_noreap_copyout(wo, p, pid, uid, why, exit_code);
-
-        retval = wo->wo_rusage
-                ? getrusage(p, RUSAGE_BOTH, wo->wo_rusage) : 0;
-        if (!retval && wo->wo_stat)
-                retval = put_user((exit_code << 8) | 0x7f, wo->wo_stat);
+        if (likely(!(wo->wo_flags & WNOWAIT)))
+                wo->wo_stat = (exit_code << 8) | 0x7f;
 
         infop = wo->wo_info;
-        if (!retval && infop)
-                retval = put_user(SIGCHLD, &infop->si_signo);
-        if (!retval && infop)
-                retval = put_user(0, &infop->si_errno);
-        if (!retval && infop)
-                retval = put_user((short)why, &infop->si_code);
-        if (!retval && infop)
-                retval = put_user(exit_code, &infop->si_status);
-        if (!retval && infop)
-                retval = put_user(pid, &infop->si_pid);
-        if (!retval && infop)
-                retval = put_user(uid, &infop->si_uid);
-        if (!retval)
-                retval = pid;
-        put_task_struct(p);
-
-        BUG_ON(!retval);
-        return retval;
+        if (infop) {
+                infop->cause = why;
+                infop->status = exit_code;
+                infop->pid = pid;
+                infop->uid = uid;
+        }
+        return pid;
 }
 
 /*
@@ -1349,7 +1282,7 @@ unlock_sig:
  */
 static int wait_task_continued(struct wait_opts *wo, struct task_struct *p)
 {
-        int retval;
+        struct waitid_info *infop;
         pid_t pid;
         uid_t uid;
 
@@ -1374,22 +1307,20 @@ static int wait_task_continued(struct wait_opts *wo, struct task_struct *p)
         get_task_struct(p);
         read_unlock(&tasklist_lock);
         sched_annotate_sleep();
+        if (wo->wo_rusage)
+                getrusage(p, RUSAGE_BOTH, wo->wo_rusage);
+        put_task_struct(p);
 
-        if (!wo->wo_info) {
-                retval = wo->wo_rusage
-                        ? getrusage(p, RUSAGE_BOTH, wo->wo_rusage) : 0;
-                put_task_struct(p);
-                if (!retval && wo->wo_stat)
-                        retval = put_user(0xffff, wo->wo_stat);
-                if (!retval)
-                        retval = pid;
+        infop = wo->wo_info;
+        if (!infop) {
+                wo->wo_stat = 0xffff;
         } else {
-                retval = wait_noreap_copyout(wo, p, pid, uid,
-                                             CLD_CONTINUED, SIGCONT);
-                BUG_ON(retval == 0);
+                infop->cause = CLD_CONTINUED;
+                infop->pid = pid;
+                infop->uid = uid;
+                infop->status = SIGCONT;
         }
-
-        return retval;
+        return pid;
 }
 
 /*
@@ -1541,7 +1472,7 @@ static int ptrace_do_wait(struct wait_opts *wo, struct task_struct *tsk)
         return 0;
 }
 
-static int child_wait_callback(wait_queue_t *wait, unsigned mode,
+static int child_wait_callback(wait_queue_entry_t *wait, unsigned mode,
                                 int sync, void *key)
 {
         struct wait_opts *wo = container_of(wait, struct wait_opts,
@@ -1617,8 +1548,8 @@ end:
         return retval;
 }
 
-SYSCALL_DEFINE5(waitid, int, which, pid_t, upid, struct siginfo __user *,
-                infop, int, options, struct rusage __user *, ru)
+static long kernel_waitid(int which, pid_t upid, struct waitid_info *infop,
+                          int options, struct rusage *ru)
 {
         struct wait_opts wo;
         struct pid *pid = NULL;
@@ -1656,38 +1587,48 @@ SYSCALL_DEFINE5(waitid, int, which, pid_t, upid, struct siginfo __user *,
         wo.wo_pid       = pid;
         wo.wo_flags     = options;
         wo.wo_info      = infop;
-        wo.wo_stat      = NULL;
         wo.wo_rusage    = ru;
         ret = do_wait(&wo);
 
-        if (ret > 0) {
-                ret = 0;
-        } else if (infop) {
-                /*
-                 * For a WNOHANG return, clear out all the fields
-                 * we would set so the user can easily tell the
-                 * difference.
-                 */
-                if (!ret)
-                        ret = put_user(0, &infop->si_signo);
-                if (!ret)
-                        ret = put_user(0, &infop->si_errno);
-                if (!ret)
-                        ret = put_user(0, &infop->si_code);
-                if (!ret)
-                        ret = put_user(0, &infop->si_pid);
-                if (!ret)
-                        ret = put_user(0, &infop->si_uid);
-                if (!ret)
-                        ret = put_user(0, &infop->si_status);
-        }
-
         put_pid(pid);
         return ret;
 }
 
-SYSCALL_DEFINE4(wait4, pid_t, upid, int __user *, stat_addr,
-                int, options, struct rusage __user *, ru)
+SYSCALL_DEFINE5(waitid, int, which, pid_t, upid, struct siginfo __user *,
+                infop, int, options, struct rusage __user *, ru)
+{
+        struct rusage r;
+        struct waitid_info info = {.status = 0};
+        long err = kernel_waitid(which, upid, &info, options, ru ? &r : NULL);
+        int signo = 0;
+        if (err > 0) {
+                signo = SIGCHLD;
+                err = 0;
+        }
+
+        if (!err) {
+                if (ru && copy_to_user(ru, &r, sizeof(struct rusage)))
+                        return -EFAULT;
+        }
+        if (!infop)
+                return err;
+
+        user_access_begin();
+        unsafe_put_user(signo, &infop->si_signo, Efault);
+        unsafe_put_user(0, &infop->si_errno, Efault);
+        unsafe_put_user((short)info.cause, &infop->si_code, Efault);
+        unsafe_put_user(info.pid, &infop->si_pid, Efault);
+        unsafe_put_user(info.uid, &infop->si_uid, Efault);
+        unsafe_put_user(info.status, &infop->si_status, Efault);
+        user_access_end();
+        return err;
+Efault:
+        user_access_end();
+        return -EFAULT;
+}
+
+long kernel_wait4(pid_t upid, int __user *stat_addr, int options,
+                  struct rusage *ru)
 {
         struct wait_opts wo;
         struct pid *pid = NULL;
@@ -1698,6 +1639,10 @@ SYSCALL_DEFINE4(wait4, pid_t, upid, int __user *, stat_addr,
                         __WNOTHREAD|__WCLONE|__WALL))
                 return -EINVAL;
 
+        /* -INT_MIN is not defined */
+        if (upid == INT_MIN)
+                return -ESRCH;
+
         if (upid == -1)
                 type = PIDTYPE_MAX;
         else if (upid < 0) {
@@ -1715,14 +1660,29 @@ SYSCALL_DEFINE4(wait4, pid_t, upid, int __user *, stat_addr,
         wo.wo_pid       = pid;
         wo.wo_flags     = options | WEXITED;
         wo.wo_info      = NULL;
-        wo.wo_stat      = stat_addr;
+        wo.wo_stat      = 0;
         wo.wo_rusage    = ru;
         ret = do_wait(&wo);
         put_pid(pid);
+        if (ret > 0 && stat_addr && put_user(wo.wo_stat, stat_addr))
+                ret = -EFAULT;
 
         return ret;
 }
 
+SYSCALL_DEFINE4(wait4, pid_t, upid, int __user *, stat_addr,
+                int, options, struct rusage __user *, ru)
+{
+        struct rusage r;
+        long err = kernel_wait4(upid, stat_addr, options, ru ? &r : NULL);
+
+        if (err > 0) {
+                if (ru && copy_to_user(ru, &r, sizeof(struct rusage)))
+                        return -EFAULT;
+        }
+        return err;
+}
+
 #ifdef __ARCH_WANT_SYS_WAITPID
 
 /*
@@ -1735,3 +1695,61 @@ SYSCALL_DEFINE3(waitpid, pid_t, pid, int __user *, stat_addr, int, options)
 }
 
 #endif
+
+#ifdef CONFIG_COMPAT
+COMPAT_SYSCALL_DEFINE4(wait4,
+        compat_pid_t, pid,
+        compat_uint_t __user *, stat_addr,
+        int, options,
+        struct compat_rusage __user *, ru)
+{
+        struct rusage r;
+        long err = kernel_wait4(pid, stat_addr, options, ru ? &r : NULL);
+        if (err > 0) {
+                if (ru && put_compat_rusage(&r, ru))
+                        return -EFAULT;
+        }
+        return err;
+}
+
+COMPAT_SYSCALL_DEFINE5(waitid,
+                int, which, compat_pid_t, pid,
+                struct compat_siginfo __user *, infop, int, options,
+                struct compat_rusage __user *, uru)
+{
+        struct rusage ru;
+        struct waitid_info info = {.status = 0};
+        long err = kernel_waitid(which, pid, &info, options, uru ? &ru : NULL);
+        int signo = 0;
+        if (err > 0) {
+                signo = SIGCHLD;
+                err = 0;
+        }
+
+        if (!err && uru) {
+                /* kernel_waitid() overwrites everything in ru */
+                if (COMPAT_USE_64BIT_TIME)
+                        err = copy_to_user(uru, &ru, sizeof(ru));
+                else
+                        err = put_compat_rusage(&ru, uru);
+                if (err)
+                        return -EFAULT;
+        }
+
+        if (!infop)
+                return err;
+
+        user_access_begin();
+        unsafe_put_user(signo, &infop->si_signo, Efault);
+        unsafe_put_user(0, &infop->si_errno, Efault);
+        unsafe_put_user((short)info.cause, &infop->si_code, Efault);
+        unsafe_put_user(info.pid, &infop->si_pid, Efault);
+        unsafe_put_user(info.uid, &infop->si_uid, Efault);
+        unsafe_put_user(info.status, &infop->si_status, Efault);
+        user_access_end();
+        return err;
+Efault:
+        user_access_end();
+        return -EFAULT;
+}
+#endif
diff --git a/kernel/extable.c b/kernel/extable.c
index 2676d7f8baf6..38c2412401a1 100644
--- a/kernel/extable.c
+++ b/kernel/extable.c
@@ -55,7 +55,8 @@ const struct exception_table_entry *search_exception_tables(unsigned long addr)
 {
         const struct exception_table_entry *e;
 
-        e = search_extable(__start___ex_table, __stop___ex_table-1, addr);
+        e = search_extable(__start___ex_table,
+                           __stop___ex_table - __start___ex_table, addr);
         if (!e)
                 e = search_module_extables(addr);
         return e;
@@ -69,13 +70,13 @@ static inline int init_kernel_text(unsigned long addr)
         return 0;
 }
 
-int core_kernel_text(unsigned long addr)
+int notrace core_kernel_text(unsigned long addr)
 {
         if (addr >= (unsigned long)_stext &&
             addr < (unsigned long)_etext)
                 return 1;
 
-        if (system_state == SYSTEM_BOOTING &&
+        if (system_state < SYSTEM_RUNNING &&
             init_kernel_text(addr))
                 return 1;
         return 0;
diff --git a/kernel/fork.c b/kernel/fork.c
index 3a13a940a6ea..5ff0ebcaafc3 100644
--- a/kernel/fork.c
+++ b/kernel/fork.c
@@ -205,19 +205,17 @@ static unsigned long *alloc_thread_stack_node(struct task_struct *tsk, int node)
         void *stack;
         int i;
 
-        local_irq_disable();
         for (i = 0; i < NR_CACHED_STACKS; i++) {
-                struct vm_struct *s = this_cpu_read(cached_stacks[i]);
+                struct vm_struct *s;
+
+                s = this_cpu_xchg(cached_stacks[i], NULL);
 
                 if (!s)
                         continue;
-                this_cpu_write(cached_stacks[i], NULL);
 
                 tsk->stack_vm_area = s;
-                local_irq_enable();
                 return s->addr;
         }
-        local_irq_enable();
 
         stack = __vmalloc_node_range(THREAD_SIZE, THREAD_SIZE,
                                      VMALLOC_START, VMALLOC_END,
@@ -245,19 +243,15 @@ static inline void free_thread_stack(struct task_struct *tsk)
 {
 #ifdef CONFIG_VMAP_STACK
         if (task_stack_vm_area(tsk)) {
-                unsigned long flags;
                 int i;
 
-                local_irq_save(flags);
                 for (i = 0; i < NR_CACHED_STACKS; i++) {
-                        if (this_cpu_read(cached_stacks[i]))
+                        if (this_cpu_cmpxchg(cached_stacks[i],
+                                        NULL, tsk->stack_vm_area) != NULL)
                                 continue;
 
-                        this_cpu_write(cached_stacks[i], tsk->stack_vm_area);
-                        local_irq_restore(flags);
                         return;
                 }
-                local_irq_restore(flags);
 
                 vfree_atomic(tsk->stack);
                 return;
@@ -326,8 +320,8 @@ static void account_kernel_stack(struct task_struct *tsk, int account)
                 }
 
                 /* All stack pages belong to the same memcg. */
-                memcg_kmem_update_page_stat(vm->pages[0], MEMCG_KERNEL_STACK_KB,
-                                            account * (THREAD_SIZE / 1024));
+                mod_memcg_page_state(vm->pages[0], MEMCG_KERNEL_STACK_KB,
+                                     account * (THREAD_SIZE / 1024));
         } else {
                 /*
                  * All stack pages are in the same zone and belong to the
@@ -338,8 +332,8 @@ static void account_kernel_stack(struct task_struct *tsk, int account)
                 mod_zone_page_state(page_zone(first_page), NR_KERNEL_STACK_KB,
                                     THREAD_SIZE / 1024 * account);
 
-                memcg_kmem_update_page_stat(first_page, MEMCG_KERNEL_STACK_KB,
-                                            account * (THREAD_SIZE / 1024));
+                mod_memcg_page_state(first_page, MEMCG_KERNEL_STACK_KB,
+                                     account * (THREAD_SIZE / 1024));
         }
 }
 
@@ -560,7 +554,7 @@ static struct task_struct *dup_task_struct(struct task_struct *orig, int node)
         set_task_stack_end_magic(tsk);
 
 #ifdef CONFIG_CC_STACKPROTECTOR
-        tsk->stack_canary = get_random_long();
+        tsk->stack_canary = get_random_canary();
 #endif
 
         /*
@@ -579,6 +573,10 @@ static struct task_struct *dup_task_struct(struct task_struct *orig, int node)
 
         kcov_task_init(tsk);
 
+#ifdef CONFIG_FAULT_INJECTION
+        tsk->fail_nth = 0;
+#endif
+
         return tsk;
 
 free_stack:
@@ -1573,6 +1571,18 @@ static __latent_entropy struct task_struct *copy_process(
         if (!p)
                 goto fork_out;
 
+        /*
+         * This _must_ happen before we call free_task(), i.e. before we jump
+         * to any of the bad_fork_* labels. This is to avoid freeing
+         * p->set_child_tid which is (ab)used as a kthread's data pointer for
+         * kernel threads (PF_KTHREAD).
+         */
+        p->set_child_tid = (clone_flags & CLONE_CHILD_SETTID) ? child_tidptr : NULL;
+        /*
+         * Clear TID on mm_release()?
+         */
+        p->clear_child_tid = (clone_flags & CLONE_CHILD_CLEARTID) ? child_tidptr : NULL;
+
         ftrace_graph_init_task(p);
 
         rt_mutex_init_task(p);
@@ -1621,9 +1631,9 @@ static __latent_entropy struct task_struct *copy_process(
         prev_cputime_init(&p->prev_cputime);
 
 #ifdef CONFIG_VIRT_CPU_ACCOUNTING_GEN
-        seqcount_init(&p->vtime_seqcount);
-        p->vtime_snap = 0;
-        p->vtime_snap_whence = VTIME_INACTIVE;
+        seqcount_init(&p->vtime.seqcount);
+        p->vtime.starttime = 0;
+        p->vtime.state = VTIME_INACTIVE;
 #endif
 
 #if defined(SPLIT_RSS_COUNTING)
@@ -1739,11 +1749,6 @@ static __latent_entropy struct task_struct *copy_process(
                 }
         }
 
-        p->set_child_tid = (clone_flags & CLONE_CHILD_SETTID) ? child_tidptr : NULL;
-        /*
-         * Clear TID on mm_release()?
-         */
-        p->clear_child_tid = (clone_flags & CLONE_CHILD_CLEARTID) ? child_tidptr : NULL;
 #ifdef CONFIG_BLOCK
         p->plug = NULL;
 #endif
diff --git a/kernel/futex.c b/kernel/futex.c
index 357348a6cf6b..16dbe4c93895 100644
--- a/kernel/futex.c
+++ b/kernel/futex.c
@@ -212,7 +212,7 @@ struct futex_pi_state {
         atomic_t refcount;
 
         union futex_key key;
-};
+} __randomize_layout;
 
 /**
  * struct futex_q - The hashed futex queue entry, one per waiting task
@@ -225,7 +225,7 @@ struct futex_pi_state {
  * @requeue_pi_key:     the requeue_pi target futex key
  * @bitset:             bitset for the optional bitmasked wakeup
  *
- * We use this hashed waitqueue, instead of a normal wait_queue_t, so
+ * We use this hashed waitqueue, instead of a normal wait_queue_entry_t, so
  * we can wake only the relevant ones (hashed queues may be shared).
  *
  * A futex_q has a woken state, just like tasks have TASK_RUNNING.
@@ -246,7 +246,7 @@ struct futex_q {
         struct rt_mutex_waiter *rt_waiter;
         union futex_key *requeue_pi_key;
         u32 bitset;
-};
+} __randomize_layout;
 
 static const struct futex_q futex_q_init = {
         /* list gets initialized in queue_me()*/
@@ -488,7 +488,7 @@ static void drop_futex_key_refs(union futex_key *key)
  *
  * Return: a negative error code or 0
  *
- * The key words are stored in *key on success.
+ * The key words are stored in @key on success.
  *
  * For shared mappings, it's (page->index, file_inode(vma->vm_file),
  * offset_within_page).  For private mappings, it's (uaddr, current->mm).
@@ -1259,9 +1259,9 @@ static int lock_pi_update_atomic(u32 __user *uaddr, u32 uval, u32 newval)
  * @set_waiters:        force setting the FUTEX_WAITERS bit (1) or not (0)
  *
  * Return:
- *  0 - ready to wait;
- *  1 - acquired the lock;
- * <0 - error
+ *  -  0 - ready to wait;
+ *  -  1 - acquired the lock;
+ *  - <0 - error
  *
  * The hb->lock and futex_key refs shall be held by the caller.
  */
@@ -1717,9 +1717,9 @@ void requeue_pi_wake_futex(struct futex_q *q, union futex_key *key,
  * hb1 and hb2 must be held by the caller.
  *
  * Return:
- *  0 - failed to acquire the lock atomically;
- * >0 - acquired the lock, return value is vpid of the top_waiter
- * <0 - error
+ *  -  0 - failed to acquire the lock atomically;
+ *  - >0 - acquired the lock, return value is vpid of the top_waiter
+ *  - <0 - error
  */
 static int futex_proxy_trylock_atomic(u32 __user *pifutex,
                                  struct futex_hash_bucket *hb1,
@@ -1785,8 +1785,8 @@ static int futex_proxy_trylock_atomic(u32 __user *pifutex,
  * uaddr2 atomically on behalf of the top waiter.
  *
  * Return:
- * >=0 - on success, the number of tasks requeued or woken;
- *  <0 - on error
+ *  - >=0 - on success, the number of tasks requeued or woken;
+ *  -  <0 - on error
  */
 static int futex_requeue(u32 __user *uaddr1, unsigned int flags,
                          u32 __user *uaddr2, int nr_wake, int nr_requeue,
@@ -2142,8 +2142,8 @@ static inline void queue_me(struct futex_q *q, struct futex_hash_bucket *hb)
  * be paired with exactly one earlier call to queue_me().
  *
  * Return:
- *   1 - if the futex_q was still queued (and we removed unqueued it);
- *   0 - if the futex_q was already removed by the waking thread
+ *  - 1 - if the futex_q was still queued (and we removed unqueued it);
+ *  - 0 - if the futex_q was already removed by the waking thread
  */
 static int unqueue_me(struct futex_q *q)
 {
@@ -2333,9 +2333,9 @@ static long futex_wait_restart(struct restart_block *restart);
  * acquire the lock. Must be called with the hb lock held.
  *
  * Return:
- *  1 - success, lock taken;
- *  0 - success, lock not taken;
- * <0 - on error (-EFAULT)
+ *  -  1 - success, lock taken;
+ *  -  0 - success, lock not taken;
+ *  - <0 - on error (-EFAULT)
  */
 static int fixup_owner(u32 __user *uaddr, struct futex_q *q, int locked)
 {
@@ -2422,8 +2422,8 @@ static void futex_wait_queue_me(struct futex_hash_bucket *hb, struct futex_q *q,
  * with no q.key reference on failure.
  *
  * Return:
- *  0 - uaddr contains val and hb has been locked;
- * <1 - -EFAULT or -EWOULDBLOCK (uaddr does not contain val) and hb is unlocked
+ *  -  0 - uaddr contains val and hb has been locked;
+ *  - <1 - -EFAULT or -EWOULDBLOCK (uaddr does not contain val) and hb is unlocked
  */
 static int futex_wait_setup(u32 __user *uaddr, u32 val, unsigned int flags,
                            struct futex_q *q, struct futex_hash_bucket **hb)
@@ -2895,8 +2895,8 @@ pi_faulted:
  * called with the hb lock held.
  *
  * Return:
- *  0 = no early wakeup detected;
- * <0 = -ETIMEDOUT or -ERESTARTNOINTR
+ *  -  0 = no early wakeup detected;
+ *  - <0 = -ETIMEDOUT or -ERESTARTNOINTR
  */
 static inline
 int handle_early_requeue_pi_wakeup(struct futex_hash_bucket *hb,
@@ -2968,8 +2968,8 @@ int handle_early_requeue_pi_wakeup(struct futex_hash_bucket *hb,
  * If 4 or 7, we cleanup and return with -ETIMEDOUT.
  *
  * Return:
- *  0 - On success;
- * <0 - On error
+ *  -  0 - On success;
+ *  - <0 - On error
  */
 static int futex_wait_requeue_pi(u32 __user *uaddr, unsigned int flags,
                                  u32 val, ktime_t *abs_time, u32 bitset,
diff --git a/kernel/groups.c b/kernel/groups.c
index d09727692a2a..434f6665f187 100644
--- a/kernel/groups.c
+++ b/kernel/groups.c
@@ -5,6 +5,7 @@
 #include <linux/export.h>
 #include <linux/slab.h>
 #include <linux/security.h>
+#include <linux/sort.h>
 #include <linux/syscalls.h>
 #include <linux/user_namespace.h>
 #include <linux/vmalloc.h>
@@ -76,32 +77,18 @@ static int groups_from_user(struct group_info *group_info,
         return 0;
 }
 
-/* a simple Shell sort */
+static int gid_cmp(const void *_a, const void *_b)
+{
+        kgid_t a = *(kgid_t *)_a;
+        kgid_t b = *(kgid_t *)_b;
+
+        return gid_gt(a, b) - gid_lt(a, b);
+}
+
 static void groups_sort(struct group_info *group_info)
 {
-        int base, max, stride;
-        int gidsetsize = group_info->ngroups;
-
-        for (stride = 1; stride < gidsetsize; stride = 3 * stride + 1)
-                ; /* nothing */
-        stride /= 3;
-
-        while (stride) {
-                max = gidsetsize - stride;
-                for (base = 0; base < max; base++) {
-                        int left = base;
-                        int right = left + stride;
-                        kgid_t tmp = group_info->gid[right];
-
-                        while (left >= 0 && gid_gt(group_info->gid[left], tmp)) {
-                                group_info->gid[right] = group_info->gid[left];
-                                right = left;
-                                left -= stride;
-                        }
-                        group_info->gid[right] = tmp;
-                }
-                stride /= 3;
-        }
+        sort(group_info->gid, group_info->ngroups, sizeof(*group_info->gid),
+             gid_cmp, NULL);
 }
 
 /* a simple bsearch */
diff --git a/kernel/irq/Kconfig b/kernel/irq/Kconfig
index 3bbfd6a9c475..27c4e774071c 100644
--- a/kernel/irq/Kconfig
+++ b/kernel/irq/Kconfig
@@ -21,6 +21,10 @@ config GENERIC_IRQ_SHOW
 config GENERIC_IRQ_SHOW_LEVEL
        bool
 
+# Supports effective affinity mask
+config GENERIC_IRQ_EFFECTIVE_AFF_MASK
+       bool
+
 # Facility to allocate a hardware interrupt. This is legacy support
 # and should not be used in new code. Use irq domains instead.
 config GENERIC_IRQ_LEGACY_ALLOC_HWIRQ
@@ -81,6 +85,9 @@ config GENERIC_MSI_IRQ_DOMAIN
 config HANDLE_DOMAIN_IRQ
         bool
 
+config IRQ_TIMINGS
+        bool
+
 config IRQ_DOMAIN_DEBUG
         bool "Expose hardware/virtual IRQ mapping via debugfs"
         depends on IRQ_DOMAIN && DEBUG_FS
@@ -108,4 +115,15 @@ config SPARSE_IRQ
 
           If you don't know what to do here, say N.
 
+config GENERIC_IRQ_DEBUGFS
+        bool "Expose irq internals in debugfs"
+        depends on DEBUG_FS
+        default n
+        ---help---
+
+          Exposes internal state information through debugfs. Mostly for
+          developers and debugging of hard to diagnose interrupt problems.
+
+          If you don't know what to do here, say N.
+
 endmenu
diff --git a/kernel/irq/Makefile b/kernel/irq/Makefile
index 1d3ee3169202..e4aef7351f2b 100644
--- a/kernel/irq/Makefile
+++ b/kernel/irq/Makefile
@@ -1,5 +1,6 @@
 
 obj-y := irqdesc.o handle.o manage.o spurious.o resend.o chip.o dummychip.o devres.o
+obj-$(CONFIG_IRQ_TIMINGS) += timings.o
 obj-$(CONFIG_GENERIC_IRQ_CHIP) += generic-chip.o
 obj-$(CONFIG_GENERIC_IRQ_PROBE) += autoprobe.o
 obj-$(CONFIG_IRQ_DOMAIN) += irqdomain.o
@@ -10,3 +11,4 @@ obj-$(CONFIG_PM_SLEEP) += pm.o
 obj-$(CONFIG_GENERIC_MSI_IRQ) += msi.o
 obj-$(CONFIG_GENERIC_IRQ_IPI) += ipi.o
 obj-$(CONFIG_SMP) += affinity.o
+obj-$(CONFIG_GENERIC_IRQ_DEBUGFS) += debugfs.o
diff --git a/kernel/irq/affinity.c b/kernel/irq/affinity.c
index e2d356dd7581..d69bd77252a7 100644
--- a/kernel/irq/affinity.c
+++ b/kernel/irq/affinity.c
@@ -1,4 +1,7 @@
-
+/*
+ * Copyright (C) 2016 Thomas Gleixner.
+ * Copyright (C) 2016-2017 Christoph Hellwig.
+ */
 #include <linux/interrupt.h>
 #include <linux/kernel.h>
 #include <linux/slab.h>
@@ -35,13 +38,54 @@ static void irq_spread_init_one(struct cpumask *irqmsk, struct cpumask *nmsk,
         }
 }
 
-static int get_nodes_in_cpumask(const struct cpumask *mask, nodemask_t *nodemsk)
+static cpumask_var_t *alloc_node_to_present_cpumask(void)
+{
+        cpumask_var_t *masks;
+        int node;
+
+        masks = kcalloc(nr_node_ids, sizeof(cpumask_var_t), GFP_KERNEL);
+        if (!masks)
+                return NULL;
+
+        for (node = 0; node < nr_node_ids; node++) {
+                if (!zalloc_cpumask_var(&masks[node], GFP_KERNEL))
+                        goto out_unwind;
+        }
+
+        return masks;
+
+out_unwind:
+        while (--node >= 0)
+                free_cpumask_var(masks[node]);
+        kfree(masks);
+        return NULL;
+}
+
+static void free_node_to_present_cpumask(cpumask_var_t *masks)
+{
+        int node;
+
+        for (node = 0; node < nr_node_ids; node++)
+                free_cpumask_var(masks[node]);
+        kfree(masks);
+}
+
+static void build_node_to_present_cpumask(cpumask_var_t *masks)
+{
+        int cpu;
+
+        for_each_present_cpu(cpu)
+                cpumask_set_cpu(cpu, masks[cpu_to_node(cpu)]);
+}
+
+static int get_nodes_in_cpumask(cpumask_var_t *node_to_present_cpumask,
+                                const struct cpumask *mask, nodemask_t *nodemsk)
 {
         int n, nodes = 0;
 
         /* Calculate the number of nodes in the supplied affinity mask */
-        for_each_online_node(n) {
-                if (cpumask_intersects(mask, cpumask_of_node(n))) {
+        for_each_node(n) {
+                if (cpumask_intersects(mask, node_to_present_cpumask[n])) {
                         node_set(n, *nodemsk);
                         nodes++;
                 }
@@ -64,7 +108,14 @@ irq_create_affinity_masks(int nvecs, const struct irq_affinity *affd)
         int last_affv = affv + affd->pre_vectors;
         nodemask_t nodemsk = NODE_MASK_NONE;
         struct cpumask *masks;
-        cpumask_var_t nmsk;
+        cpumask_var_t nmsk, *node_to_present_cpumask;
+
+        /*
+         * If there aren't any vectors left after applying the pre/post
+         * vectors don't bother with assigning affinity.
+         */
+        if (!affv)
+                return NULL;
 
         if (!zalloc_cpumask_var(&nmsk, GFP_KERNEL))
                 return NULL;
@@ -73,13 +124,19 @@ irq_create_affinity_masks(int nvecs, const struct irq_affinity *affd)
         if (!masks)
                 goto out;
 
+        node_to_present_cpumask = alloc_node_to_present_cpumask();
+        if (!node_to_present_cpumask)
+                goto out;
+
         /* Fill out vectors at the beginning that don't need affinity */
         for (curvec = 0; curvec < affd->pre_vectors; curvec++)
                 cpumask_copy(masks + curvec, irq_default_affinity);
 
         /* Stabilize the cpumasks */
         get_online_cpus();
-        nodes = get_nodes_in_cpumask(cpu_online_mask, &nodemsk);
+        build_node_to_present_cpumask(node_to_present_cpumask);
+        nodes = get_nodes_in_cpumask(node_to_present_cpumask, cpu_present_mask,
+                                     &nodemsk);
 
         /*
          * If the number of nodes in the mask is greater than or equal the
@@ -87,7 +144,8 @@ irq_create_affinity_masks(int nvecs, const struct irq_affinity *affd)
          */
         if (affv <= nodes) {
                 for_each_node_mask(n, nodemsk) {
-                        cpumask_copy(masks + curvec, cpumask_of_node(n));
+                        cpumask_copy(masks + curvec,
+                                     node_to_present_cpumask[n]);
                         if (++curvec == last_affv)
                                 break;
                 }
@@ -101,7 +159,7 @@ irq_create_affinity_masks(int nvecs, const struct irq_affinity *affd)
                 vecs_per_node = (affv - (curvec - affd->pre_vectors)) / nodes;
 
                 /* Get the cpus on this node which are in the mask */
-                cpumask_and(nmsk, cpu_online_mask, cpumask_of_node(n));
+                cpumask_and(nmsk, cpu_present_mask, node_to_present_cpumask[n]);
 
                 /* Calculate the number of cpus per vector */
                 ncpus = cpumask_weight(nmsk);
@@ -133,6 +191,7 @@ done:
         /* Fill out vectors at the end that don't need affinity */
         for (; curvec < nvecs; curvec++)
                 cpumask_copy(masks + curvec, irq_default_affinity);
+        free_node_to_present_cpumask(node_to_present_cpumask);
 out:
         free_cpumask_var(nmsk);
         return masks;
@@ -140,19 +199,21 @@ out:
 
 /**
  * irq_calc_affinity_vectors - Calculate the optimal number of vectors
+ * @minvec:     The minimum number of vectors available
  * @maxvec:     The maximum number of vectors available
  * @affd:       Description of the affinity requirements
  */
-int irq_calc_affinity_vectors(int maxvec, const struct irq_affinity *affd)
+int irq_calc_affinity_vectors(int minvec, int maxvec, const struct irq_affinity *affd)
 {
         int resv = affd->pre_vectors + affd->post_vectors;
         int vecs = maxvec - resv;
-        int cpus;
+        int ret;
+
+        if (resv > minvec)
+                return 0;
 
-        /* Stabilize the cpumasks */
         get_online_cpus();
-        cpus = cpumask_weight(cpu_online_mask);
+        ret = min_t(int, cpumask_weight(cpu_present_mask), vecs) + resv;
         put_online_cpus();
-
-        return min(cpus, vecs) + resv;
+        return ret;
 }
diff --git a/kernel/irq/autoprobe.c b/kernel/irq/autoprobe.c
index 0119b9d467ae..d30a0dd5cc02 100644
--- a/kernel/irq/autoprobe.c
+++ b/kernel/irq/autoprobe.c
@@ -53,7 +53,7 @@ unsigned long probe_irq_on(void)
                         if (desc->irq_data.chip->irq_set_type)
                                 desc->irq_data.chip->irq_set_type(&desc->irq_data,
                                                          IRQ_TYPE_PROBE);
-                        irq_startup(desc, false);
+                        irq_startup(desc, IRQ_NORESEND, IRQ_START_FORCE);
                 }
                 raw_spin_unlock_irq(&desc->lock);
         }
@@ -70,7 +70,7 @@ unsigned long probe_irq_on(void)
                 raw_spin_lock_irq(&desc->lock);
                 if (!desc->action && irq_settings_can_probe(desc)) {
                         desc->istate |= IRQS_AUTODETECT | IRQS_WAITING;
-                        if (irq_startup(desc, false))
+                        if (irq_startup(desc, IRQ_NORESEND, IRQ_START_FORCE))
                                 desc->istate |= IRQS_PENDING;
                 }
                 raw_spin_unlock_irq(&desc->lock);
diff --git a/kernel/irq/chip.c b/kernel/irq/chip.c
index c94da688ee9b..a3cc37c0c85e 100644
--- a/kernel/irq/chip.c
+++ b/kernel/irq/chip.c
@@ -7,7 +7,7 @@
  * This file contains the core interrupt handling code, for irq-chip
  * based architectures.
  *
- * Detailed information is available in Documentation/DocBook/genericirq
+ * Detailed information is available in Documentation/core-api/genericirq.rst
  */
 
 #include <linux/irq.h>
@@ -170,62 +170,167 @@ static void irq_state_clr_disabled(struct irq_desc *desc)
         irqd_clear(&desc->irq_data, IRQD_IRQ_DISABLED);
 }
 
-static void irq_state_set_disabled(struct irq_desc *desc)
+static void irq_state_clr_masked(struct irq_desc *desc)
 {
-        irqd_set(&desc->irq_data, IRQD_IRQ_DISABLED);
+        irqd_clear(&desc->irq_data, IRQD_IRQ_MASKED);
 }
 
-static void irq_state_clr_masked(struct irq_desc *desc)
+static void irq_state_clr_started(struct irq_desc *desc)
 {
-        irqd_clear(&desc->irq_data, IRQD_IRQ_MASKED);
+        irqd_clear(&desc->irq_data, IRQD_IRQ_STARTED);
 }
 
-static void irq_state_set_masked(struct irq_desc *desc)
+static void irq_state_set_started(struct irq_desc *desc)
 {
-        irqd_set(&desc->irq_data, IRQD_IRQ_MASKED);
+        irqd_set(&desc->irq_data, IRQD_IRQ_STARTED);
 }
 
-int irq_startup(struct irq_desc *desc, bool resend)
+enum {
+        IRQ_STARTUP_NORMAL,
+        IRQ_STARTUP_MANAGED,
+        IRQ_STARTUP_ABORT,
+};
+
+#ifdef CONFIG_SMP
+static int
+__irq_startup_managed(struct irq_desc *desc, struct cpumask *aff, bool force)
 {
-        int ret = 0;
+        struct irq_data *d = irq_desc_get_irq_data(desc);
 
-        irq_state_clr_disabled(desc);
-        desc->depth = 0;
+        if (!irqd_affinity_is_managed(d))
+                return IRQ_STARTUP_NORMAL;
+
+        irqd_clr_managed_shutdown(d);
+
+        if (cpumask_any_and(aff, cpu_online_mask) > nr_cpu_ids) {
+                /*
+                 * Catch code which fiddles with enable_irq() on a managed
+                 * and potentially shutdown IRQ. Chained interrupt
+                 * installment or irq auto probing should not happen on
+                 * managed irqs either. Emit a warning, break the affinity
+                 * and start it up as a normal interrupt.
+                 */
+                if (WARN_ON_ONCE(force))
+                        return IRQ_STARTUP_NORMAL;
+                /*
+                 * The interrupt was requested, but there is no online CPU
+                 * in it's affinity mask. Put it into managed shutdown
+                 * state and let the cpu hotplug mechanism start it up once
+                 * a CPU in the mask becomes available.
+                 */
+                irqd_set_managed_shutdown(d);
+                return IRQ_STARTUP_ABORT;
+        }
+        return IRQ_STARTUP_MANAGED;
+}
+#else
+static __always_inline int
+__irq_startup_managed(struct irq_desc *desc, struct cpumask *aff, bool force)
+{
+        return IRQ_STARTUP_NORMAL;
+}
+#endif
 
-        irq_domain_activate_irq(&desc->irq_data);
-        if (desc->irq_data.chip->irq_startup) {
-                ret = desc->irq_data.chip->irq_startup(&desc->irq_data);
+static int __irq_startup(struct irq_desc *desc)
+{
+        struct irq_data *d = irq_desc_get_irq_data(desc);
+        int ret = 0;
+
+        irq_domain_activate_irq(d);
+        if (d->chip->irq_startup) {
+                ret = d->chip->irq_startup(d);
+                irq_state_clr_disabled(desc);
                 irq_state_clr_masked(desc);
         } else {
                 irq_enable(desc);
         }
+        irq_state_set_started(desc);
+        return ret;
+}
+
+int irq_startup(struct irq_desc *desc, bool resend, bool force)
+{
+        struct irq_data *d = irq_desc_get_irq_data(desc);
+        struct cpumask *aff = irq_data_get_affinity_mask(d);
+        int ret = 0;
+
+        desc->depth = 0;
+
+        if (irqd_is_started(d)) {
+                irq_enable(desc);
+        } else {
+                switch (__irq_startup_managed(desc, aff, force)) {
+                case IRQ_STARTUP_NORMAL:
+                        ret = __irq_startup(desc);
+                        irq_setup_affinity(desc);
+                        break;
+                case IRQ_STARTUP_MANAGED:
+                        ret = __irq_startup(desc);
+                        irq_set_affinity_locked(d, aff, false);
+                        break;
+                case IRQ_STARTUP_ABORT:
+                        return 0;
+                }
+        }
         if (resend)
                 check_irq_resend(desc);
+
         return ret;
 }
 
+static void __irq_disable(struct irq_desc *desc, bool mask);
+
 void irq_shutdown(struct irq_desc *desc)
 {
-        irq_state_set_disabled(desc);
-        desc->depth = 1;
-        if (desc->irq_data.chip->irq_shutdown)
-                desc->irq_data.chip->irq_shutdown(&desc->irq_data);
-        else if (desc->irq_data.chip->irq_disable)
-                desc->irq_data.chip->irq_disable(&desc->irq_data);
-        else
-                desc->irq_data.chip->irq_mask(&desc->irq_data);
+        if (irqd_is_started(&desc->irq_data)) {
+                desc->depth = 1;
+                if (desc->irq_data.chip->irq_shutdown) {
+                        desc->irq_data.chip->irq_shutdown(&desc->irq_data);
+                        irq_state_set_disabled(desc);
+                        irq_state_set_masked(desc);
+                } else {
+                        __irq_disable(desc, true);
+                }
+                irq_state_clr_started(desc);
+        }
+        /*
+         * This must be called even if the interrupt was never started up,
+         * because the activation can happen before the interrupt is
+         * available for request/startup. It has it's own state tracking so
+         * it's safe to call it unconditionally.
+         */
         irq_domain_deactivate_irq(&desc->irq_data);
-        irq_state_set_masked(desc);
 }
 
 void irq_enable(struct irq_desc *desc)
 {
-        irq_state_clr_disabled(desc);
-        if (desc->irq_data.chip->irq_enable)
-                desc->irq_data.chip->irq_enable(&desc->irq_data);
-        else
-                desc->irq_data.chip->irq_unmask(&desc->irq_data);
-        irq_state_clr_masked(desc);
+        if (!irqd_irq_disabled(&desc->irq_data)) {
+                unmask_irq(desc);
+        } else {
+                irq_state_clr_disabled(desc);
+                if (desc->irq_data.chip->irq_enable) {
+                        desc->irq_data.chip->irq_enable(&desc->irq_data);
+                        irq_state_clr_masked(desc);
+                } else {
+                        unmask_irq(desc);
+                }
+        }
+}
+
+static void __irq_disable(struct irq_desc *desc, bool mask)
+{
+        if (irqd_irq_disabled(&desc->irq_data)) {
+                if (mask)
+                        mask_irq(desc);
+        } else {
+                irq_state_set_disabled(desc);
+                if (desc->irq_data.chip->irq_disable) {
+                        desc->irq_data.chip->irq_disable(&desc->irq_data);
+                        irq_state_set_masked(desc);
+                } else if (mask) {
+                        mask_irq(desc);
+                }
+        }
 }
 
 /**
@@ -250,13 +355,7 @@ void irq_enable(struct irq_desc *desc)
  */
 void irq_disable(struct irq_desc *desc)
 {
-        irq_state_set_disabled(desc);
-        if (desc->irq_data.chip->irq_disable) {
-                desc->irq_data.chip->irq_disable(&desc->irq_data);
-                irq_state_set_masked(desc);
-        } else if (irq_settings_disable_unlazy(desc)) {
-                mask_irq(desc);
-        }
+        __irq_disable(desc, irq_settings_disable_unlazy(desc));
 }
 
 void irq_percpu_enable(struct irq_desc *desc, unsigned int cpu)
@@ -279,18 +378,21 @@ void irq_percpu_disable(struct irq_desc *desc, unsigned int cpu)
 
 static inline void mask_ack_irq(struct irq_desc *desc)
 {
-        if (desc->irq_data.chip->irq_mask_ack)
+        if (desc->irq_data.chip->irq_mask_ack) {
                 desc->irq_data.chip->irq_mask_ack(&desc->irq_data);
-        else {
-                desc->irq_data.chip->irq_mask(&desc->irq_data);
+                irq_state_set_masked(desc);
+        } else {
+                mask_irq(desc);
                 if (desc->irq_data.chip->irq_ack)
                         desc->irq_data.chip->irq_ack(&desc->irq_data);
         }
-        irq_state_set_masked(desc);
 }
 
 void mask_irq(struct irq_desc *desc)
 {
+        if (irqd_irq_masked(&desc->irq_data))
+                return;
+
         if (desc->irq_data.chip->irq_mask) {
                 desc->irq_data.chip->irq_mask(&desc->irq_data);
                 irq_state_set_masked(desc);
@@ -299,6 +401,9 @@ void mask_irq(struct irq_desc *desc)
 
 void unmask_irq(struct irq_desc *desc)
 {
+        if (!irqd_irq_masked(&desc->irq_data))
+                return;
+
         if (desc->irq_data.chip->irq_unmask) {
                 desc->irq_data.chip->irq_unmask(&desc->irq_data);
                 irq_state_clr_masked(desc);
@@ -312,10 +417,7 @@ void unmask_threaded_irq(struct irq_desc *desc)
         if (chip->flags & IRQCHIP_EOI_THREADED)
                 chip->irq_eoi(&desc->irq_data);
 
-        if (chip->irq_unmask) {
-                chip->irq_unmask(&desc->irq_data);
-                irq_state_clr_masked(desc);
-        }
+        unmask_irq(desc);
 }
 
 /*
@@ -851,7 +953,7 @@ __irq_do_set_handler(struct irq_desc *desc, irq_flow_handler_t handle,
                 irq_settings_set_norequest(desc);
                 irq_settings_set_nothread(desc);
                 desc->action = &chained_action;
-                irq_startup(desc, true);
+                irq_startup(desc, IRQ_RESEND, IRQ_START_FORCE);
         }
 }
 
@@ -903,6 +1005,13 @@ void irq_modify_status(unsigned int irq, unsigned long clr, unsigned long set)
 
         if (!desc)
                 return;
+
+        /*
+         * Warn when a driver sets the no autoenable flag on an already
+         * active interrupt.
+         */
+        WARN_ON_ONCE(!desc->depth && (set & _IRQ_NOAUTOEN));
+
         irq_settings_clr_and_set(desc, clr, set);
 
         irqd_clear(&desc->irq_data, IRQD_NO_BALANCING | IRQD_PER_CPU |
diff --git a/kernel/irq/cpuhotplug.c b/kernel/irq/cpuhotplug.c
index 011f8c4c63da..aee8f7ec40af 100644
--- a/kernel/irq/cpuhotplug.c
+++ b/kernel/irq/cpuhotplug.c
@@ -14,37 +14,99 @@
 
 #include "internals.h"
 
+/* For !GENERIC_IRQ_EFFECTIVE_AFF_MASK this looks at general affinity mask */
+static inline bool irq_needs_fixup(struct irq_data *d)
+{
+        const struct cpumask *m = irq_data_get_effective_affinity_mask(d);
+
+        return cpumask_test_cpu(smp_processor_id(), m);
+}
+
 static bool migrate_one_irq(struct irq_desc *desc)
 {
         struct irq_data *d = irq_desc_get_irq_data(desc);
-        const struct cpumask *affinity = d->common->affinity;
-        struct irq_chip *c;
-        bool ret = false;
+        struct irq_chip *chip = irq_data_get_irq_chip(d);
+        bool maskchip = !irq_can_move_pcntxt(d) && !irqd_irq_masked(d);
+        const struct cpumask *affinity;
+        bool brokeaff = false;
+        int err;
 
         /*
-         * If this is a per-CPU interrupt, or the affinity does not
-         * include this CPU, then we have nothing to do.
+         * IRQ chip might be already torn down, but the irq descriptor is
+         * still in the radix tree. Also if the chip has no affinity setter,
+         * nothing can be done here.
          */
-        if (irqd_is_per_cpu(d) ||
-            !cpumask_test_cpu(smp_processor_id(), affinity))
+        if (!chip || !chip->irq_set_affinity) {
+                pr_debug("IRQ %u: Unable to migrate away\n", d->irq);
                 return false;
+        }
+
+        /*
+         * No move required, if:
+         * - Interrupt is per cpu
+         * - Interrupt is not started
+         * - Affinity mask does not include this CPU.
+         *
+         * Note: Do not check desc->action as this might be a chained
+         * interrupt.
+         */
+        if (irqd_is_per_cpu(d) || !irqd_is_started(d) || !irq_needs_fixup(d)) {
+                /*
+                 * If an irq move is pending, abort it if the dying CPU is
+                 * the sole target.
+                 */
+                irq_fixup_move_pending(desc, false);
+                return false;
+        }
+
+        /*
+         * Complete an eventually pending irq move cleanup. If this
+         * interrupt was moved in hard irq context, then the vectors need
+         * to be cleaned up. It can't wait until this interrupt actually
+         * happens and this CPU was involved.
+         */
+        irq_force_complete_move(desc);
+
+        /*
+         * If there is a setaffinity pending, then try to reuse the pending
+         * mask, so the last change of the affinity does not get lost. If
+         * there is no move pending or the pending mask does not contain
+         * any online CPU, use the current affinity mask.
+         */
+        if (irq_fixup_move_pending(desc, true))
+                affinity = irq_desc_get_pending_mask(desc);
+        else
+                affinity = irq_data_get_affinity_mask(d);
+
+        /* Mask the chip for interrupts which cannot move in process context */
+        if (maskchip && chip->irq_mask)
+                chip->irq_mask(d);
 
         if (cpumask_any_and(affinity, cpu_online_mask) >= nr_cpu_ids) {
+                /*
+                 * If the interrupt is managed, then shut it down and leave
+                 * the affinity untouched.
+                 */
+                if (irqd_affinity_is_managed(d)) {
+                        irqd_set_managed_shutdown(d);
+                        irq_shutdown(desc);
+                        return false;
+                }
                 affinity = cpu_online_mask;
-                ret = true;
+                brokeaff = true;
         }
 
-        c = irq_data_get_irq_chip(d);
-        if (!c->irq_set_affinity) {
-                pr_debug("IRQ%u: unable to set affinity\n", d->irq);
-        } else {
-                int r = irq_do_set_affinity(d, affinity, false);
-                if (r)
-                        pr_warn_ratelimited("IRQ%u: set affinity failed(%d).\n",
-                                            d->irq, r);
+        err = irq_do_set_affinity(d, affinity, true);
+        if (err) {
+                pr_warn_ratelimited("IRQ%u: set affinity failed(%d).\n",
+                                    d->irq, err);
+                brokeaff = false;
         }
 
-        return ret;
+        if (maskchip && chip->irq_unmask)
+                chip->irq_unmask(d);
+
+        return brokeaff;
 }
 
 /**
@@ -59,11 +121,8 @@ static bool migrate_one_irq(struct irq_desc *desc)
  */
 void irq_migrate_all_off_this_cpu(void)
 {
-        unsigned int irq;
         struct irq_desc *desc;
-        unsigned long flags;
-
-        local_irq_save(flags);
+        unsigned int irq;
 
         for_each_active_irq(irq) {
                 bool affinity_broken;
@@ -73,10 +132,53 @@ void irq_migrate_all_off_this_cpu(void)
                 affinity_broken = migrate_one_irq(desc);
                 raw_spin_unlock(&desc->lock);
 
-                if (affinity_broken)
-                        pr_warn_ratelimited("IRQ%u no longer affine to CPU%u\n",
+                if (affinity_broken) {
+                        pr_warn_ratelimited("IRQ %u: no longer affine to CPU%u\n",
                                             irq, smp_processor_id());
+                }
+        }
+}
+
+static void irq_restore_affinity_of_irq(struct irq_desc *desc, unsigned int cpu)
+{
+        struct irq_data *data = irq_desc_get_irq_data(desc);
+        const struct cpumask *affinity = irq_data_get_affinity_mask(data);
+
+        if (!irqd_affinity_is_managed(data) || !desc->action ||
+            !irq_data_get_irq_chip(data) || !cpumask_test_cpu(cpu, affinity))
+                return;
+
+        if (irqd_is_managed_and_shutdown(data)) {
+                irq_startup(desc, IRQ_RESEND, IRQ_START_COND);
+                return;
+        }
+
+        /*
+         * If the interrupt can only be directed to a single target
+         * CPU then it is already assigned to a CPU in the affinity
+         * mask. No point in trying to move it around.
+         */
+        if (!irqd_is_single_target(data))
+                irq_set_affinity_locked(data, affinity, false);
+}
+
+/**
+ * irq_affinity_online_cpu - Restore affinity for managed interrupts
+ * @cpu:        Upcoming CPU for which interrupts should be restored
+ */
+int irq_affinity_online_cpu(unsigned int cpu)
+{
+        struct irq_desc *desc;
+        unsigned int irq;
+
+        irq_lock_sparse();
+        for_each_active_irq(irq) {
+                desc = irq_to_desc(irq);
+                raw_spin_lock_irq(&desc->lock);
+                irq_restore_affinity_of_irq(desc, cpu);
+                raw_spin_unlock_irq(&desc->lock);
         }
+        irq_unlock_sparse();
 
-        local_irq_restore(flags);
+        return 0;
 }
diff --git a/kernel/irq/debugfs.c b/kernel/irq/debugfs.c
new file mode 100644
index 000000000000..4d384edc0c64
--- /dev/null
+++ b/kernel/irq/debugfs.c
@@ -0,0 +1,213 @@
+/*
+ * Copyright 2017 Thomas Gleixner <tglx@linutronix.de>
+ *
+ * This file is licensed under the GPL V2.
+ */
+#include <linux/irqdomain.h>
+#include <linux/irq.h>
+
+#include "internals.h"
+
+static struct dentry *irq_dir;
+
+struct irq_bit_descr {
+        unsigned int    mask;
+        char            *name;
+};
+#define BIT_MASK_DESCR(m)       { .mask = m, .name = #m }
+
+static void irq_debug_show_bits(struct seq_file *m, int ind, unsigned int state,
+                                const struct irq_bit_descr *sd, int size)
+{
+        int i;
+
+        for (i = 0; i < size; i++, sd++) {
+                if (state & sd->mask)
+                        seq_printf(m, "%*s%s\n", ind + 12, "", sd->name);
+        }
+}
+
+#ifdef CONFIG_SMP
+static void irq_debug_show_masks(struct seq_file *m, struct irq_desc *desc)
+{
+        struct irq_data *data = irq_desc_get_irq_data(desc);
+        struct cpumask *msk;
+
+        msk = irq_data_get_affinity_mask(data);
+        seq_printf(m, "affinity: %*pbl\n", cpumask_pr_args(msk));
+#ifdef CONFIG_GENERIC_IRQ_EFFECTIVE_AFF_MASK
+        msk = irq_data_get_effective_affinity_mask(data);
+        seq_printf(m, "effectiv: %*pbl\n", cpumask_pr_args(msk));
+#endif
+#ifdef CONFIG_GENERIC_PENDING_IRQ
+        msk = desc->pending_mask;
+        seq_printf(m, "pending:  %*pbl\n", cpumask_pr_args(msk));
+#endif
+}
+#else
+static void irq_debug_show_masks(struct seq_file *m, struct irq_desc *desc) { }
+#endif
+
+static const struct irq_bit_descr irqchip_flags[] = {
+        BIT_MASK_DESCR(IRQCHIP_SET_TYPE_MASKED),
+        BIT_MASK_DESCR(IRQCHIP_EOI_IF_HANDLED),
+        BIT_MASK_DESCR(IRQCHIP_MASK_ON_SUSPEND),
+        BIT_MASK_DESCR(IRQCHIP_ONOFFLINE_ENABLED),
+        BIT_MASK_DESCR(IRQCHIP_SKIP_SET_WAKE),
+        BIT_MASK_DESCR(IRQCHIP_ONESHOT_SAFE),
+        BIT_MASK_DESCR(IRQCHIP_EOI_THREADED),
+};
+
+static void
+irq_debug_show_chip(struct seq_file *m, struct irq_data *data, int ind)
+{
+        struct irq_chip *chip = data->chip;
+
+        if (!chip) {
+                seq_printf(m, "chip: None\n");
+                return;
+        }
+        seq_printf(m, "%*schip:    %s\n", ind, "", chip->name);
+        seq_printf(m, "%*sflags:   0x%lx\n", ind + 1, "", chip->flags);
+        irq_debug_show_bits(m, ind, chip->flags, irqchip_flags,
+                            ARRAY_SIZE(irqchip_flags));
+}
+
+static void
+irq_debug_show_data(struct seq_file *m, struct irq_data *data, int ind)
+{
+        seq_printf(m, "%*sdomain:  %s\n", ind, "",
+                   data->domain ? data->domain->name : "");
+        seq_printf(m, "%*shwirq:   0x%lx\n", ind + 1, "", data->hwirq);
+        irq_debug_show_chip(m, data, ind + 1);
+#ifdef  CONFIG_IRQ_DOMAIN_HIERARCHY
+        if (!data->parent_data)
+                return;
+        seq_printf(m, "%*sparent:\n", ind + 1, "");
+        irq_debug_show_data(m, data->parent_data, ind + 4);
+#endif
+}
+
+static const struct irq_bit_descr irqdata_states[] = {
+        BIT_MASK_DESCR(IRQ_TYPE_EDGE_RISING),
+        BIT_MASK_DESCR(IRQ_TYPE_EDGE_FALLING),
+        BIT_MASK_DESCR(IRQ_TYPE_LEVEL_HIGH),
+        BIT_MASK_DESCR(IRQ_TYPE_LEVEL_LOW),
+        BIT_MASK_DESCR(IRQD_LEVEL),
+
+        BIT_MASK_DESCR(IRQD_ACTIVATED),
+        BIT_MASK_DESCR(IRQD_IRQ_STARTED),
+        BIT_MASK_DESCR(IRQD_IRQ_DISABLED),
+        BIT_MASK_DESCR(IRQD_IRQ_MASKED),
+        BIT_MASK_DESCR(IRQD_IRQ_INPROGRESS),
+
+        BIT_MASK_DESCR(IRQD_PER_CPU),
+        BIT_MASK_DESCR(IRQD_NO_BALANCING),
+
+        BIT_MASK_DESCR(IRQD_SINGLE_TARGET),
+        BIT_MASK_DESCR(IRQD_MOVE_PCNTXT),
+        BIT_MASK_DESCR(IRQD_AFFINITY_SET),
+        BIT_MASK_DESCR(IRQD_SETAFFINITY_PENDING),
+        BIT_MASK_DESCR(IRQD_AFFINITY_MANAGED),
+        BIT_MASK_DESCR(IRQD_MANAGED_SHUTDOWN),
+
+        BIT_MASK_DESCR(IRQD_FORWARDED_TO_VCPU),
+
+        BIT_MASK_DESCR(IRQD_WAKEUP_STATE),
+        BIT_MASK_DESCR(IRQD_WAKEUP_ARMED),
+};
+
+static const struct irq_bit_descr irqdesc_states[] = {
+        BIT_MASK_DESCR(_IRQ_NOPROBE),
+        BIT_MASK_DESCR(_IRQ_NOREQUEST),
+        BIT_MASK_DESCR(_IRQ_NOTHREAD),
+        BIT_MASK_DESCR(_IRQ_NOAUTOEN),
+        BIT_MASK_DESCR(_IRQ_NESTED_THREAD),
+        BIT_MASK_DESCR(_IRQ_PER_CPU_DEVID),
+        BIT_MASK_DESCR(_IRQ_IS_POLLED),
+        BIT_MASK_DESCR(_IRQ_DISABLE_UNLAZY),
+};
+
+static const struct irq_bit_descr irqdesc_istates[] = {
+        BIT_MASK_DESCR(IRQS_AUTODETECT),
+        BIT_MASK_DESCR(IRQS_SPURIOUS_DISABLED),
+        BIT_MASK_DESCR(IRQS_POLL_INPROGRESS),
+        BIT_MASK_DESCR(IRQS_ONESHOT),
+        BIT_MASK_DESCR(IRQS_REPLAY),
+        BIT_MASK_DESCR(IRQS_WAITING),
+        BIT_MASK_DESCR(IRQS_PENDING),
+        BIT_MASK_DESCR(IRQS_SUSPENDED),
+};
+
+
+static int irq_debug_show(struct seq_file *m, void *p)
+{
+        struct irq_desc *desc = m->private;
+        struct irq_data *data;
+
+        raw_spin_lock_irq(&desc->lock);
+        data = irq_desc_get_irq_data(desc);
+        seq_printf(m, "handler:  %pf\n", desc->handle_irq);
+        seq_printf(m, "status:   0x%08x\n", desc->status_use_accessors);
+        irq_debug_show_bits(m, 0, desc->status_use_accessors, irqdesc_states,
+                            ARRAY_SIZE(irqdesc_states));
+        seq_printf(m, "istate:   0x%08x\n", desc->istate);
+        irq_debug_show_bits(m, 0, desc->istate, irqdesc_istates,
+                            ARRAY_SIZE(irqdesc_istates));
+        seq_printf(m, "ddepth:   %u\n", desc->depth);
+        seq_printf(m, "wdepth:   %u\n", desc->wake_depth);
+        seq_printf(m, "dstate:   0x%08x\n", irqd_get(data));
+        irq_debug_show_bits(m, 0, irqd_get(data), irqdata_states,
+                            ARRAY_SIZE(irqdata_states));
+        seq_printf(m, "node:     %d\n", irq_data_get_node(data));
+        irq_debug_show_masks(m, desc);
+        irq_debug_show_data(m, data, 0);
+        raw_spin_unlock_irq(&desc->lock);
+        return 0;
+}
+
+static int irq_debug_open(struct inode *inode, struct file *file)
+{
+        return single_open(file, irq_debug_show, inode->i_private);
+}
+
+static const struct file_operations dfs_irq_ops = {
+        .open           = irq_debug_open,
+        .read           = seq_read,
+        .llseek         = seq_lseek,
+        .release        = single_release,
+};
+
+void irq_add_debugfs_entry(unsigned int irq, struct irq_desc *desc)
+{
+        char name [10];
+
+        if (!irq_dir || !desc || desc->debugfs_file)
+                return;
+
+        sprintf(name, "%d", irq);
+        desc->debugfs_file = debugfs_create_file(name, 0444, irq_dir, desc,
+                                                 &dfs_irq_ops);
+}
+
+static int __init irq_debugfs_init(void)
+{
+        struct dentry *root_dir;
+        int irq;
+
+        root_dir = debugfs_create_dir("irq", NULL);
+        if (!root_dir)
+                return -ENOMEM;
+
+        irq_domain_debugfs_init(root_dir);
+
+        irq_dir = debugfs_create_dir("irqs", root_dir);
+
+        irq_lock_sparse();
+        for_each_active_irq(irq)
+                irq_add_debugfs_entry(irq, irq_to_desc(irq));
+        irq_unlock_sparse();
+
+        return 0;
+}
+__initcall(irq_debugfs_init);
diff --git a/kernel/irq/devres.c b/kernel/irq/devres.c
index 1613bfd48365..194c506d9d20 100644
--- a/kernel/irq/devres.c
+++ b/kernel/irq/devres.c
@@ -4,6 +4,8 @@
 #include <linux/gfp.h>
 #include <linux/irq.h>
 
+#include "internals.h"
+
 /*
  * Device resource management aware IRQ request/free implementation.
  */
@@ -198,3 +200,87 @@ int __devm_irq_alloc_descs(struct device *dev, int irq, unsigned int from,
         return base;
 }
 EXPORT_SYMBOL_GPL(__devm_irq_alloc_descs);
+
+#ifdef CONFIG_GENERIC_IRQ_CHIP
+/**
+ * devm_irq_alloc_generic_chip - Allocate and initialize a generic chip
+ *                               for a managed device
+ * @dev:        Device to allocate the generic chip for
+ * @name:       Name of the irq chip
+ * @num_ct:     Number of irq_chip_type instances associated with this
+ * @irq_base:   Interrupt base nr for this chip
+ * @reg_base:   Register base address (virtual)
+ * @handler:    Default flow handler associated with this chip
+ *
+ * Returns an initialized irq_chip_generic structure. The chip defaults
+ * to the primary (index 0) irq_chip_type and @handler
+ */
+struct irq_chip_generic *
+devm_irq_alloc_generic_chip(struct device *dev, const char *name, int num_ct,
+                            unsigned int irq_base, void __iomem *reg_base,
+                            irq_flow_handler_t handler)
+{
+        struct irq_chip_generic *gc;
+        unsigned long sz = sizeof(*gc) + num_ct * sizeof(struct irq_chip_type);
+
+        gc = devm_kzalloc(dev, sz, GFP_KERNEL);
+        if (gc)
+                irq_init_generic_chip(gc, name, num_ct,
+                                      irq_base, reg_base, handler);
+
+        return gc;
+}
+EXPORT_SYMBOL_GPL(devm_irq_alloc_generic_chip);
+
+struct irq_generic_chip_devres {
+        struct irq_chip_generic *gc;
+        u32 msk;
+        unsigned int clr;
+        unsigned int set;
+};
+
+static void devm_irq_remove_generic_chip(struct device *dev, void *res)
+{
+        struct irq_generic_chip_devres *this = res;
+
+        irq_remove_generic_chip(this->gc, this->msk, this->clr, this->set);
+}
+
+/**
+ * devm_irq_setup_generic_chip - Setup a range of interrupts with a generic
+ *                               chip for a managed device
+ *
+ * @dev:        Device to setup the generic chip for
+ * @gc:         Generic irq chip holding all data
+ * @msk:        Bitmask holding the irqs to initialize relative to gc->irq_base
+ * @flags:      Flags for initialization
+ * @clr:        IRQ_* bits to clear
+ * @set:        IRQ_* bits to set
+ *
+ * Set up max. 32 interrupts starting from gc->irq_base. Note, this
+ * initializes all interrupts to the primary irq_chip_type and its
+ * associated handler.
+ */
+int devm_irq_setup_generic_chip(struct device *dev, struct irq_chip_generic *gc,
+                                u32 msk, enum irq_gc_flags flags,
+                                unsigned int clr, unsigned int set)
+{
+        struct irq_generic_chip_devres *dr;
+
+        dr = devres_alloc(devm_irq_remove_generic_chip,
+                          sizeof(*dr), GFP_KERNEL);
+        if (!dr)
+                return -ENOMEM;
+
+        irq_setup_generic_chip(gc, msk, flags, clr, set);
+
+        dr->gc = gc;
+        dr->msk = msk;
+        dr->clr = clr;
+        dr->set = set;
+        devres_add(dev, dr);
+
+        return 0;
+}
+EXPORT_SYMBOL_GPL(devm_irq_setup_generic_chip);
+#endif /* CONFIG_GENERIC_IRQ_CHIP */
diff --git a/kernel/irq/generic-chip.c b/kernel/irq/generic-chip.c
index ee32870079c9..f7086b78ad6e 100644
--- a/kernel/irq/generic-chip.c
+++ b/kernel/irq/generic-chip.c
@@ -201,10 +201,9 @@ static void irq_writel_be(u32 val, void __iomem *addr)
         iowrite32be(val, addr);
 }
 
-static void
-irq_init_generic_chip(struct irq_chip_generic *gc, const char *name,
-                      int num_ct, unsigned int irq_base,
-                      void __iomem *reg_base, irq_flow_handler_t handler)
+void irq_init_generic_chip(struct irq_chip_generic *gc, const char *name,
+                           int num_ct, unsigned int irq_base,
+                           void __iomem *reg_base, irq_flow_handler_t handler)
 {
         raw_spin_lock_init(&gc->lock);
         gc->num_ct = num_ct;
diff --git a/kernel/irq/handle.c b/kernel/irq/handle.c
index d3f24905852c..79f987b942b8 100644
--- a/kernel/irq/handle.c
+++ b/kernel/irq/handle.c
@@ -6,7 +6,7 @@
  *
  * This file contains the core interrupt handling code.
  *
- * Detailed information is available in Documentation/DocBook/genericirq
+ * Detailed information is available in Documentation/core-api/genericirq.rst
  *
  */
 
@@ -138,6 +138,8 @@ irqreturn_t __handle_irq_event_percpu(struct irq_desc *desc, unsigned int *flags
         unsigned int irq = desc->irq_data.irq;
         struct irqaction *action;
 
+        record_irq_time(desc);
+
         for_each_action_of_desc(desc, action) {
                 irqreturn_t res;
 
diff --git a/kernel/irq/internals.h b/kernel/irq/internals.h
index bc226e783bd2..a2c48058354c 100644
--- a/kernel/irq/internals.h
+++ b/kernel/irq/internals.h
@@ -8,6 +8,7 @@
 #include <linux/irqdesc.h>
 #include <linux/kernel_stat.h>
 #include <linux/pm_runtime.h>
+#include <linux/sched/clock.h>
 
 #ifdef CONFIG_SPARSE_IRQ
 # define IRQ_BITMAP_BITS        (NR_IRQS + 8196)
@@ -57,6 +58,7 @@ enum {
         IRQS_WAITING            = 0x00000080,
         IRQS_PENDING            = 0x00000200,
         IRQS_SUSPENDED          = 0x00000800,
+        IRQS_TIMINGS            = 0x00001000,
 };
 
 #include "debug.h"
@@ -66,7 +68,14 @@ extern int __irq_set_trigger(struct irq_desc *desc, unsigned long flags);
 extern void __disable_irq(struct irq_desc *desc);
 extern void __enable_irq(struct irq_desc *desc);
 
-extern int irq_startup(struct irq_desc *desc, bool resend);
+#define IRQ_RESEND      true
+#define IRQ_NORESEND    false
+
+#define IRQ_START_FORCE true
+#define IRQ_START_COND  false
+
+extern int irq_startup(struct irq_desc *desc, bool resend, bool force);
+
 extern void irq_shutdown(struct irq_desc *desc);
 extern void irq_enable(struct irq_desc *desc);
 extern void irq_disable(struct irq_desc *desc);
@@ -109,13 +118,19 @@ static inline void unregister_handler_proc(unsigned int irq,
 
 extern bool irq_can_set_affinity_usr(unsigned int irq);
 
-extern int irq_select_affinity_usr(unsigned int irq, struct cpumask *mask);
+extern int irq_select_affinity_usr(unsigned int irq);
 
 extern void irq_set_thread_affinity(struct irq_desc *desc);
 
 extern int irq_do_set_affinity(struct irq_data *data,
                                const struct cpumask *dest, bool force);
 
+#ifdef CONFIG_SMP
+extern int irq_setup_affinity(struct irq_desc *desc);
+#else
+static inline int irq_setup_affinity(struct irq_desc *desc) { return 0; }
+#endif
+
 /* Inline functions for support of irq chips on slow busses */
 static inline void chip_bus_lock(struct irq_desc *desc)
 {
@@ -169,6 +184,11 @@ irq_put_desc_unlock(struct irq_desc *desc, unsigned long flags)
 
 #define __irqd_to_state(d) ACCESS_PRIVATE((d)->common, state_use_accessors)
 
+static inline unsigned int irqd_get(struct irq_data *d)
+{
+        return __irqd_to_state(d);
+}
+
 /*
  * Manipulation functions for irq_data.state
  */
@@ -182,6 +202,16 @@ static inline void irqd_clr_move_pending(struct irq_data *d)
         __irqd_to_state(d) &= ~IRQD_SETAFFINITY_PENDING;
 }
 
+static inline void irqd_set_managed_shutdown(struct irq_data *d)
+{
+        __irqd_to_state(d) |= IRQD_MANAGED_SHUTDOWN;
+}
+
+static inline void irqd_clr_managed_shutdown(struct irq_data *d)
+{
+        __irqd_to_state(d) &= ~IRQD_MANAGED_SHUTDOWN;
+}
+
 static inline void irqd_clear(struct irq_data *d, unsigned int mask)
 {
         __irqd_to_state(d) &= ~mask;
@@ -197,6 +227,16 @@ static inline bool irqd_has_set(struct irq_data *d, unsigned int mask)
         return __irqd_to_state(d) & mask;
 }
 
+static inline void irq_state_set_disabled(struct irq_desc *desc)
+{
+        irqd_set(&desc->irq_data, IRQD_IRQ_DISABLED);
+}
+
+static inline void irq_state_set_masked(struct irq_desc *desc)
+{
+        irqd_set(&desc->irq_data, IRQD_IRQ_MASKED);
+}
+
 #undef __irqd_to_state
 
 static inline void kstat_incr_irqs_this_cpu(struct irq_desc *desc)
@@ -226,3 +266,196 @@ irq_pm_install_action(struct irq_desc *desc, struct irqaction *action) { }
 static inline void
 irq_pm_remove_action(struct irq_desc *desc, struct irqaction *action) { }
 #endif
+
+#ifdef CONFIG_IRQ_TIMINGS
+
+#define IRQ_TIMINGS_SHIFT       5
+#define IRQ_TIMINGS_SIZE        (1 << IRQ_TIMINGS_SHIFT)
+#define IRQ_TIMINGS_MASK        (IRQ_TIMINGS_SIZE - 1)
+
+/**
+ * struct irq_timings - irq timings storing structure
+ * @values: a circular buffer of u64 encoded <timestamp,irq> values
+ * @count: the number of elements in the array
+ */
+struct irq_timings {
+        u64     values[IRQ_TIMINGS_SIZE];
+        int     count;
+};
+
+DECLARE_PER_CPU(struct irq_timings, irq_timings);
+
+extern void irq_timings_free(int irq);
+extern int irq_timings_alloc(int irq);
+
+static inline void irq_remove_timings(struct irq_desc *desc)
+{
+        desc->istate &= ~IRQS_TIMINGS;
+
+        irq_timings_free(irq_desc_get_irq(desc));
+}
+
+static inline void irq_setup_timings(struct irq_desc *desc, struct irqaction *act)
+{
+        int irq = irq_desc_get_irq(desc);
+        int ret;
+
+        /*
+         * We don't need the measurement because the idle code already
+         * knows the next expiry event.
+         */
+        if (act->flags & __IRQF_TIMER)
+                return;
+
+        /*
+         * In case the timing allocation fails, we just want to warn,
+         * not fail, so letting the system boot anyway.
+         */
+        ret = irq_timings_alloc(irq);
+        if (ret) {
+                pr_warn("Failed to allocate irq timing stats for irq%d (%d)",
+                        irq, ret);
+                return;
+        }
+
+        desc->istate |= IRQS_TIMINGS;
+}
+
+extern void irq_timings_enable(void);
+extern void irq_timings_disable(void);
+
+DECLARE_STATIC_KEY_FALSE(irq_timing_enabled);
+
+/*
+ * The interrupt number and the timestamp are encoded into a single
+ * u64 variable to optimize the size.
+ * 48 bit time stamp and 16 bit IRQ number is way sufficient.
+ *  Who cares an IRQ after 78 hours of idle time?
+ */
+static inline u64 irq_timing_encode(u64 timestamp, int irq)
+{
+        return (timestamp << 16) | irq;
+}
+
+static inline int irq_timing_decode(u64 value, u64 *timestamp)
+{
+        *timestamp = value >> 16;
+        return value & U16_MAX;
+}
+
+/*
+ * The function record_irq_time is only called in one place in the
+ * interrupts handler. We want this function always inline so the code
+ * inside is embedded in the function and the static key branching
+ * code can act at the higher level. Without the explicit
+ * __always_inline we can end up with a function call and a small
+ * overhead in the hotpath for nothing.
+ */
+static __always_inline void record_irq_time(struct irq_desc *desc)
+{
+        if (!static_branch_likely(&irq_timing_enabled))
+                return;
+
+        if (desc->istate & IRQS_TIMINGS) {
+                struct irq_timings *timings = this_cpu_ptr(&irq_timings);
+
+                timings->values[timings->count & IRQ_TIMINGS_MASK] =
+                        irq_timing_encode(local_clock(),
+                                          irq_desc_get_irq(desc));
+
+                timings->count++;
+        }
+}
+#else
+static inline void irq_remove_timings(struct irq_desc *desc) {}
+static inline void irq_setup_timings(struct irq_desc *desc,
+                                     struct irqaction *act) {};
+static inline void record_irq_time(struct irq_desc *desc) {}
+#endif /* CONFIG_IRQ_TIMINGS */
+
+
+#ifdef CONFIG_GENERIC_IRQ_CHIP
+void irq_init_generic_chip(struct irq_chip_generic *gc, const char *name,
+                           int num_ct, unsigned int irq_base,
+                           void __iomem *reg_base, irq_flow_handler_t handler);
+#else
+static inline void
+irq_init_generic_chip(struct irq_chip_generic *gc, const char *name,
+                      int num_ct, unsigned int irq_base,
+                      void __iomem *reg_base, irq_flow_handler_t handler) { }
+#endif /* CONFIG_GENERIC_IRQ_CHIP */
+
+#ifdef CONFIG_GENERIC_PENDING_IRQ
+static inline bool irq_can_move_pcntxt(struct irq_data *data)
+{
+        return irqd_can_move_in_process_context(data);
+}
+static inline bool irq_move_pending(struct irq_data *data)
+{
+        return irqd_is_setaffinity_pending(data);
+}
+static inline void
+irq_copy_pending(struct irq_desc *desc, const struct cpumask *mask)
+{
+        cpumask_copy(desc->pending_mask, mask);
+}
+static inline void
+irq_get_pending(struct cpumask *mask, struct irq_desc *desc)
+{
+        cpumask_copy(mask, desc->pending_mask);
+}
+static inline struct cpumask *irq_desc_get_pending_mask(struct irq_desc *desc)
+{
+        return desc->pending_mask;
+}
+bool irq_fixup_move_pending(struct irq_desc *desc, bool force_clear);
+#else /* CONFIG_GENERIC_PENDING_IRQ */
+static inline bool irq_can_move_pcntxt(struct irq_data *data)
+{
+        return true;
+}
+static inline bool irq_move_pending(struct irq_data *data)
+{
+        return false;
+}
+static inline void
+irq_copy_pending(struct irq_desc *desc, const struct cpumask *mask)
+{
+}
+static inline void
+irq_get_pending(struct cpumask *mask, struct irq_desc *desc)
+{
+}
+static inline struct cpumask *irq_desc_get_pending_mask(struct irq_desc *desc)
+{
+        return NULL;
+}
+static inline bool irq_fixup_move_pending(struct irq_desc *desc, bool fclear)
+{
+        return false;
+}
+#endif /* !CONFIG_GENERIC_PENDING_IRQ */
+
+#ifdef CONFIG_GENERIC_IRQ_DEBUGFS
+#include <linux/debugfs.h>
+
+void irq_add_debugfs_entry(unsigned int irq, struct irq_desc *desc);
+static inline void irq_remove_debugfs_entry(struct irq_desc *desc)
+{
+        debugfs_remove(desc->debugfs_file);
+}
+# ifdef CONFIG_IRQ_DOMAIN
+void irq_domain_debugfs_init(struct dentry *root);
+# else
+static inline void irq_domain_debugfs_init(struct dentry *root)
+{
+}
+# endif
+#else /* CONFIG_GENERIC_IRQ_DEBUGFS */
+static inline void irq_add_debugfs_entry(unsigned int irq, struct irq_desc *d)
+{
+}
+static inline void irq_remove_debugfs_entry(struct irq_desc *d)
+{
+}
+#endif /* CONFIG_GENERIC_IRQ_DEBUGFS */
diff --git a/kernel/irq/irqdesc.c b/kernel/irq/irqdesc.c
index 00bb0aeea1d0..73be2b3909bd 100644
--- a/kernel/irq/irqdesc.c
+++ b/kernel/irq/irqdesc.c
@@ -4,7 +4,7 @@
  *
  * This file contains the interrupt descriptor management code
  *
- * Detailed information is available in Documentation/DocBook/genericirq
+ * Detailed information is available in Documentation/core-api/genericirq.rst
  *
  */
 #include <linux/irq.h>
@@ -54,14 +54,25 @@ static void __init init_irq_default_affinity(void)
 #endif
 
 #ifdef CONFIG_SMP
-static int alloc_masks(struct irq_desc *desc, gfp_t gfp, int node)
+static int alloc_masks(struct irq_desc *desc, int node)
 {
         if (!zalloc_cpumask_var_node(&desc->irq_common_data.affinity,
-                                     gfp, node))
+                                     GFP_KERNEL, node))
                 return -ENOMEM;
 
+#ifdef CONFIG_GENERIC_IRQ_EFFECTIVE_AFF_MASK
+        if (!zalloc_cpumask_var_node(&desc->irq_common_data.effective_affinity,
+                                     GFP_KERNEL, node)) {
+                free_cpumask_var(desc->irq_common_data.affinity);
+                return -ENOMEM;
+        }
+#endif
+
 #ifdef CONFIG_GENERIC_PENDING_IRQ
-        if (!zalloc_cpumask_var_node(&desc->pending_mask, gfp, node)) {
+        if (!zalloc_cpumask_var_node(&desc->pending_mask, GFP_KERNEL, node)) {
+#ifdef CONFIG_GENERIC_IRQ_EFFECTIVE_AFF_MASK
+                free_cpumask_var(desc->irq_common_data.effective_affinity);
+#endif
                 free_cpumask_var(desc->irq_common_data.affinity);
                 return -ENOMEM;
         }
@@ -86,7 +97,7 @@ static void desc_smp_init(struct irq_desc *desc, int node,
 
 #else
 static inline int
-alloc_masks(struct irq_desc *desc, gfp_t gfp, int node) { return 0; }
+alloc_masks(struct irq_desc *desc, int node) { return 0; }
 static inline void
 desc_smp_init(struct irq_desc *desc, int node, const struct cpumask *affinity) { }
 #endif
@@ -105,6 +116,7 @@ static void desc_set_defaults(unsigned int irq, struct irq_desc *desc, int node,
         desc->irq_data.chip_data = NULL;
         irq_settings_clr_and_set(desc, ~0, _IRQ_DEFAULT_INIT_FLAGS);
         irqd_set(&desc->irq_data, IRQD_IRQ_DISABLED);
+        irqd_set(&desc->irq_data, IRQD_IRQ_MASKED);
         desc->handle_irq = handle_bad_irq;
         desc->depth = 1;
         desc->irq_count = 0;
@@ -324,6 +336,9 @@ static void free_masks(struct irq_desc *desc)
         free_cpumask_var(desc->pending_mask);
 #endif
         free_cpumask_var(desc->irq_common_data.affinity);
+#ifdef CONFIG_GENERIC_IRQ_EFFECTIVE_AFF_MASK
+        free_cpumask_var(desc->irq_common_data.effective_affinity);
+#endif
 }
 #else
 static inline void free_masks(struct irq_desc *desc) { }
@@ -344,9 +359,8 @@ static struct irq_desc *alloc_desc(int irq, int node, unsigned int flags,
                                    struct module *owner)
 {
         struct irq_desc *desc;
-        gfp_t gfp = GFP_KERNEL;
 
-        desc = kzalloc_node(sizeof(*desc), gfp, node);
+        desc = kzalloc_node(sizeof(*desc), GFP_KERNEL, node);
         if (!desc)
                 return NULL;
         /* allocate based on nr_cpu_ids */
@@ -354,11 +368,12 @@ static struct irq_desc *alloc_desc(int irq, int node, unsigned int flags,
         if (!desc->kstat_irqs)
                 goto err_desc;
 
-        if (alloc_masks(desc, gfp, node))
+        if (alloc_masks(desc, node))
                 goto err_kstat;
 
         raw_spin_lock_init(&desc->lock);
         lockdep_set_class(&desc->lock, &irq_desc_lock_class);
+        mutex_init(&desc->request_mutex);
         init_rcu_head(&desc->rcu);
 
         desc_set_defaults(irq, desc, node, affinity, owner);
@@ -394,6 +409,7 @@ static void free_desc(unsigned int irq)
 {
         struct irq_desc *desc = irq_to_desc(irq);
 
+        irq_remove_debugfs_entry(desc);
         unregister_irq_proc(irq, desc);
 
         /*
@@ -480,7 +496,8 @@ int __init early_irq_init(void)
 
         /* Let arch update nr_irqs and return the nr of preallocated irqs */
         initcnt = arch_probe_nr_irqs();
-        printk(KERN_INFO "NR_IRQS:%d nr_irqs:%d %d\n", NR_IRQS, nr_irqs, initcnt);
+        printk(KERN_INFO "NR_IRQS: %d, nr_irqs: %d, preallocated irqs: %d\n",
+               NR_IRQS, nr_irqs, initcnt);
 
         if (WARN_ON(nr_irqs > IRQ_BITMAP_BITS))
                 nr_irqs = IRQ_BITMAP_BITS;
@@ -516,14 +533,14 @@ int __init early_irq_init(void)
 
         init_irq_default_affinity();
 
-        printk(KERN_INFO "NR_IRQS:%d\n", NR_IRQS);
+        printk(KERN_INFO "NR_IRQS: %d\n", NR_IRQS);
 
         desc = irq_desc;
         count = ARRAY_SIZE(irq_desc);
 
         for (i = 0; i < count; i++) {
                 desc[i].kstat_irqs = alloc_percpu(unsigned int);
-                alloc_masks(&desc[i], GFP_KERNEL, node);
+                alloc_masks(&desc[i], node);
                 raw_spin_lock_init(&desc[i].lock);
                 lockdep_set_class(&desc[i].lock, &irq_desc_lock_class);
                 desc_set_defaults(i, &desc[i], node, NULL, NULL);
diff --git a/kernel/irq/irqdomain.c b/kernel/irq/irqdomain.c
index 31805f237396..f1f251479aa6 100644
--- a/kernel/irq/irqdomain.c
+++ b/kernel/irq/irqdomain.c
@@ -1,5 +1,6 @@
 #define pr_fmt(fmt)  "irq: " fmt
 
+#include <linux/acpi.h>
 #include <linux/debugfs.h>
 #include <linux/hardirq.h>
 #include <linux/interrupt.h>
@@ -26,39 +27,69 @@ static struct irq_domain *irq_default_domain;
 static void irq_domain_check_hierarchy(struct irq_domain *domain);
 
 struct irqchip_fwid {
-        struct fwnode_handle fwnode;
-        char *name;
+        struct fwnode_handle    fwnode;
+        unsigned int            type;
+        char                    *name;
         void *data;
 };
 
+#ifdef CONFIG_GENERIC_IRQ_DEBUGFS
+static void debugfs_add_domain_dir(struct irq_domain *d);
+static void debugfs_remove_domain_dir(struct irq_domain *d);
+#else
+static inline void debugfs_add_domain_dir(struct irq_domain *d) { }
+static inline void debugfs_remove_domain_dir(struct irq_domain *d) { }
+#endif
+
 /**
  * irq_domain_alloc_fwnode - Allocate a fwnode_handle suitable for
  *                           identifying an irq domain
- * @data: optional user-provided data
+ * @type:       Type of irqchip_fwnode. See linux/irqdomain.h
+ * @name:       Optional user provided domain name
+ * @id:         Optional user provided id if name != NULL
+ * @data:       Optional user-provided data
  *
- * Allocate a struct device_node, and return a poiner to the embedded
+ * Allocate a struct irqchip_fwid, and return a poiner to the embedded
  * fwnode_handle (or NULL on failure).
+ *
+ * Note: The types IRQCHIP_FWNODE_NAMED and IRQCHIP_FWNODE_NAMED_ID are
+ * solely to transport name information to irqdomain creation code. The
+ * node is not stored. For other types the pointer is kept in the irq
+ * domain struct.
  */
-struct fwnode_handle *irq_domain_alloc_fwnode(void *data)
+struct fwnode_handle *__irq_domain_alloc_fwnode(unsigned int type, int id,
+                                                const char *name, void *data)
 {
         struct irqchip_fwid *fwid;
-        char *name;
+        char *n;
 
         fwid = kzalloc(sizeof(*fwid), GFP_KERNEL);
-        name = kasprintf(GFP_KERNEL, "irqchip@%p", data);
 
-        if (!fwid || !name) {
+        switch (type) {
+        case IRQCHIP_FWNODE_NAMED:
+                n = kasprintf(GFP_KERNEL, "%s", name);
+                break;
+        case IRQCHIP_FWNODE_NAMED_ID:
+                n = kasprintf(GFP_KERNEL, "%s-%d", name, id);
+                break;
+        default:
+                n = kasprintf(GFP_KERNEL, "irqchip@%p", data);
+                break;
+        }
+
+        if (!fwid || !n) {
                 kfree(fwid);
-                kfree(name);
+                kfree(n);
                 return NULL;
         }
 
-        fwid->name = name;
+        fwid->type = type;
+        fwid->name = n;
         fwid->data = data;
         fwid->fwnode.type = FWNODE_IRQCHIP;
         return &fwid->fwnode;
 }
-EXPORT_SYMBOL_GPL(irq_domain_alloc_fwnode);
+EXPORT_SYMBOL_GPL(__irq_domain_alloc_fwnode);
 
 /**
  * irq_domain_free_fwnode - Free a non-OF-backed fwnode_handle
@@ -97,26 +128,97 @@ struct irq_domain *__irq_domain_add(struct fwnode_handle *fwnode, int size,
                                     void *host_data)
 {
         struct device_node *of_node = to_of_node(fwnode);
+        struct irqchip_fwid *fwid;
         struct irq_domain *domain;
 
+        static atomic_t unknown_domains;
+
         domain = kzalloc_node(sizeof(*domain) + (sizeof(unsigned int) * size),
                               GFP_KERNEL, of_node_to_nid(of_node));
         if (WARN_ON(!domain))
                 return NULL;
 
+        if (fwnode && is_fwnode_irqchip(fwnode)) {
+                fwid = container_of(fwnode, struct irqchip_fwid, fwnode);
+
+                switch (fwid->type) {
+                case IRQCHIP_FWNODE_NAMED:
+                case IRQCHIP_FWNODE_NAMED_ID:
+                        domain->name = kstrdup(fwid->name, GFP_KERNEL);
+                        if (!domain->name) {
+                                kfree(domain);
+                                return NULL;
+                        }
+                        domain->flags |= IRQ_DOMAIN_NAME_ALLOCATED;
+                        break;
+                default:
+                        domain->fwnode = fwnode;
+                        domain->name = fwid->name;
+                        break;
+                }
+#ifdef CONFIG_ACPI
+        } else if (is_acpi_device_node(fwnode)) {
+                struct acpi_buffer buf = {
+                        .length = ACPI_ALLOCATE_BUFFER,
+                };
+                acpi_handle handle;
+
+                handle = acpi_device_handle(to_acpi_device_node(fwnode));
+                if (acpi_get_name(handle, ACPI_FULL_PATHNAME, &buf) == AE_OK) {
+                        domain->name = buf.pointer;
+                        domain->flags |= IRQ_DOMAIN_NAME_ALLOCATED;
+                }
+
+                domain->fwnode = fwnode;
+#endif
+        } else if (of_node) {
+                char *name;
+
+                /*
+                 * DT paths contain '/', which debugfs is legitimately
+                 * unhappy about. Replace them with ':', which does
+                 * the trick and is not as offensive as '\'...
+                 */
+                name = kstrdup(of_node_full_name(of_node), GFP_KERNEL);
+                if (!name) {
+                        kfree(domain);
+                        return NULL;
+                }
+
+                strreplace(name, '/', ':');
+
+                domain->name = name;
+                domain->fwnode = fwnode;
+                domain->flags |= IRQ_DOMAIN_NAME_ALLOCATED;
+        }
+
+        if (!domain->name) {
+                if (fwnode) {
+                        pr_err("Invalid fwnode type (%d) for irqdomain\n",
+                               fwnode->type);
+                }
+                domain->name = kasprintf(GFP_KERNEL, "unknown-%d",
+                                         atomic_inc_return(&unknown_domains));
+                if (!domain->name) {
+                        kfree(domain);
+                        return NULL;
+                }
+                domain->flags |= IRQ_DOMAIN_NAME_ALLOCATED;
+        }
+
         of_node_get(of_node);
 
         /* Fill structure */
         INIT_RADIX_TREE(&domain->revmap_tree, GFP_KERNEL);
         domain->ops = ops;
         domain->host_data = host_data;
-        domain->fwnode = fwnode;
         domain->hwirq_max = hwirq_max;
         domain->revmap_size = size;
         domain->revmap_direct_max_irq = direct_max;
         irq_domain_check_hierarchy(domain);
 
         mutex_lock(&irq_domain_mutex);
+        debugfs_add_domain_dir(domain);
         list_add(&domain->link, &irq_domain_list);
         mutex_unlock(&irq_domain_mutex);
 
@@ -136,6 +238,7 @@ EXPORT_SYMBOL_GPL(__irq_domain_add);
 void irq_domain_remove(struct irq_domain *domain)
 {
         mutex_lock(&irq_domain_mutex);
+        debugfs_remove_domain_dir(domain);
 
         WARN_ON(!radix_tree_empty(&domain->revmap_tree));
 
@@ -152,10 +255,43 @@ void irq_domain_remove(struct irq_domain *domain)
         pr_debug("Removed domain %s\n", domain->name);
 
         of_node_put(irq_domain_get_of_node(domain));
+        if (domain->flags & IRQ_DOMAIN_NAME_ALLOCATED)
+                kfree(domain->name);
         kfree(domain);
 }
 EXPORT_SYMBOL_GPL(irq_domain_remove);
 
+void irq_domain_update_bus_token(struct irq_domain *domain,
+                                 enum irq_domain_bus_token bus_token)
+{
+        char *name;
+
+        if (domain->bus_token == bus_token)
+                return;
+
+        mutex_lock(&irq_domain_mutex);
+
+        domain->bus_token = bus_token;
+
+        name = kasprintf(GFP_KERNEL, "%s-%d", domain->name, bus_token);
+        if (!name) {
+                mutex_unlock(&irq_domain_mutex);
+                return;
+        }
+
+        debugfs_remove_domain_dir(domain);
+
+        if (domain->flags & IRQ_DOMAIN_NAME_ALLOCATED)
+                kfree(domain->name);
+        else
+                domain->flags |= IRQ_DOMAIN_NAME_ALLOCATED;
+
+        domain->name = name;
+        debugfs_add_domain_dir(domain);
+
+        mutex_unlock(&irq_domain_mutex);
+}
+
 /**
  * irq_domain_add_simple() - Register an irq_domain and optionally map a range of irqs
  * @of_node: pointer to interrupt controller's device tree node.
@@ -344,6 +480,7 @@ void irq_domain_disassociate(struct irq_domain *domain, unsigned int irq)
 
         irq_data->domain = NULL;
         irq_data->hwirq = 0;
+        domain->mapcount--;
 
         /* Clear reverse map for this hwirq */
         if (hwirq < domain->revmap_size) {
@@ -395,6 +532,7 @@ int irq_domain_associate(struct irq_domain *domain, unsigned int virq,
                         domain->name = irq_data->chip->name;
         }
 
+        domain->mapcount++;
         if (hwirq < domain->revmap_size) {
                 domain->linear_revmap[hwirq] = virq;
         } else {
@@ -746,13 +884,54 @@ unsigned int irq_find_mapping(struct irq_domain *domain,
 EXPORT_SYMBOL_GPL(irq_find_mapping);
 
 #ifdef CONFIG_IRQ_DOMAIN_DEBUG
+static void virq_debug_show_one(struct seq_file *m, struct irq_desc *desc)
+{
+        struct irq_domain *domain;
+        struct irq_data *data;
+
+        domain = desc->irq_data.domain;
+        data = &desc->irq_data;
+
+        while (domain) {
+                unsigned int irq = data->irq;
+                unsigned long hwirq = data->hwirq;
+                struct irq_chip *chip;
+                bool direct;
+
+                if (data == &desc->irq_data)
+                        seq_printf(m, "%5d  ", irq);
+                else
+                        seq_printf(m, "%5d+ ", irq);
+                seq_printf(m, "0x%05lx  ", hwirq);
+
+                chip = irq_data_get_irq_chip(data);
+                seq_printf(m, "%-15s  ", (chip && chip->name) ? chip->name : "none");
+
+                seq_printf(m, data ? "0x%p  " : "  %p  ",
+                           irq_data_get_irq_chip_data(data));
+
+                seq_printf(m, "   %c    ", (desc->action && desc->action->handler) ? '*' : ' ');
+                direct = (irq == hwirq) && (irq < domain->revmap_direct_max_irq);
+                seq_printf(m, "%6s%-8s  ",
+                           (hwirq < domain->revmap_size) ? "LINEAR" : "RADIX",
+                           direct ? "(DIRECT)" : "");
+                seq_printf(m, "%s\n", domain->name);
+#ifdef CONFIG_IRQ_DOMAIN_HIERARCHY
+                domain = domain->parent;
+                data = data->parent_data;
+#else
+                domain = NULL;
+#endif
+        }
+}
+
 static int virq_debug_show(struct seq_file *m, void *private)
 {
         unsigned long flags;
         struct irq_desc *desc;
         struct irq_domain *domain;
         struct radix_tree_iter iter;
-        void *data, **slot;
+        void **slot;
         int i;
 
         seq_printf(m, " %-16s  %-6s  %-10s  %-10s  %s\n",
@@ -760,15 +939,26 @@ static int virq_debug_show(struct seq_file *m, void *private)
         mutex_lock(&irq_domain_mutex);
         list_for_each_entry(domain, &irq_domain_list, link) {
                 struct device_node *of_node;
+                const char *name;
+
                 int count = 0;
+
                 of_node = irq_domain_get_of_node(domain);
+                if (of_node)
+                        name = of_node_full_name(of_node);
+                else if (is_fwnode_irqchip(domain->fwnode))
+                        name = container_of(domain->fwnode, struct irqchip_fwid,
+                                            fwnode)->name;
+                else
+                        name = "";
+
                 radix_tree_for_each_slot(slot, &domain->revmap_tree, &iter, 0)
                         count++;
                 seq_printf(m, "%c%-16s  %6u  %10u  %10u  %s\n",
                            domain == irq_default_domain ? '*' : ' ', domain->name,
                            domain->revmap_size + count, domain->revmap_size,
                            domain->revmap_direct_max_irq,
-                           of_node ? of_node_full_name(of_node) : "");
+                           name);
         }
         mutex_unlock(&irq_domain_mutex);
 
@@ -782,30 +972,7 @@ static int virq_debug_show(struct seq_file *m, void *private)
                         continue;
 
                 raw_spin_lock_irqsave(&desc->lock, flags);
-                domain = desc->irq_data.domain;
-
-                if (domain) {
-                        struct irq_chip *chip;
-                        int hwirq = desc->irq_data.hwirq;
-                        bool direct;
-
-                        seq_printf(m, "%5d  ", i);
-                        seq_printf(m, "0x%05x  ", hwirq);
-
-                        chip = irq_desc_get_chip(desc);
-                        seq_printf(m, "%-15s  ", (chip && chip->name) ? chip->name : "none");
-
-                        data = irq_desc_get_chip_data(desc);
-                        seq_printf(m, data ? "0x%p  " : "  %p  ", data);
-
-                        seq_printf(m, "   %c    ", (desc->action && desc->action->handler) ? '*' : ' ');
-                        direct = (i == hwirq) && (i < domain->revmap_direct_max_irq);
-                        seq_printf(m, "%6s%-8s  ",
-                                   (hwirq < domain->revmap_size) ? "LINEAR" : "RADIX",
-                                   direct ? "(DIRECT)" : "");
-                        seq_printf(m, "%s\n", desc->irq_data.domain->name);
-                }
-
+                virq_debug_show_one(m, desc);
                 raw_spin_unlock_irqrestore(&desc->lock, flags);
         }
 
@@ -973,6 +1140,7 @@ static void irq_domain_insert_irq(int virq)
                 struct irq_domain *domain = data->domain;
                 irq_hw_number_t hwirq = data->hwirq;
 
+                domain->mapcount++;
                 if (hwirq < domain->revmap_size) {
                         domain->linear_revmap[hwirq] = virq;
                 } else {
@@ -1002,6 +1170,7 @@ static void irq_domain_remove_irq(int virq)
                 struct irq_domain *domain = data->domain;
                 irq_hw_number_t hwirq = data->hwirq;
 
+                domain->mapcount--;
                 if (hwirq < domain->revmap_size) {
                         domain->linear_revmap[hwirq] = 0;
                 } else {
@@ -1189,43 +1358,18 @@ void irq_domain_free_irqs_top(struct irq_domain *domain, unsigned int virq,
         irq_domain_free_irqs_common(domain, virq, nr_irqs);
 }
 
-static bool irq_domain_is_auto_recursive(struct irq_domain *domain)
-{
-        return domain->flags & IRQ_DOMAIN_FLAG_AUTO_RECURSIVE;
-}
-
-static void irq_domain_free_irqs_recursive(struct irq_domain *domain,
+static void irq_domain_free_irqs_hierarchy(struct irq_domain *domain,
                                            unsigned int irq_base,
                                            unsigned int nr_irqs)
 {
         domain->ops->free(domain, irq_base, nr_irqs);
-        if (irq_domain_is_auto_recursive(domain)) {
-                BUG_ON(!domain->parent);
-                irq_domain_free_irqs_recursive(domain->parent, irq_base,
-                                               nr_irqs);
-        }
 }
 
-int irq_domain_alloc_irqs_recursive(struct irq_domain *domain,
+int irq_domain_alloc_irqs_hierarchy(struct irq_domain *domain,
                                     unsigned int irq_base,
                                     unsigned int nr_irqs, void *arg)
 {
-        int ret = 0;
-        struct irq_domain *parent = domain->parent;
-        bool recursive = irq_domain_is_auto_recursive(domain);
-
-        BUG_ON(recursive && !parent);
-        if (recursive)
-                ret = irq_domain_alloc_irqs_recursive(parent, irq_base,
-                                                      nr_irqs, arg);
-        if (ret < 0)
-                return ret;
-
-        ret = domain->ops->alloc(domain, irq_base, nr_irqs, arg);
-        if (ret < 0 && recursive)
-                irq_domain_free_irqs_recursive(parent, irq_base, nr_irqs);
-
-        return ret;
+        return domain->ops->alloc(domain, irq_base, nr_irqs, arg);
 }
 
 /**
@@ -1286,7 +1430,7 @@ int __irq_domain_alloc_irqs(struct irq_domain *domain, int irq_base,
         }
 
         mutex_lock(&irq_domain_mutex);
-        ret = irq_domain_alloc_irqs_recursive(domain, virq, nr_irqs, arg);
+        ret = irq_domain_alloc_irqs_hierarchy(domain, virq, nr_irqs, arg);
         if (ret < 0) {
                 mutex_unlock(&irq_domain_mutex);
                 goto out_free_irq_data;
@@ -1321,7 +1465,7 @@ void irq_domain_free_irqs(unsigned int virq, unsigned int nr_irqs)
         mutex_lock(&irq_domain_mutex);
         for (i = 0; i < nr_irqs; i++)
                 irq_domain_remove_irq(virq + i);
-        irq_domain_free_irqs_recursive(data->domain, virq, nr_irqs);
+        irq_domain_free_irqs_hierarchy(data->domain, virq, nr_irqs);
         mutex_unlock(&irq_domain_mutex);
 
         irq_domain_free_irq_data(virq, nr_irqs);
@@ -1341,15 +1485,11 @@ int irq_domain_alloc_irqs_parent(struct irq_domain *domain,
                                  unsigned int irq_base, unsigned int nr_irqs,
                                  void *arg)
 {
-        /* irq_domain_alloc_irqs_recursive() has called parent's alloc() */
-        if (irq_domain_is_auto_recursive(domain))
-                return 0;
+        if (!domain->parent)
+                return -ENOSYS;
 
-        domain = domain->parent;
-        if (domain)
-                return irq_domain_alloc_irqs_recursive(domain, irq_base,
-                                                       nr_irqs, arg);
-        return -ENOSYS;
+        return irq_domain_alloc_irqs_hierarchy(domain->parent, irq_base,
+                                               nr_irqs, arg);
 }
 EXPORT_SYMBOL_GPL(irq_domain_alloc_irqs_parent);
 
@@ -1364,10 +1504,10 @@ EXPORT_SYMBOL_GPL(irq_domain_alloc_irqs_parent);
 void irq_domain_free_irqs_parent(struct irq_domain *domain,
                                  unsigned int irq_base, unsigned int nr_irqs)
 {
-        /* irq_domain_free_irqs_recursive() will call parent's free */
-        if (!irq_domain_is_auto_recursive(domain) && domain->parent)
-                irq_domain_free_irqs_recursive(domain->parent, irq_base,
-                                               nr_irqs);
+        if (!domain->parent)
+                return;
+
+        irq_domain_free_irqs_hierarchy(domain->parent, irq_base, nr_irqs);
 }
 EXPORT_SYMBOL_GPL(irq_domain_free_irqs_parent);
 
@@ -1487,3 +1627,77 @@ static void irq_domain_check_hierarchy(struct irq_domain *domain)
 {
 }
 #endif  /* CONFIG_IRQ_DOMAIN_HIERARCHY */
+
+#ifdef CONFIG_GENERIC_IRQ_DEBUGFS
+static struct dentry *domain_dir;
+
+static void
+irq_domain_debug_show_one(struct seq_file *m, struct irq_domain *d, int ind)
+{
+        seq_printf(m, "%*sname:   %s\n", ind, "", d->name);
+        seq_printf(m, "%*ssize:   %u\n", ind + 1, "",
+                   d->revmap_size + d->revmap_direct_max_irq);
+        seq_printf(m, "%*smapped: %u\n", ind + 1, "", d->mapcount);
+        seq_printf(m, "%*sflags:  0x%08x\n", ind +1 , "", d->flags);
+#ifdef  CONFIG_IRQ_DOMAIN_HIERARCHY
+        if (!d->parent)
+                return;
+        seq_printf(m, "%*sparent: %s\n", ind + 1, "", d->parent->name);
+        irq_domain_debug_show_one(m, d->parent, ind + 4);
+#endif
+}
+
+static int irq_domain_debug_show(struct seq_file *m, void *p)
+{
+        struct irq_domain *d = m->private;
+
+        /* Default domain? Might be NULL */
+        if (!d) {
+                if (!irq_default_domain)
+                        return 0;
+                d = irq_default_domain;
+        }
+        irq_domain_debug_show_one(m, d, 0);
+        return 0;
+}
+
+static int irq_domain_debug_open(struct inode *inode, struct file *file)
+{
+        return single_open(file, irq_domain_debug_show, inode->i_private);
+}
+
+static const struct file_operations dfs_domain_ops = {
+        .open           = irq_domain_debug_open,
+        .read           = seq_read,
+        .llseek         = seq_lseek,
+        .release        = single_release,
+};
+
+static void debugfs_add_domain_dir(struct irq_domain *d)
+{
+        if (!d->name || !domain_dir || d->debugfs_file)
+                return;
+        d->debugfs_file = debugfs_create_file(d->name, 0444, domain_dir, d,
+                                              &dfs_domain_ops);
+}
+
+static void debugfs_remove_domain_dir(struct irq_domain *d)
+{
+        debugfs_remove(d->debugfs_file);
+}
+
+void __init irq_domain_debugfs_init(struct dentry *root)
+{
+        struct irq_domain *d;
+
+        domain_dir = debugfs_create_dir("domains", root);
+        if (!domain_dir)
+                return;
+
+        debugfs_create_file("default", 0444, domain_dir, NULL, &dfs_domain_ops);
+        mutex_lock(&irq_domain_mutex);
+        list_for_each_entry(d, &irq_domain_list, link)
+                debugfs_add_domain_dir(d);
+        mutex_unlock(&irq_domain_mutex);
+}
+#endif
diff --git a/kernel/irq/manage.c b/kernel/irq/manage.c
index 070be980c37a..1d1a5b945ab4 100644
--- a/kernel/irq/manage.c
+++ b/kernel/irq/manage.c
@@ -168,34 +168,6 @@ void irq_set_thread_affinity(struct irq_desc *desc)
                         set_bit(IRQTF_AFFINITY, &action->thread_flags);
 }
 
-#ifdef CONFIG_GENERIC_PENDING_IRQ
-static inline bool irq_can_move_pcntxt(struct irq_data *data)
-{
-        return irqd_can_move_in_process_context(data);
-}
-static inline bool irq_move_pending(struct irq_data *data)
-{
-        return irqd_is_setaffinity_pending(data);
-}
-static inline void
-irq_copy_pending(struct irq_desc *desc, const struct cpumask *mask)
-{
-        cpumask_copy(desc->pending_mask, mask);
-}
-static inline void
-irq_get_pending(struct cpumask *mask, struct irq_desc *desc)
-{
-        cpumask_copy(mask, desc->pending_mask);
-}
-#else
-static inline bool irq_can_move_pcntxt(struct irq_data *data) { return true; }
-static inline bool irq_move_pending(struct irq_data *data) { return false; }
-static inline void
-irq_copy_pending(struct irq_desc *desc, const struct cpumask *mask) { }
-static inline void
-irq_get_pending(struct cpumask *mask, struct irq_desc *desc) { }
-#endif
-
 int irq_do_set_affinity(struct irq_data *data, const struct cpumask *mask,
                         bool force)
 {
@@ -345,15 +317,18 @@ EXPORT_SYMBOL_GPL(irq_set_affinity_notifier);
 /*
  * Generic version of the affinity autoselector.
  */
-static int setup_affinity(struct irq_desc *desc, struct cpumask *mask)
+int irq_setup_affinity(struct irq_desc *desc)
 {
         struct cpumask *set = irq_default_affinity;
-        int node = irq_desc_get_node(desc);
+        int ret, node = irq_desc_get_node(desc);
+        static DEFINE_RAW_SPINLOCK(mask_lock);
+        static struct cpumask mask;
 
         /* Excludes PER_CPU and NO_BALANCE interrupts */
         if (!__irq_can_set_affinity(desc))
                 return 0;
 
+        raw_spin_lock(&mask_lock);
         /*
          * Preserve the managed affinity setting and a userspace affinity
          * setup, but make sure that one of the targets is online.
@@ -367,46 +342,40 @@ static int setup_affinity(struct irq_desc *desc, struct cpumask *mask)
                         irqd_clear(&desc->irq_data, IRQD_AFFINITY_SET);
         }
 
-        cpumask_and(mask, cpu_online_mask, set);
+        cpumask_and(&mask, cpu_online_mask, set);
         if (node != NUMA_NO_NODE) {
                 const struct cpumask *nodemask = cpumask_of_node(node);
 
                 /* make sure at least one of the cpus in nodemask is online */
-                if (cpumask_intersects(mask, nodemask))
-                        cpumask_and(mask, mask, nodemask);
+                if (cpumask_intersects(&mask, nodemask))
+                        cpumask_and(&mask, &mask, nodemask);
         }
-        irq_do_set_affinity(&desc->irq_data, mask, false);
-        return 0;
+        ret = irq_do_set_affinity(&desc->irq_data, &mask, false);
+        raw_spin_unlock(&mask_lock);
+        return ret;
 }
 #else
 /* Wrapper for ALPHA specific affinity selector magic */
-static inline int setup_affinity(struct irq_desc *d, struct cpumask *mask)
+int irq_setup_affinity(struct irq_desc *desc)
 {
-        return irq_select_affinity(irq_desc_get_irq(d));
+        return irq_select_affinity(irq_desc_get_irq(desc));
 }
 #endif
 
 /*
- * Called when affinity is set via /proc/irq
+ * Called when a bogus affinity is set via /proc/irq
  */
-int irq_select_affinity_usr(unsigned int irq, struct cpumask *mask)
+int irq_select_affinity_usr(unsigned int irq)
 {
         struct irq_desc *desc = irq_to_desc(irq);
         unsigned long flags;
         int ret;
 
         raw_spin_lock_irqsave(&desc->lock, flags);
-        ret = setup_affinity(desc, mask);
+        ret = irq_setup_affinity(desc);
         raw_spin_unlock_irqrestore(&desc->lock, flags);
         return ret;
 }
-
-#else
-static inline int
-setup_affinity(struct irq_desc *desc, struct cpumask *mask)
-{
-        return 0;
-}
 #endif
 
 /**
@@ -533,9 +502,15 @@ void __enable_irq(struct irq_desc *desc)
                         goto err_out;
                 /* Prevent probing on this irq: */
                 irq_settings_set_noprobe(desc);
-                irq_enable(desc);
-                check_irq_resend(desc);
-                /* fall-through */
+                /*
+                 * Call irq_startup() not irq_enable() here because the
+                 * interrupt might be marked NOAUTOEN. So irq_startup()
+                 * needs to be invoked when it gets enabled the first
+                 * time. If it was already started up, then irq_startup()
+                 * will invoke irq_enable() under the hood.
+                 */
+                irq_startup(desc, IRQ_RESEND, IRQ_START_COND);
+                break;
         }
         default:
                 desc->depth--;
@@ -1115,6 +1090,16 @@ setup_irq_thread(struct irqaction *new, unsigned int irq, bool secondary)
 /*
  * Internal function to register an irqaction - typically used to
  * allocate special interrupts that are part of the architecture.
+ *
+ * Locking rules:
+ *
+ * desc->request_mutex  Provides serialization against a concurrent free_irq()
+ *   chip_bus_lock      Provides serialization for slow bus operations
+ *     desc->lock       Provides serialization against hard interrupts
+ *
+ * chip_bus_lock and desc->lock are sufficient for all other management and
+ * interrupt related functions. desc->request_mutex solely serializes
+ * request/free_irq().
  */
 static int
 __setup_irq(unsigned int irq, struct irq_desc *desc, struct irqaction *new)
@@ -1122,7 +1107,6 @@ __setup_irq(unsigned int irq, struct irq_desc *desc, struct irqaction *new)
         struct irqaction *old, **old_ptr;
         unsigned long flags, thread_mask = 0;
         int ret, nested, shared = 0;
-        cpumask_var_t mask;
 
         if (!desc)
                 return -EINVAL;
@@ -1181,11 +1165,6 @@ __setup_irq(unsigned int irq, struct irq_desc *desc, struct irqaction *new)
                 }
         }
 
-        if (!alloc_cpumask_var(&mask, GFP_KERNEL)) {
-                ret = -ENOMEM;
-                goto out_thread;
-        }
-
         /*
          * Drivers are often written to work w/o knowledge about the
          * underlying irq chip implementation, so a request for a
@@ -1199,7 +1178,34 @@ __setup_irq(unsigned int irq, struct irq_desc *desc, struct irqaction *new)
                 new->flags &= ~IRQF_ONESHOT;
 
         /*
+         * Protects against a concurrent __free_irq() call which might wait
+         * for synchronize_irq() to complete without holding the optional
+         * chip bus lock and desc->lock.
+         */
+        mutex_lock(&desc->request_mutex);
+
+        /*
+         * Acquire bus lock as the irq_request_resources() callback below
+         * might rely on the serialization or the magic power management
+         * functions which are abusing the irq_bus_lock() callback,
+         */
+        chip_bus_lock(desc);
+
+        /* First installed action requests resources. */
+        if (!desc->action) {
+                ret = irq_request_resources(desc);
+                if (ret) {
+                        pr_err("Failed to request resources for %s (irq %d) on irqchip %s\n",
+                               new->name, irq, desc->irq_data.chip->name);
+                        goto out_bus_unlock;
+                }
+        }
+
+        /*
          * The following block of code has to be executed atomically
+         * protected against a concurrent interrupt and any of the other
+         * management calls which are not serialized via
+         * desc->request_mutex or the optional bus lock.
          */
         raw_spin_lock_irqsave(&desc->lock, flags);
         old_ptr = &desc->action;
@@ -1250,7 +1256,7 @@ __setup_irq(unsigned int irq, struct irq_desc *desc, struct irqaction *new)
                  */
                 if (thread_mask == ~0UL) {
                         ret = -EBUSY;
-                        goto out_mask;
+                        goto out_unlock;
                 }
                 /*
                  * The thread_mask for the action is or'ed to
@@ -1294,17 +1300,10 @@ __setup_irq(unsigned int irq, struct irq_desc *desc, struct irqaction *new)
                 pr_err("Threaded irq requested with handler=NULL and !ONESHOT for irq %d\n",
                        irq);
                 ret = -EINVAL;
-                goto out_mask;
+                goto out_unlock;
         }
 
         if (!shared) {
-                ret = irq_request_resources(desc);
-                if (ret) {
-                        pr_err("Failed to request resources for %s (irq %d) on irqchip %s\n",
-                               new->name, irq, desc->irq_data.chip->name);
-                        goto out_mask;
-                }
-
                 init_waitqueue_head(&desc->wait_for_threads);
 
                 /* Setup the type (level, edge polarity) if configured: */
@@ -1313,7 +1312,7 @@ __setup_irq(unsigned int irq, struct irq_desc *desc, struct irqaction *new)
                                                 new->flags & IRQF_TRIGGER_MASK);
 
                         if (ret)
-                                goto out_mask;
+                                goto out_unlock;
                 }
 
                 desc->istate &= ~(IRQS_AUTODETECT | IRQS_SPURIOUS_DISABLED | \
@@ -1328,20 +1327,25 @@ __setup_irq(unsigned int irq, struct irq_desc *desc, struct irqaction *new)
                 if (new->flags & IRQF_ONESHOT)
                         desc->istate |= IRQS_ONESHOT;
 
-                if (irq_settings_can_autoenable(desc))
-                        irq_startup(desc, true);
-                else
-                        /* Undo nested disables: */
-                        desc->depth = 1;
-
                 /* Exclude IRQ from balancing if requested */
                 if (new->flags & IRQF_NOBALANCING) {
                         irq_settings_set_no_balancing(desc);
                         irqd_set(&desc->irq_data, IRQD_NO_BALANCING);
                 }
 
-                /* Set default affinity mask once everything is setup */
-                setup_affinity(desc, mask);
+                if (irq_settings_can_autoenable(desc)) {
+                        irq_startup(desc, IRQ_RESEND, IRQ_START_COND);
+                } else {
+                        /*
+                         * Shared interrupts do not go well with disabling
+                         * auto enable. The sharing interrupt might request
+                         * it while it's still disabled and then wait for
+                         * interrupts forever.
+                         */
+                        WARN_ON_ONCE(new->flags & IRQF_SHARED);
+                        /* Undo nested disables: */
+                        desc->depth = 1;
+                }
 
         } else if (new->flags & IRQF_TRIGGER_MASK) {
                 unsigned int nmsk = new->flags & IRQF_TRIGGER_MASK;
@@ -1371,6 +1375,10 @@ __setup_irq(unsigned int irq, struct irq_desc *desc, struct irqaction *new)
         }
 
         raw_spin_unlock_irqrestore(&desc->lock, flags);
+        chip_bus_sync_unlock(desc);
+        mutex_unlock(&desc->request_mutex);
+
+        irq_setup_timings(desc, new);
 
         /*
          * Strictly no need to wake it up, but hung_task complains
@@ -1382,10 +1390,9 @@ __setup_irq(unsigned int irq, struct irq_desc *desc, struct irqaction *new)
                 wake_up_process(new->secondary->thread);
 
         register_irq_proc(irq, desc);
+        irq_add_debugfs_entry(irq, desc);
         new->dir = NULL;
         register_handler_proc(irq, new);
-        free_cpumask_var(mask);
-
         return 0;
 
 mismatch:
@@ -1398,9 +1405,14 @@ mismatch:
         }
         ret = -EBUSY;
 
-out_mask:
+out_unlock:
         raw_spin_unlock_irqrestore(&desc->lock, flags);
-        free_cpumask_var(mask);
+
+        if (!desc->action)
+                irq_release_resources(desc);
+out_bus_unlock:
+        chip_bus_sync_unlock(desc);
+        mutex_unlock(&desc->request_mutex);
 
 out_thread:
         if (new->thread) {
@@ -1441,9 +1453,7 @@ int setup_irq(unsigned int irq, struct irqaction *act)
         if (retval < 0)
                 return retval;
 
-        chip_bus_lock(desc);
         retval = __setup_irq(irq, desc, act);
-        chip_bus_sync_unlock(desc);
 
         if (retval)
                 irq_chip_pm_put(&desc->irq_data);
@@ -1467,6 +1477,7 @@ static struct irqaction *__free_irq(unsigned int irq, void *dev_id)
         if (!desc)
                 return NULL;
 
+        mutex_lock(&desc->request_mutex);
         chip_bus_lock(desc);
         raw_spin_lock_irqsave(&desc->lock, flags);
 
@@ -1482,6 +1493,7 @@ static struct irqaction *__free_irq(unsigned int irq, void *dev_id)
                         WARN(1, "Trying to free already-free IRQ %d\n", irq);
                         raw_spin_unlock_irqrestore(&desc->lock, flags);
                         chip_bus_sync_unlock(desc);
+                        mutex_unlock(&desc->request_mutex);
                         return NULL;
                 }
 
@@ -1499,7 +1511,6 @@ static struct irqaction *__free_irq(unsigned int irq, void *dev_id)
         if (!desc->action) {
                 irq_settings_clr_disable_unlazy(desc);
                 irq_shutdown(desc);
-                irq_release_resources(desc);
         }
 
 #ifdef CONFIG_SMP
@@ -1509,6 +1520,20 @@ static struct irqaction *__free_irq(unsigned int irq, void *dev_id)
 #endif
 
         raw_spin_unlock_irqrestore(&desc->lock, flags);
+        /*
+         * Drop bus_lock here so the changes which were done in the chip
+         * callbacks above are synced out to the irq chips which hang
+         * behind a slow bus (I2C, SPI) before calling synchronize_irq().
+         *
+         * Aside of that the bus_lock can also be taken from the threaded
+         * handler in irq_finalize_oneshot() which results in a deadlock
+         * because synchronize_irq() would wait forever for the thread to
+         * complete, which is blocked on the bus lock.
+         *
+         * The still held desc->request_mutex() protects against a
+         * concurrent request_irq() of this irq so the release of resources
+         * and timing data is properly serialized.
+         */
         chip_bus_sync_unlock(desc);
 
         unregister_handler_proc(irq, action);
@@ -1541,6 +1566,20 @@ static struct irqaction *__free_irq(unsigned int irq, void *dev_id)
                 }
         }
 
+        /* Last action releases resources */
+        if (!desc->action) {
+                /*
+                 * Reaquire bus lock as irq_release_resources() might
+                 * require it to deallocate resources over the slow bus.
+                 */
+                chip_bus_lock(desc);
+                irq_release_resources(desc);
+                chip_bus_sync_unlock(desc);
+                irq_remove_timings(desc);
+        }
+
+        mutex_unlock(&desc->request_mutex);
+
         irq_chip_pm_put(&desc->irq_data);
         module_put(desc->owner);
         kfree(action->secondary);
@@ -1697,9 +1736,7 @@ int request_threaded_irq(unsigned int irq, irq_handler_t handler,
                 return retval;
         }
 
-        chip_bus_lock(desc);
         retval = __setup_irq(irq, desc, action);
-        chip_bus_sync_unlock(desc);
 
         if (retval) {
                 irq_chip_pm_put(&desc->irq_data);
@@ -1947,9 +1984,7 @@ int setup_percpu_irq(unsigned int irq, struct irqaction *act)
         if (retval < 0)
                 return retval;
 
-        chip_bus_lock(desc);
         retval = __setup_irq(irq, desc, act);
-        chip_bus_sync_unlock(desc);
 
         if (retval)
                 irq_chip_pm_put(&desc->irq_data);
@@ -1958,9 +1993,10 @@ int setup_percpu_irq(unsigned int irq, struct irqaction *act)
 }
 
 /**
- *      request_percpu_irq - allocate a percpu interrupt line
+ *      __request_percpu_irq - allocate a percpu interrupt line
  *      @irq: Interrupt line to allocate
  *      @handler: Function to be called when the IRQ occurs.
+ *      @flags: Interrupt type flags (IRQF_TIMER only)
  *      @devname: An ascii name for the claiming device
  *      @dev_id: A percpu cookie passed back to the handler function
  *
@@ -1973,8 +2009,9 @@ int setup_percpu_irq(unsigned int irq, struct irqaction *act)
  *      the handler gets called with the interrupted CPU's instance of
  *      that variable.
  */
-int request_percpu_irq(unsigned int irq, irq_handler_t handler,
-                       const char *devname, void __percpu *dev_id)
+int __request_percpu_irq(unsigned int irq, irq_handler_t handler,
+                         unsigned long flags, const char *devname,
+                         void __percpu *dev_id)
 {
         struct irqaction *action;
         struct irq_desc *desc;
@@ -1988,12 +2025,15 @@ int request_percpu_irq(unsigned int irq, irq_handler_t handler,
             !irq_settings_is_per_cpu_devid(desc))
                 return -EINVAL;
 
+        if (flags && flags != IRQF_TIMER)
+                return -EINVAL;
+
         action = kzalloc(sizeof(struct irqaction), GFP_KERNEL);
         if (!action)
                 return -ENOMEM;
 
         action->handler = handler;
-        action->flags = IRQF_PERCPU | IRQF_NO_SUSPEND;
+        action->flags = flags | IRQF_PERCPU | IRQF_NO_SUSPEND;
         action->name = devname;
         action->percpu_dev_id = dev_id;
 
@@ -2003,9 +2043,7 @@ int request_percpu_irq(unsigned int irq, irq_handler_t handler,
                 return retval;
         }
 
-        chip_bus_lock(desc);
         retval = __setup_irq(irq, desc, action);
-        chip_bus_sync_unlock(desc);
 
         if (retval) {
                 irq_chip_pm_put(&desc->irq_data);
@@ -2014,7 +2052,7 @@ int request_percpu_irq(unsigned int irq, irq_handler_t handler,
 
         return retval;
 }
-EXPORT_SYMBOL_GPL(request_percpu_irq);
+EXPORT_SYMBOL_GPL(__request_percpu_irq);
 
 /**
  *      irq_get_irqchip_state - returns the irqchip state of a interrupt.
diff --git a/kernel/irq/migration.c b/kernel/irq/migration.c
index 37ddb7bda651..6ca054a3f91d 100644
--- a/kernel/irq/migration.c
+++ b/kernel/irq/migration.c
@@ -4,6 +4,36 @@
 
 #include "internals.h"
 
+/**
+ * irq_fixup_move_pending - Cleanup irq move pending from a dying CPU
+ * @desc:               Interrupt descpriptor to clean up
+ * @force_clear:        If set clear the move pending bit unconditionally.
+ *                      If not set, clear it only when the dying CPU is the
+ *                      last one in the pending mask.
+ *
+ * Returns true if the pending bit was set and the pending mask contains an
+ * online CPU other than the dying CPU.
+ */
+bool irq_fixup_move_pending(struct irq_desc *desc, bool force_clear)
+{
+        struct irq_data *data = irq_desc_get_irq_data(desc);
+
+        if (!irqd_is_setaffinity_pending(data))
+                return false;
+
+        /*
+         * The outgoing CPU might be the last online target in a pending
+         * interrupt move. If that's the case clear the pending move bit.
+         */
+        if (cpumask_any_and(desc->pending_mask, cpu_online_mask) >= nr_cpu_ids) {
+                irqd_clr_move_pending(data);
+                return false;
+        }
+        if (force_clear)
+                irqd_clr_move_pending(data);
+        return true;
+}
+
 void irq_move_masked_irq(struct irq_data *idata)
 {
         struct irq_desc *desc = irq_data_to_desc(idata);
diff --git a/kernel/irq/msi.c b/kernel/irq/msi.c
index ddc2f5427f75..48eadf416c24 100644
--- a/kernel/irq/msi.c
+++ b/kernel/irq/msi.c
@@ -265,13 +265,20 @@ struct irq_domain *msi_create_irq_domain(struct fwnode_handle *fwnode,
                                          struct msi_domain_info *info,
                                          struct irq_domain *parent)
 {
+        struct irq_domain *domain;
+
         if (info->flags & MSI_FLAG_USE_DEF_DOM_OPS)
                 msi_domain_update_dom_ops(info);
         if (info->flags & MSI_FLAG_USE_DEF_CHIP_OPS)
                 msi_domain_update_chip_ops(info);
 
-        return irq_domain_create_hierarchy(parent, IRQ_DOMAIN_FLAG_MSI, 0,
-                                           fwnode, &msi_domain_ops, info);
+        domain = irq_domain_create_hierarchy(parent, IRQ_DOMAIN_FLAG_MSI, 0,
+                                             fwnode, &msi_domain_ops, info);
+
+        if (domain && !domain->name && info->chip)
+                domain->name = info->chip->name;
+
+        return domain;
 }
 
 int msi_domain_prepare_irqs(struct irq_domain *domain, struct device *dev,
@@ -308,7 +315,7 @@ int msi_domain_populate_irqs(struct irq_domain *domain, struct device *dev,
 
                 ops->set_desc(arg, desc);
                 /* Assumes the domain mutex is held! */
-                ret = irq_domain_alloc_irqs_recursive(domain, virq, 1, arg);
+                ret = irq_domain_alloc_irqs_hierarchy(domain, virq, 1, arg);
                 if (ret)
                         break;
 
diff --git a/kernel/irq/pm.c b/kernel/irq/pm.c
index cea1de0161f1..6bd9b58429cc 100644
--- a/kernel/irq/pm.c
+++ b/kernel/irq/pm.c
@@ -149,6 +149,8 @@ static void resume_irq(struct irq_desc *desc)
 
         /* Pretend that it got disabled ! */
         desc->depth++;
+        irq_state_set_disabled(desc);
+        irq_state_set_masked(desc);
 resume:
         desc->istate &= ~IRQS_SUSPENDED;
         __enable_irq(desc);
diff --git a/kernel/irq/proc.c b/kernel/irq/proc.c
index c53edad7b459..7f9642a1e267 100644
--- a/kernel/irq/proc.c
+++ b/kernel/irq/proc.c
@@ -37,19 +37,47 @@ static struct proc_dir_entry *root_irq_dir;
 
 #ifdef CONFIG_SMP
 
-static int show_irq_affinity(int type, struct seq_file *m, void *v)
+enum {
+        AFFINITY,
+        AFFINITY_LIST,
+        EFFECTIVE,
+        EFFECTIVE_LIST,
+};
+
+static int show_irq_affinity(int type, struct seq_file *m)
 {
         struct irq_desc *desc = irq_to_desc((long)m->private);
-        const struct cpumask *mask = desc->irq_common_data.affinity;
+        const struct cpumask *mask;
 
+        switch (type) {
+        case AFFINITY:
+        case AFFINITY_LIST:
+                mask = desc->irq_common_data.affinity;
 #ifdef CONFIG_GENERIC_PENDING_IRQ
-        if (irqd_is_setaffinity_pending(&desc->irq_data))
-                mask = desc->pending_mask;
+                if (irqd_is_setaffinity_pending(&desc->irq_data))
+                        mask = desc->pending_mask;
 #endif
-        if (type)
+                break;
+        case EFFECTIVE:
+        case EFFECTIVE_LIST:
+#ifdef CONFIG_GENERIC_IRQ_EFFECTIVE_AFF_MASK
+                mask = desc->irq_common_data.effective_affinity;
+                break;
+#else
+                return -EINVAL;
+#endif
+        };
+
+        switch (type) {
+        case AFFINITY_LIST:
+        case EFFECTIVE_LIST:
                 seq_printf(m, "%*pbl\n", cpumask_pr_args(mask));
-        else
+                break;
+        case AFFINITY:
+        case EFFECTIVE:
                 seq_printf(m, "%*pb\n", cpumask_pr_args(mask));
+                break;
+        }
         return 0;
 }
 
@@ -80,12 +108,12 @@ static int irq_affinity_hint_proc_show(struct seq_file *m, void *v)
 int no_irq_affinity;
 static int irq_affinity_proc_show(struct seq_file *m, void *v)
 {
-        return show_irq_affinity(0, m, v);
+        return show_irq_affinity(AFFINITY, m);
 }
 
 static int irq_affinity_list_proc_show(struct seq_file *m, void *v)
 {
-        return show_irq_affinity(1, m, v);
+        return show_irq_affinity(AFFINITY_LIST, m);
 }
 
 
@@ -120,9 +148,11 @@ static ssize_t write_irq_affinity(int type, struct file *file,
          * one online CPU still has to be targeted.
          */
         if (!cpumask_intersects(new_value, cpu_online_mask)) {
-                /* Special case for empty set - allow the architecture
-                   code to set default SMP affinity. */
-                err = irq_select_affinity_usr(irq, new_value) ? -EINVAL : count;
+                /*
+                 * Special case for empty set - allow the architecture code
+                 * to set default SMP affinity.
+                 */
+                err = irq_select_affinity_usr(irq) ? -EINVAL : count;
         } else {
                 irq_set_affinity(irq, new_value);
                 err = count;
@@ -183,6 +213,44 @@ static const struct file_operations irq_affinity_list_proc_fops = {
         .write          = irq_affinity_list_proc_write,
 };
 
+#ifdef CONFIG_GENERIC_IRQ_EFFECTIVE_AFF_MASK
+static int irq_effective_aff_proc_show(struct seq_file *m, void *v)
+{
+        return show_irq_affinity(EFFECTIVE, m);
+}
+
+static int irq_effective_aff_list_proc_show(struct seq_file *m, void *v)
+{
+        return show_irq_affinity(EFFECTIVE_LIST, m);
+}
+
+static int irq_effective_aff_proc_open(struct inode *inode, struct file *file)
+{
+        return single_open(file, irq_effective_aff_proc_show, PDE_DATA(inode));
+}
+
+static int irq_effective_aff_list_proc_open(struct inode *inode,
+                                            struct file *file)
+{
+        return single_open(file, irq_effective_aff_list_proc_show,
+                           PDE_DATA(inode));
+}
+
+static const struct file_operations irq_effective_aff_proc_fops = {
+        .open           = irq_effective_aff_proc_open,
+        .read           = seq_read,
+        .llseek         = seq_lseek,
+        .release        = single_release,
+};
+
+static const struct file_operations irq_effective_aff_list_proc_fops = {
+        .open           = irq_effective_aff_list_proc_open,
+        .read           = seq_read,
+        .llseek         = seq_lseek,
+        .release        = single_release,
+};
+#endif
+
 static int default_affinity_show(struct seq_file *m, void *v)
 {
         seq_printf(m, "%*pb\n", cpumask_pr_args(irq_default_affinity));
@@ -324,6 +392,7 @@ void register_handler_proc(unsigned int irq, struct irqaction *action)
 void register_irq_proc(unsigned int irq, struct irq_desc *desc)
 {
         static DEFINE_MUTEX(register_lock);
+        void __maybe_unused *irqp = (void *)(unsigned long) irq;
         char name [MAX_NAMELEN];
 
         if (!root_irq_dir || (desc->irq_data.chip == &no_irq_chip))
@@ -349,20 +418,25 @@ void register_irq_proc(unsigned int irq, struct irq_desc *desc)
 #ifdef CONFIG_SMP
         /* create /proc/irq/<irq>/smp_affinity */
         proc_create_data("smp_affinity", 0644, desc->dir,
-                         &irq_affinity_proc_fops, (void *)(long)irq);
+                         &irq_affinity_proc_fops, irqp);
 
         /* create /proc/irq/<irq>/affinity_hint */
         proc_create_data("affinity_hint", 0444, desc->dir,
-                         &irq_affinity_hint_proc_fops, (void *)(long)irq);
+                         &irq_affinity_hint_proc_fops, irqp);
 
         /* create /proc/irq/<irq>/smp_affinity_list */
         proc_create_data("smp_affinity_list", 0644, desc->dir,
-                         &irq_affinity_list_proc_fops, (void *)(long)irq);
+                         &irq_affinity_list_proc_fops, irqp);
 
         proc_create_data("node", 0444, desc->dir,
-                         &irq_node_proc_fops, (void *)(long)irq);
+                         &irq_node_proc_fops, irqp);
+# ifdef CONFIG_GENERIC_IRQ_EFFECTIVE_AFF_MASK
+        proc_create_data("effective_affinity", 0444, desc->dir,
+                         &irq_effective_aff_proc_fops, irqp);
+        proc_create_data("effective_affinity_list", 0444, desc->dir,
+                         &irq_effective_aff_list_proc_fops, irqp);
+# endif
 #endif
-
         proc_create_data("spurious", 0444, desc->dir,
                          &irq_spurious_proc_fops, (void *)(long)irq);
 
@@ -381,6 +455,10 @@ void unregister_irq_proc(unsigned int irq, struct irq_desc *desc)
         remove_proc_entry("affinity_hint", desc->dir);
         remove_proc_entry("smp_affinity_list", desc->dir);
         remove_proc_entry("node", desc->dir);
+# ifdef CONFIG_GENERIC_IRQ_EFFECTIVE_AFF_MASK
+        remove_proc_entry("effective_affinity", desc->dir);
+        remove_proc_entry("effective_affinity_list", desc->dir);
+# endif
 #endif
         remove_proc_entry("spurious", desc->dir);
 
diff --git a/kernel/irq/timings.c b/kernel/irq/timings.c
new file mode 100644
index 000000000000..c8c1d073fbf1
--- /dev/null
+++ b/kernel/irq/timings.c
@@ -0,0 +1,369 @@
+/*
+ * linux/kernel/irq/timings.c
+ *
+ * Copyright (C) 2016, Linaro Ltd - Daniel Lezcano <daniel.lezcano@linaro.org>
+ *
+ * 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.
+ *
+ */
+#include <linux/kernel.h>
+#include <linux/percpu.h>
+#include <linux/slab.h>
+#include <linux/static_key.h>
+#include <linux/interrupt.h>
+#include <linux/idr.h>
+#include <linux/irq.h>
+#include <linux/math64.h>
+
+#include <trace/events/irq.h>
+
+#include "internals.h"
+
+DEFINE_STATIC_KEY_FALSE(irq_timing_enabled);
+
+DEFINE_PER_CPU(struct irq_timings, irq_timings);
+
+struct irqt_stat {
+        u64     next_evt;
+        u64     last_ts;
+        u64     variance;
+        u32     avg;
+        u32     nr_samples;
+        int     anomalies;
+        int     valid;
+};
+
+static DEFINE_IDR(irqt_stats);
+
+void irq_timings_enable(void)
+{
+        static_branch_enable(&irq_timing_enabled);
+}
+
+void irq_timings_disable(void)
+{
+        static_branch_disable(&irq_timing_enabled);
+}
+
+/**
+ * irqs_update - update the irq timing statistics with a new timestamp
+ *
+ * @irqs: an irqt_stat struct pointer
+ * @ts: the new timestamp
+ *
+ * The statistics are computed online, in other words, the code is
+ * designed to compute the statistics on a stream of values rather
+ * than doing multiple passes on the values to compute the average,
+ * then the variance. The integer division introduces a loss of
+ * precision but with an acceptable error margin regarding the results
+ * we would have with the double floating precision: we are dealing
+ * with nanosec, so big numbers, consequently the mantisse is
+ * negligeable, especially when converting the time in usec
+ * afterwards.
+ *
+ * The computation happens at idle time. When the CPU is not idle, the
+ * interrupts' timestamps are stored in the circular buffer, when the
+ * CPU goes idle and this routine is called, all the buffer's values
+ * are injected in the statistical model continuying to extend the
+ * statistics from the previous busy-idle cycle.
+ *
+ * The observations showed a device will trigger a burst of periodic
+ * interrupts followed by one or two peaks of longer time, for
+ * instance when a SD card device flushes its cache, then the periodic
+ * intervals occur again. A one second inactivity period resets the
+ * stats, that gives us the certitude the statistical values won't
+ * exceed 1x10^9, thus the computation won't overflow.
+ *
+ * Basically, the purpose of the algorithm is to watch the periodic
+ * interrupts and eliminate the peaks.
+ *
+ * An interrupt is considered periodically stable if the interval of
+ * its occurences follow the normal distribution, thus the values
+ * comply with:
+ *
+ *      avg - 3 x stddev < value < avg + 3 x stddev
+ *
+ * Which can be simplified to:
+ *
+ *      -3 x stddev < value - avg < 3 x stddev
+ *
+ *      abs(value - avg) < 3 x stddev
+ *
+ * In order to save a costly square root computation, we use the
+ * variance. For the record, stddev = sqrt(variance). The equation
+ * above becomes:
+ *
+ *      abs(value - avg) < 3 x sqrt(variance)
+ *
+ * And finally we square it:
+ *
+ *      (value - avg) ^ 2 < (3 x sqrt(variance)) ^ 2
+ *
+ *      (value - avg) x (value - avg) < 9 x variance
+ *
+ * Statistically speaking, any values out of this interval is
+ * considered as an anomaly and is discarded. However, a normal
+ * distribution appears when the number of samples is 30 (it is the
+ * rule of thumb in statistics, cf. "30 samples" on Internet). When
+ * there are three consecutive anomalies, the statistics are resetted.
+ *
+ */
+static void irqs_update(struct irqt_stat *irqs, u64 ts)
+{
+        u64 old_ts = irqs->last_ts;
+        u64 variance = 0;
+        u64 interval;
+        s64 diff;
+
+        /*
+         * The timestamps are absolute time values, we need to compute
+         * the timing interval between two interrupts.
+         */
+        irqs->last_ts = ts;
+
+        /*
+         * The interval type is u64 in order to deal with the same
+         * type in our computation, that prevent mindfuck issues with
+         * overflow, sign and division.
+         */
+        interval = ts - old_ts;
+
+        /*
+         * The interrupt triggered more than one second apart, that
+         * ends the sequence as predictible for our purpose. In this
+         * case, assume we have the beginning of a sequence and the
+         * timestamp is the first value. As it is impossible to
+         * predict anything at this point, return.
+         *
+         * Note the first timestamp of the sequence will always fall
+         * in this test because the old_ts is zero. That is what we
+         * want as we need another timestamp to compute an interval.
+         */
+        if (interval >= NSEC_PER_SEC) {
+                memset(irqs, 0, sizeof(*irqs));
+                irqs->last_ts = ts;
+                return;
+        }
+
+        /*
+         * Pre-compute the delta with the average as the result is
+         * used several times in this function.
+         */
+        diff = interval - irqs->avg;
+
+        /*
+         * Increment the number of samples.
+         */
+        irqs->nr_samples++;
+
+        /*
+         * Online variance divided by the number of elements if there
+         * is more than one sample.  Normally the formula is division
+         * by nr_samples - 1 but we assume the number of element will be
+         * more than 32 and dividing by 32 instead of 31 is enough
+         * precise.
+         */
+        if (likely(irqs->nr_samples > 1))
+                variance = irqs->variance >> IRQ_TIMINGS_SHIFT;
+
+        /*
+         * The rule of thumb in statistics for the normal distribution
+         * is having at least 30 samples in order to have the model to
+         * apply. Values outside the interval are considered as an
+         * anomaly.
+         */
+        if ((irqs->nr_samples >= 30) && ((diff * diff) > (9 * variance))) {
+                /*
+                 * After three consecutive anomalies, we reset the
+                 * stats as it is no longer stable enough.
+                 */
+                if (irqs->anomalies++ >= 3) {
+                        memset(irqs, 0, sizeof(*irqs));
+                        irqs->last_ts = ts;
+                        return;
+                }
+        } else {
+                /*
+                 * The anomalies must be consecutives, so at this
+                 * point, we reset the anomalies counter.
+                 */
+                irqs->anomalies = 0;
+        }
+
+        /*
+         * The interrupt is considered stable enough to try to predict
+         * the next event on it.
+         */
+        irqs->valid = 1;
+
+        /*
+         * Online average algorithm:
+         *
+         *  new_average = average + ((value - average) / count)
+         *
+         * The variance computation depends on the new average
+         * to be computed here first.
+         *
+         */
+        irqs->avg = irqs->avg + (diff >> IRQ_TIMINGS_SHIFT);
+
+        /*
+         * Online variance algorithm:
+         *
+         *  new_variance = variance + (value - average) x (value - new_average)
+         *
+         * Warning: irqs->avg is updated with the line above, hence
+         * 'interval - irqs->avg' is no longer equal to 'diff'
+         */
+        irqs->variance = irqs->variance + (diff * (interval - irqs->avg));
+
+        /*
+         * Update the next event
+         */
+        irqs->next_evt = ts + irqs->avg;
+}
+
+/**
+ * irq_timings_next_event - Return when the next event is supposed to arrive
+ *
+ * During the last busy cycle, the number of interrupts is incremented
+ * and stored in the irq_timings structure. This information is
+ * necessary to:
+ *
+ * - know if the index in the table wrapped up:
+ *
+ *      If more than the array size interrupts happened during the
+ *      last busy/idle cycle, the index wrapped up and we have to
+ *      begin with the next element in the array which is the last one
+ *      in the sequence, otherwise it is a the index 0.
+ *
+ * - have an indication of the interrupts activity on this CPU
+ *   (eg. irq/sec)
+ *
+ * The values are 'consumed' after inserting in the statistical model,
+ * thus the count is reinitialized.
+ *
+ * The array of values **must** be browsed in the time direction, the
+ * timestamp must increase between an element and the next one.
+ *
+ * Returns a nanosec time based estimation of the earliest interrupt,
+ * U64_MAX otherwise.
+ */
+u64 irq_timings_next_event(u64 now)
+{
+        struct irq_timings *irqts = this_cpu_ptr(&irq_timings);
+        struct irqt_stat *irqs;
+        struct irqt_stat __percpu *s;
+        u64 ts, next_evt = U64_MAX;
+        int i, irq = 0;
+
+        /*
+         * This function must be called with the local irq disabled in
+         * order to prevent the timings circular buffer to be updated
+         * while we are reading it.
+         */
+        WARN_ON_ONCE(!irqs_disabled());
+
+        /*
+         * Number of elements in the circular buffer: If it happens it
+         * was flushed before, then the number of elements could be
+         * smaller than IRQ_TIMINGS_SIZE, so the count is used,
+         * otherwise the array size is used as we wrapped. The index
+         * begins from zero when we did not wrap. That could be done
+         * in a nicer way with the proper circular array structure
+         * type but with the cost of extra computation in the
+         * interrupt handler hot path. We choose efficiency.
+         *
+         * Inject measured irq/timestamp to the statistical model
+         * while decrementing the counter because we consume the data
+         * from our circular buffer.
+         */
+        for (i = irqts->count & IRQ_TIMINGS_MASK,
+                     irqts->count = min(IRQ_TIMINGS_SIZE, irqts->count);
+             irqts->count > 0; irqts->count--, i = (i + 1) & IRQ_TIMINGS_MASK) {
+
+                irq = irq_timing_decode(irqts->values[i], &ts);
+
+                s = idr_find(&irqt_stats, irq);
+                if (s) {
+                        irqs = this_cpu_ptr(s);
+                        irqs_update(irqs, ts);
+                }
+        }
+
+        /*
+         * Look in the list of interrupts' statistics, the earliest
+         * next event.
+         */
+        idr_for_each_entry(&irqt_stats, s, i) {
+
+                irqs = this_cpu_ptr(s);
+
+                if (!irqs->valid)
+                        continue;
+
+                if (irqs->next_evt <= now) {
+                        irq = i;
+                        next_evt = now;
+
+                        /*
+                         * This interrupt mustn't use in the future
+                         * until new events occur and update the
+                         * statistics.
+                         */
+                        irqs->valid = 0;
+                        break;
+                }
+
+                if (irqs->next_evt < next_evt) {
+                        irq = i;
+                        next_evt = irqs->next_evt;
+                }
+        }
+
+        return next_evt;
+}
+
+void irq_timings_free(int irq)
+{
+        struct irqt_stat __percpu *s;
+
+        s = idr_find(&irqt_stats, irq);
+        if (s) {
+                free_percpu(s);
+                idr_remove(&irqt_stats, irq);
+        }
+}
+
+int irq_timings_alloc(int irq)
+{
+        struct irqt_stat __percpu *s;
+        int id;
+
+        /*
+         * Some platforms can have the same private interrupt per cpu,
+         * so this function may be be called several times with the
+         * same interrupt number. Just bail out in case the per cpu
+         * stat structure is already allocated.
+         */
+        s = idr_find(&irqt_stats, irq);
+        if (s)
+                return 0;
+
+        s = alloc_percpu(*s);
+        if (!s)
+                return -ENOMEM;
+
+        idr_preload(GFP_KERNEL);
+        id = idr_alloc(&irqt_stats, s, irq, irq + 1, GFP_NOWAIT);
+        idr_preload_end();
+
+        if (id < 0) {
+                free_percpu(s);
+                return id;
+        }
+
+        return 0;
+}
diff --git a/kernel/jump_label.c b/kernel/jump_label.c
index 6c9cb208ac48..d11c506a6ac3 100644
--- a/kernel/jump_label.c
+++ b/kernel/jump_label.c
@@ -15,6 +15,7 @@
 #include <linux/static_key.h>
 #include <linux/jump_label_ratelimit.h>
 #include <linux/bug.h>
+#include <linux/cpu.h>
 
 #ifdef HAVE_JUMP_LABEL
 
@@ -124,6 +125,7 @@ void static_key_slow_inc(struct static_key *key)
                         return;
         }
 
+        cpus_read_lock();
         jump_label_lock();
         if (atomic_read(&key->enabled) == 0) {
                 atomic_set(&key->enabled, -1);
@@ -133,12 +135,14 @@ void static_key_slow_inc(struct static_key *key)
                 atomic_inc(&key->enabled);
         }
         jump_label_unlock();
+        cpus_read_unlock();
 }
 EXPORT_SYMBOL_GPL(static_key_slow_inc);
 
 static void __static_key_slow_dec(struct static_key *key,
                 unsigned long rate_limit, struct delayed_work *work)
 {
+        cpus_read_lock();
         /*
          * The negative count check is valid even when a negative
          * key->enabled is in use by static_key_slow_inc(); a
@@ -149,6 +153,7 @@ static void __static_key_slow_dec(struct static_key *key,
         if (!atomic_dec_and_mutex_lock(&key->enabled, &jump_label_mutex)) {
                 WARN(atomic_read(&key->enabled) < 0,
                      "jump label: negative count!\n");
+                cpus_read_unlock();
                 return;
         }
 
@@ -159,6 +164,7 @@ static void __static_key_slow_dec(struct static_key *key,
                 jump_label_update(key);
         }
         jump_label_unlock();
+        cpus_read_unlock();
 }
 
 static void jump_label_update_timeout(struct work_struct *work)
@@ -334,6 +340,7 @@ void __init jump_label_init(void)
         if (static_key_initialized)
                 return;
 
+        cpus_read_lock();
         jump_label_lock();
         jump_label_sort_entries(iter_start, iter_stop);
 
@@ -353,6 +360,7 @@ void __init jump_label_init(void)
         }
         static_key_initialized = true;
         jump_label_unlock();
+        cpus_read_unlock();
 }
 
 #ifdef CONFIG_MODULES
@@ -590,28 +598,28 @@ jump_label_module_notify(struct notifier_block *self, unsigned long val,
         struct module *mod = data;
         int ret = 0;
 
+        cpus_read_lock();
+        jump_label_lock();
+
         switch (val) {
         case MODULE_STATE_COMING:
-                jump_label_lock();
                 ret = jump_label_add_module(mod);
                 if (ret) {
                         WARN(1, "Failed to allocatote memory: jump_label may not work properly.\n");
                         jump_label_del_module(mod);
                 }
-                jump_label_unlock();
                 break;
         case MODULE_STATE_GOING:
-                jump_label_lock();
                 jump_label_del_module(mod);
-                jump_label_unlock();
                 break;
         case MODULE_STATE_LIVE:
-                jump_label_lock();
                 jump_label_invalidate_module_init(mod);
-                jump_label_unlock();
                 break;
         }
 
+        jump_label_unlock();
+        cpus_read_unlock();
+
         return notifier_from_errno(ret);
 }
 
diff --git a/kernel/kallsyms.c b/kernel/kallsyms.c
index 6a3b249a2ae1..127e7cfafa55 100644
--- a/kernel/kallsyms.c
+++ b/kernel/kallsyms.c
@@ -28,12 +28,6 @@
 
 #include <asm/sections.h>
 
-#ifdef CONFIG_KALLSYMS_ALL
-#define all_var 1
-#else
-#define all_var 0
-#endif
-
 /*
  * These will be re-linked against their real values
  * during the second link stage.
@@ -82,7 +76,7 @@ static inline int is_kernel(unsigned long addr)
 
 static int is_ksym_addr(unsigned long addr)
 {
-        if (all_var)
+        if (IS_ENABLED(CONFIG_KALLSYMS_ALL))
                 return is_kernel(addr);
 
         return is_kernel_text(addr) || is_kernel_inittext(addr);
@@ -280,7 +274,7 @@ static unsigned long get_symbol_pos(unsigned long addr,
         if (!symbol_end) {
                 if (is_kernel_inittext(addr))
                         symbol_end = (unsigned long)_einittext;
-                else if (all_var)
+                else if (IS_ENABLED(CONFIG_KALLSYMS_ALL))
                         symbol_end = (unsigned long)_end;
                 else
                         symbol_end = (unsigned long)_etext;
diff --git a/kernel/kcmp.c b/kernel/kcmp.c
index 3a47fa998fe0..ea34ed8bb952 100644
--- a/kernel/kcmp.c
+++ b/kernel/kcmp.c
@@ -11,6 +11,10 @@
 #include <linux/bug.h>
 #include <linux/err.h>
 #include <linux/kcmp.h>
+#include <linux/capability.h>
+#include <linux/list.h>
+#include <linux/eventpoll.h>
+#include <linux/file.h>
 
 #include <asm/unistd.h>
 
@@ -94,6 +98,56 @@ static int kcmp_lock(struct mutex *m1, struct mutex *m2)
         return err;
 }
 
+#ifdef CONFIG_EPOLL
+static int kcmp_epoll_target(struct task_struct *task1,
+                             struct task_struct *task2,
+                             unsigned long idx1,
+                             struct kcmp_epoll_slot __user *uslot)
+{
+        struct file *filp, *filp_epoll, *filp_tgt;
+        struct kcmp_epoll_slot slot;
+        struct files_struct *files;
+
+        if (copy_from_user(&slot, uslot, sizeof(slot)))
+                return -EFAULT;
+
+        filp = get_file_raw_ptr(task1, idx1);
+        if (!filp)
+                return -EBADF;
+
+        files = get_files_struct(task2);
+        if (!files)
+                return -EBADF;
+
+        spin_lock(&files->file_lock);
+        filp_epoll = fcheck_files(files, slot.efd);
+        if (filp_epoll)
+                get_file(filp_epoll);
+        else
+                filp_tgt = ERR_PTR(-EBADF);
+        spin_unlock(&files->file_lock);
+        put_files_struct(files);
+
+        if (filp_epoll) {
+                filp_tgt = get_epoll_tfile_raw_ptr(filp_epoll, slot.tfd, slot.toff);
+                fput(filp_epoll);
+        } else
+
+        if (IS_ERR(filp_tgt))
+                return PTR_ERR(filp_tgt);
+
+        return kcmp_ptr(filp, filp_tgt, KCMP_FILE);
+}
+#else
+static int kcmp_epoll_target(struct task_struct *task1,
+                             struct task_struct *task2,
+                             unsigned long idx1,
+                             struct kcmp_epoll_slot __user *uslot)
+{
+        return -EOPNOTSUPP;
+}
+#endif
+
 SYSCALL_DEFINE5(kcmp, pid_t, pid1, pid_t, pid2, int, type,
                 unsigned long, idx1, unsigned long, idx2)
 {
@@ -165,6 +219,9 @@ SYSCALL_DEFINE5(kcmp, pid_t, pid1, pid_t, pid2, int, type,
                 ret = -EOPNOTSUPP;
 #endif
                 break;
+        case KCMP_EPOLL_TFD:
+                ret = kcmp_epoll_target(task1, task2, idx1, (void *)idx2);
+                break;
         default:
                 ret = -EINVAL;
                 break;
diff --git a/kernel/kexec.c b/kernel/kexec.c
index 980936a90ee6..e62ec4dc6620 100644
--- a/kernel/kexec.c
+++ b/kernel/kexec.c
@@ -144,6 +144,14 @@ static int do_kexec_load(unsigned long entry, unsigned long nr_segments,
         if (ret)
                 goto out;
 
+        /*
+         * Some architecture(like S390) may touch the crash memory before
+         * machine_kexec_prepare(), we must copy vmcoreinfo data after it.
+         */
+        ret = kimage_crash_copy_vmcoreinfo(image);
+        if (ret)
+                goto out;
+
         for (i = 0; i < nr_segments; i++) {
                 ret = kimage_load_segment(image, &image->segment[i]);
                 if (ret)
diff --git a/kernel/kexec_core.c b/kernel/kexec_core.c
index ae1a3ba24df5..1ae7c41c33c1 100644
--- a/kernel/kexec_core.c
+++ b/kernel/kexec_core.c
@@ -38,6 +38,7 @@
 #include <linux/syscore_ops.h>
 #include <linux/compiler.h>
 #include <linux/hugetlb.h>
+#include <linux/frame.h>
 
 #include <asm/page.h>
 #include <asm/sections.h>
@@ -481,6 +482,40 @@ struct page *kimage_alloc_control_pages(struct kimage *image,
         return pages;
 }
 
+int kimage_crash_copy_vmcoreinfo(struct kimage *image)
+{
+        struct page *vmcoreinfo_page;
+        void *safecopy;
+
+        if (image->type != KEXEC_TYPE_CRASH)
+                return 0;
+
+        /*
+         * For kdump, allocate one vmcoreinfo safe copy from the
+         * crash memory. as we have arch_kexec_protect_crashkres()
+         * after kexec syscall, we naturally protect it from write
+         * (even read) access under kernel direct mapping. But on
+         * the other hand, we still need to operate it when crash
+         * happens to generate vmcoreinfo note, hereby we rely on
+         * vmap for this purpose.
+         */
+        vmcoreinfo_page = kimage_alloc_control_pages(image, 0);
+        if (!vmcoreinfo_page) {
+                pr_warn("Could not allocate vmcoreinfo buffer\n");
+                return -ENOMEM;
+        }
+        safecopy = vmap(&vmcoreinfo_page, 1, VM_MAP, PAGE_KERNEL);
+        if (!safecopy) {
+                pr_warn("Could not vmap vmcoreinfo buffer\n");
+                return -ENOMEM;
+        }
+
+        image->vmcoreinfo_data_copy = safecopy;
+        crash_update_vmcoreinfo_safecopy(safecopy);
+
+        return 0;
+}
+
 static int kimage_add_entry(struct kimage *image, kimage_entry_t entry)
 {
         if (*image->entry != 0)
@@ -568,6 +603,11 @@ void kimage_free(struct kimage *image)
         if (!image)
                 return;
 
+        if (image->vmcoreinfo_data_copy) {
+                crash_update_vmcoreinfo_safecopy(NULL);
+                vunmap(image->vmcoreinfo_data_copy);
+        }
+
         kimage_free_extra_pages(image);
         for_each_kimage_entry(image, ptr, entry) {
                 if (entry & IND_INDIRECTION) {
@@ -874,7 +914,7 @@ int kexec_load_disabled;
  * only when panic_cpu holds the current CPU number; this is the only CPU
  * which processes crash_kexec routines.
  */
-void __crash_kexec(struct pt_regs *regs)
+void __noclone __crash_kexec(struct pt_regs *regs)
 {
         /* Take the kexec_mutex here to prevent sys_kexec_load
          * running on one cpu from replacing the crash kernel
@@ -896,6 +936,7 @@ void __crash_kexec(struct pt_regs *regs)
                 mutex_unlock(&kexec_mutex);
         }
 }
+STACK_FRAME_NON_STANDARD(__crash_kexec);
 
 void crash_kexec(struct pt_regs *regs)
 {
diff --git a/kernel/kexec_file.c b/kernel/kexec_file.c
index b118735fea9d..9f48f4412297 100644
--- a/kernel/kexec_file.c
+++ b/kernel/kexec_file.c
@@ -26,13 +26,6 @@
 #include <linux/vmalloc.h>
 #include "kexec_internal.h"
 
-/*
- * Declare these symbols weak so that if architecture provides a purgatory,
- * these will be overridden.
- */
-char __weak kexec_purgatory[0];
-size_t __weak kexec_purgatory_size = 0;
-
 static int kexec_calculate_store_digests(struct kimage *image);
 
 /* Architectures can provide this probe function */
@@ -162,16 +155,10 @@ kimage_file_prepare_segments(struct kimage *image, int kernel_fd, int initrd_fd,
         }
 
         if (cmdline_len) {
-                image->cmdline_buf = kzalloc(cmdline_len, GFP_KERNEL);
-                if (!image->cmdline_buf) {
-                        ret = -ENOMEM;
-                        goto out;
-                }
-
-                ret = copy_from_user(image->cmdline_buf, cmdline_ptr,
-                                     cmdline_len);
-                if (ret) {
-                        ret = -EFAULT;
+                image->cmdline_buf = memdup_user(cmdline_ptr, cmdline_len);
+                if (IS_ERR(image->cmdline_buf)) {
+                        ret = PTR_ERR(image->cmdline_buf);
+                        image->cmdline_buf = NULL;
                         goto out;
                 }
 
@@ -304,6 +291,14 @@ SYSCALL_DEFINE5(kexec_file_load, int, kernel_fd, int, initrd_fd,
         if (ret)
                 goto out;
 
+        /*
+         * Some architecture(like S390) may touch the crash memory before
+         * machine_kexec_prepare(), we must copy vmcoreinfo data after it.
+         */
+        ret = kimage_crash_copy_vmcoreinfo(image);
+        if (ret)
+                goto out;
+
         ret = kexec_calculate_store_digests(image);
         if (ret)
                 goto out;
diff --git a/kernel/kexec_internal.h b/kernel/kexec_internal.h
index 799a8a452187..50dfcb039a41 100644
--- a/kernel/kexec_internal.h
+++ b/kernel/kexec_internal.h
@@ -17,6 +17,8 @@ extern struct mutex kexec_mutex;
 #ifdef CONFIG_KEXEC_FILE
 #include <linux/purgatory.h>
 void kimage_file_post_load_cleanup(struct kimage *image);
+extern char kexec_purgatory[];
+extern size_t kexec_purgatory_size;
 #else /* CONFIG_KEXEC_FILE */
 static inline void kimage_file_post_load_cleanup(struct kimage *image) { }
 #endif /* CONFIG_KEXEC_FILE */
diff --git a/kernel/kmod.c b/kernel/kmod.c
index 563f97e2be36..6d016c5d97c8 100644
--- a/kernel/kmod.c
+++ b/kernel/kmod.c
@@ -45,8 +45,6 @@
 
 #include <trace/events/module.h>
 
-extern int max_threads;
-
 #define CAP_BSET        (void *)1
 #define CAP_PI          (void *)2
 
@@ -56,6 +54,21 @@ static DEFINE_SPINLOCK(umh_sysctl_lock);
 static DECLARE_RWSEM(umhelper_sem);
 
 #ifdef CONFIG_MODULES
+/*
+ * Assuming:
+ *
+ * threads = div64_u64((u64) totalram_pages * (u64) PAGE_SIZE,
+ *                     (u64) THREAD_SIZE * 8UL);
+ *
+ * If you need less than 50 threads would mean we're dealing with systems
+ * smaller than 3200 pages. This assuems you are capable of having ~13M memory,
+ * and this would only be an be an upper limit, after which the OOM killer
+ * would take effect. Systems like these are very unlikely if modules are
+ * enabled.
+ */
+#define MAX_KMOD_CONCURRENT 50
+static atomic_t kmod_concurrent_max = ATOMIC_INIT(MAX_KMOD_CONCURRENT);
+static DECLARE_WAIT_QUEUE_HEAD(kmod_wq);
 
 /*
         modprobe_path is set via /proc/sys.
@@ -127,11 +140,7 @@ int __request_module(bool wait, const char *fmt, ...)
 {
         va_list args;
         char module_name[MODULE_NAME_LEN];
-        unsigned int max_modprobes;
         int ret;
-        static atomic_t kmod_concurrent = ATOMIC_INIT(0);
-#define MAX_KMOD_CONCURRENT 50  /* Completely arbitrary value - KAO */
-        static int kmod_loop_msg;
 
         /*
          * We don't allow synchronous module loading from async.  Module
@@ -154,40 +163,25 @@ int __request_module(bool wait, const char *fmt, ...)
         if (ret)
                 return ret;
 
-        /* If modprobe needs a service that is in a module, we get a recursive
-         * loop.  Limit the number of running kmod threads to max_threads/2 or
-         * MAX_KMOD_CONCURRENT, whichever is the smaller.  A cleaner method
-         * would be to run the parents of this process, counting how many times
-         * kmod was invoked.  That would mean accessing the internals of the
-         * process tables to get the command line, proc_pid_cmdline is static
-         * and it is not worth changing the proc code just to handle this case. 
-         * KAO.
-         *
-         * "trace the ppid" is simple, but will fail if someone's
-         * parent exits.  I think this is as good as it gets. --RR
-         */
-        max_modprobes = min(max_threads/2, MAX_KMOD_CONCURRENT);
-        atomic_inc(&kmod_concurrent);
-        if (atomic_read(&kmod_concurrent) > max_modprobes) {
-                /* We may be blaming an innocent here, but unlikely */
-                if (kmod_loop_msg < 5) {
-                        printk(KERN_ERR
-                               "request_module: runaway loop modprobe %s\n",
-                               module_name);
-                        kmod_loop_msg++;
-                }
-                atomic_dec(&kmod_concurrent);
-                return -ENOMEM;
+        if (atomic_dec_if_positive(&kmod_concurrent_max) < 0) {
+                pr_warn_ratelimited("request_module: kmod_concurrent_max (%u) close to 0 (max_modprobes: %u), for module %s, throttling...",
+                                    atomic_read(&kmod_concurrent_max),
+                                    MAX_KMOD_CONCURRENT, module_name);
+                wait_event_interruptible(kmod_wq,
+                                         atomic_dec_if_positive(&kmod_concurrent_max) >= 0);
         }
 
         trace_module_request(module_name, wait, _RET_IP_);
 
         ret = call_modprobe(module_name, wait ? UMH_WAIT_PROC : UMH_WAIT_EXEC);
 
-        atomic_dec(&kmod_concurrent);
+        atomic_inc(&kmod_concurrent_max);
+        wake_up(&kmod_wq);
+
         return ret;
 }
 EXPORT_SYMBOL(__request_module);
+
 #endif /* CONFIG_MODULES */
 
 static void call_usermodehelper_freeinfo(struct subprocess_info *info)
diff --git a/kernel/kprobes.c b/kernel/kprobes.c
index 2d2d3a568e4e..a1606a4224e1 100644
--- a/kernel/kprobes.c
+++ b/kernel/kprobes.c
@@ -122,7 +122,7 @@ static void *alloc_insn_page(void)
         return module_alloc(PAGE_SIZE);
 }
 
-static void free_insn_page(void *page)
+void __weak free_insn_page(void *page)
 {
         module_memfree(page);
 }
@@ -483,11 +483,6 @@ static DECLARE_DELAYED_WORK(optimizing_work, kprobe_optimizer);
  */
 static void do_optimize_kprobes(void)
 {
-        /* Optimization never be done when disarmed */
-        if (kprobes_all_disarmed || !kprobes_allow_optimization ||
-            list_empty(&optimizing_list))
-                return;
-
         /*
          * The optimization/unoptimization refers online_cpus via
          * stop_machine() and cpu-hotplug modifies online_cpus.
@@ -495,14 +490,19 @@ static void do_optimize_kprobes(void)
          * This combination can cause a deadlock (cpu-hotplug try to lock
          * text_mutex but stop_machine can not be done because online_cpus
          * has been changed)
-         * To avoid this deadlock, we need to call get_online_cpus()
+         * To avoid this deadlock, caller must have locked cpu hotplug
          * for preventing cpu-hotplug outside of text_mutex locking.
          */
-        get_online_cpus();
+        lockdep_assert_cpus_held();
+
+        /* Optimization never be done when disarmed */
+        if (kprobes_all_disarmed || !kprobes_allow_optimization ||
+            list_empty(&optimizing_list))
+                return;
+
         mutex_lock(&text_mutex);
         arch_optimize_kprobes(&optimizing_list);
         mutex_unlock(&text_mutex);
-        put_online_cpus();
 }
 
 /*
@@ -513,12 +513,13 @@ static void do_unoptimize_kprobes(void)
 {
         struct optimized_kprobe *op, *tmp;
 
+        /* See comment in do_optimize_kprobes() */
+        lockdep_assert_cpus_held();
+
         /* Unoptimization must be done anytime */
         if (list_empty(&unoptimizing_list))
                 return;
 
-        /* Ditto to do_optimize_kprobes */
-        get_online_cpus();
         mutex_lock(&text_mutex);
         arch_unoptimize_kprobes(&unoptimizing_list, &freeing_list);
         /* Loop free_list for disarming */
@@ -537,7 +538,6 @@ static void do_unoptimize_kprobes(void)
                         list_del_init(&op->list);
         }
         mutex_unlock(&text_mutex);
-        put_online_cpus();
 }
 
 /* Reclaim all kprobes on the free_list */
@@ -562,6 +562,7 @@ static void kick_kprobe_optimizer(void)
 static void kprobe_optimizer(struct work_struct *work)
 {
         mutex_lock(&kprobe_mutex);
+        cpus_read_lock();
         /* Lock modules while optimizing kprobes */
         mutex_lock(&module_mutex);
 
@@ -587,6 +588,7 @@ static void kprobe_optimizer(struct work_struct *work)
         do_free_cleaned_kprobes();
 
         mutex_unlock(&module_mutex);
+        cpus_read_unlock();
         mutex_unlock(&kprobe_mutex);
 
         /* Step 5: Kick optimizer again if needed */
@@ -650,9 +652,8 @@ static void optimize_kprobe(struct kprobe *p)
 /* Short cut to direct unoptimizing */
 static void force_unoptimize_kprobe(struct optimized_kprobe *op)
 {
-        get_online_cpus();
+        lockdep_assert_cpus_held();
         arch_unoptimize_kprobe(op);
-        put_online_cpus();
         if (kprobe_disabled(&op->kp))
                 arch_disarm_kprobe(&op->kp);
 }
@@ -791,6 +792,7 @@ static void try_to_optimize_kprobe(struct kprobe *p)
                 return;
 
         /* For preparing optimization, jump_label_text_reserved() is called */
+        cpus_read_lock();
         jump_label_lock();
         mutex_lock(&text_mutex);
 
@@ -812,6 +814,7 @@ static void try_to_optimize_kprobe(struct kprobe *p)
 out:
         mutex_unlock(&text_mutex);
         jump_label_unlock();
+        cpus_read_unlock();
 }
 
 #ifdef CONFIG_SYSCTL
@@ -826,6 +829,7 @@ static void optimize_all_kprobes(void)
         if (kprobes_allow_optimization)
                 goto out;
 
+        cpus_read_lock();
         kprobes_allow_optimization = true;
         for (i = 0; i < KPROBE_TABLE_SIZE; i++) {
                 head = &kprobe_table[i];
@@ -833,6 +837,7 @@ static void optimize_all_kprobes(void)
                         if (!kprobe_disabled(p))
                                 optimize_kprobe(p);
         }
+        cpus_read_unlock();
         printk(KERN_INFO "Kprobes globally optimized\n");
 out:
         mutex_unlock(&kprobe_mutex);
@@ -851,6 +856,7 @@ static void unoptimize_all_kprobes(void)
                 return;
         }
 
+        cpus_read_lock();
         kprobes_allow_optimization = false;
         for (i = 0; i < KPROBE_TABLE_SIZE; i++) {
                 head = &kprobe_table[i];
@@ -859,6 +865,7 @@ static void unoptimize_all_kprobes(void)
                                 unoptimize_kprobe(p, false);
                 }
         }
+        cpus_read_unlock();
         mutex_unlock(&kprobe_mutex);
 
         /* Wait for unoptimizing completion */
@@ -1010,14 +1017,11 @@ static void arm_kprobe(struct kprobe *kp)
                 arm_kprobe_ftrace(kp);
                 return;
         }
-        /*
-         * Here, since __arm_kprobe() doesn't use stop_machine(),
-         * this doesn't cause deadlock on text_mutex. So, we don't
-         * need get_online_cpus().
-         */
+        cpus_read_lock();
         mutex_lock(&text_mutex);
         __arm_kprobe(kp);
         mutex_unlock(&text_mutex);
+        cpus_read_unlock();
 }
 
 /* Disarm a kprobe with text_mutex */
@@ -1027,10 +1031,12 @@ static void disarm_kprobe(struct kprobe *kp, bool reopt)
                 disarm_kprobe_ftrace(kp);
                 return;
         }
-        /* Ditto */
+
+        cpus_read_lock();
         mutex_lock(&text_mutex);
         __disarm_kprobe(kp, reopt);
         mutex_unlock(&text_mutex);
+        cpus_read_unlock();
 }
 
 /*
@@ -1298,13 +1304,10 @@ static int register_aggr_kprobe(struct kprobe *orig_p, struct kprobe *p)
         int ret = 0;
         struct kprobe *ap = orig_p;
 
+        cpus_read_lock();
+
         /* For preparing optimization, jump_label_text_reserved() is called */
         jump_label_lock();
-        /*
-         * Get online CPUs to avoid text_mutex deadlock.with stop machine,
-         * which is invoked by unoptimize_kprobe() in add_new_kprobe()
-         */
-        get_online_cpus();
         mutex_lock(&text_mutex);
 
         if (!kprobe_aggrprobe(orig_p)) {
@@ -1352,8 +1355,8 @@ static int register_aggr_kprobe(struct kprobe *orig_p, struct kprobe *p)
 
 out:
         mutex_unlock(&text_mutex);
-        put_online_cpus();
         jump_label_unlock();
+        cpus_read_unlock();
 
         if (ret == 0 && kprobe_disabled(ap) && !kprobe_disabled(p)) {
                 ap->flags &= ~KPROBE_FLAG_DISABLED;
@@ -1555,9 +1558,12 @@ int register_kprobe(struct kprobe *p)
                 goto out;
         }
 
-        mutex_lock(&text_mutex);        /* Avoiding text modification */
+        cpus_read_lock();
+        /* Prevent text modification */
+        mutex_lock(&text_mutex);
         ret = prepare_kprobe(p);
         mutex_unlock(&text_mutex);
+        cpus_read_unlock();
         if (ret)
                 goto out;
 
@@ -1570,7 +1576,6 @@ int register_kprobe(struct kprobe *p)
 
         /* Try to optimize kprobe */
         try_to_optimize_kprobe(p);
-
 out:
         mutex_unlock(&kprobe_mutex);
 
@@ -1766,24 +1771,13 @@ unsigned long __weak arch_deref_entry_point(void *entry)
 
 int register_jprobes(struct jprobe **jps, int num)
 {
-        struct jprobe *jp;
         int ret = 0, i;
 
         if (num <= 0)
                 return -EINVAL;
+
         for (i = 0; i < num; i++) {
-                unsigned long addr, offset;
-                jp = jps[i];
-                addr = arch_deref_entry_point(jp->entry);
-
-                /* Verify probepoint is a function entry point */
-                if (kallsyms_lookup_size_offset(addr, NULL, &offset) &&
-                    offset == 0) {
-                        jp->kp.pre_handler = setjmp_pre_handler;
-                        jp->kp.break_handler = longjmp_break_handler;
-                        ret = register_kprobe(&jp->kp);
-                } else
-                        ret = -EINVAL;
+                ret = register_jprobe(jps[i]);
 
                 if (ret < 0) {
                         if (i > 0)
@@ -1791,13 +1785,30 @@ int register_jprobes(struct jprobe **jps, int num)
                         break;
                 }
         }
+
         return ret;
 }
 EXPORT_SYMBOL_GPL(register_jprobes);
 
 int register_jprobe(struct jprobe *jp)
 {
-        return register_jprobes(&jp, 1);
+        unsigned long addr, offset;
+        struct kprobe *kp = &jp->kp;
+
+        /*
+         * Verify probepoint as well as the jprobe handler are
+         * valid function entry points.
+         */
+        addr = arch_deref_entry_point(jp->entry);
+
+        if (kallsyms_lookup_size_offset(addr, NULL, &offset) && offset == 0 &&
+            kprobe_on_func_entry(kp->addr, kp->symbol_name, kp->offset)) {
+                kp->pre_handler = setjmp_pre_handler;
+                kp->break_handler = longjmp_break_handler;
+                return register_kprobe(kp);
+        }
+
+        return -EINVAL;
 }
 EXPORT_SYMBOL_GPL(register_jprobe);
 
@@ -1883,12 +1894,12 @@ static int pre_handler_kretprobe(struct kprobe *p, struct pt_regs *regs)
 }
 NOKPROBE_SYMBOL(pre_handler_kretprobe);
 
-bool __weak arch_function_offset_within_entry(unsigned long offset)
+bool __weak arch_kprobe_on_func_entry(unsigned long offset)
 {
         return !offset;
 }
 
-bool function_offset_within_entry(kprobe_opcode_t *addr, const char *sym, unsigned long offset)
+bool kprobe_on_func_entry(kprobe_opcode_t *addr, const char *sym, unsigned long offset)
 {
         kprobe_opcode_t *kp_addr = _kprobe_addr(addr, sym, offset);
 
@@ -1896,7 +1907,7 @@ bool function_offset_within_entry(kprobe_opcode_t *addr, const char *sym, unsign
                 return false;
 
         if (!kallsyms_lookup_size_offset((unsigned long)kp_addr, NULL, &offset) ||
-                                                !arch_function_offset_within_entry(offset))
+                                                !arch_kprobe_on_func_entry(offset))
                 return false;
 
         return true;
@@ -1909,7 +1920,7 @@ int register_kretprobe(struct kretprobe *rp)
         int i;
         void *addr;
 
-        if (!function_offset_within_entry(rp->kp.addr, rp->kp.symbol_name, rp->kp.offset))
+        if (!kprobe_on_func_entry(rp->kp.addr, rp->kp.symbol_name, rp->kp.offset))
                 return -EINVAL;
 
         if (kretprobe_blacklist_size) {
diff --git a/kernel/ksysfs.c b/kernel/ksysfs.c
index 23cd70651238..46ba853656f6 100644
--- a/kernel/ksysfs.c
+++ b/kernel/ksysfs.c
@@ -134,7 +134,7 @@ static ssize_t vmcoreinfo_show(struct kobject *kobj,
 {
         phys_addr_t vmcore_base = paddr_vmcoreinfo_note();
         return sprintf(buf, "%pa %x\n", &vmcore_base,
-                       (unsigned int)sizeof(vmcoreinfo_note));
+                        (unsigned int)VMCOREINFO_NOTE_SIZE);
 }
 KERNEL_ATTR_RO(vmcoreinfo);
 
@@ -234,7 +234,7 @@ static struct attribute * kernel_attrs[] = {
         NULL
 };
 
-static struct attribute_group kernel_attr_group = {
+static const struct attribute_group kernel_attr_group = {
         .attrs = kernel_attrs,
 };
 
diff --git a/kernel/livepatch/Kconfig b/kernel/livepatch/Kconfig
index 045022557936..ec4565122e65 100644
--- a/kernel/livepatch/Kconfig
+++ b/kernel/livepatch/Kconfig
@@ -10,6 +10,7 @@ config LIVEPATCH
         depends on SYSFS
         depends on KALLSYMS_ALL
         depends on HAVE_LIVEPATCH
+        depends on !TRIM_UNUSED_KSYMS
         help
           Say Y here if you want to support kernel live patching.
           This option has no runtime impact until a kernel "patch"
diff --git a/kernel/livepatch/patch.c b/kernel/livepatch/patch.c
index f8269036bf0b..52c4e907c14b 100644
--- a/kernel/livepatch/patch.c
+++ b/kernel/livepatch/patch.c
@@ -59,7 +59,11 @@ static void notrace klp_ftrace_handler(unsigned long ip,
 
         ops = container_of(fops, struct klp_ops, fops);
 
-        rcu_read_lock();
+        /*
+         * A variant of synchronize_sched() is used to allow patching functions
+         * where RCU is not watching, see klp_synchronize_transition().
+         */
+        preempt_disable_notrace();
 
         func = list_first_or_null_rcu(&ops->func_stack, struct klp_func,
                                       stack_node);
@@ -115,7 +119,7 @@ static void notrace klp_ftrace_handler(unsigned long ip,
 
         klp_arch_set_pc(regs, (unsigned long)func->new_func);
 unlock:
-        rcu_read_unlock();
+        preempt_enable_notrace();
 }
 
 /*
diff --git a/kernel/livepatch/transition.c b/kernel/livepatch/transition.c
index adc0cc64aa4b..b004a1fb6032 100644
--- a/kernel/livepatch/transition.c
+++ b/kernel/livepatch/transition.c
@@ -49,6 +49,28 @@ static void klp_transition_work_fn(struct work_struct *work)
 static DECLARE_DELAYED_WORK(klp_transition_work, klp_transition_work_fn);
 
 /*
+ * This function is just a stub to implement a hard force
+ * of synchronize_sched(). This requires synchronizing
+ * tasks even in userspace and idle.
+ */
+static void klp_sync(struct work_struct *work)
+{
+}
+
+/*
+ * We allow to patch also functions where RCU is not watching,
+ * e.g. before user_exit(). We can not rely on the RCU infrastructure
+ * to do the synchronization. Instead hard force the sched synchronization.
+ *
+ * This approach allows to use RCU functions for manipulating func_stack
+ * safely.
+ */
+static void klp_synchronize_transition(void)
+{
+        schedule_on_each_cpu(klp_sync);
+}
+
+/*
  * The transition to the target patch state is complete.  Clean up the data
  * structures.
  */
@@ -73,7 +95,7 @@ static void klp_complete_transition(void)
                  * func->transition gets cleared, the handler may choose a
                  * removed function.
                  */
-                synchronize_rcu();
+                klp_synchronize_transition();
         }
 
         if (klp_transition_patch->immediate)
@@ -92,7 +114,7 @@ static void klp_complete_transition(void)
 
         /* Prevent klp_ftrace_handler() from seeing KLP_UNDEFINED state */
         if (klp_target_state == KLP_PATCHED)
-                synchronize_rcu();
+                klp_synchronize_transition();
 
         read_lock(&tasklist_lock);
         for_each_process_thread(g, task) {
@@ -136,7 +158,11 @@ void klp_cancel_transition(void)
  */
 void klp_update_patch_state(struct task_struct *task)
 {
-        rcu_read_lock();
+        /*
+         * A variant of synchronize_sched() is used to allow patching functions
+         * where RCU is not watching, see klp_synchronize_transition().
+         */
+        preempt_disable_notrace();
 
         /*
          * This test_and_clear_tsk_thread_flag() call also serves as a read
@@ -153,7 +179,7 @@ void klp_update_patch_state(struct task_struct *task)
         if (test_and_clear_tsk_thread_flag(task, TIF_PATCH_PENDING))
                 task->patch_state = READ_ONCE(klp_target_state);
 
-        rcu_read_unlock();
+        preempt_enable_notrace();
 }
 
 /*
@@ -539,7 +565,7 @@ void klp_reverse_transition(void)
                 clear_tsk_thread_flag(idle_task(cpu), TIF_PATCH_PENDING);
 
         /* Let any remaining calls to klp_update_patch_state() complete */
-        synchronize_rcu();
+        klp_synchronize_transition();
 
         klp_start_transition();
 }
diff --git a/kernel/locking/lockdep.c b/kernel/locking/lockdep.c
index c0e31bfee25c..7d2499bec5fe 100644
--- a/kernel/locking/lockdep.c
+++ b/kernel/locking/lockdep.c
@@ -1157,18 +1157,18 @@ print_circular_bug_header(struct lock_list *entry, unsigned int depth,
         if (debug_locks_silent)
                 return 0;
 
-        printk("\n");
+        pr_warn("\n");
         pr_warn("======================================================\n");
         pr_warn("WARNING: possible circular locking dependency detected\n");
         print_kernel_ident();
         pr_warn("------------------------------------------------------\n");
-        printk("%s/%d is trying to acquire lock:\n",
+        pr_warn("%s/%d is trying to acquire lock:\n",
                 curr->comm, task_pid_nr(curr));
         print_lock(check_src);
-        printk("\nbut task is already holding lock:\n");
+        pr_warn("\nbut task is already holding lock:\n");
         print_lock(check_tgt);
-        printk("\nwhich lock already depends on the new lock.\n\n");
-        printk("\nthe existing dependency chain (in reverse order) is:\n");
+        pr_warn("\nwhich lock already depends on the new lock.\n\n");
+        pr_warn("\nthe existing dependency chain (in reverse order) is:\n");
 
         print_circular_bug_entry(entry, depth);
 
@@ -1495,13 +1495,13 @@ print_bad_irq_dependency(struct task_struct *curr,
         if (!debug_locks_off_graph_unlock() || debug_locks_silent)
                 return 0;
 
-        printk("\n");
+        pr_warn("\n");
         pr_warn("=====================================================\n");
         pr_warn("WARNING: %s-safe -> %s-unsafe lock order detected\n",
                 irqclass, irqclass);
         print_kernel_ident();
         pr_warn("-----------------------------------------------------\n");
-        printk("%s/%d [HC%u[%lu]:SC%u[%lu]:HE%u:SE%u] is trying to acquire:\n",
+        pr_warn("%s/%d [HC%u[%lu]:SC%u[%lu]:HE%u:SE%u] is trying to acquire:\n",
                 curr->comm, task_pid_nr(curr),
                 curr->hardirq_context, hardirq_count() >> HARDIRQ_SHIFT,
                 curr->softirq_context, softirq_count() >> SOFTIRQ_SHIFT,
@@ -1509,46 +1509,46 @@ print_bad_irq_dependency(struct task_struct *curr,
                 curr->softirqs_enabled);
         print_lock(next);
 
-        printk("\nand this task is already holding:\n");
+        pr_warn("\nand this task is already holding:\n");
         print_lock(prev);
-        printk("which would create a new lock dependency:\n");
+        pr_warn("which would create a new lock dependency:\n");
         print_lock_name(hlock_class(prev));
-        printk(KERN_CONT " ->");
+        pr_cont(" ->");
         print_lock_name(hlock_class(next));
-        printk(KERN_CONT "\n");
+        pr_cont("\n");
 
-        printk("\nbut this new dependency connects a %s-irq-safe lock:\n",
+        pr_warn("\nbut this new dependency connects a %s-irq-safe lock:\n",
                 irqclass);
         print_lock_name(backwards_entry->class);
-        printk("\n... which became %s-irq-safe at:\n", irqclass);
+        pr_warn("\n... which became %s-irq-safe at:\n", irqclass);
 
         print_stack_trace(backwards_entry->class->usage_traces + bit1, 1);
 
-        printk("\nto a %s-irq-unsafe lock:\n", irqclass);
+        pr_warn("\nto a %s-irq-unsafe lock:\n", irqclass);
         print_lock_name(forwards_entry->class);
-        printk("\n... which became %s-irq-unsafe at:\n", irqclass);
-        printk("...");
+        pr_warn("\n... which became %s-irq-unsafe at:\n", irqclass);
+        pr_warn("...");
 
         print_stack_trace(forwards_entry->class->usage_traces + bit2, 1);
 
-        printk("\nother info that might help us debug this:\n\n");
+        pr_warn("\nother info that might help us debug this:\n\n");
         print_irq_lock_scenario(backwards_entry, forwards_entry,
                                 hlock_class(prev), hlock_class(next));
 
         lockdep_print_held_locks(curr);
 
-        printk("\nthe dependencies between %s-irq-safe lock and the holding lock:\n", irqclass);
+        pr_warn("\nthe dependencies between %s-irq-safe lock and the holding lock:\n", irqclass);
         if (!save_trace(&prev_root->trace))
                 return 0;
         print_shortest_lock_dependencies(backwards_entry, prev_root);
 
-        printk("\nthe dependencies between the lock to be acquired");
-        printk(" and %s-irq-unsafe lock:\n", irqclass);
+        pr_warn("\nthe dependencies between the lock to be acquired");
+        pr_warn(" and %s-irq-unsafe lock:\n", irqclass);
         if (!save_trace(&next_root->trace))
                 return 0;
         print_shortest_lock_dependencies(forwards_entry, next_root);
 
-        printk("\nstack backtrace:\n");
+        pr_warn("\nstack backtrace:\n");
         dump_stack();
 
         return 0;
@@ -1724,22 +1724,22 @@ print_deadlock_bug(struct task_struct *curr, struct held_lock *prev,
         if (!debug_locks_off_graph_unlock() || debug_locks_silent)
                 return 0;
 
-        printk("\n");
+        pr_warn("\n");
         pr_warn("============================================\n");
         pr_warn("WARNING: possible recursive locking detected\n");
         print_kernel_ident();
         pr_warn("--------------------------------------------\n");
-        printk("%s/%d is trying to acquire lock:\n",
+        pr_warn("%s/%d is trying to acquire lock:\n",
                 curr->comm, task_pid_nr(curr));
         print_lock(next);
-        printk("\nbut task is already holding lock:\n");
+        pr_warn("\nbut task is already holding lock:\n");
         print_lock(prev);
 
-        printk("\nother info that might help us debug this:\n");
+        pr_warn("\nother info that might help us debug this:\n");
         print_deadlock_scenario(next, prev);
         lockdep_print_held_locks(curr);
 
-        printk("\nstack backtrace:\n");
+        pr_warn("\nstack backtrace:\n");
         dump_stack();
 
         return 0;
@@ -2074,21 +2074,21 @@ static void print_collision(struct task_struct *curr,
                         struct held_lock *hlock_next,
                         struct lock_chain *chain)
 {
-        printk("\n");
+        pr_warn("\n");
         pr_warn("============================\n");
         pr_warn("WARNING: chain_key collision\n");
         print_kernel_ident();
         pr_warn("----------------------------\n");
-        printk("%s/%d: ", current->comm, task_pid_nr(current));
-        printk("Hash chain already cached but the contents don't match!\n");
+        pr_warn("%s/%d: ", current->comm, task_pid_nr(current));
+        pr_warn("Hash chain already cached but the contents don't match!\n");
 
-        printk("Held locks:");
+        pr_warn("Held locks:");
         print_chain_keys_held_locks(curr, hlock_next);
 
-        printk("Locks in cached chain:");
+        pr_warn("Locks in cached chain:");
         print_chain_keys_chain(chain);
 
-        printk("\nstack backtrace:\n");
+        pr_warn("\nstack backtrace:\n");
         dump_stack();
 }
 #endif
@@ -2373,16 +2373,16 @@ print_usage_bug(struct task_struct *curr, struct held_lock *this,
         if (!debug_locks_off_graph_unlock() || debug_locks_silent)
                 return 0;
 
-        printk("\n");
+        pr_warn("\n");
         pr_warn("================================\n");
         pr_warn("WARNING: inconsistent lock state\n");
         print_kernel_ident();
         pr_warn("--------------------------------\n");
 
-        printk("inconsistent {%s} -> {%s} usage.\n",
+        pr_warn("inconsistent {%s} -> {%s} usage.\n",
                 usage_str[prev_bit], usage_str[new_bit]);
 
-        printk("%s/%d [HC%u[%lu]:SC%u[%lu]:HE%u:SE%u] takes:\n",
+        pr_warn("%s/%d [HC%u[%lu]:SC%u[%lu]:HE%u:SE%u] takes:\n",
                 curr->comm, task_pid_nr(curr),
                 trace_hardirq_context(curr), hardirq_count() >> HARDIRQ_SHIFT,
                 trace_softirq_context(curr), softirq_count() >> SOFTIRQ_SHIFT,
@@ -2390,16 +2390,16 @@ print_usage_bug(struct task_struct *curr, struct held_lock *this,
                 trace_softirqs_enabled(curr));
         print_lock(this);
 
-        printk("{%s} state was registered at:\n", usage_str[prev_bit]);
+        pr_warn("{%s} state was registered at:\n", usage_str[prev_bit]);
         print_stack_trace(hlock_class(this)->usage_traces + prev_bit, 1);
 
         print_irqtrace_events(curr);
-        printk("\nother info that might help us debug this:\n");
+        pr_warn("\nother info that might help us debug this:\n");
         print_usage_bug_scenario(this);
 
         lockdep_print_held_locks(curr);
 
-        printk("\nstack backtrace:\n");
+        pr_warn("\nstack backtrace:\n");
         dump_stack();
 
         return 0;
@@ -2438,28 +2438,28 @@ print_irq_inversion_bug(struct task_struct *curr,
         if (!debug_locks_off_graph_unlock() || debug_locks_silent)
                 return 0;
 
-        printk("\n");
+        pr_warn("\n");
         pr_warn("========================================================\n");
         pr_warn("WARNING: possible irq lock inversion dependency detected\n");
         print_kernel_ident();
         pr_warn("--------------------------------------------------------\n");
-        printk("%s/%d just changed the state of lock:\n",
+        pr_warn("%s/%d just changed the state of lock:\n",
                 curr->comm, task_pid_nr(curr));
         print_lock(this);
         if (forwards)
-                printk("but this lock took another, %s-unsafe lock in the past:\n", irqclass);
+                pr_warn("but this lock took another, %s-unsafe lock in the past:\n", irqclass);
         else
-                printk("but this lock was taken by another, %s-safe lock in the past:\n", irqclass);
+                pr_warn("but this lock was taken by another, %s-safe lock in the past:\n", irqclass);
         print_lock_name(other->class);
-        printk("\n\nand interrupts could create inverse lock ordering between them.\n\n");
+        pr_warn("\n\nand interrupts could create inverse lock ordering between them.\n\n");
 
-        printk("\nother info that might help us debug this:\n");
+        pr_warn("\nother info that might help us debug this:\n");
 
         /* Find a middle lock (if one exists) */
         depth = get_lock_depth(other);
         do {
                 if (depth == 0 && (entry != root)) {
-                        printk("lockdep:%s bad path found in chain graph\n", __func__);
+                        pr_warn("lockdep:%s bad path found in chain graph\n", __func__);
                         break;
                 }
                 middle = entry;
@@ -2475,12 +2475,12 @@ print_irq_inversion_bug(struct task_struct *curr,
 
         lockdep_print_held_locks(curr);
 
-        printk("\nthe shortest dependencies between 2nd lock and 1st lock:\n");
+        pr_warn("\nthe shortest dependencies between 2nd lock and 1st lock:\n");
         if (!save_trace(&root->trace))
                 return 0;
         print_shortest_lock_dependencies(other, root);
 
-        printk("\nstack backtrace:\n");
+        pr_warn("\nstack backtrace:\n");
         dump_stack();
 
         return 0;
@@ -3189,25 +3189,25 @@ print_lock_nested_lock_not_held(struct task_struct *curr,
         if (debug_locks_silent)
                 return 0;
 
-        printk("\n");
+        pr_warn("\n");
         pr_warn("==================================\n");
         pr_warn("WARNING: Nested lock was not taken\n");
         print_kernel_ident();
         pr_warn("----------------------------------\n");
 
-        printk("%s/%d is trying to lock:\n", curr->comm, task_pid_nr(curr));
+        pr_warn("%s/%d is trying to lock:\n", curr->comm, task_pid_nr(curr));
         print_lock(hlock);
 
-        printk("\nbut this task is not holding:\n");
-        printk("%s\n", hlock->nest_lock->name);
+        pr_warn("\nbut this task is not holding:\n");
+        pr_warn("%s\n", hlock->nest_lock->name);
 
-        printk("\nstack backtrace:\n");
+        pr_warn("\nstack backtrace:\n");
         dump_stack();
 
-        printk("\nother info that might help us debug this:\n");
+        pr_warn("\nother info that might help us debug this:\n");
         lockdep_print_held_locks(curr);
 
-        printk("\nstack backtrace:\n");
+        pr_warn("\nstack backtrace:\n");
         dump_stack();
 
         return 0;
@@ -3402,21 +3402,21 @@ print_unlock_imbalance_bug(struct task_struct *curr, struct lockdep_map *lock,
         if (debug_locks_silent)
                 return 0;
 
-        printk("\n");
+        pr_warn("\n");
         pr_warn("=====================================\n");
         pr_warn("WARNING: bad unlock balance detected!\n");
         print_kernel_ident();
         pr_warn("-------------------------------------\n");
-        printk("%s/%d is trying to release lock (",
+        pr_warn("%s/%d is trying to release lock (",
                 curr->comm, task_pid_nr(curr));
         print_lockdep_cache(lock);
-        printk(KERN_CONT ") at:\n");
+        pr_cont(") at:\n");
         print_ip_sym(ip);
-        printk("but there are no more locks to release!\n");
-        printk("\nother info that might help us debug this:\n");
+        pr_warn("but there are no more locks to release!\n");
+        pr_warn("\nother info that might help us debug this:\n");
         lockdep_print_held_locks(curr);
 
-        printk("\nstack backtrace:\n");
+        pr_warn("\nstack backtrace:\n");
         dump_stack();
 
         return 0;
@@ -3974,21 +3974,21 @@ print_lock_contention_bug(struct task_struct *curr, struct lockdep_map *lock,
         if (debug_locks_silent)
                 return 0;
 
-        printk("\n");
+        pr_warn("\n");
         pr_warn("=================================\n");
         pr_warn("WARNING: bad contention detected!\n");
         print_kernel_ident();
         pr_warn("---------------------------------\n");
-        printk("%s/%d is trying to contend lock (",
+        pr_warn("%s/%d is trying to contend lock (",
                 curr->comm, task_pid_nr(curr));
         print_lockdep_cache(lock);
-        printk(KERN_CONT ") at:\n");
+        pr_cont(") at:\n");
         print_ip_sym(ip);
-        printk("but there are no locks held!\n");
-        printk("\nother info that might help us debug this:\n");
+        pr_warn("but there are no locks held!\n");
+        pr_warn("\nother info that might help us debug this:\n");
         lockdep_print_held_locks(curr);
 
-        printk("\nstack backtrace:\n");
+        pr_warn("\nstack backtrace:\n");
         dump_stack();
 
         return 0;
@@ -4318,17 +4318,17 @@ print_freed_lock_bug(struct task_struct *curr, const void *mem_from,
         if (debug_locks_silent)
                 return;
 
-        printk("\n");
+        pr_warn("\n");
         pr_warn("=========================\n");
         pr_warn("WARNING: held lock freed!\n");
         print_kernel_ident();
         pr_warn("-------------------------\n");
-        printk("%s/%d is freeing memory %p-%p, with a lock still held there!\n",
+        pr_warn("%s/%d is freeing memory %p-%p, with a lock still held there!\n",
                 curr->comm, task_pid_nr(curr), mem_from, mem_to-1);
         print_lock(hlock);
         lockdep_print_held_locks(curr);
 
-        printk("\nstack backtrace:\n");
+        pr_warn("\nstack backtrace:\n");
         dump_stack();
 }
 
@@ -4376,14 +4376,14 @@ static void print_held_locks_bug(void)
         if (debug_locks_silent)
                 return;
 
-        printk("\n");
+        pr_warn("\n");
         pr_warn("====================================\n");
         pr_warn("WARNING: %s/%d still has locks held!\n",
                current->comm, task_pid_nr(current));
         print_kernel_ident();
         pr_warn("------------------------------------\n");
         lockdep_print_held_locks(current);
-        printk("\nstack backtrace:\n");
+        pr_warn("\nstack backtrace:\n");
         dump_stack();
 }
 
@@ -4402,10 +4402,10 @@ void debug_show_all_locks(void)
         int unlock = 1;
 
         if (unlikely(!debug_locks)) {
-                printk("INFO: lockdep is turned off.\n");
+                pr_warn("INFO: lockdep is turned off.\n");
                 return;
         }
-        printk("\nShowing all locks held in the system:\n");
+        pr_warn("\nShowing all locks held in the system:\n");
 
         /*
          * Here we try to get the tasklist_lock as hard as possible,
@@ -4416,18 +4416,18 @@ void debug_show_all_locks(void)
 retry:
         if (!read_trylock(&tasklist_lock)) {
                 if (count == 10)
-                        printk("hm, tasklist_lock locked, retrying... ");
+                        pr_warn("hm, tasklist_lock locked, retrying... ");
                 if (count) {
                         count--;
-                        printk(" #%d", 10-count);
+                        pr_cont(" #%d", 10-count);
                         mdelay(200);
                         goto retry;
                 }
-                printk(" ignoring it.\n");
+                pr_cont(" ignoring it.\n");
                 unlock = 0;
         } else {
                 if (count != 10)
-                        printk(KERN_CONT " locked it.\n");
+                        pr_cont(" locked it.\n");
         }
 
         do_each_thread(g, p) {
@@ -4445,7 +4445,7 @@ retry:
                                 unlock = 1;
         } while_each_thread(g, p);
 
-        printk("\n");
+        pr_warn("\n");
         pr_warn("=============================================\n\n");
 
         if (unlock)
@@ -4475,12 +4475,12 @@ asmlinkage __visible void lockdep_sys_exit(void)
         if (unlikely(curr->lockdep_depth)) {
                 if (!debug_locks_off())
                         return;
-                printk("\n");
+                pr_warn("\n");
                 pr_warn("================================================\n");
                 pr_warn("WARNING: lock held when returning to user space!\n");
                 print_kernel_ident();
                 pr_warn("------------------------------------------------\n");
-                printk("%s/%d is leaving the kernel with locks still held!\n",
+                pr_warn("%s/%d is leaving the kernel with locks still held!\n",
                                 curr->comm, curr->pid);
                 lockdep_print_held_locks(curr);
         }
@@ -4490,19 +4490,15 @@ void lockdep_rcu_suspicious(const char *file, const int line, const char *s)
 {
         struct task_struct *curr = current;
 
-#ifndef CONFIG_PROVE_RCU_REPEATEDLY
-        if (!debug_locks_off())
-                return;
-#endif /* #ifdef CONFIG_PROVE_RCU_REPEATEDLY */
         /* Note: the following can be executed concurrently, so be careful. */
-        printk("\n");
+        pr_warn("\n");
         pr_warn("=============================\n");
         pr_warn("WARNING: suspicious RCU usage\n");
         print_kernel_ident();
         pr_warn("-----------------------------\n");
-        printk("%s:%d %s!\n", file, line, s);
-        printk("\nother info that might help us debug this:\n\n");
-        printk("\n%srcu_scheduler_active = %d, debug_locks = %d\n",
+        pr_warn("%s:%d %s!\n", file, line, s);
+        pr_warn("\nother info that might help us debug this:\n\n");
+        pr_warn("\n%srcu_scheduler_active = %d, debug_locks = %d\n",
                !rcu_lockdep_current_cpu_online()
                         ? "RCU used illegally from offline CPU!\n"
                         : !rcu_is_watching()
@@ -4529,10 +4525,10 @@ void lockdep_rcu_suspicious(const char *file, const int line, const char *s)
          * rcu_read_lock_bh() and so on from extended quiescent states.
          */
         if (!rcu_is_watching())
-                printk("RCU used illegally from extended quiescent state!\n");
+                pr_warn("RCU used illegally from extended quiescent state!\n");
 
         lockdep_print_held_locks(curr);
-        printk("\nstack backtrace:\n");
+        pr_warn("\nstack backtrace:\n");
         dump_stack();
 }
 EXPORT_SYMBOL_GPL(lockdep_rcu_suspicious);
diff --git a/kernel/locking/mutex.c b/kernel/locking/mutex.c
index 198527a62149..858a07590e39 100644
--- a/kernel/locking/mutex.c
+++ b/kernel/locking/mutex.c
@@ -227,9 +227,9 @@ static void __sched __mutex_lock_slowpath(struct mutex *lock);
  * (or statically defined) before it can be locked. memset()-ing
  * the mutex to 0 is not allowed.
  *
- * ( The CONFIG_DEBUG_MUTEXES .config option turns on debugging
- *   checks that will enforce the restrictions and will also do
- *   deadlock debugging. )
+ * (The CONFIG_DEBUG_MUTEXES .config option turns on debugging
+ * checks that will enforce the restrictions and will also do
+ * deadlock debugging)
  *
  * This function is similar to (but not equivalent to) down().
  */
diff --git a/kernel/locking/qrwlock.c b/kernel/locking/qrwlock.c
index cc3ed0ccdfa2..2655f26ec882 100644
--- a/kernel/locking/qrwlock.c
+++ b/kernel/locking/qrwlock.c
@@ -20,6 +20,7 @@
 #include <linux/cpumask.h>
 #include <linux/percpu.h>
 #include <linux/hardirq.h>
+#include <linux/spinlock.h>
 #include <asm/qrwlock.h>
 
 /*
diff --git a/kernel/locking/qspinlock.c b/kernel/locking/qspinlock.c
index b2caec7315af..fd24153e8a48 100644
--- a/kernel/locking/qspinlock.c
+++ b/kernel/locking/qspinlock.c
@@ -28,6 +28,7 @@
 #include <linux/percpu.h>
 #include <linux/hardirq.h>
 #include <linux/mutex.h>
+#include <linux/prefetch.h>
 #include <asm/byteorder.h>
 #include <asm/qspinlock.h>
 
diff --git a/kernel/locking/qspinlock_paravirt.h b/kernel/locking/qspinlock_paravirt.h
index e6b2f7ad3e51..4ccfcaae5b89 100644
--- a/kernel/locking/qspinlock_paravirt.h
+++ b/kernel/locking/qspinlock_paravirt.h
@@ -193,7 +193,8 @@ void __init __pv_init_lock_hash(void)
          */
         pv_lock_hash = alloc_large_system_hash("PV qspinlock",
                                                sizeof(struct pv_hash_entry),
-                                               pv_hash_size, 0, HASH_EARLY,
+                                               pv_hash_size, 0,
+                                               HASH_EARLY | HASH_ZERO,
                                                &pv_lock_hash_bits, NULL,
                                                pv_hash_size, pv_hash_size);
 }
diff --git a/kernel/locking/rtmutex-debug.c b/kernel/locking/rtmutex-debug.c
index 58e366ad36f4..ac35e648b0e5 100644
--- a/kernel/locking/rtmutex-debug.c
+++ b/kernel/locking/rtmutex-debug.c
@@ -166,12 +166,16 @@ void debug_rt_mutex_free_waiter(struct rt_mutex_waiter *waiter)
         memset(waiter, 0x22, sizeof(*waiter));
 }
 
-void debug_rt_mutex_init(struct rt_mutex *lock, const char *name)
+void debug_rt_mutex_init(struct rt_mutex *lock, const char *name, struct lock_class_key *key)
 {
         /*
          * Make sure we are not reinitializing a held lock:
          */
         debug_check_no_locks_freed((void *)lock, sizeof(*lock));
         lock->name = name;
+
+#ifdef CONFIG_DEBUG_LOCK_ALLOC
+        lockdep_init_map(&lock->dep_map, name, key, 0);
+#endif
 }
 
diff --git a/kernel/locking/rtmutex-debug.h b/kernel/locking/rtmutex-debug.h
index b585af9a1b50..5078c6ddf4a5 100644
--- a/kernel/locking/rtmutex-debug.h
+++ b/kernel/locking/rtmutex-debug.h
@@ -11,7 +11,7 @@
 
 extern void debug_rt_mutex_init_waiter(struct rt_mutex_waiter *waiter);
 extern void debug_rt_mutex_free_waiter(struct rt_mutex_waiter *waiter);
-extern void debug_rt_mutex_init(struct rt_mutex *lock, const char *name);
+extern void debug_rt_mutex_init(struct rt_mutex *lock, const char *name, struct lock_class_key *key);
 extern void debug_rt_mutex_lock(struct rt_mutex *lock);
 extern void debug_rt_mutex_unlock(struct rt_mutex *lock);
 extern void debug_rt_mutex_proxy_lock(struct rt_mutex *lock,
diff --git a/kernel/locking/rtmutex.c b/kernel/locking/rtmutex.c
index b95509416909..649dc9d3951a 100644
--- a/kernel/locking/rtmutex.c
+++ b/kernel/locking/rtmutex.c
@@ -963,7 +963,6 @@ static int task_blocks_on_rt_mutex(struct rt_mutex *lock,
                 return -EDEADLK;
 
         raw_spin_lock(&task->pi_lock);
-        rt_mutex_adjust_prio(task);
         waiter->task = task;
         waiter->lock = lock;
         waiter->prio = task->prio;
@@ -1481,6 +1480,7 @@ void __sched rt_mutex_lock(struct rt_mutex *lock)
 {
         might_sleep();
 
+        mutex_acquire(&lock->dep_map, 0, 0, _RET_IP_);
         rt_mutex_fastlock(lock, TASK_UNINTERRUPTIBLE, rt_mutex_slowlock);
 }
 EXPORT_SYMBOL_GPL(rt_mutex_lock);
@@ -1496,9 +1496,16 @@ EXPORT_SYMBOL_GPL(rt_mutex_lock);
  */
 int __sched rt_mutex_lock_interruptible(struct rt_mutex *lock)
 {
+        int ret;
+
         might_sleep();
 
-        return rt_mutex_fastlock(lock, TASK_INTERRUPTIBLE, rt_mutex_slowlock);
+        mutex_acquire(&lock->dep_map, 0, 0, _RET_IP_);
+        ret = rt_mutex_fastlock(lock, TASK_INTERRUPTIBLE, rt_mutex_slowlock);
+        if (ret)
+                mutex_release(&lock->dep_map, 1, _RET_IP_);
+
+        return ret;
 }
 EXPORT_SYMBOL_GPL(rt_mutex_lock_interruptible);
 
@@ -1526,11 +1533,18 @@ int __sched rt_mutex_futex_trylock(struct rt_mutex *lock)
 int
 rt_mutex_timed_lock(struct rt_mutex *lock, struct hrtimer_sleeper *timeout)
 {
+        int ret;
+
         might_sleep();
 
-        return rt_mutex_timed_fastlock(lock, TASK_INTERRUPTIBLE, timeout,
+        mutex_acquire(&lock->dep_map, 0, 0, _RET_IP_);
+        ret = rt_mutex_timed_fastlock(lock, TASK_INTERRUPTIBLE, timeout,
                                        RT_MUTEX_MIN_CHAINWALK,
                                        rt_mutex_slowlock);
+        if (ret)
+                mutex_release(&lock->dep_map, 1, _RET_IP_);
+
+        return ret;
 }
 EXPORT_SYMBOL_GPL(rt_mutex_timed_lock);
 
@@ -1547,10 +1561,16 @@ EXPORT_SYMBOL_GPL(rt_mutex_timed_lock);
  */
 int __sched rt_mutex_trylock(struct rt_mutex *lock)
 {
+        int ret;
+
         if (WARN_ON_ONCE(in_irq() || in_nmi() || in_serving_softirq()))
                 return 0;
 
-        return rt_mutex_fasttrylock(lock, rt_mutex_slowtrylock);
+        ret = rt_mutex_fasttrylock(lock, rt_mutex_slowtrylock);
+        if (ret)
+                mutex_acquire(&lock->dep_map, 0, 1, _RET_IP_);
+
+        return ret;
 }
 EXPORT_SYMBOL_GPL(rt_mutex_trylock);
 
@@ -1561,6 +1581,7 @@ EXPORT_SYMBOL_GPL(rt_mutex_trylock);
  */
 void __sched rt_mutex_unlock(struct rt_mutex *lock)
 {
+        mutex_release(&lock->dep_map, 1, _RET_IP_);
         rt_mutex_fastunlock(lock, rt_mutex_slowunlock);
 }
 EXPORT_SYMBOL_GPL(rt_mutex_unlock);
@@ -1620,7 +1641,6 @@ void rt_mutex_destroy(struct rt_mutex *lock)
         lock->magic = NULL;
 #endif
 }
-
 EXPORT_SYMBOL_GPL(rt_mutex_destroy);
 
 /**
@@ -1632,14 +1652,16 @@ EXPORT_SYMBOL_GPL(rt_mutex_destroy);
  *
  * Initializing of a locked rt lock is not allowed
  */
-void __rt_mutex_init(struct rt_mutex *lock, const char *name)
+void __rt_mutex_init(struct rt_mutex *lock, const char *name,
+                     struct lock_class_key *key)
 {
         lock->owner = NULL;
         raw_spin_lock_init(&lock->wait_lock);
         lock->waiters = RB_ROOT;
         lock->waiters_leftmost = NULL;
 
-        debug_rt_mutex_init(lock, name);
+        if (name && key)
+                debug_rt_mutex_init(lock, name, key);
 }
 EXPORT_SYMBOL_GPL(__rt_mutex_init);
 
@@ -1660,7 +1682,7 @@ EXPORT_SYMBOL_GPL(__rt_mutex_init);
 void rt_mutex_init_proxy_locked(struct rt_mutex *lock,
                                 struct task_struct *proxy_owner)
 {
-        __rt_mutex_init(lock, NULL);
+        __rt_mutex_init(lock, NULL, NULL);
         debug_rt_mutex_proxy_lock(lock, proxy_owner);
         rt_mutex_set_owner(lock, proxy_owner);
 }
@@ -1785,12 +1807,14 @@ int rt_mutex_wait_proxy_lock(struct rt_mutex *lock,
         int ret;
 
         raw_spin_lock_irq(&lock->wait_lock);
-
-        set_current_state(TASK_INTERRUPTIBLE);
-
         /* sleep on the mutex */
+        set_current_state(TASK_INTERRUPTIBLE);
         ret = __rt_mutex_slowlock(lock, TASK_INTERRUPTIBLE, to, waiter);
-
+        /*
+         * try_to_take_rt_mutex() sets the waiter bit unconditionally. We might
+         * have to fix that up.
+         */
+        fixup_rt_mutex_waiters(lock);
         raw_spin_unlock_irq(&lock->wait_lock);
 
         return ret;
@@ -1822,15 +1846,25 @@ bool rt_mutex_cleanup_proxy_lock(struct rt_mutex *lock,
 
         raw_spin_lock_irq(&lock->wait_lock);
         /*
+         * Do an unconditional try-lock, this deals with the lock stealing
+         * state where __rt_mutex_futex_unlock() -> mark_wakeup_next_waiter()
+         * sets a NULL owner.
+         *
+         * We're not interested in the return value, because the subsequent
+         * test on rt_mutex_owner() will infer that. If the trylock succeeded,
+         * we will own the lock and it will have removed the waiter. If we
+         * failed the trylock, we're still not owner and we need to remove
+         * ourselves.
+         */
+        try_to_take_rt_mutex(lock, current, waiter);
+        /*
          * Unless we're the owner; we're still enqueued on the wait_list.
          * So check if we became owner, if not, take us off the wait_list.
          */
         if (rt_mutex_owner(lock) != current) {
                 remove_waiter(lock, waiter);
-                fixup_rt_mutex_waiters(lock);
                 cleanup = true;
         }
-
         /*
          * try_to_take_rt_mutex() sets the waiter bit unconditionally. We might
          * have to fix that up.
diff --git a/kernel/locking/rtmutex.h b/kernel/locking/rtmutex.h
index 6607802efa8b..5c253caffe91 100644
--- a/kernel/locking/rtmutex.h
+++ b/kernel/locking/rtmutex.h
@@ -17,7 +17,7 @@
 #define debug_rt_mutex_proxy_lock(l,p)                  do { } while (0)
 #define debug_rt_mutex_proxy_unlock(l)                  do { } while (0)
 #define debug_rt_mutex_unlock(l)                        do { } while (0)
-#define debug_rt_mutex_init(m, n)                       do { } while (0)
+#define debug_rt_mutex_init(m, n, k)                    do { } while (0)
 #define debug_rt_mutex_deadlock(d, a ,l)                do { } while (0)
 #define debug_rt_mutex_print_deadlock(w)                do { } while (0)
 #define debug_rt_mutex_reset_waiter(w)                  do { } while (0)
diff --git a/kernel/locking/rwsem-spinlock.c b/kernel/locking/rwsem-spinlock.c
index c65f7989f850..20819df98125 100644
--- a/kernel/locking/rwsem-spinlock.c
+++ b/kernel/locking/rwsem-spinlock.c
@@ -231,8 +231,8 @@ int __sched __down_write_common(struct rw_semaphore *sem, int state)
 
 out_nolock:
         list_del(&waiter.list);
-        if (!list_empty(&sem->wait_list))
-                __rwsem_do_wake(sem, 1);
+        if (!list_empty(&sem->wait_list) && sem->count >= 0)
+                __rwsem_do_wake(sem, 0);
         raw_spin_unlock_irqrestore(&sem->wait_lock, flags);
 
         return -EINTR;
diff --git a/kernel/memremap.c b/kernel/memremap.c
index 23a6483c3666..124bed776532 100644
--- a/kernel/memremap.c
+++ b/kernel/memremap.c
@@ -358,7 +358,11 @@ void *devm_memremap_pages(struct device *dev, struct resource *res,
                 goto err_pfn_remap;
 
         mem_hotplug_begin();
-        error = arch_add_memory(nid, align_start, align_size, true);
+        error = arch_add_memory(nid, align_start, align_size, false);
+        if (!error)
+                move_pfn_range_to_zone(&NODE_DATA(nid)->node_zones[ZONE_DEVICE],
+                                        align_start >> PAGE_SHIFT,
+                                        align_size >> PAGE_SHIFT);
         mem_hotplug_done();
         if (error)
                 goto err_add_memory;
diff --git a/kernel/module.c b/kernel/module.c
index 4a3665f8f837..40f983cbea81 100644
--- a/kernel/module.c
+++ b/kernel/module.c
@@ -49,9 +49,7 @@
 #include <linux/rculist.h>
 #include <linux/uaccess.h>
 #include <asm/cacheflush.h>
-#ifdef CONFIG_STRICT_MODULE_RWX
-#include <asm/set_memory.h>
-#endif
+#include <linux/set_memory.h>
 #include <asm/mmu_context.h>
 #include <linux/license.h>
 #include <asm/sections.h>
@@ -302,6 +300,7 @@ int unregister_module_notifier(struct notifier_block *nb)
 EXPORT_SYMBOL(unregister_module_notifier);
 
 struct load_info {
+        const char *name;
         Elf_Ehdr *hdr;
         unsigned long len;
         Elf_Shdr *sechdrs;
@@ -602,7 +601,7 @@ static struct module *find_module_all(const char *name, size_t len,
 
         module_assert_mutex_or_preempt();
 
-        list_for_each_entry(mod, &modules, list) {
+        list_for_each_entry_rcu(mod, &modules, list) {
                 if (!even_unformed && mod->state == MODULE_STATE_UNFORMED)
                         continue;
                 if (strlen(mod->name) == len && !memcmp(mod->name, name, len))
@@ -1202,10 +1201,7 @@ static ssize_t store_uevent(struct module_attribute *mattr,
                             struct module_kobject *mk,
                             const char *buffer, size_t count)
 {
-        enum kobject_action action;
-
-        if (kobject_action_type(buffer, count, &action) == 0)
-                kobject_uevent(&mk->kobj, action);
+        kobject_synth_uevent(&mk->kobj, buffer, count);
         return count;
 }
 
@@ -1278,12 +1274,13 @@ static u32 resolve_rel_crc(const s32 *crc)
         return *(u32 *)((void *)crc + *crc);
 }
 
-static int check_version(Elf_Shdr *sechdrs,
-                         unsigned int versindex,
+static int check_version(const struct load_info *info,
                          const char *symname,
                          struct module *mod,
                          const s32 *crc)
 {
+        Elf_Shdr *sechdrs = info->sechdrs;
+        unsigned int versindex = info->index.vers;
         unsigned int i, num_versions;
         struct modversion_info *versions;
 
@@ -1317,17 +1314,16 @@ static int check_version(Elf_Shdr *sechdrs,
         }
 
         /* Broken toolchain. Warn once, then let it go.. */
-        pr_warn_once("%s: no symbol version for %s\n", mod->name, symname);
+        pr_warn_once("%s: no symbol version for %s\n", info->name, symname);
         return 1;
 
 bad_version:
         pr_warn("%s: disagrees about version of symbol %s\n",
-               mod->name, symname);
+               info->name, symname);
         return 0;
 }
 
-static inline int check_modstruct_version(Elf_Shdr *sechdrs,
-                                          unsigned int versindex,
+static inline int check_modstruct_version(const struct load_info *info,
                                           struct module *mod)
 {
         const s32 *crc;
@@ -1343,8 +1339,8 @@ static inline int check_modstruct_version(Elf_Shdr *sechdrs,
                 BUG();
         }
         preempt_enable();
-        return check_version(sechdrs, versindex,
-                             VMLINUX_SYMBOL_STR(module_layout), mod, crc);
+        return check_version(info, VMLINUX_SYMBOL_STR(module_layout),
+                             mod, crc);
 }
 
 /* First part is kernel version, which we ignore if module has crcs. */
@@ -1358,8 +1354,7 @@ static inline int same_magic(const char *amagic, const char *bmagic,
         return strcmp(amagic, bmagic) == 0;
 }
 #else
-static inline int check_version(Elf_Shdr *sechdrs,
-                                unsigned int versindex,
+static inline int check_version(const struct load_info *info,
                                 const char *symname,
                                 struct module *mod,
                                 const s32 *crc)
@@ -1367,8 +1362,7 @@ static inline int check_version(Elf_Shdr *sechdrs,
         return 1;
 }
 
-static inline int check_modstruct_version(Elf_Shdr *sechdrs,
-                                          unsigned int versindex,
+static inline int check_modstruct_version(const struct load_info *info,
                                           struct module *mod)
 {
         return 1;
@@ -1404,7 +1398,7 @@ static const struct kernel_symbol *resolve_symbol(struct module *mod,
         if (!sym)
                 goto unlock;
 
-        if (!check_version(info->sechdrs, info->index.vers, name, mod, crc)) {
+        if (!check_version(info, name, mod, crc)) {
                 sym = ERR_PTR(-EINVAL);
                 goto getname;
         }
@@ -1667,31 +1661,36 @@ static inline void remove_notes_attrs(struct module *mod)
 }
 #endif /* CONFIG_KALLSYMS */
 
-static void add_usage_links(struct module *mod)
+static void del_usage_links(struct module *mod)
 {
 #ifdef CONFIG_MODULE_UNLOAD
         struct module_use *use;
-        int nowarn;
 
         mutex_lock(&module_mutex);
-        list_for_each_entry(use, &mod->target_list, target_list) {
-                nowarn = sysfs_create_link(use->target->holders_dir,
-                                           &mod->mkobj.kobj, mod->name);
-        }
+        list_for_each_entry(use, &mod->target_list, target_list)
+                sysfs_remove_link(use->target->holders_dir, mod->name);
         mutex_unlock(&module_mutex);
 #endif
 }
 
-static void del_usage_links(struct module *mod)
+static int add_usage_links(struct module *mod)
 {
+        int ret = 0;
 #ifdef CONFIG_MODULE_UNLOAD
         struct module_use *use;
 
         mutex_lock(&module_mutex);
-        list_for_each_entry(use, &mod->target_list, target_list)
-                sysfs_remove_link(use->target->holders_dir, mod->name);
+        list_for_each_entry(use, &mod->target_list, target_list) {
+                ret = sysfs_create_link(use->target->holders_dir,
+                                        &mod->mkobj.kobj, mod->name);
+                if (ret)
+                        break;
+        }
         mutex_unlock(&module_mutex);
+        if (ret)
+                del_usage_links(mod);
 #endif
+        return ret;
 }
 
 static int module_add_modinfo_attrs(struct module *mod)
@@ -1802,13 +1801,18 @@ static int mod_sysfs_setup(struct module *mod,
         if (err)
                 goto out_unreg_param;
 
-        add_usage_links(mod);
+        err = add_usage_links(mod);
+        if (err)
+                goto out_unreg_modinfo_attrs;
+
         add_sect_attrs(mod, info);
         add_notes_attrs(mod, info);
 
         kobject_uevent(&mod->mkobj.kobj, KOBJ_ADD);
         return 0;
 
+out_unreg_modinfo_attrs:
+        module_remove_modinfo_attrs(mod);
 out_unreg_param:
         module_param_sysfs_remove(mod);
 out_unreg_holders:
@@ -2915,9 +2919,15 @@ static int rewrite_section_headers(struct load_info *info, int flags)
                 info->index.vers = 0; /* Pretend no __versions section! */
         else
                 info->index.vers = find_sec(info, "__versions");
+        info->sechdrs[info->index.vers].sh_flags &= ~(unsigned long)SHF_ALLOC;
+
         info->index.info = find_sec(info, ".modinfo");
+        if (!info->index.info)
+                info->name = "(missing .modinfo section)";
+        else
+                info->name = get_modinfo(info, "name");
         info->sechdrs[info->index.info].sh_flags &= ~(unsigned long)SHF_ALLOC;
-        info->sechdrs[info->index.vers].sh_flags &= ~(unsigned long)SHF_ALLOC;
+
         return 0;
 }
 
@@ -2957,21 +2967,29 @@ static struct module *setup_load_info(struct load_info *info, int flags)
 
         info->index.mod = find_sec(info, ".gnu.linkonce.this_module");
         if (!info->index.mod) {
-                pr_warn("No module found in object\n");
+                pr_warn("%s: No module found in object\n",
+                        info->name ?: "(missing .modinfo name field)");
                 return ERR_PTR(-ENOEXEC);
         }
         /* This is temporary: point mod into copy of data. */
         mod = (void *)info->sechdrs[info->index.mod].sh_addr;
 
+        /*
+         * If we didn't load the .modinfo 'name' field, fall back to
+         * on-disk struct mod 'name' field.
+         */
+        if (!info->name)
+                info->name = mod->name;
+
         if (info->index.sym == 0) {
-                pr_warn("%s: module has no symbols (stripped?)\n", mod->name);
+                pr_warn("%s: module has no symbols (stripped?)\n", info->name);
                 return ERR_PTR(-ENOEXEC);
         }
 
         info->index.pcpu = find_pcpusec(info);
 
         /* Check module struct version now, before we try to use module. */
-        if (!check_modstruct_version(info->sechdrs, info->index.vers, mod))
+        if (!check_modstruct_version(info, mod))
                 return ERR_PTR(-ENOEXEC);
 
         return mod;
@@ -2992,7 +3010,7 @@ static int check_modinfo(struct module *mod, struct load_info *info, int flags)
                         return err;
         } else if (!same_magic(modmagic, vermagic, info->index.vers)) {
                 pr_err("%s: version magic '%s' should be '%s'\n",
-                       mod->name, modmagic, vermagic);
+                       info->name, modmagic, vermagic);
                 return -ENOEXEC;
         }
 
@@ -3077,9 +3095,9 @@ static int find_module_sections(struct module *mod, struct load_info *info)
         mod->trace_events = section_objs(info, "_ftrace_events",
                                          sizeof(*mod->trace_events),
                                          &mod->num_trace_events);
-        mod->trace_enums = section_objs(info, "_ftrace_enum_map",
-                                        sizeof(*mod->trace_enums),
-                                        &mod->num_trace_enums);
+        mod->trace_evals = section_objs(info, "_ftrace_eval_map",
+                                        sizeof(*mod->trace_evals),
+                                        &mod->num_trace_evals);
 #endif
 #ifdef CONFIG_TRACING
         mod->trace_bprintk_fmt_start = section_objs(info, "__trace_printk_fmt",
@@ -3242,7 +3260,7 @@ int __weak module_frob_arch_sections(Elf_Ehdr *hdr,
 
 /* module_blacklist is a comma-separated list of module names */
 static char *module_blacklist;
-static bool blacklisted(char *module_name)
+static bool blacklisted(const char *module_name)
 {
         const char *p;
         size_t len;
@@ -3272,7 +3290,7 @@ static struct module *layout_and_allocate(struct load_info *info, int flags)
         if (IS_ERR(mod))
                 return mod;
 
-        if (blacklisted(mod->name))
+        if (blacklisted(info->name))
                 return ERR_PTR(-EPERM);
 
         err = check_modinfo(mod, info, flags);
@@ -4201,7 +4219,7 @@ const struct exception_table_entry *search_module_extables(unsigned long addr)
                 goto out;
 
         e = search_extable(mod->extable,
-                           mod->extable + mod->num_exentries - 1,
+                           mod->num_exentries,
                            addr);
 out:
         preempt_enable();
diff --git a/kernel/padata.c b/kernel/padata.c
index ac8f1e524836..868f947166d7 100644
--- a/kernel/padata.c
+++ b/kernel/padata.c
@@ -934,29 +934,18 @@ static struct kobj_type padata_attr_type = {
 };
 
 /**
- * padata_alloc_possible - Allocate and initialize padata instance.
- *                         Use the cpu_possible_mask for serial and
- *                         parallel workers.
- *
- * @wq: workqueue to use for the allocated padata instance
- */
-struct padata_instance *padata_alloc_possible(struct workqueue_struct *wq)
-{
-        return padata_alloc(wq, cpu_possible_mask, cpu_possible_mask);
-}
-EXPORT_SYMBOL(padata_alloc_possible);
-
-/**
  * padata_alloc - allocate and initialize a padata instance and specify
  *                cpumasks for serial and parallel workers.
  *
  * @wq: workqueue to use for the allocated padata instance
  * @pcpumask: cpumask that will be used for padata parallelization
  * @cbcpumask: cpumask that will be used for padata serialization
+ *
+ * Must be called from a cpus_read_lock() protected region
  */
-struct padata_instance *padata_alloc(struct workqueue_struct *wq,
-                                     const struct cpumask *pcpumask,
-                                     const struct cpumask *cbcpumask)
+static struct padata_instance *padata_alloc(struct workqueue_struct *wq,
+                                            const struct cpumask *pcpumask,
+                                            const struct cpumask *cbcpumask)
 {
         struct padata_instance *pinst;
         struct parallel_data *pd = NULL;
@@ -965,7 +954,6 @@ struct padata_instance *padata_alloc(struct workqueue_struct *wq,
         if (!pinst)
                 goto err;
 
-        get_online_cpus();
         if (!alloc_cpumask_var(&pinst->cpumask.pcpu, GFP_KERNEL))
                 goto err_free_inst;
         if (!alloc_cpumask_var(&pinst->cpumask.cbcpu, GFP_KERNEL)) {
@@ -989,14 +977,12 @@ struct padata_instance *padata_alloc(struct workqueue_struct *wq,
 
         pinst->flags = 0;
 
-        put_online_cpus();
-
         BLOCKING_INIT_NOTIFIER_HEAD(&pinst->cpumask_change_notifier);
         kobject_init(&pinst->kobj, &padata_attr_type);
         mutex_init(&pinst->lock);
 
 #ifdef CONFIG_HOTPLUG_CPU
-        cpuhp_state_add_instance_nocalls(hp_online, &pinst->node);
+        cpuhp_state_add_instance_nocalls_cpuslocked(hp_online, &pinst->node);
 #endif
         return pinst;
 
@@ -1005,12 +991,27 @@ err_free_masks:
         free_cpumask_var(pinst->cpumask.cbcpu);
 err_free_inst:
         kfree(pinst);
-        put_online_cpus();
 err:
         return NULL;
 }
 
 /**
+ * padata_alloc_possible - Allocate and initialize padata instance.
+ *                         Use the cpu_possible_mask for serial and
+ *                         parallel workers.
+ *
+ * @wq: workqueue to use for the allocated padata instance
+ *
+ * Must be called from a cpus_read_lock() protected region
+ */
+struct padata_instance *padata_alloc_possible(struct workqueue_struct *wq)
+{
+        lockdep_assert_cpus_held();
+        return padata_alloc(wq, cpu_possible_mask, cpu_possible_mask);
+}
+EXPORT_SYMBOL(padata_alloc_possible);
+
+/**
  * padata_free - free a padata instance
  *
  * @padata_inst: padata instance to free
diff --git a/kernel/pid.c b/kernel/pid.c
index fd1cde1e4576..731c4e528f4e 100644
--- a/kernel/pid.c
+++ b/kernel/pid.c
@@ -575,16 +575,13 @@ struct pid *find_ge_pid(int nr, struct pid_namespace *ns)
  */
 void __init pidhash_init(void)
 {
-        unsigned int i, pidhash_size;
+        unsigned int pidhash_size;
 
         pid_hash = alloc_large_system_hash("PID", sizeof(*pid_hash), 0, 18,
-                                           HASH_EARLY | HASH_SMALL,
+                                           HASH_EARLY | HASH_SMALL | HASH_ZERO,
                                            &pidhash_shift, NULL,
                                            0, 4096);
         pidhash_size = 1U << pidhash_shift;
-
-        for (i = 0; i < pidhash_size; i++)
-                INIT_HLIST_HEAD(&pid_hash[i]);
 }
 
 void __init pidmap_init(void)
diff --git a/kernel/power/hibernate.c b/kernel/power/hibernate.c
index a8b978c35a6a..e1914c7b85b1 100644
--- a/kernel/power/hibernate.c
+++ b/kernel/power/hibernate.c
@@ -1108,7 +1108,7 @@ static struct attribute * g[] = {
 };
 
 
-static struct attribute_group attr_group = {
+static const struct attribute_group attr_group = {
         .attrs = g,
 };
 
diff --git a/kernel/power/main.c b/kernel/power/main.c
index d401c21136d1..42bd800a6755 100644
--- a/kernel/power/main.c
+++ b/kernel/power/main.c
@@ -705,7 +705,7 @@ static struct attribute * g[] = {
         NULL,
 };
 
-static struct attribute_group attr_group = {
+static const struct attribute_group attr_group = {
         .attrs = g,
 };
 
diff --git a/kernel/power/snapshot.c b/kernel/power/snapshot.c
index 3b1e0f3ad07f..222317721c5a 100644
--- a/kernel/power/snapshot.c
+++ b/kernel/power/snapshot.c
@@ -30,19 +30,17 @@
 #include <linux/slab.h>
 #include <linux/compiler.h>
 #include <linux/ktime.h>
+#include <linux/set_memory.h>
 
 #include <linux/uaccess.h>
 #include <asm/mmu_context.h>
 #include <asm/pgtable.h>
 #include <asm/tlbflush.h>
 #include <asm/io.h>
-#ifdef CONFIG_STRICT_KERNEL_RWX
-#include <asm/set_memory.h>
-#endif
 
 #include "power.h"
 
-#ifdef CONFIG_STRICT_KERNEL_RWX
+#if defined(CONFIG_STRICT_KERNEL_RWX) && defined(CONFIG_ARCH_HAS_SET_MEMORY)
 static bool hibernate_restore_protection;
 static bool hibernate_restore_protection_active;
 
@@ -77,7 +75,7 @@ static inline void hibernate_restore_protection_begin(void) {}
 static inline void hibernate_restore_protection_end(void) {}
 static inline void hibernate_restore_protect_page(void *page_address) {}
 static inline void hibernate_restore_unprotect_page(void *page_address) {}
-#endif /* CONFIG_STRICT_KERNEL_RWX */
+#endif /* CONFIG_STRICT_KERNEL_RWX  && CONFIG_ARCH_HAS_SET_MEMORY */
 
 static int swsusp_page_is_free(struct page *);
 static void swsusp_set_page_forbidden(struct page *);
@@ -1425,7 +1423,7 @@ static unsigned int nr_meta_pages;
  * Numbers of normal and highmem page frames allocated for hibernation image
  * before suspending devices.
  */
-unsigned int alloc_normal, alloc_highmem;
+static unsigned int alloc_normal, alloc_highmem;
 /*
  * Memory bitmap used for marking saveable pages (during hibernation) or
  * hibernation image pages (during restore)
@@ -1929,8 +1927,7 @@ static inline unsigned int alloc_highmem_pages(struct memory_bitmap *bm,
  * also be located in the high memory, because of the way in which
  * copy_data_pages() works.
  */
-static int swsusp_alloc(struct memory_bitmap *orig_bm,
-                        struct memory_bitmap *copy_bm,
+static int swsusp_alloc(struct memory_bitmap *copy_bm,
                         unsigned int nr_pages, unsigned int nr_highmem)
 {
         if (nr_highmem > 0) {
@@ -1976,7 +1973,7 @@ asmlinkage __visible int swsusp_save(void)
                 return -ENOMEM;
         }
 
-        if (swsusp_alloc(&orig_bm, &copy_bm, nr_pages, nr_highmem)) {
+        if (swsusp_alloc(&copy_bm, nr_pages, nr_highmem)) {
                 printk(KERN_ERR "PM: Memory allocation failed\n");
                 return -ENOMEM;
         }
diff --git a/kernel/power/suspend.c b/kernel/power/suspend.c
index c0248c74d6d4..3ecf275d7e44 100644
--- a/kernel/power/suspend.c
+++ b/kernel/power/suspend.c
@@ -86,11 +86,9 @@ static void freeze_enter(void)
 
         /* Push all the CPUs into the idle loop. */
         wake_up_all_idle_cpus();
-        pr_debug("PM: suspend-to-idle\n");
         /* Make the current CPU wait so it can enter the idle loop too. */
         wait_event(suspend_freeze_wait_head,
                    suspend_freeze_state == FREEZE_STATE_WAKE);
-        pr_debug("PM: resume from suspend-to-idle\n");
 
         cpuidle_pause();
         put_online_cpus();
@@ -106,6 +104,8 @@ static void freeze_enter(void)
 
 static void s2idle_loop(void)
 {
+        pr_debug("PM: suspend-to-idle\n");
+
         do {
                 freeze_enter();
 
@@ -121,6 +121,8 @@ static void s2idle_loop(void)
 
                 pm_wakeup_clear(false);
         } while (!dpm_suspend_noirq(PMSG_SUSPEND));
+
+        pr_debug("PM: resume from suspend-to-idle\n");
 }
 
 void freeze_wake(void)
diff --git a/kernel/power/swap.c b/kernel/power/swap.c
index f80fd33639e0..57d22571f306 100644
--- a/kernel/power/swap.c
+++ b/kernel/power/swap.c
@@ -225,14 +225,14 @@ static struct block_device *hib_resume_bdev;
 struct hib_bio_batch {
         atomic_t                count;
         wait_queue_head_t       wait;
-        int                     error;
+        blk_status_t            error;
 };
 
 static void hib_init_batch(struct hib_bio_batch *hb)
 {
         atomic_set(&hb->count, 0);
         init_waitqueue_head(&hb->wait);
-        hb->error = 0;
+        hb->error = BLK_STS_OK;
 }
 
 static void hib_end_io(struct bio *bio)
@@ -240,7 +240,7 @@ static void hib_end_io(struct bio *bio)
         struct hib_bio_batch *hb = bio->bi_private;
         struct page *page = bio->bi_io_vec[0].bv_page;
 
-        if (bio->bi_error) {
+        if (bio->bi_status) {
                 printk(KERN_ALERT "Read-error on swap-device (%u:%u:%Lu)\n",
                                 imajor(bio->bi_bdev->bd_inode),
                                 iminor(bio->bi_bdev->bd_inode),
@@ -253,8 +253,8 @@ static void hib_end_io(struct bio *bio)
                 flush_icache_range((unsigned long)page_address(page),
                                    (unsigned long)page_address(page) + PAGE_SIZE);
 
-        if (bio->bi_error && !hb->error)
-                hb->error = bio->bi_error;
+        if (bio->bi_status && !hb->error)
+                hb->error = bio->bi_status;
         if (atomic_dec_and_test(&hb->count))
                 wake_up(&hb->wait);
 
@@ -293,10 +293,10 @@ static int hib_submit_io(int op, int op_flags, pgoff_t page_off, void *addr,
         return error;
 }
 
-static int hib_wait_io(struct hib_bio_batch *hb)
+static blk_status_t hib_wait_io(struct hib_bio_batch *hb)
 {
         wait_event(hb->wait, atomic_read(&hb->count) == 0);
-        return hb->error;
+        return blk_status_to_errno(hb->error);
 }
 
 /*
diff --git a/kernel/printk/internal.h b/kernel/printk/internal.h
index 1db044f808b7..2a7d04049af4 100644
--- a/kernel/printk/internal.h
+++ b/kernel/printk/internal.h
@@ -18,12 +18,14 @@
 
 #ifdef CONFIG_PRINTK
 
-#define PRINTK_SAFE_CONTEXT_MASK        0x7fffffff
-#define PRINTK_NMI_CONTEXT_MASK 0x80000000
+#define PRINTK_SAFE_CONTEXT_MASK         0x3fffffff
+#define PRINTK_NMI_DEFERRED_CONTEXT_MASK 0x40000000
+#define PRINTK_NMI_CONTEXT_MASK          0x80000000
 
 extern raw_spinlock_t logbuf_lock;
 
 __printf(1, 0) int vprintk_default(const char *fmt, va_list args);
+__printf(1, 0) int vprintk_deferred(const char *fmt, va_list args);
 __printf(1, 0) int vprintk_func(const char *fmt, va_list args);
 void __printk_safe_enter(void);
 void __printk_safe_exit(void);
diff --git a/kernel/printk/printk.c b/kernel/printk/printk.c
index a1aecf44ab07..fc47863f629c 100644
--- a/kernel/printk/printk.c
+++ b/kernel/printk/printk.c
@@ -269,7 +269,6 @@ static struct console *exclusive_console;
 #define MAX_CMDLINECONSOLES 8
 
 static struct console_cmdline console_cmdline[MAX_CMDLINECONSOLES];
-static int console_cmdline_cnt;
 
 static int preferred_console = -1;
 int console_set_on_cmdline;
@@ -1176,7 +1175,7 @@ static void boot_delay_msec(int level)
         unsigned long long k;
         unsigned long timeout;
 
-        if ((boot_delay == 0 || system_state != SYSTEM_BOOTING)
+        if ((boot_delay == 0 || system_state >= SYSTEM_RUNNING)
                 || suppress_message_printing(level)) {
                 return;
         }
@@ -1906,25 +1905,12 @@ static int __add_preferred_console(char *name, int idx, char *options,
          *      See if this tty is not yet registered, and
          *      if we have a slot free.
          */
-        for (i = 0, c = console_cmdline; i < console_cmdline_cnt; i++, c++) {
+        for (i = 0, c = console_cmdline;
+             i < MAX_CMDLINECONSOLES && c->name[0];
+             i++, c++) {
                 if (strcmp(c->name, name) == 0 && c->index == idx) {
-                        if (brl_options)
-                                return 0;
-
-                        /*
-                         * Maintain an invariant that will help to find if
-                         * the matching console is preferred, see
-                         * register_console():
-                         *
-                         * The last non-braille console is always
-                         * the preferred one.
-                         */
-                        if (i != console_cmdline_cnt - 1)
-                                swap(console_cmdline[i],
-                                     console_cmdline[console_cmdline_cnt - 1]);
-
-                        preferred_console = console_cmdline_cnt - 1;
-
+                        if (!brl_options)
+                                preferred_console = i;
                         return 0;
                 }
         }
@@ -1937,7 +1923,6 @@ static int __add_preferred_console(char *name, int idx, char *options,
         braille_set_options(c, brl_options);
 
         c->index = idx;
-        console_cmdline_cnt++;
         return 0;
 }
 /*
@@ -2477,23 +2462,12 @@ void register_console(struct console *newcon)
         }
 
         /*
-         * See if this console matches one we selected on the command line.
-         *
-         * There may be several entries in the console_cmdline array matching
-         * with the same console, one with newcon->match(), another by
-         * name/index:
-         *
-         *      pl011,mmio,0x87e024000000,115200 -- added from SPCR
-         *      ttyAMA0 -- added from command line
-         *
-         * Traverse the console_cmdline array in reverse order to be
-         * sure that if this console is preferred then it will be the first
-         * matching entry.  We use the invariant that is maintained in
-         * __add_preferred_console().
+         *      See if this console matches one we selected on
+         *      the command line.
          */
-        for (i = console_cmdline_cnt - 1; i >= 0; i--) {
-                c = console_cmdline + i;
-
+        for (i = 0, c = console_cmdline;
+             i < MAX_CMDLINECONSOLES && c->name[0];
+             i++, c++) {
                 if (!newcon->match ||
                     newcon->match(newcon, c->name, c->index, c->options) != 0) {
                         /* default matching */
@@ -2746,16 +2720,13 @@ void wake_up_klogd(void)
         preempt_enable();
 }
 
-int printk_deferred(const char *fmt, ...)
+int vprintk_deferred(const char *fmt, va_list args)
 {
-        va_list args;
         int r;
 
-        preempt_disable();
-        va_start(args, fmt);
         r = vprintk_emit(0, LOGLEVEL_SCHED, NULL, 0, fmt, args);
-        va_end(args);
 
+        preempt_disable();
         __this_cpu_or(printk_pending, PRINTK_PENDING_OUTPUT);
         irq_work_queue(this_cpu_ptr(&wake_up_klogd_work));
         preempt_enable();
@@ -2763,6 +2734,18 @@ int printk_deferred(const char *fmt, ...)
         return r;
 }
 
+int printk_deferred(const char *fmt, ...)
+{
+        va_list args;
+        int r;
+
+        va_start(args, fmt);
+        r = vprintk_deferred(fmt, args);
+        va_end(args);
+
+        return r;
+}
+
 /*
  * printk rate limiting, lifted from the networking subsystem.
  *
diff --git a/kernel/printk/printk_safe.c b/kernel/printk/printk_safe.c
index 033e50a7d706..3cdaeaef9ce1 100644
--- a/kernel/printk/printk_safe.c
+++ b/kernel/printk/printk_safe.c
@@ -80,8 +80,8 @@ static void queue_flush_work(struct printk_safe_seq_buf *s)
  * happen, printk_safe_log_store() will notice the buffer->len mismatch
  * and repeat the write.
  */
-static int printk_safe_log_store(struct printk_safe_seq_buf *s,
-                                 const char *fmt, va_list args)
+static __printf(2, 0) int printk_safe_log_store(struct printk_safe_seq_buf *s,
+                                                const char *fmt, va_list args)
 {
         int add;
         size_t len;
@@ -299,7 +299,7 @@ void printk_safe_flush_on_panic(void)
  * one writer running. But the buffer might get flushed from another
  * CPU, so we need to be careful.
  */
-static int vprintk_nmi(const char *fmt, va_list args)
+static __printf(1, 0) int vprintk_nmi(const char *fmt, va_list args)
 {
         struct printk_safe_seq_buf *s = this_cpu_ptr(&nmi_print_seq);
 
@@ -308,17 +308,29 @@ static int vprintk_nmi(const char *fmt, va_list args)
 
 void printk_nmi_enter(void)
 {
-        this_cpu_or(printk_context, PRINTK_NMI_CONTEXT_MASK);
+        /*
+         * The size of the extra per-CPU buffer is limited. Use it only when
+         * the main one is locked. If this CPU is not in the safe context,
+         * the lock must be taken on another CPU and we could wait for it.
+         */
+        if ((this_cpu_read(printk_context) & PRINTK_SAFE_CONTEXT_MASK) &&
+            raw_spin_is_locked(&logbuf_lock)) {
+                this_cpu_or(printk_context, PRINTK_NMI_CONTEXT_MASK);
+        } else {
+                this_cpu_or(printk_context, PRINTK_NMI_DEFERRED_CONTEXT_MASK);
+        }
 }
 
 void printk_nmi_exit(void)
 {
-        this_cpu_and(printk_context, ~PRINTK_NMI_CONTEXT_MASK);
+        this_cpu_and(printk_context,
+                     ~(PRINTK_NMI_CONTEXT_MASK |
+                       PRINTK_NMI_DEFERRED_CONTEXT_MASK));
 }
 
 #else
 
-static int vprintk_nmi(const char *fmt, va_list args)
+static __printf(1, 0) int vprintk_nmi(const char *fmt, va_list args)
 {
         return 0;
 }
@@ -330,7 +342,7 @@ static int vprintk_nmi(const char *fmt, va_list args)
  * into itself. It uses a per-CPU buffer to store the message, just like
  * NMI.
  */
-static int vprintk_safe(const char *fmt, va_list args)
+static __printf(1, 0) int vprintk_safe(const char *fmt, va_list args)
 {
         struct printk_safe_seq_buf *s = this_cpu_ptr(&safe_print_seq);
 
@@ -351,12 +363,22 @@ void __printk_safe_exit(void)
 
 __printf(1, 0) int vprintk_func(const char *fmt, va_list args)
 {
+        /* Use extra buffer in NMI when logbuf_lock is taken or in safe mode. */
         if (this_cpu_read(printk_context) & PRINTK_NMI_CONTEXT_MASK)
                 return vprintk_nmi(fmt, args);
 
+        /* Use extra buffer to prevent a recursion deadlock in safe mode. */
         if (this_cpu_read(printk_context) & PRINTK_SAFE_CONTEXT_MASK)
                 return vprintk_safe(fmt, args);
 
+        /*
+         * Use the main logbuf when logbuf_lock is available in NMI.
+         * But avoid calling console drivers that might have their own locks.
+         */
+        if (this_cpu_read(printk_context) & PRINTK_NMI_DEFERRED_CONTEXT_MASK)
+                return vprintk_deferred(fmt, args);
+
+        /* No obstacles. */
         return vprintk_default(fmt, args);
 }
 
diff --git a/kernel/ptrace.c b/kernel/ptrace.c
index 266ddcc1d8bb..60f356d91060 100644
--- a/kernel/ptrace.c
+++ b/kernel/ptrace.c
@@ -60,19 +60,25 @@ int ptrace_access_vm(struct task_struct *tsk, unsigned long addr,
 }
 
 
+void __ptrace_link(struct task_struct *child, struct task_struct *new_parent,
+                   const struct cred *ptracer_cred)
+{
+        BUG_ON(!list_empty(&child->ptrace_entry));
+        list_add(&child->ptrace_entry, &new_parent->ptraced);
+        child->parent = new_parent;
+        child->ptracer_cred = get_cred(ptracer_cred);
+}
+
 /*
  * ptrace a task: make the debugger its new parent and
  * move it to the ptrace list.
  *
  * Must be called with the tasklist lock write-held.
  */
-void __ptrace_link(struct task_struct *child, struct task_struct *new_parent)
+static void ptrace_link(struct task_struct *child, struct task_struct *new_parent)
 {
-        BUG_ON(!list_empty(&child->ptrace_entry));
-        list_add(&child->ptrace_entry, &new_parent->ptraced);
-        child->parent = new_parent;
         rcu_read_lock();
-        child->ptracer_cred = get_cred(__task_cred(new_parent));
+        __ptrace_link(child, new_parent, __task_cred(new_parent));
         rcu_read_unlock();
 }
 
@@ -386,7 +392,7 @@ static int ptrace_attach(struct task_struct *task, long request,
                 flags |= PT_SEIZED;
         task->ptrace = flags;
 
-        __ptrace_link(task, current);
+        ptrace_link(task, current);
 
         /* SEIZE doesn't trap tracee on attach */
         if (!seize)
@@ -459,7 +465,7 @@ static int ptrace_traceme(void)
                  */
                 if (!ret && !(current->real_parent->flags & PF_EXITING)) {
                         current->ptrace = PT_PTRACED;
-                        __ptrace_link(current, current->real_parent);
+                        ptrace_link(current, current->real_parent);
                 }
         }
         write_unlock_irq(&tasklist_lock);
diff --git a/kernel/rcu/Kconfig b/kernel/rcu/Kconfig
new file mode 100644
index 000000000000..be90c945063f
--- /dev/null
+++ b/kernel/rcu/Kconfig
@@ -0,0 +1,242 @@
+#
+# RCU-related configuration options
+#
+
+menu "RCU Subsystem"
+
+config TREE_RCU
+        bool
+        default y if !PREEMPT && SMP
+        help
+          This option selects the RCU implementation that is
+          designed for very large SMP system with hundreds or
+          thousands of CPUs.  It also scales down nicely to
+          smaller systems.
+
+config PREEMPT_RCU
+        bool
+        default y if PREEMPT
+        help
+          This option selects the RCU implementation that is
+          designed for very large SMP systems with hundreds or
+          thousands of CPUs, but for which real-time response
+          is also required.  It also scales down nicely to
+          smaller systems.
+
+          Select this option if you are unsure.
+
+config TINY_RCU
+        bool
+        default y if !PREEMPT && !SMP
+        help
+          This option selects the RCU implementation that is
+          designed for UP systems from which real-time response
+          is not required.  This option greatly reduces the
+          memory footprint of RCU.
+
+config RCU_EXPERT
+        bool "Make expert-level adjustments to RCU configuration"
+        default n
+        help
+          This option needs to be enabled if you wish to make
+          expert-level adjustments to RCU configuration.  By default,
+          no such adjustments can be made, which has the often-beneficial
+          side-effect of preventing "make oldconfig" from asking you all
+          sorts of detailed questions about how you would like numerous
+          obscure RCU options to be set up.
+
+          Say Y if you need to make expert-level adjustments to RCU.
+
+          Say N if you are unsure.
+
+config SRCU
+        bool
+        help
+          This option selects the sleepable version of RCU. This version
+          permits arbitrary sleeping or blocking within RCU read-side critical
+          sections.
+
+config TINY_SRCU
+        bool
+        default y if SRCU && TINY_RCU
+        help
+          This option selects the single-CPU non-preemptible version of SRCU.
+
+config TREE_SRCU
+        bool
+        default y if SRCU && !TINY_RCU
+        help
+          This option selects the full-fledged version of SRCU.
+
+config TASKS_RCU
+        bool
+        default n
+        select SRCU
+        help
+          This option enables a task-based RCU implementation that uses
+          only voluntary context switch (not preemption!), idle, and
+          user-mode execution as quiescent states.
+
+config RCU_STALL_COMMON
+        def_bool ( TREE_RCU || PREEMPT_RCU )
+        help
+          This option enables RCU CPU stall code that is common between
+          the TINY and TREE variants of RCU.  The purpose is to allow
+          the tiny variants to disable RCU CPU stall warnings, while
+          making these warnings mandatory for the tree variants.
+
+config RCU_NEED_SEGCBLIST
+        def_bool ( TREE_RCU || PREEMPT_RCU || TREE_SRCU )
+
+config CONTEXT_TRACKING
+       bool
+
+config CONTEXT_TRACKING_FORCE
+        bool "Force context tracking"
+        depends on CONTEXT_TRACKING
+        default y if !NO_HZ_FULL
+        help
+          The major pre-requirement for full dynticks to work is to
+          support the context tracking subsystem. But there are also
+          other dependencies to provide in order to make the full
+          dynticks working.
+
+          This option stands for testing when an arch implements the
+          context tracking backend but doesn't yet fullfill all the
+          requirements to make the full dynticks feature working.
+          Without the full dynticks, there is no way to test the support
+          for context tracking and the subsystems that rely on it: RCU
+          userspace extended quiescent state and tickless cputime
+          accounting. This option copes with the absence of the full
+          dynticks subsystem by forcing the context tracking on all
+          CPUs in the system.
+
+          Say Y only if you're working on the development of an
+          architecture backend for the context tracking.
+
+          Say N otherwise, this option brings an overhead that you
+          don't want in production.
+
+
+config RCU_FANOUT
+        int "Tree-based hierarchical RCU fanout value"
+        range 2 64 if 64BIT
+        range 2 32 if !64BIT
+        depends on (TREE_RCU || PREEMPT_RCU) && RCU_EXPERT
+        default 64 if 64BIT
+        default 32 if !64BIT
+        help
+          This option controls the fanout of hierarchical implementations
+          of RCU, allowing RCU to work efficiently on machines with
+          large numbers of CPUs.  This value must be at least the fourth
+          root of NR_CPUS, which allows NR_CPUS to be insanely large.
+          The default value of RCU_FANOUT should be used for production
+          systems, but if you are stress-testing the RCU implementation
+          itself, small RCU_FANOUT values allow you to test large-system
+          code paths on small(er) systems.
+
+          Select a specific number if testing RCU itself.
+          Take the default if unsure.
+
+config RCU_FANOUT_LEAF
+        int "Tree-based hierarchical RCU leaf-level fanout value"
+        range 2 64 if 64BIT
+        range 2 32 if !64BIT
+        depends on (TREE_RCU || PREEMPT_RCU) && RCU_EXPERT
+        default 16
+        help
+          This option controls the leaf-level fanout of hierarchical
+          implementations of RCU, and allows trading off cache misses
+          against lock contention.  Systems that synchronize their
+          scheduling-clock interrupts for energy-efficiency reasons will
+          want the default because the smaller leaf-level fanout keeps
+          lock contention levels acceptably low.  Very large systems
+          (hundreds or thousands of CPUs) will instead want to set this
+          value to the maximum value possible in order to reduce the
+          number of cache misses incurred during RCU's grace-period
+          initialization.  These systems tend to run CPU-bound, and thus
+          are not helped by synchronized interrupts, and thus tend to
+          skew them, which reduces lock contention enough that large
+          leaf-level fanouts work well.  That said, setting leaf-level
+          fanout to a large number will likely cause problematic
+          lock contention on the leaf-level rcu_node structures unless
+          you boot with the skew_tick kernel parameter.
+
+          Select a specific number if testing RCU itself.
+
+          Select the maximum permissible value for large systems, but
+          please understand that you may also need to set the skew_tick
+          kernel boot parameter to avoid contention on the rcu_node
+          structure's locks.
+
+          Take the default if unsure.
+
+config RCU_FAST_NO_HZ
+        bool "Accelerate last non-dyntick-idle CPU's grace periods"
+        depends on NO_HZ_COMMON && SMP && RCU_EXPERT
+        default n
+        help
+          This option permits CPUs to enter dynticks-idle state even if
+          they have RCU callbacks queued, and prevents RCU from waking
+          these CPUs up more than roughly once every four jiffies (by
+          default, you can adjust this using the rcutree.rcu_idle_gp_delay
+          parameter), thus improving energy efficiency.  On the other
+          hand, this option increases the duration of RCU grace periods,
+          for example, slowing down synchronize_rcu().
+
+          Say Y if energy efficiency is critically important, and you
+                don't care about increased grace-period durations.
+
+          Say N if you are unsure.
+
+config RCU_BOOST
+        bool "Enable RCU priority boosting"
+        depends on RT_MUTEXES && PREEMPT_RCU && RCU_EXPERT
+        default n
+        help
+          This option boosts the priority of preempted RCU readers that
+          block the current preemptible RCU grace period for too long.
+          This option also prevents heavy loads from blocking RCU
+          callback invocation for all flavors of RCU.
+
+          Say Y here if you are working with real-time apps or heavy loads
+          Say N here if you are unsure.
+
+config RCU_BOOST_DELAY
+        int "Milliseconds to delay boosting after RCU grace-period start"
+        range 0 3000
+        depends on RCU_BOOST
+        default 500
+        help
+          This option specifies the time to wait after the beginning of
+          a given grace period before priority-boosting preempted RCU
+          readers blocking that grace period.  Note that any RCU reader
+          blocking an expedited RCU grace period is boosted immediately.
+
+          Accept the default if unsure.
+
+config RCU_NOCB_CPU
+        bool "Offload RCU callback processing from boot-selected CPUs"
+        depends on TREE_RCU || PREEMPT_RCU
+        depends on RCU_EXPERT || NO_HZ_FULL
+        default n
+        help
+          Use this option to reduce OS jitter for aggressive HPC or
+          real-time workloads.  It can also be used to offload RCU
+          callback invocation to energy-efficient CPUs in battery-powered
+          asymmetric multiprocessors.
+
+          This option offloads callback invocation from the set of
+          CPUs specified at boot time by the rcu_nocbs parameter.
+          For each such CPU, a kthread ("rcuox/N") will be created to
+          invoke callbacks, where the "N" is the CPU being offloaded,
+          and where the "x" is "b" for RCU-bh, "p" for RCU-preempt, and
+          "s" for RCU-sched.  Nothing prevents this kthread from running
+          on the specified CPUs, but (1) the kthreads may be preempted
+          between each callback, and (2) affinity or cgroups can be used
+          to force the kthreads to run on whatever set of CPUs is desired.
+
+          Say Y here if you want to help to debug reduced OS jitter.
+          Say N here if you are unsure.
+
+endmenu # "RCU Subsystem"
diff --git a/kernel/rcu/Kconfig.debug b/kernel/rcu/Kconfig.debug
new file mode 100644
index 000000000000..0ec7d1d33a14
--- /dev/null
+++ b/kernel/rcu/Kconfig.debug
@@ -0,0 +1,82 @@
+#
+# RCU-related debugging configuration options
+#
+
+menu "RCU Debugging"
+
+config PROVE_RCU
+        def_bool PROVE_LOCKING
+
+config TORTURE_TEST
+        tristate
+        default n
+
+config RCU_PERF_TEST
+        tristate "performance tests for RCU"
+        depends on DEBUG_KERNEL
+        select TORTURE_TEST
+        select SRCU
+        select TASKS_RCU
+        default n
+        help
+          This option provides a kernel module that runs performance
+          tests on the RCU infrastructure.  The kernel module may be built
+          after the fact on the running kernel to be tested, if desired.
+
+          Say Y here if you want RCU performance tests to be built into
+          the kernel.
+          Say M if you want the RCU performance tests to build as a module.
+          Say N if you are unsure.
+
+config RCU_TORTURE_TEST
+        tristate "torture tests for RCU"
+        depends on DEBUG_KERNEL
+        select TORTURE_TEST
+        select SRCU
+        select TASKS_RCU
+        default n
+        help
+          This option provides a kernel module that runs torture tests
+          on the RCU infrastructure.  The kernel module may be built
+          after the fact on the running kernel to be tested, if desired.
+
+          Say Y here if you want RCU torture tests to be built into
+          the kernel.
+          Say M if you want the RCU torture tests to build as a module.
+          Say N if you are unsure.
+
+config RCU_CPU_STALL_TIMEOUT
+        int "RCU CPU stall timeout in seconds"
+        depends on RCU_STALL_COMMON
+        range 3 300
+        default 21
+        help
+          If a given RCU grace period extends more than the specified
+          number of seconds, a CPU stall warning is printed.  If the
+          RCU grace period persists, additional CPU stall warnings are
+          printed at more widely spaced intervals.
+
+config RCU_TRACE
+        bool "Enable tracing for RCU"
+        depends on DEBUG_KERNEL
+        default y if TREE_RCU
+        select TRACE_CLOCK
+        help
+          This option enables additional tracepoints for ftrace-style
+          event tracing.
+
+          Say Y here if you want to enable RCU tracing
+          Say N if you are unsure.
+
+config RCU_EQS_DEBUG
+        bool "Provide debugging asserts for adding NO_HZ support to an arch"
+        depends on DEBUG_KERNEL
+        help
+          This option provides consistency checks in RCU's handling of
+          NO_HZ.  These checks have proven quite helpful in detecting
+          bugs in arch-specific NO_HZ code.
+
+          Say N here if you need ultimate kernel/user switch latencies
+          Say Y if you are unsure
+
+endmenu # "RCU Debugging"
diff --git a/kernel/rcu/Makefile b/kernel/rcu/Makefile
index 23803c7d5180..13c0fc852767 100644
--- a/kernel/rcu/Makefile
+++ b/kernel/rcu/Makefile
@@ -3,13 +3,11 @@
 KCOV_INSTRUMENT := n
 
 obj-y += update.o sync.o
-obj-$(CONFIG_CLASSIC_SRCU) += srcu.o
 obj-$(CONFIG_TREE_SRCU) += srcutree.o
 obj-$(CONFIG_TINY_SRCU) += srcutiny.o
 obj-$(CONFIG_RCU_TORTURE_TEST) += rcutorture.o
 obj-$(CONFIG_RCU_PERF_TEST) += rcuperf.o
 obj-$(CONFIG_TREE_RCU) += tree.o
 obj-$(CONFIG_PREEMPT_RCU) += tree.o
-obj-$(CONFIG_TREE_RCU_TRACE) += tree_trace.o
 obj-$(CONFIG_TINY_RCU) += tiny.o
 obj-$(CONFIG_RCU_NEED_SEGCBLIST) += rcu_segcblist.o
diff --git a/kernel/rcu/rcu.h b/kernel/rcu/rcu.h
index 73e16ec4054b..808b8c85f626 100644
--- a/kernel/rcu/rcu.h
+++ b/kernel/rcu/rcu.h
@@ -212,6 +212,18 @@ int rcu_jiffies_till_stall_check(void);
  */
 #define TPS(x)  tracepoint_string(x)
 
+/*
+ * Dump the ftrace buffer, but only one time per callsite per boot.
+ */
+#define rcu_ftrace_dump(oops_dump_mode) \
+do { \
+        static atomic_t ___rfd_beenhere = ATOMIC_INIT(0); \
+        \
+        if (!atomic_read(&___rfd_beenhere) && \
+            !atomic_xchg(&___rfd_beenhere, 1)) \
+                ftrace_dump(oops_dump_mode); \
+} while (0)
+
 void rcu_early_boot_tests(void);
 void rcu_test_sync_prims(void);
 
@@ -291,6 +303,271 @@ static inline void rcu_init_levelspread(int *levelspread, const int *levelcnt)
              cpu <= rnp->grphi; \
              cpu = cpumask_next((cpu), cpu_possible_mask))
 
+/*
+ * Wrappers for the rcu_node::lock acquire and release.
+ *
+ * Because the rcu_nodes form a tree, the tree traversal locking will observe
+ * different lock values, this in turn means that an UNLOCK of one level
+ * followed by a LOCK of another level does not imply a full memory barrier;
+ * and most importantly transitivity is lost.
+ *
+ * In order to restore full ordering between tree levels, augment the regular
+ * lock acquire functions with smp_mb__after_unlock_lock().
+ *
+ * As ->lock of struct rcu_node is a __private field, therefore one should use
+ * these wrappers rather than directly call raw_spin_{lock,unlock}* on ->lock.
+ */
+#define raw_spin_lock_rcu_node(p)                                       \
+do {                                                                    \
+        raw_spin_lock(&ACCESS_PRIVATE(p, lock));                        \
+        smp_mb__after_unlock_lock();                                    \
+} while (0)
+
+#define raw_spin_unlock_rcu_node(p) raw_spin_unlock(&ACCESS_PRIVATE(p, lock))
+
+#define raw_spin_lock_irq_rcu_node(p)                                   \
+do {                                                                    \
+        raw_spin_lock_irq(&ACCESS_PRIVATE(p, lock));                    \
+        smp_mb__after_unlock_lock();                                    \
+} while (0)
+
+#define raw_spin_unlock_irq_rcu_node(p)                                 \
+        raw_spin_unlock_irq(&ACCESS_PRIVATE(p, lock))
+
+#define raw_spin_lock_irqsave_rcu_node(p, flags)                        \
+do {                                                                    \
+        raw_spin_lock_irqsave(&ACCESS_PRIVATE(p, lock), flags); \
+        smp_mb__after_unlock_lock();                                    \
+} while (0)
+
+#define raw_spin_unlock_irqrestore_rcu_node(p, flags)                   \
+        raw_spin_unlock_irqrestore(&ACCESS_PRIVATE(p, lock), flags)     \
+
+#define raw_spin_trylock_rcu_node(p)                                    \
+({                                                                      \
+        bool ___locked = raw_spin_trylock(&ACCESS_PRIVATE(p, lock));    \
+                                                                        \
+        if (___locked)                                                  \
+                smp_mb__after_unlock_lock();                            \
+        ___locked;                                                      \
+})
+
 #endif /* #if defined(SRCU) || !defined(TINY_RCU) */
 
+#ifdef CONFIG_TINY_RCU
+/* Tiny RCU doesn't expedite, as its purpose in life is instead to be tiny. */
+static inline bool rcu_gp_is_normal(void)  /* Internal RCU use. */
+{
+        return true;
+}
+static inline bool rcu_gp_is_expedited(void)  /* Internal RCU use. */
+{
+        return false;
+}
+
+static inline void rcu_expedite_gp(void)
+{
+}
+
+static inline void rcu_unexpedite_gp(void)
+{
+}
+#else /* #ifdef CONFIG_TINY_RCU */
+bool rcu_gp_is_normal(void);     /* Internal RCU use. */
+bool rcu_gp_is_expedited(void);  /* Internal RCU use. */
+void rcu_expedite_gp(void);
+void rcu_unexpedite_gp(void);
+void rcupdate_announce_bootup_oddness(void);
+#endif /* #else #ifdef CONFIG_TINY_RCU */
+
+#define RCU_SCHEDULER_INACTIVE  0
+#define RCU_SCHEDULER_INIT      1
+#define RCU_SCHEDULER_RUNNING   2
+
+#ifdef CONFIG_TINY_RCU
+static inline void rcu_request_urgent_qs_task(struct task_struct *t) { }
+#else /* #ifdef CONFIG_TINY_RCU */
+void rcu_request_urgent_qs_task(struct task_struct *t);
+#endif /* #else #ifdef CONFIG_TINY_RCU */
+
+enum rcutorture_type {
+        RCU_FLAVOR,
+        RCU_BH_FLAVOR,
+        RCU_SCHED_FLAVOR,
+        RCU_TASKS_FLAVOR,
+        SRCU_FLAVOR,
+        INVALID_RCU_FLAVOR
+};
+
+#if defined(CONFIG_TREE_RCU) || defined(CONFIG_PREEMPT_RCU)
+void rcutorture_get_gp_data(enum rcutorture_type test_type, int *flags,
+                            unsigned long *gpnum, unsigned long *completed);
+void rcutorture_record_test_transition(void);
+void rcutorture_record_progress(unsigned long vernum);
+void do_trace_rcu_torture_read(const char *rcutorturename,
+                               struct rcu_head *rhp,
+                               unsigned long secs,
+                               unsigned long c_old,
+                               unsigned long c);
+#else
+static inline void rcutorture_get_gp_data(enum rcutorture_type test_type,
+                                          int *flags,
+                                          unsigned long *gpnum,
+                                          unsigned long *completed)
+{
+        *flags = 0;
+        *gpnum = 0;
+        *completed = 0;
+}
+static inline void rcutorture_record_test_transition(void)
+{
+}
+static inline void rcutorture_record_progress(unsigned long vernum)
+{
+}
+#ifdef CONFIG_RCU_TRACE
+void do_trace_rcu_torture_read(const char *rcutorturename,
+                               struct rcu_head *rhp,
+                               unsigned long secs,
+                               unsigned long c_old,
+                               unsigned long c);
+#else
+#define do_trace_rcu_torture_read(rcutorturename, rhp, secs, c_old, c) \
+        do { } while (0)
+#endif
+#endif
+
+#ifdef CONFIG_TINY_SRCU
+
+static inline void srcutorture_get_gp_data(enum rcutorture_type test_type,
+                                           struct srcu_struct *sp, int *flags,
+                                           unsigned long *gpnum,
+                                           unsigned long *completed)
+{
+        if (test_type != SRCU_FLAVOR)
+                return;
+        *flags = 0;
+        *completed = sp->srcu_idx;
+        *gpnum = *completed;
+}
+
+#elif defined(CONFIG_TREE_SRCU)
+
+void srcutorture_get_gp_data(enum rcutorture_type test_type,
+                             struct srcu_struct *sp, int *flags,
+                             unsigned long *gpnum, unsigned long *completed);
+
+#endif
+
+#ifdef CONFIG_TINY_RCU
+
+/*
+ * Return the number of grace periods started.
+ */
+static inline unsigned long rcu_batches_started(void)
+{
+        return 0;
+}
+
+/*
+ * Return the number of bottom-half grace periods started.
+ */
+static inline unsigned long rcu_batches_started_bh(void)
+{
+        return 0;
+}
+
+/*
+ * Return the number of sched grace periods started.
+ */
+static inline unsigned long rcu_batches_started_sched(void)
+{
+        return 0;
+}
+
+/*
+ * Return the number of grace periods completed.
+ */
+static inline unsigned long rcu_batches_completed(void)
+{
+        return 0;
+}
+
+/*
+ * Return the number of bottom-half grace periods completed.
+ */
+static inline unsigned long rcu_batches_completed_bh(void)
+{
+        return 0;
+}
+
+/*
+ * Return the number of sched grace periods completed.
+ */
+static inline unsigned long rcu_batches_completed_sched(void)
+{
+        return 0;
+}
+
+/*
+ * Return the number of expedited grace periods completed.
+ */
+static inline unsigned long rcu_exp_batches_completed(void)
+{
+        return 0;
+}
+
+/*
+ * Return the number of expedited sched grace periods completed.
+ */
+static inline unsigned long rcu_exp_batches_completed_sched(void)
+{
+        return 0;
+}
+
+static inline unsigned long srcu_batches_completed(struct srcu_struct *sp)
+{
+        return 0;
+}
+
+static inline void rcu_force_quiescent_state(void)
+{
+}
+
+static inline void rcu_bh_force_quiescent_state(void)
+{
+}
+
+static inline void rcu_sched_force_quiescent_state(void)
+{
+}
+
+static inline void show_rcu_gp_kthreads(void)
+{
+}
+
+#else /* #ifdef CONFIG_TINY_RCU */
+extern unsigned long rcutorture_testseq;
+extern unsigned long rcutorture_vernum;
+unsigned long rcu_batches_started(void);
+unsigned long rcu_batches_started_bh(void);
+unsigned long rcu_batches_started_sched(void);
+unsigned long rcu_batches_completed(void);
+unsigned long rcu_batches_completed_bh(void);
+unsigned long rcu_batches_completed_sched(void);
+unsigned long rcu_exp_batches_completed(void);
+unsigned long rcu_exp_batches_completed_sched(void);
+unsigned long srcu_batches_completed(struct srcu_struct *sp);
+void show_rcu_gp_kthreads(void);
+void rcu_force_quiescent_state(void);
+void rcu_bh_force_quiescent_state(void);
+void rcu_sched_force_quiescent_state(void);
+#endif /* #else #ifdef CONFIG_TINY_RCU */
+
+#ifdef CONFIG_RCU_NOCB_CPU
+bool rcu_is_nocb_cpu(int cpu);
+#else
+static inline bool rcu_is_nocb_cpu(int cpu) { return false; }
+#endif
+
 #endif /* __LINUX_RCU_H */
diff --git a/kernel/rcu/rcuperf.c b/kernel/rcu/rcuperf.c
index a4a86fb47e4a..3cc18110b612 100644
--- a/kernel/rcu/rcuperf.c
+++ b/kernel/rcu/rcuperf.c
@@ -48,6 +48,8 @@
 #include <linux/torture.h>
 #include <linux/vmalloc.h>
 
+#include "rcu.h"
+
 MODULE_LICENSE("GPL");
 MODULE_AUTHOR("Paul E. McKenney <paulmck@linux.vnet.ibm.com>");
 
@@ -59,12 +61,16 @@ MODULE_AUTHOR("Paul E. McKenney <paulmck@linux.vnet.ibm.com>");
 #define VERBOSE_PERFOUT_ERRSTRING(s) \
         do { if (verbose) pr_alert("%s" PERF_FLAG "!!! %s\n", perf_type, s); } while (0)
 
+torture_param(bool, gp_async, false, "Use asynchronous GP wait primitives");
+torture_param(int, gp_async_max, 1000, "Max # outstanding waits per reader");
 torture_param(bool, gp_exp, false, "Use expedited GP wait primitives");
 torture_param(int, holdoff, 10, "Holdoff time before test start (s)");
-torture_param(int, nreaders, -1, "Number of RCU reader threads");
+torture_param(int, nreaders, 0, "Number of RCU reader threads");
 torture_param(int, nwriters, -1, "Number of RCU updater threads");
-torture_param(bool, shutdown, false, "Shutdown at end of performance tests.");
+torture_param(bool, shutdown, !IS_ENABLED(MODULE),
+              "Shutdown at end of performance tests.");
 torture_param(bool, verbose, true, "Enable verbose debugging printk()s");
+torture_param(int, writer_holdoff, 0, "Holdoff (us) between GPs, zero to disable");
 
 static char *perf_type = "rcu";
 module_param(perf_type, charp, 0444);
@@ -86,13 +92,16 @@ static u64 t_rcu_perf_writer_started;
 static u64 t_rcu_perf_writer_finished;
 static unsigned long b_rcu_perf_writer_started;
 static unsigned long b_rcu_perf_writer_finished;
+static DEFINE_PER_CPU(atomic_t, n_async_inflight);
 
 static int rcu_perf_writer_state;
 #define RTWS_INIT               0
-#define RTWS_EXP_SYNC           1
-#define RTWS_SYNC               2
-#define RTWS_IDLE               2
-#define RTWS_STOPPING           3
+#define RTWS_ASYNC              1
+#define RTWS_BARRIER            2
+#define RTWS_EXP_SYNC           3
+#define RTWS_SYNC               4
+#define RTWS_IDLE               5
+#define RTWS_STOPPING           6
 
 #define MAX_MEAS 10000
 #define MIN_MEAS 100
@@ -114,6 +123,8 @@ struct rcu_perf_ops {
         unsigned long (*started)(void);
         unsigned long (*completed)(void);
         unsigned long (*exp_completed)(void);
+        void (*async)(struct rcu_head *head, rcu_callback_t func);
+        void (*gp_barrier)(void);
         void (*sync)(void);
         void (*exp_sync)(void);
         const char *name;
@@ -153,6 +164,8 @@ static struct rcu_perf_ops rcu_ops = {
         .started        = rcu_batches_started,
         .completed      = rcu_batches_completed,
         .exp_completed  = rcu_exp_batches_completed,
+        .async          = call_rcu,
+        .gp_barrier     = rcu_barrier,
         .sync           = synchronize_rcu,
         .exp_sync       = synchronize_rcu_expedited,
         .name           = "rcu"
@@ -181,6 +194,8 @@ static struct rcu_perf_ops rcu_bh_ops = {
         .started        = rcu_batches_started_bh,
         .completed      = rcu_batches_completed_bh,
         .exp_completed  = rcu_exp_batches_completed_sched,
+        .async          = call_rcu_bh,
+        .gp_barrier     = rcu_barrier_bh,
         .sync           = synchronize_rcu_bh,
         .exp_sync       = synchronize_rcu_bh_expedited,
         .name           = "rcu_bh"
@@ -208,6 +223,16 @@ static unsigned long srcu_perf_completed(void)
         return srcu_batches_completed(srcu_ctlp);
 }
 
+static void srcu_call_rcu(struct rcu_head *head, rcu_callback_t func)
+{
+        call_srcu(srcu_ctlp, head, func);
+}
+
+static void srcu_rcu_barrier(void)
+{
+        srcu_barrier(srcu_ctlp);
+}
+
 static void srcu_perf_synchronize(void)
 {
         synchronize_srcu(srcu_ctlp);
@@ -226,11 +251,42 @@ static struct rcu_perf_ops srcu_ops = {
         .started        = NULL,
         .completed      = srcu_perf_completed,
         .exp_completed  = srcu_perf_completed,
+        .async          = srcu_call_rcu,
+        .gp_barrier     = srcu_rcu_barrier,
         .sync           = srcu_perf_synchronize,
         .exp_sync       = srcu_perf_synchronize_expedited,
         .name           = "srcu"
 };
 
+static struct srcu_struct srcud;
+
+static void srcu_sync_perf_init(void)
+{
+        srcu_ctlp = &srcud;
+        init_srcu_struct(srcu_ctlp);
+}
+
+static void srcu_sync_perf_cleanup(void)
+{
+        cleanup_srcu_struct(srcu_ctlp);
+}
+
+static struct rcu_perf_ops srcud_ops = {
+        .ptype          = SRCU_FLAVOR,
+        .init           = srcu_sync_perf_init,
+        .cleanup        = srcu_sync_perf_cleanup,
+        .readlock       = srcu_perf_read_lock,
+        .readunlock     = srcu_perf_read_unlock,
+        .started        = NULL,
+        .completed      = srcu_perf_completed,
+        .exp_completed  = srcu_perf_completed,
+        .async          = srcu_call_rcu,
+        .gp_barrier     = srcu_rcu_barrier,
+        .sync           = srcu_perf_synchronize,
+        .exp_sync       = srcu_perf_synchronize_expedited,
+        .name           = "srcud"
+};
+
 /*
  * Definitions for sched perf testing.
  */
@@ -254,6 +310,8 @@ static struct rcu_perf_ops sched_ops = {
         .started        = rcu_batches_started_sched,
         .completed      = rcu_batches_completed_sched,
         .exp_completed  = rcu_exp_batches_completed_sched,
+        .async          = call_rcu_sched,
+        .gp_barrier     = rcu_barrier_sched,
         .sync           = synchronize_sched,
         .exp_sync       = synchronize_sched_expedited,
         .name           = "sched"
@@ -281,6 +339,8 @@ static struct rcu_perf_ops tasks_ops = {
         .readunlock     = tasks_perf_read_unlock,
         .started        = rcu_no_completed,
         .completed      = rcu_no_completed,
+        .async          = call_rcu_tasks,
+        .gp_barrier     = rcu_barrier_tasks,
         .sync           = synchronize_rcu_tasks,
         .exp_sync       = synchronize_rcu_tasks,
         .name           = "tasks"
@@ -344,6 +404,15 @@ rcu_perf_reader(void *arg)
 }
 
 /*
+ * Callback function for asynchronous grace periods from rcu_perf_writer().
+ */
+static void rcu_perf_async_cb(struct rcu_head *rhp)
+{
+        atomic_dec(this_cpu_ptr(&n_async_inflight));
+        kfree(rhp);
+}
+
+/*
  * RCU perf writer kthread.  Repeatedly does a grace period.
  */
 static int
@@ -352,6 +421,7 @@ rcu_perf_writer(void *arg)
         int i = 0;
         int i_max;
         long me = (long)arg;
+        struct rcu_head *rhp = NULL;
         struct sched_param sp;
         bool started = false, done = false, alldone = false;
         u64 t;
@@ -380,9 +450,27 @@ rcu_perf_writer(void *arg)
         }
 
         do {
+                if (writer_holdoff)
+                        udelay(writer_holdoff);
                 wdp = &wdpp[i];
                 *wdp = ktime_get_mono_fast_ns();
-                if (gp_exp) {
+                if (gp_async) {
+retry:
+                        if (!rhp)
+                                rhp = kmalloc(sizeof(*rhp), GFP_KERNEL);
+                        if (rhp && atomic_read(this_cpu_ptr(&n_async_inflight)) < gp_async_max) {
+                                rcu_perf_writer_state = RTWS_ASYNC;
+                                atomic_inc(this_cpu_ptr(&n_async_inflight));
+                                cur_ops->async(rhp, rcu_perf_async_cb);
+                                rhp = NULL;
+                        } else if (!kthread_should_stop()) {
+                                rcu_perf_writer_state = RTWS_BARRIER;
+                                cur_ops->gp_barrier();
+                                goto retry;
+                        } else {
+                                kfree(rhp); /* Because we are stopping. */
+                        }
+                } else if (gp_exp) {
                         rcu_perf_writer_state = RTWS_EXP_SYNC;
                         cur_ops->exp_sync();
                 } else {
@@ -429,6 +517,10 @@ rcu_perf_writer(void *arg)
                         i++;
                 rcu_perf_wait_shutdown();
         } while (!torture_must_stop());
+        if (gp_async) {
+                rcu_perf_writer_state = RTWS_BARRIER;
+                cur_ops->gp_barrier();
+        }
         rcu_perf_writer_state = RTWS_STOPPING;
         writer_n_durations[me] = i_max;
         torture_kthread_stopping("rcu_perf_writer");
@@ -452,6 +544,17 @@ rcu_perf_cleanup(void)
         u64 *wdp;
         u64 *wdpp;
 
+        /*
+         * Would like warning at start, but everything is expedited
+         * during the mid-boot phase, so have to wait till the end.
+         */
+        if (rcu_gp_is_expedited() && !rcu_gp_is_normal() && !gp_exp)
+                VERBOSE_PERFOUT_ERRSTRING("All grace periods expedited, no normal ones to measure!");
+        if (rcu_gp_is_normal() && gp_exp)
+                VERBOSE_PERFOUT_ERRSTRING("All grace periods normal, no expedited ones to measure!");
+        if (gp_exp && gp_async)
+                VERBOSE_PERFOUT_ERRSTRING("No expedited async GPs, so went with async!");
+
         if (torture_cleanup_begin())
                 return;
 
@@ -554,7 +657,7 @@ rcu_perf_init(void)
         long i;
         int firsterr = 0;
         static struct rcu_perf_ops *perf_ops[] = {
-                &rcu_ops, &rcu_bh_ops, &srcu_ops, &sched_ops,
+                &rcu_ops, &rcu_bh_ops, &srcu_ops, &srcud_ops, &sched_ops,
                 RCUPERF_TASKS_OPS
         };
 
@@ -624,16 +727,6 @@ rcu_perf_init(void)
                 firsterr = -ENOMEM;
                 goto unwind;
         }
-        if (rcu_gp_is_expedited() && !rcu_gp_is_normal() && !gp_exp) {
-                VERBOSE_PERFOUT_ERRSTRING("All grace periods expedited, no normal ones to measure!");
-                firsterr = -EINVAL;
-                goto unwind;
-        }
-        if (rcu_gp_is_normal() && gp_exp) {
-                VERBOSE_PERFOUT_ERRSTRING("All grace periods normal, no expedited ones to measure!");
-                firsterr = -EINVAL;
-                goto unwind;
-        }
         for (i = 0; i < nrealwriters; i++) {
                 writer_durations[i] =
                         kcalloc(MAX_MEAS, sizeof(*writer_durations[i]),
diff --git a/kernel/rcu/rcutorture.c b/kernel/rcu/rcutorture.c
index ae6e574d4cf5..b8f7f8ce8575 100644
--- a/kernel/rcu/rcutorture.c
+++ b/kernel/rcu/rcutorture.c
@@ -52,6 +52,8 @@
 #include <linux/torture.h>
 #include <linux/vmalloc.h>
 
+#include "rcu.h"
+
 MODULE_LICENSE("GPL");
 MODULE_AUTHOR("Paul E. McKenney <paulmck@us.ibm.com> and Josh Triplett <josh@joshtriplett.org>");
 
@@ -562,31 +564,19 @@ static void srcu_torture_stats(void)
         int __maybe_unused cpu;
         int idx;
 
-#if defined(CONFIG_TREE_SRCU) || defined(CONFIG_CLASSIC_SRCU)
 #ifdef CONFIG_TREE_SRCU
         idx = srcu_ctlp->srcu_idx & 0x1;
-#else /* #ifdef CONFIG_TREE_SRCU */
-        idx = srcu_ctlp->completed & 0x1;
-#endif /* #else #ifdef CONFIG_TREE_SRCU */
         pr_alert("%s%s Tree SRCU per-CPU(idx=%d):",
                  torture_type, TORTURE_FLAG, idx);
         for_each_possible_cpu(cpu) {
                 unsigned long l0, l1;
                 unsigned long u0, u1;
                 long c0, c1;
-#ifdef CONFIG_TREE_SRCU
                 struct srcu_data *counts;
 
                 counts = per_cpu_ptr(srcu_ctlp->sda, cpu);
                 u0 = counts->srcu_unlock_count[!idx];
                 u1 = counts->srcu_unlock_count[idx];
-#else /* #ifdef CONFIG_TREE_SRCU */
-                struct srcu_array *counts;
-
-                counts = per_cpu_ptr(srcu_ctlp->per_cpu_ref, cpu);
-                u0 = counts->unlock_count[!idx];
-                u1 = counts->unlock_count[idx];
-#endif /* #else #ifdef CONFIG_TREE_SRCU */
 
                 /*
                  * Make sure that a lock is always counted if the corresponding
@@ -594,13 +584,8 @@ static void srcu_torture_stats(void)
                  */
                 smp_rmb();
 
-#ifdef CONFIG_TREE_SRCU
                 l0 = counts->srcu_lock_count[!idx];
                 l1 = counts->srcu_lock_count[idx];
-#else /* #ifdef CONFIG_TREE_SRCU */
-                l0 = counts->lock_count[!idx];
-                l1 = counts->lock_count[idx];
-#endif /* #else #ifdef CONFIG_TREE_SRCU */
 
                 c0 = l0 - u0;
                 c1 = l1 - u1;
@@ -609,7 +594,7 @@ static void srcu_torture_stats(void)
         pr_cont("\n");
 #elif defined(CONFIG_TINY_SRCU)
         idx = READ_ONCE(srcu_ctlp->srcu_idx) & 0x1;
-        pr_alert("%s%s Tiny SRCU per-CPU(idx=%d): (%d,%d)\n",
+        pr_alert("%s%s Tiny SRCU per-CPU(idx=%d): (%hd,%hd)\n",
                  torture_type, TORTURE_FLAG, idx,
                  READ_ONCE(srcu_ctlp->srcu_lock_nesting[!idx]),
                  READ_ONCE(srcu_ctlp->srcu_lock_nesting[idx]));
diff --git a/kernel/rcu/srcu.c b/kernel/rcu/srcu.c
deleted file mode 100644
index 584d8a983883..000000000000
--- a/kernel/rcu/srcu.c
+++ /dev/null
@@ -1,662 +0,0 @@
-/*
- * Sleepable Read-Copy Update mechanism for mutual exclusion.
- *
- * 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, you can access it online at
- * http://www.gnu.org/licenses/gpl-2.0.html.
- *
- * Copyright (C) IBM Corporation, 2006
- * Copyright (C) Fujitsu, 2012
- *
- * Author: Paul McKenney <paulmck@us.ibm.com>
- *         Lai Jiangshan <laijs@cn.fujitsu.com>
- *
- * For detailed explanation of Read-Copy Update mechanism see -
- *              Documentation/RCU/ *.txt
- *
- */
-
-#include <linux/export.h>
-#include <linux/mutex.h>
-#include <linux/percpu.h>
-#include <linux/preempt.h>
-#include <linux/rcupdate_wait.h>
-#include <linux/sched.h>
-#include <linux/smp.h>
-#include <linux/delay.h>
-#include <linux/srcu.h>
-
-#include "rcu.h"
-
-/*
- * Initialize an rcu_batch structure to empty.
- */
-static inline void rcu_batch_init(struct rcu_batch *b)
-{
-        b->head = NULL;
-        b->tail = &b->head;
-}
-
-/*
- * Enqueue a callback onto the tail of the specified rcu_batch structure.
- */
-static inline void rcu_batch_queue(struct rcu_batch *b, struct rcu_head *head)
-{
-        *b->tail = head;
-        b->tail = &head->next;
-}
-
-/*
- * Is the specified rcu_batch structure empty?
- */
-static inline bool rcu_batch_empty(struct rcu_batch *b)
-{
-        return b->tail == &b->head;
-}
-
-/*
- * Remove the callback at the head of the specified rcu_batch structure
- * and return a pointer to it, or return NULL if the structure is empty.
- */
-static inline struct rcu_head *rcu_batch_dequeue(struct rcu_batch *b)
-{
-        struct rcu_head *head;
-
-        if (rcu_batch_empty(b))
-                return NULL;
-
-        head = b->head;
-        b->head = head->next;
-        if (b->tail == &head->next)
-                rcu_batch_init(b);
-
-        return head;
-}
-
-/*
- * Move all callbacks from the rcu_batch structure specified by "from" to
- * the structure specified by "to".
- */
-static inline void rcu_batch_move(struct rcu_batch *to, struct rcu_batch *from)
-{
-        if (!rcu_batch_empty(from)) {
-                *to->tail = from->head;
-                to->tail = from->tail;
-                rcu_batch_init(from);
-        }
-}
-
-static int init_srcu_struct_fields(struct srcu_struct *sp)
-{
-        sp->completed = 0;
-        spin_lock_init(&sp->queue_lock);
-        sp->running = false;
-        rcu_batch_init(&sp->batch_queue);
-        rcu_batch_init(&sp->batch_check0);
-        rcu_batch_init(&sp->batch_check1);
-        rcu_batch_init(&sp->batch_done);
-        INIT_DELAYED_WORK(&sp->work, process_srcu);
-        sp->per_cpu_ref = alloc_percpu(struct srcu_array);
-        return sp->per_cpu_ref ? 0 : -ENOMEM;
-}
-
-#ifdef CONFIG_DEBUG_LOCK_ALLOC
-
-int __init_srcu_struct(struct srcu_struct *sp, const char *name,
-                       struct lock_class_key *key)
-{
-        /* Don't re-initialize a lock while it is held. */
-        debug_check_no_locks_freed((void *)sp, sizeof(*sp));
-        lockdep_init_map(&sp->dep_map, name, key, 0);
-        return init_srcu_struct_fields(sp);
-}
-EXPORT_SYMBOL_GPL(__init_srcu_struct);
-
-#else /* #ifdef CONFIG_DEBUG_LOCK_ALLOC */
-
-/**
- * init_srcu_struct - initialize a sleep-RCU structure
- * @sp: structure to initialize.
- *
- * Must invoke this on a given srcu_struct before passing that srcu_struct
- * to any other function.  Each srcu_struct represents a separate domain
- * of SRCU protection.
- */
-int init_srcu_struct(struct srcu_struct *sp)
-{
-        return init_srcu_struct_fields(sp);
-}
-EXPORT_SYMBOL_GPL(init_srcu_struct);
-
-#endif /* #else #ifdef CONFIG_DEBUG_LOCK_ALLOC */
-
-/*
- * Returns approximate total of the readers' ->lock_count[] values for the
- * rank of per-CPU counters specified by idx.
- */
-static unsigned long srcu_readers_lock_idx(struct srcu_struct *sp, int idx)
-{
-        int cpu;
-        unsigned long sum = 0;
-
-        for_each_possible_cpu(cpu) {
-                struct srcu_array *cpuc = per_cpu_ptr(sp->per_cpu_ref, cpu);
-
-                sum += READ_ONCE(cpuc->lock_count[idx]);
-        }
-        return sum;
-}
-
-/*
- * Returns approximate total of the readers' ->unlock_count[] values for the
- * rank of per-CPU counters specified by idx.
- */
-static unsigned long srcu_readers_unlock_idx(struct srcu_struct *sp, int idx)
-{
-        int cpu;
-        unsigned long sum = 0;
-
-        for_each_possible_cpu(cpu) {
-                struct srcu_array *cpuc = per_cpu_ptr(sp->per_cpu_ref, cpu);
-
-                sum += READ_ONCE(cpuc->unlock_count[idx]);
-        }
-        return sum;
-}
-
-/*
- * Return true if the number of pre-existing readers is determined to
- * be zero.
- */
-static bool srcu_readers_active_idx_check(struct srcu_struct *sp, int idx)
-{
-        unsigned long unlocks;
-
-        unlocks = srcu_readers_unlock_idx(sp, idx);
-
-        /*
-         * Make sure that a lock is always counted if the corresponding unlock
-         * is counted. Needs to be a smp_mb() as the read side may contain a
-         * read from a variable that is written to before the synchronize_srcu()
-         * in the write side. In this case smp_mb()s A and B act like the store
-         * buffering pattern.
-         *
-         * This smp_mb() also pairs with smp_mb() C to prevent accesses after the
-         * synchronize_srcu() from being executed before the grace period ends.
-         */
-        smp_mb(); /* A */
-
-        /*
-         * If the locks are the same as the unlocks, then there must have
-         * been no readers on this index at some time in between. This does not
-         * mean that there are no more readers, as one could have read the
-         * current index but not have incremented the lock counter yet.
-         *
-         * Possible bug: There is no guarantee that there haven't been ULONG_MAX
-         * increments of ->lock_count[] since the unlocks were counted, meaning
-         * that this could return true even if there are still active readers.
-         * Since there are no memory barriers around srcu_flip(), the CPU is not
-         * required to increment ->completed before running
-         * srcu_readers_unlock_idx(), which means that there could be an
-         * arbitrarily large number of critical sections that execute after
-         * srcu_readers_unlock_idx() but use the old value of ->completed.
-         */
-        return srcu_readers_lock_idx(sp, idx) == unlocks;
-}
-
-/**
- * srcu_readers_active - returns true if there are readers. and false
- *                       otherwise
- * @sp: which srcu_struct to count active readers (holding srcu_read_lock).
- *
- * Note that this is not an atomic primitive, and can therefore suffer
- * severe errors when invoked on an active srcu_struct.  That said, it
- * can be useful as an error check at cleanup time.
- */
-static bool srcu_readers_active(struct srcu_struct *sp)
-{
-        int cpu;
-        unsigned long sum = 0;
-
-        for_each_possible_cpu(cpu) {
-                struct srcu_array *cpuc = per_cpu_ptr(sp->per_cpu_ref, cpu);
-
-                sum += READ_ONCE(cpuc->lock_count[0]);
-                sum += READ_ONCE(cpuc->lock_count[1]);
-                sum -= READ_ONCE(cpuc->unlock_count[0]);
-                sum -= READ_ONCE(cpuc->unlock_count[1]);
-        }
-        return sum;
-}
-
-/**
- * cleanup_srcu_struct - deconstruct a sleep-RCU structure
- * @sp: structure to clean up.
- *
- * Must invoke this only after you are finished using a given srcu_struct
- * that was initialized via init_srcu_struct().  This code does some
- * probabalistic checking, spotting late uses of srcu_read_lock(),
- * synchronize_srcu(), synchronize_srcu_expedited(), and call_srcu().
- * If any such late uses are detected, the per-CPU memory associated with
- * the srcu_struct is simply leaked and WARN_ON() is invoked.  If the
- * caller frees the srcu_struct itself, a use-after-free crash will likely
- * ensue, but at least there will be a warning printed.
- */
-void cleanup_srcu_struct(struct srcu_struct *sp)
-{
-        if (WARN_ON(srcu_readers_active(sp)))
-                return; /* Leakage unless caller handles error. */
-        free_percpu(sp->per_cpu_ref);
-        sp->per_cpu_ref = NULL;
-}
-EXPORT_SYMBOL_GPL(cleanup_srcu_struct);
-
-/*
- * Counts the new reader in the appropriate per-CPU element of the
- * srcu_struct.  Must be called from process context.
- * Returns an index that must be passed to the matching srcu_read_unlock().
- */
-int __srcu_read_lock(struct srcu_struct *sp)
-{
-        int idx;
-
-        idx = READ_ONCE(sp->completed) & 0x1;
-        __this_cpu_inc(sp->per_cpu_ref->lock_count[idx]);
-        smp_mb(); /* B */  /* Avoid leaking the critical section. */
-        return idx;
-}
-EXPORT_SYMBOL_GPL(__srcu_read_lock);
-
-/*
- * Removes the count for the old reader from the appropriate per-CPU
- * element of the srcu_struct.  Note that this may well be a different
- * CPU than that which was incremented by the corresponding srcu_read_lock().
- * Must be called from process context.
- */
-void __srcu_read_unlock(struct srcu_struct *sp, int idx)
-{
-        smp_mb(); /* C */  /* Avoid leaking the critical section. */
-        this_cpu_inc(sp->per_cpu_ref->unlock_count[idx]);
-}
-EXPORT_SYMBOL_GPL(__srcu_read_unlock);
-
-/*
- * We use an adaptive strategy for synchronize_srcu() and especially for
- * synchronize_srcu_expedited().  We spin for a fixed time period
- * (defined below) to allow SRCU readers to exit their read-side critical
- * sections.  If there are still some readers after 10 microseconds,
- * we repeatedly block for 1-millisecond time periods.  This approach
- * has done well in testing, so there is no need for a config parameter.
- */
-#define SRCU_RETRY_CHECK_DELAY          5
-#define SYNCHRONIZE_SRCU_TRYCOUNT       2
-#define SYNCHRONIZE_SRCU_EXP_TRYCOUNT   12
-
-/*
- * @@@ Wait until all pre-existing readers complete.  Such readers
- * will have used the index specified by "idx".
- * the caller should ensures the ->completed is not changed while checking
- * and idx = (->completed & 1) ^ 1
- */
-static bool try_check_zero(struct srcu_struct *sp, int idx, int trycount)
-{
-        for (;;) {
-                if (srcu_readers_active_idx_check(sp, idx))
-                        return true;
-                if (--trycount <= 0)
-                        return false;
-                udelay(SRCU_RETRY_CHECK_DELAY);
-        }
-}
-
-/*
- * Increment the ->completed counter so that future SRCU readers will
- * use the other rank of the ->(un)lock_count[] arrays.  This allows
- * us to wait for pre-existing readers in a starvation-free manner.
- */
-static void srcu_flip(struct srcu_struct *sp)
-{
-        WRITE_ONCE(sp->completed, sp->completed + 1);
-
-        /*
-         * Ensure that if the updater misses an __srcu_read_unlock()
-         * increment, that task's next __srcu_read_lock() will see the
-         * above counter update.  Note that both this memory barrier
-         * and the one in srcu_readers_active_idx_check() provide the
-         * guarantee for __srcu_read_lock().
-         */
-        smp_mb(); /* D */  /* Pairs with C. */
-}
-
-/*
- * Enqueue an SRCU callback on the specified srcu_struct structure,
- * initiating grace-period processing if it is not already running.
- *
- * Note that all CPUs must agree that the grace period extended beyond
- * all pre-existing SRCU read-side critical section.  On systems with
- * more than one CPU, this means that when "func()" is invoked, each CPU
- * is guaranteed to have executed a full memory barrier since the end of
- * its last corresponding SRCU read-side critical section whose beginning
- * preceded the call to call_rcu().  It also means that each CPU executing
- * an SRCU read-side critical section that continues beyond the start of
- * "func()" must have executed a memory barrier after the call_rcu()
- * but before the beginning of that SRCU read-side critical section.
- * Note that these guarantees include CPUs that are offline, idle, or
- * executing in user mode, as well as CPUs that are executing in the kernel.
- *
- * Furthermore, if CPU A invoked call_rcu() and CPU B invoked the
- * resulting SRCU callback function "func()", then both CPU A and CPU
- * B are guaranteed to execute a full memory barrier during the time
- * interval between the call to call_rcu() and the invocation of "func()".
- * This guarantee applies even if CPU A and CPU B are the same CPU (but
- * again only if the system has more than one CPU).
- *
- * Of course, these guarantees apply only for invocations of call_srcu(),
- * srcu_read_lock(), and srcu_read_unlock() that are all passed the same
- * srcu_struct structure.
- */
-void call_srcu(struct srcu_struct *sp, struct rcu_head *head,
-               rcu_callback_t func)
-{
-        unsigned long flags;
-
-        head->next = NULL;
-        head->func = func;
-        spin_lock_irqsave(&sp->queue_lock, flags);
-        smp_mb__after_unlock_lock(); /* Caller's prior accesses before GP. */
-        rcu_batch_queue(&sp->batch_queue, head);
-        if (!sp->running) {
-                sp->running = true;
-                queue_delayed_work(system_power_efficient_wq, &sp->work, 0);
-        }
-        spin_unlock_irqrestore(&sp->queue_lock, flags);
-}
-EXPORT_SYMBOL_GPL(call_srcu);
-
-static void srcu_advance_batches(struct srcu_struct *sp, int trycount);
-static void srcu_reschedule(struct srcu_struct *sp);
-
-/*
- * Helper function for synchronize_srcu() and synchronize_srcu_expedited().
- */
-static void __synchronize_srcu(struct srcu_struct *sp, int trycount)
-{
-        struct rcu_synchronize rcu;
-        struct rcu_head *head = &rcu.head;
-        bool done = false;
-
-        RCU_LOCKDEP_WARN(lock_is_held(&sp->dep_map) ||
-                         lock_is_held(&rcu_bh_lock_map) ||
-                         lock_is_held(&rcu_lock_map) ||
-                         lock_is_held(&rcu_sched_lock_map),
-                         "Illegal synchronize_srcu() in same-type SRCU (or in RCU) read-side critical section");
-
-        might_sleep();
-        init_completion(&rcu.completion);
-
-        head->next = NULL;
-        head->func = wakeme_after_rcu;
-        spin_lock_irq(&sp->queue_lock);
-        smp_mb__after_unlock_lock(); /* Caller's prior accesses before GP. */
-        if (!sp->running) {
-                /* steal the processing owner */
-                sp->running = true;
-                rcu_batch_queue(&sp->batch_check0, head);
-                spin_unlock_irq(&sp->queue_lock);
-
-                srcu_advance_batches(sp, trycount);
-                if (!rcu_batch_empty(&sp->batch_done)) {
-                        BUG_ON(sp->batch_done.head != head);
-                        rcu_batch_dequeue(&sp->batch_done);
-                        done = true;
-                }
-                /* give the processing owner to work_struct */
-                srcu_reschedule(sp);
-        } else {
-                rcu_batch_queue(&sp->batch_queue, head);
-                spin_unlock_irq(&sp->queue_lock);
-        }
-
-        if (!done) {
-                wait_for_completion(&rcu.completion);
-                smp_mb(); /* Caller's later accesses after GP. */
-        }
-
-}
-
-/**
- * synchronize_srcu - wait for prior SRCU read-side critical-section completion
- * @sp: srcu_struct with which to synchronize.
- *
- * Wait for the count to drain to zero of both indexes. To avoid the
- * possible starvation of synchronize_srcu(), it waits for the count of
- * the index=((->completed & 1) ^ 1) to drain to zero at first,
- * and then flip the completed and wait for the count of the other index.
- *
- * Can block; must be called from process context.
- *
- * Note that it is illegal to call synchronize_srcu() from the corresponding
- * SRCU read-side critical section; doing so will result in deadlock.
- * However, it is perfectly legal to call synchronize_srcu() on one
- * srcu_struct from some other srcu_struct's read-side critical section,
- * as long as the resulting graph of srcu_structs is acyclic.
- *
- * There are memory-ordering constraints implied by synchronize_srcu().
- * On systems with more than one CPU, when synchronize_srcu() returns,
- * each CPU is guaranteed to have executed a full memory barrier since
- * the end of its last corresponding SRCU-sched read-side critical section
- * whose beginning preceded the call to synchronize_srcu().  In addition,
- * each CPU having an SRCU read-side critical section that extends beyond
- * the return from synchronize_srcu() is guaranteed to have executed a
- * full memory barrier after the beginning of synchronize_srcu() and before
- * the beginning of that SRCU read-side critical section.  Note that these
- * guarantees include CPUs that are offline, idle, or executing in user mode,
- * as well as CPUs that are executing in the kernel.
- *
- * Furthermore, if CPU A invoked synchronize_srcu(), which returned
- * to its caller on CPU B, then both CPU A and CPU B are guaranteed
- * to have executed a full memory barrier during the execution of
- * synchronize_srcu().  This guarantee applies even if CPU A and CPU B
- * are the same CPU, but again only if the system has more than one CPU.
- *
- * Of course, these memory-ordering guarantees apply only when
- * synchronize_srcu(), srcu_read_lock(), and srcu_read_unlock() are
- * passed the same srcu_struct structure.
- */
-void synchronize_srcu(struct srcu_struct *sp)
-{
-        __synchronize_srcu(sp, (rcu_gp_is_expedited() && !rcu_gp_is_normal())
-                           ? SYNCHRONIZE_SRCU_EXP_TRYCOUNT
-                           : SYNCHRONIZE_SRCU_TRYCOUNT);
-}
-EXPORT_SYMBOL_GPL(synchronize_srcu);
-
-/**
- * synchronize_srcu_expedited - Brute-force SRCU grace period
- * @sp: srcu_struct with which to synchronize.
- *
- * Wait for an SRCU grace period to elapse, but be more aggressive about
- * spinning rather than blocking when waiting.
- *
- * Note that synchronize_srcu_expedited() has the same deadlock and
- * memory-ordering properties as does synchronize_srcu().
- */
-void synchronize_srcu_expedited(struct srcu_struct *sp)
-{
-        __synchronize_srcu(sp, SYNCHRONIZE_SRCU_EXP_TRYCOUNT);
-}
-EXPORT_SYMBOL_GPL(synchronize_srcu_expedited);
-
-/**
- * srcu_barrier - Wait until all in-flight call_srcu() callbacks complete.
- * @sp: srcu_struct on which to wait for in-flight callbacks.
- */
-void srcu_barrier(struct srcu_struct *sp)
-{
-        synchronize_srcu(sp);
-}
-EXPORT_SYMBOL_GPL(srcu_barrier);
-
-/**
- * srcu_batches_completed - return batches completed.
- * @sp: srcu_struct on which to report batch completion.
- *
- * Report the number of batches, correlated with, but not necessarily
- * precisely the same as, the number of grace periods that have elapsed.
- */
-unsigned long srcu_batches_completed(struct srcu_struct *sp)
-{
-        return sp->completed;
-}
-EXPORT_SYMBOL_GPL(srcu_batches_completed);
-
-#define SRCU_CALLBACK_BATCH     10
-#define SRCU_INTERVAL           1
-
-/*
- * Move any new SRCU callbacks to the first stage of the SRCU grace
- * period pipeline.
- */
-static void srcu_collect_new(struct srcu_struct *sp)
-{
-        if (!rcu_batch_empty(&sp->batch_queue)) {
-                spin_lock_irq(&sp->queue_lock);
-                rcu_batch_move(&sp->batch_check0, &sp->batch_queue);
-                spin_unlock_irq(&sp->queue_lock);
-        }
-}
-
-/*
- * Core SRCU state machine.  Advance callbacks from ->batch_check0 to
- * ->batch_check1 and then to ->batch_done as readers drain.
- */
-static void srcu_advance_batches(struct srcu_struct *sp, int trycount)
-{
-        int idx = 1 ^ (sp->completed & 1);
-
-        /*
-         * Because readers might be delayed for an extended period after
-         * fetching ->completed for their index, at any point in time there
-         * might well be readers using both idx=0 and idx=1.  We therefore
-         * need to wait for readers to clear from both index values before
-         * invoking a callback.
-         */
-
-        if (rcu_batch_empty(&sp->batch_check0) &&
-            rcu_batch_empty(&sp->batch_check1))
-                return; /* no callbacks need to be advanced */
-
-        if (!try_check_zero(sp, idx, trycount))
-                return; /* failed to advance, will try after SRCU_INTERVAL */
-
-        /*
-         * The callbacks in ->batch_check1 have already done with their
-         * first zero check and flip back when they were enqueued on
-         * ->batch_check0 in a previous invocation of srcu_advance_batches().
-         * (Presumably try_check_zero() returned false during that
-         * invocation, leaving the callbacks stranded on ->batch_check1.)
-         * They are therefore ready to invoke, so move them to ->batch_done.
-         */
-        rcu_batch_move(&sp->batch_done, &sp->batch_check1);
-
-        if (rcu_batch_empty(&sp->batch_check0))
-                return; /* no callbacks need to be advanced */
-        srcu_flip(sp);
-
-        /*
-         * The callbacks in ->batch_check0 just finished their
-         * first check zero and flip, so move them to ->batch_check1
-         * for future checking on the other idx.
-         */
-        rcu_batch_move(&sp->batch_check1, &sp->batch_check0);
-
-        /*
-         * SRCU read-side critical sections are normally short, so check
-         * at least twice in quick succession after a flip.
-         */
-        trycount = trycount < 2 ? 2 : trycount;
-        if (!try_check_zero(sp, idx^1, trycount))
-                return; /* failed to advance, will try after SRCU_INTERVAL */
-
-        /*
-         * The callbacks in ->batch_check1 have now waited for all
-         * pre-existing readers using both idx values.  They are therefore
-         * ready to invoke, so move them to ->batch_done.
-         */
-        rcu_batch_move(&sp->batch_done, &sp->batch_check1);
-}
-
-/*
- * Invoke a limited number of SRCU callbacks that have passed through
- * their grace period.  If there are more to do, SRCU will reschedule
- * the workqueue.  Note that needed memory barriers have been executed
- * in this task's context by srcu_readers_active_idx_check().
- */
-static void srcu_invoke_callbacks(struct srcu_struct *sp)
-{
-        int i;
-        struct rcu_head *head;
-
-        for (i = 0; i < SRCU_CALLBACK_BATCH; i++) {
-                head = rcu_batch_dequeue(&sp->batch_done);
-                if (!head)
-                        break;
-                local_bh_disable();
-                head->func(head);
-                local_bh_enable();
-        }
-}
-
-/*
- * Finished one round of SRCU grace period.  Start another if there are
- * more SRCU callbacks queued, otherwise put SRCU into not-running state.
- */
-static void srcu_reschedule(struct srcu_struct *sp)
-{
-        bool pending = true;
-
-        if (rcu_batch_empty(&sp->batch_done) &&
-            rcu_batch_empty(&sp->batch_check1) &&
-            rcu_batch_empty(&sp->batch_check0) &&
-            rcu_batch_empty(&sp->batch_queue)) {
-                spin_lock_irq(&sp->queue_lock);
-                if (rcu_batch_empty(&sp->batch_done) &&
-                    rcu_batch_empty(&sp->batch_check1) &&
-                    rcu_batch_empty(&sp->batch_check0) &&
-                    rcu_batch_empty(&sp->batch_queue)) {
-                        sp->running = false;
-                        pending = false;
-                }
-                spin_unlock_irq(&sp->queue_lock);
-        }
-
-        if (pending)
-                queue_delayed_work(system_power_efficient_wq,
-                                   &sp->work, SRCU_INTERVAL);
-}
-
-/*
- * This is the work-queue function that handles SRCU grace periods.
- */
-void process_srcu(struct work_struct *work)
-{
-        struct srcu_struct *sp;
-
-        sp = container_of(work, struct srcu_struct, work.work);
-
-        srcu_collect_new(sp);
-        srcu_advance_batches(sp, 1);
-        srcu_invoke_callbacks(sp);
-        srcu_reschedule(sp);
-}
-EXPORT_SYMBOL_GPL(process_srcu);
diff --git a/kernel/rcu/srcutiny.c b/kernel/rcu/srcutiny.c
index 36e1f82faed1..1a1c1047d2ed 100644
--- a/kernel/rcu/srcutiny.c
+++ b/kernel/rcu/srcutiny.c
@@ -38,8 +38,8 @@ static int init_srcu_struct_fields(struct srcu_struct *sp)
         sp->srcu_lock_nesting[0] = 0;
         sp->srcu_lock_nesting[1] = 0;
         init_swait_queue_head(&sp->srcu_wq);
-        sp->srcu_gp_seq = 0;
-        rcu_segcblist_init(&sp->srcu_cblist);
+        sp->srcu_cb_head = NULL;
+        sp->srcu_cb_tail = &sp->srcu_cb_head;
         sp->srcu_gp_running = false;
         sp->srcu_gp_waiting = false;
         sp->srcu_idx = 0;
@@ -88,31 +88,16 @@ void cleanup_srcu_struct(struct srcu_struct *sp)
 {
         WARN_ON(sp->srcu_lock_nesting[0] || sp->srcu_lock_nesting[1]);
         flush_work(&sp->srcu_work);
-        WARN_ON(rcu_seq_state(sp->srcu_gp_seq));
         WARN_ON(sp->srcu_gp_running);
         WARN_ON(sp->srcu_gp_waiting);
-        WARN_ON(!rcu_segcblist_empty(&sp->srcu_cblist));
+        WARN_ON(sp->srcu_cb_head);
+        WARN_ON(&sp->srcu_cb_head != sp->srcu_cb_tail);
 }
 EXPORT_SYMBOL_GPL(cleanup_srcu_struct);
 
 /*
- * Counts the new reader in the appropriate per-CPU element of the
- * srcu_struct.  Must be called from process context.
- * Returns an index that must be passed to the matching srcu_read_unlock().
- */
-int __srcu_read_lock(struct srcu_struct *sp)
-{
-        int idx;
-
-        idx = READ_ONCE(sp->srcu_idx);
-        WRITE_ONCE(sp->srcu_lock_nesting[idx], sp->srcu_lock_nesting[idx] + 1);
-        return idx;
-}
-EXPORT_SYMBOL_GPL(__srcu_read_lock);
-
-/*
  * Removes the count for the old reader from the appropriate element of
- * the srcu_struct.  Must be called from process context.
+ * the srcu_struct.
  */
 void __srcu_read_unlock(struct srcu_struct *sp, int idx)
 {
@@ -132,52 +117,44 @@ EXPORT_SYMBOL_GPL(__srcu_read_unlock);
 void srcu_drive_gp(struct work_struct *wp)
 {
         int idx;
-        struct rcu_cblist ready_cbs;
-        struct srcu_struct *sp;
+        struct rcu_head *lh;
         struct rcu_head *rhp;
+        struct srcu_struct *sp;
 
         sp = container_of(wp, struct srcu_struct, srcu_work);
-        if (sp->srcu_gp_running || rcu_segcblist_empty(&sp->srcu_cblist))
+        if (sp->srcu_gp_running || !READ_ONCE(sp->srcu_cb_head))
                 return; /* Already running or nothing to do. */
 
-        /* Tag recently arrived callbacks and wait for readers. */
+        /* Remove recently arrived callbacks and wait for readers. */
         WRITE_ONCE(sp->srcu_gp_running, true);
-        rcu_segcblist_accelerate(&sp->srcu_cblist,
-                                 rcu_seq_snap(&sp->srcu_gp_seq));
-        rcu_seq_start(&sp->srcu_gp_seq);
+        local_irq_disable();
+        lh = sp->srcu_cb_head;
+        sp->srcu_cb_head = NULL;
+        sp->srcu_cb_tail = &sp->srcu_cb_head;
+        local_irq_enable();
         idx = sp->srcu_idx;
         WRITE_ONCE(sp->srcu_idx, !sp->srcu_idx);
         WRITE_ONCE(sp->srcu_gp_waiting, true);  /* srcu_read_unlock() wakes! */
         swait_event(sp->srcu_wq, !READ_ONCE(sp->srcu_lock_nesting[idx]));
         WRITE_ONCE(sp->srcu_gp_waiting, false); /* srcu_read_unlock() cheap. */
-        rcu_seq_end(&sp->srcu_gp_seq);
-
-        /* Update callback list based on GP, and invoke ready callbacks. */
-        rcu_segcblist_advance(&sp->srcu_cblist,
-                              rcu_seq_current(&sp->srcu_gp_seq));
-        if (rcu_segcblist_ready_cbs(&sp->srcu_cblist)) {
-                rcu_cblist_init(&ready_cbs);
-                local_irq_disable();
-                rcu_segcblist_extract_done_cbs(&sp->srcu_cblist, &ready_cbs);
-                local_irq_enable();
-                rhp = rcu_cblist_dequeue(&ready_cbs);
-                for (; rhp != NULL; rhp = rcu_cblist_dequeue(&ready_cbs)) {
-                        local_bh_disable();
-                        rhp->func(rhp);
-                        local_bh_enable();
-                }
-                local_irq_disable();
-                rcu_segcblist_insert_count(&sp->srcu_cblist, &ready_cbs);
-                local_irq_enable();
+
+        /* Invoke the callbacks we removed above. */
+        while (lh) {
+                rhp = lh;
+                lh = lh->next;
+                local_bh_disable();
+                rhp->func(rhp);
+                local_bh_enable();
         }
-        WRITE_ONCE(sp->srcu_gp_running, false);
 
         /*
-         * If more callbacks, reschedule ourselves.  This can race with
-         * a call_srcu() at interrupt level, but the ->srcu_gp_running
-         * checks will straighten that out.
+         * Enable rescheduling, and if there are more callbacks,
+         * reschedule ourselves.  This can race with a call_srcu()
+         * at interrupt level, but the ->srcu_gp_running checks will
+         * straighten that out.
          */
-        if (!rcu_segcblist_empty(&sp->srcu_cblist))
+        WRITE_ONCE(sp->srcu_gp_running, false);
+        if (READ_ONCE(sp->srcu_cb_head))
                 schedule_work(&sp->srcu_work);
 }
 EXPORT_SYMBOL_GPL(srcu_drive_gp);
@@ -186,14 +163,16 @@ EXPORT_SYMBOL_GPL(srcu_drive_gp);
  * Enqueue an SRCU callback on the specified srcu_struct structure,
  * initiating grace-period processing if it is not already running.
  */
-void call_srcu(struct srcu_struct *sp, struct rcu_head *head,
+void call_srcu(struct srcu_struct *sp, struct rcu_head *rhp,
                rcu_callback_t func)
 {
         unsigned long flags;
 
-        head->func = func;
+        rhp->func = func;
+        rhp->next = NULL;
         local_irq_save(flags);
-        rcu_segcblist_enqueue(&sp->srcu_cblist, head, false);
+        *sp->srcu_cb_tail = rhp;
+        sp->srcu_cb_tail = &rhp->next;
         local_irq_restore(flags);
         if (!READ_ONCE(sp->srcu_gp_running))
                 schedule_work(&sp->srcu_work);
diff --git a/kernel/rcu/srcutree.c b/kernel/rcu/srcutree.c
index 3ae8474557df..d0ca524bf042 100644
--- a/kernel/rcu/srcutree.c
+++ b/kernel/rcu/srcutree.c
@@ -40,9 +40,15 @@
 #include "rcu.h"
 #include "rcu_segcblist.h"
 
-ulong exp_holdoff = 25 * 1000; /* Holdoff (ns) for auto-expediting. */
+/* Holdoff in nanoseconds for auto-expediting. */
+#define DEFAULT_SRCU_EXP_HOLDOFF (25 * 1000)
+static ulong exp_holdoff = DEFAULT_SRCU_EXP_HOLDOFF;
 module_param(exp_holdoff, ulong, 0444);
 
+/* Overflow-check frequency.  N bits roughly says every 2**N grace periods. */
+static ulong counter_wrap_check = (ULONG_MAX >> 2);
+module_param(counter_wrap_check, ulong, 0444);
+
 static void srcu_invoke_callbacks(struct work_struct *work);
 static void srcu_reschedule(struct srcu_struct *sp, unsigned long delay);
 
@@ -70,7 +76,7 @@ static void init_srcu_struct_nodes(struct srcu_struct *sp, bool is_static)
 
         /* Each pass through this loop initializes one srcu_node structure. */
         rcu_for_each_node_breadth_first(sp, snp) {
-                spin_lock_init(&snp->lock);
+                raw_spin_lock_init(&ACCESS_PRIVATE(snp, lock));
                 WARN_ON_ONCE(ARRAY_SIZE(snp->srcu_have_cbs) !=
                              ARRAY_SIZE(snp->srcu_data_have_cbs));
                 for (i = 0; i < ARRAY_SIZE(snp->srcu_have_cbs); i++) {
@@ -104,7 +110,7 @@ static void init_srcu_struct_nodes(struct srcu_struct *sp, bool is_static)
         snp_first = sp->level[level];
         for_each_possible_cpu(cpu) {
                 sdp = per_cpu_ptr(sp->sda, cpu);
-                spin_lock_init(&sdp->lock);
+                raw_spin_lock_init(&ACCESS_PRIVATE(sdp, lock));
                 rcu_segcblist_init(&sdp->srcu_cblist);
                 sdp->srcu_cblist_invoking = false;
                 sdp->srcu_gp_seq_needed = sp->srcu_gp_seq;
@@ -163,7 +169,7 @@ int __init_srcu_struct(struct srcu_struct *sp, const char *name,
         /* Don't re-initialize a lock while it is held. */
         debug_check_no_locks_freed((void *)sp, sizeof(*sp));
         lockdep_init_map(&sp->dep_map, name, key, 0);
-        spin_lock_init(&sp->gp_lock);
+        raw_spin_lock_init(&ACCESS_PRIVATE(sp, lock));
         return init_srcu_struct_fields(sp, false);
 }
 EXPORT_SYMBOL_GPL(__init_srcu_struct);
@@ -180,7 +186,7 @@ EXPORT_SYMBOL_GPL(__init_srcu_struct);
  */
 int init_srcu_struct(struct srcu_struct *sp)
 {
-        spin_lock_init(&sp->gp_lock);
+        raw_spin_lock_init(&ACCESS_PRIVATE(sp, lock));
         return init_srcu_struct_fields(sp, false);
 }
 EXPORT_SYMBOL_GPL(init_srcu_struct);
@@ -191,7 +197,7 @@ EXPORT_SYMBOL_GPL(init_srcu_struct);
  * First-use initialization of statically allocated srcu_struct
  * structure.  Wiring up the combining tree is more than can be
  * done with compile-time initialization, so this check is added
- * to each update-side SRCU primitive.  Use ->gp_lock, which -is-
+ * to each update-side SRCU primitive.  Use sp->lock, which -is-
  * compile-time initialized, to resolve races involving multiple
  * CPUs trying to garner first-use privileges.
  */
@@ -203,13 +209,13 @@ static void check_init_srcu_struct(struct srcu_struct *sp)
         /* The smp_load_acquire() pairs with the smp_store_release(). */
         if (!rcu_seq_state(smp_load_acquire(&sp->srcu_gp_seq_needed))) /*^^^*/
                 return; /* Already initialized. */
-        spin_lock_irqsave(&sp->gp_lock, flags);
+        raw_spin_lock_irqsave_rcu_node(sp, flags);
         if (!rcu_seq_state(sp->srcu_gp_seq_needed)) {
-                spin_unlock_irqrestore(&sp->gp_lock, flags);
+                raw_spin_unlock_irqrestore_rcu_node(sp, flags);
                 return;
         }
         init_srcu_struct_fields(sp, true);
-        spin_unlock_irqrestore(&sp->gp_lock, flags);
+        raw_spin_unlock_irqrestore_rcu_node(sp, flags);
 }
 
 /*
@@ -275,15 +281,20 @@ static bool srcu_readers_active_idx_check(struct srcu_struct *sp, int idx)
          * not mean that there are no more readers, as one could have read
          * the current index but not have incremented the lock counter yet.
          *
-         * Possible bug: There is no guarantee that there haven't been
-         * ULONG_MAX increments of ->srcu_lock_count[] since the unlocks were
-         * counted, meaning that this could return true even if there are
-         * still active readers.  Since there are no memory barriers around
-         * srcu_flip(), the CPU is not required to increment ->srcu_idx
-         * before running srcu_readers_unlock_idx(), which means that there
-         * could be an arbitrarily large number of critical sections that
-         * execute after srcu_readers_unlock_idx() but use the old value
-         * of ->srcu_idx.
+         * So suppose that the updater is preempted here for so long
+         * that more than ULONG_MAX non-nested readers come and go in
+         * the meantime.  It turns out that this cannot result in overflow
+         * because if a reader modifies its unlock count after we read it
+         * above, then that reader's next load of ->srcu_idx is guaranteed
+         * to get the new value, which will cause it to operate on the
+         * other bank of counters, where it cannot contribute to the
+         * overflow of these counters.  This means that there is a maximum
+         * of 2*NR_CPUS increments, which cannot overflow given current
+         * systems, especially not on 64-bit systems.
+         *
+         * OK, how about nesting?  This does impose a limit on nesting
+         * of floor(ULONG_MAX/NR_CPUS/2), which should be sufficient,
+         * especially on 64-bit systems.
          */
         return srcu_readers_lock_idx(sp, idx) == unlocks;
 }
@@ -357,7 +368,7 @@ EXPORT_SYMBOL_GPL(cleanup_srcu_struct);
 
 /*
  * Counts the new reader in the appropriate per-CPU element of the
- * srcu_struct.  Must be called from process context.
+ * srcu_struct.
  * Returns an index that must be passed to the matching srcu_read_unlock().
  */
 int __srcu_read_lock(struct srcu_struct *sp)
@@ -365,7 +376,7 @@ int __srcu_read_lock(struct srcu_struct *sp)
         int idx;
 
         idx = READ_ONCE(sp->srcu_idx) & 0x1;
-        __this_cpu_inc(sp->sda->srcu_lock_count[idx]);
+        this_cpu_inc(sp->sda->srcu_lock_count[idx]);
         smp_mb(); /* B */  /* Avoid leaking the critical section. */
         return idx;
 }
@@ -375,7 +386,6 @@ EXPORT_SYMBOL_GPL(__srcu_read_lock);
  * Removes the count for the old reader from the appropriate per-CPU
  * element of the srcu_struct.  Note that this may well be a different
  * CPU than that which was incremented by the corresponding srcu_read_lock().
- * Must be called from process context.
  */
 void __srcu_read_unlock(struct srcu_struct *sp, int idx)
 {
@@ -401,8 +411,7 @@ static void srcu_gp_start(struct srcu_struct *sp)
         struct srcu_data *sdp = this_cpu_ptr(sp->sda);
         int state;
 
-        RCU_LOCKDEP_WARN(!lockdep_is_held(&sp->gp_lock),
-                         "Invoked srcu_gp_start() without ->gp_lock!");
+        lockdep_assert_held(&sp->lock);
         WARN_ON_ONCE(ULONG_CMP_GE(sp->srcu_gp_seq, sp->srcu_gp_seq_needed));
         rcu_segcblist_advance(&sdp->srcu_cblist,
                               rcu_seq_current(&sp->srcu_gp_seq));
@@ -490,17 +499,20 @@ static void srcu_gp_end(struct srcu_struct *sp)
 {
         unsigned long cbdelay;
         bool cbs;
+        int cpu;
+        unsigned long flags;
         unsigned long gpseq;
         int idx;
         int idxnext;
         unsigned long mask;
+        struct srcu_data *sdp;
         struct srcu_node *snp;
 
         /* Prevent more than one additional grace period. */
         mutex_lock(&sp->srcu_cb_mutex);
 
         /* End the current grace period. */
-        spin_lock_irq(&sp->gp_lock);
+        raw_spin_lock_irq_rcu_node(sp);
         idx = rcu_seq_state(sp->srcu_gp_seq);
         WARN_ON_ONCE(idx != SRCU_STATE_SCAN2);
         cbdelay = srcu_get_delay(sp);
@@ -509,7 +521,7 @@ static void srcu_gp_end(struct srcu_struct *sp)
         gpseq = rcu_seq_current(&sp->srcu_gp_seq);
         if (ULONG_CMP_LT(sp->srcu_gp_seq_needed_exp, gpseq))
                 sp->srcu_gp_seq_needed_exp = gpseq;
-        spin_unlock_irq(&sp->gp_lock);
+        raw_spin_unlock_irq_rcu_node(sp);
         mutex_unlock(&sp->srcu_gp_mutex);
         /* A new grace period can start at this point.  But only one. */
 
@@ -517,7 +529,7 @@ static void srcu_gp_end(struct srcu_struct *sp)
         idx = rcu_seq_ctr(gpseq) % ARRAY_SIZE(snp->srcu_have_cbs);
         idxnext = (idx + 1) % ARRAY_SIZE(snp->srcu_have_cbs);
         rcu_for_each_node_breadth_first(sp, snp) {
-                spin_lock_irq(&snp->lock);
+                raw_spin_lock_irq_rcu_node(snp);
                 cbs = false;
                 if (snp >= sp->level[rcu_num_lvls - 1])
                         cbs = snp->srcu_have_cbs[idx] == gpseq;
@@ -527,28 +539,37 @@ static void srcu_gp_end(struct srcu_struct *sp)
                         snp->srcu_gp_seq_needed_exp = gpseq;
                 mask = snp->srcu_data_have_cbs[idx];
                 snp->srcu_data_have_cbs[idx] = 0;
-                spin_unlock_irq(&snp->lock);
-                if (cbs) {
-                        smp_mb(); /* GP end before CB invocation. */
+                raw_spin_unlock_irq_rcu_node(snp);
+                if (cbs)
                         srcu_schedule_cbs_snp(sp, snp, mask, cbdelay);
-                }
+
+                /* Occasionally prevent srcu_data counter wrap. */
+                if (!(gpseq & counter_wrap_check))
+                        for (cpu = snp->grplo; cpu <= snp->grphi; cpu++) {
+                                sdp = per_cpu_ptr(sp->sda, cpu);
+                                raw_spin_lock_irqsave_rcu_node(sdp, flags);
+                                if (ULONG_CMP_GE(gpseq,
+                                                 sdp->srcu_gp_seq_needed + 100))
+                                        sdp->srcu_gp_seq_needed = gpseq;
+                                raw_spin_unlock_irqrestore_rcu_node(sdp, flags);
+                        }
         }
 
         /* Callback initiation done, allow grace periods after next. */
         mutex_unlock(&sp->srcu_cb_mutex);
 
         /* Start a new grace period if needed. */
-        spin_lock_irq(&sp->gp_lock);
+        raw_spin_lock_irq_rcu_node(sp);
         gpseq = rcu_seq_current(&sp->srcu_gp_seq);
         if (!rcu_seq_state(gpseq) &&
             ULONG_CMP_LT(gpseq, sp->srcu_gp_seq_needed)) {
                 srcu_gp_start(sp);
-                spin_unlock_irq(&sp->gp_lock);
+                raw_spin_unlock_irq_rcu_node(sp);
                 /* Throttle expedited grace periods: Should be rare! */
                 srcu_reschedule(sp, rcu_seq_ctr(gpseq) & 0x3ff
                                     ? 0 : SRCU_INTERVAL);
         } else {
-                spin_unlock_irq(&sp->gp_lock);
+                raw_spin_unlock_irq_rcu_node(sp);
         }
 }
 
@@ -568,18 +589,18 @@ static void srcu_funnel_exp_start(struct srcu_struct *sp, struct srcu_node *snp,
                 if (rcu_seq_done(&sp->srcu_gp_seq, s) ||
                     ULONG_CMP_GE(READ_ONCE(snp->srcu_gp_seq_needed_exp), s))
                         return;
-                spin_lock_irqsave(&snp->lock, flags);
+                raw_spin_lock_irqsave_rcu_node(snp, flags);
                 if (ULONG_CMP_GE(snp->srcu_gp_seq_needed_exp, s)) {
-                        spin_unlock_irqrestore(&snp->lock, flags);
+                        raw_spin_unlock_irqrestore_rcu_node(snp, flags);
                         return;
                 }
                 WRITE_ONCE(snp->srcu_gp_seq_needed_exp, s);
-                spin_unlock_irqrestore(&snp->lock, flags);
+                raw_spin_unlock_irqrestore_rcu_node(snp, flags);
         }
-        spin_lock_irqsave(&sp->gp_lock, flags);
+        raw_spin_lock_irqsave_rcu_node(sp, flags);
         if (!ULONG_CMP_LT(sp->srcu_gp_seq_needed_exp, s))
                 sp->srcu_gp_seq_needed_exp = s;
-        spin_unlock_irqrestore(&sp->gp_lock, flags);
+        raw_spin_unlock_irqrestore_rcu_node(sp, flags);
 }
 
 /*
@@ -601,14 +622,13 @@ static void srcu_funnel_gp_start(struct srcu_struct *sp, struct srcu_data *sdp,
         for (; snp != NULL; snp = snp->srcu_parent) {
                 if (rcu_seq_done(&sp->srcu_gp_seq, s) && snp != sdp->mynode)
                         return; /* GP already done and CBs recorded. */
-                spin_lock_irqsave(&snp->lock, flags);
+                raw_spin_lock_irqsave_rcu_node(snp, flags);
                 if (ULONG_CMP_GE(snp->srcu_have_cbs[idx], s)) {
                         snp_seq = snp->srcu_have_cbs[idx];
                         if (snp == sdp->mynode && snp_seq == s)
                                 snp->srcu_data_have_cbs[idx] |= sdp->grpmask;
-                        spin_unlock_irqrestore(&snp->lock, flags);
+                        raw_spin_unlock_irqrestore_rcu_node(snp, flags);
                         if (snp == sdp->mynode && snp_seq != s) {
-                                smp_mb(); /* CBs after GP! */
                                 srcu_schedule_cbs_sdp(sdp, do_norm
                                                            ? SRCU_INTERVAL
                                                            : 0);
@@ -623,11 +643,11 @@ static void srcu_funnel_gp_start(struct srcu_struct *sp, struct srcu_data *sdp,
                         snp->srcu_data_have_cbs[idx] |= sdp->grpmask;
                 if (!do_norm && ULONG_CMP_LT(snp->srcu_gp_seq_needed_exp, s))
                         snp->srcu_gp_seq_needed_exp = s;
-                spin_unlock_irqrestore(&snp->lock, flags);
+                raw_spin_unlock_irqrestore_rcu_node(snp, flags);
         }
 
         /* Top of tree, must ensure the grace period will be started. */
-        spin_lock_irqsave(&sp->gp_lock, flags);
+        raw_spin_lock_irqsave_rcu_node(sp, flags);
         if (ULONG_CMP_LT(sp->srcu_gp_seq_needed, s)) {
                 /*
                  * Record need for grace period s.  Pair with load
@@ -646,7 +666,7 @@ static void srcu_funnel_gp_start(struct srcu_struct *sp, struct srcu_data *sdp,
                 queue_delayed_work(system_power_efficient_wq, &sp->work,
                                    srcu_get_delay(sp));
         }
-        spin_unlock_irqrestore(&sp->gp_lock, flags);
+        raw_spin_unlock_irqrestore_rcu_node(sp, flags);
 }
 
 /*
@@ -672,6 +692,16 @@ static bool try_check_zero(struct srcu_struct *sp, int idx, int trycount)
  */
 static void srcu_flip(struct srcu_struct *sp)
 {
+        /*
+         * Ensure that if this updater saw a given reader's increment
+         * from __srcu_read_lock(), that reader was using an old value
+         * of ->srcu_idx.  Also ensure that if a given reader sees the
+         * new value of ->srcu_idx, this updater's earlier scans cannot
+         * have seen that reader's increments (which is OK, because this
+         * grace period need not wait on that reader).
+         */
+        smp_mb(); /* E */  /* Pairs with B and C. */
+
         WRITE_ONCE(sp->srcu_idx, sp->srcu_idx + 1);
 
         /*
@@ -746,6 +776,13 @@ static bool srcu_might_be_idle(struct srcu_struct *sp)
 }
 
 /*
+ * SRCU callback function to leak a callback.
+ */
+static void srcu_leak_callback(struct rcu_head *rhp)
+{
+}
+
+/*
  * Enqueue an SRCU callback on the srcu_data structure associated with
  * the current CPU and the specified srcu_struct structure, initiating
  * grace-period processing if it is not already running.
@@ -783,10 +820,16 @@ void __call_srcu(struct srcu_struct *sp, struct rcu_head *rhp,
         struct srcu_data *sdp;
 
         check_init_srcu_struct(sp);
+        if (debug_rcu_head_queue(rhp)) {
+                /* Probable double call_srcu(), so leak the callback. */
+                WRITE_ONCE(rhp->func, srcu_leak_callback);
+                WARN_ONCE(1, "call_srcu(): Leaked duplicate callback\n");
+                return;
+        }
         rhp->func = func;
         local_irq_save(flags);
         sdp = this_cpu_ptr(sp->sda);
-        spin_lock(&sdp->lock);
+        raw_spin_lock_rcu_node(sdp);
         rcu_segcblist_enqueue(&sdp->srcu_cblist, rhp, false);
         rcu_segcblist_advance(&sdp->srcu_cblist,
                               rcu_seq_current(&sp->srcu_gp_seq));
@@ -800,13 +843,30 @@ void __call_srcu(struct srcu_struct *sp, struct rcu_head *rhp,
                 sdp->srcu_gp_seq_needed_exp = s;
                 needexp = true;
         }
-        spin_unlock_irqrestore(&sdp->lock, flags);
+        raw_spin_unlock_irqrestore_rcu_node(sdp, flags);
         if (needgp)
                 srcu_funnel_gp_start(sp, sdp, s, do_norm);
         else if (needexp)
                 srcu_funnel_exp_start(sp, sdp->mynode, s);
 }
 
+/**
+ * call_srcu() - Queue a callback for invocation after an SRCU grace period
+ * @sp: srcu_struct in queue the callback
+ * @head: structure to be used for queueing the SRCU callback.
+ * @func: function to be invoked after the SRCU grace period
+ *
+ * The callback function will be invoked some time after a full SRCU
+ * grace period elapses, in other words after all pre-existing SRCU
+ * read-side critical sections have completed.  However, the callback
+ * function might well execute concurrently with other SRCU read-side
+ * critical sections that started after call_srcu() was invoked.  SRCU
+ * read-side critical sections are delimited by srcu_read_lock() and
+ * srcu_read_unlock(), and may be nested.
+ *
+ * The callback will be invoked from process context, but must nevertheless
+ * be fast and must not block.
+ */
 void call_srcu(struct srcu_struct *sp, struct rcu_head *rhp,
                rcu_callback_t func)
 {
@@ -954,13 +1014,16 @@ void srcu_barrier(struct srcu_struct *sp)
          */
         for_each_possible_cpu(cpu) {
                 sdp = per_cpu_ptr(sp->sda, cpu);
-                spin_lock_irq(&sdp->lock);
+                raw_spin_lock_irq_rcu_node(sdp);
                 atomic_inc(&sp->srcu_barrier_cpu_cnt);
                 sdp->srcu_barrier_head.func = srcu_barrier_cb;
+                debug_rcu_head_queue(&sdp->srcu_barrier_head);
                 if (!rcu_segcblist_entrain(&sdp->srcu_cblist,
-                                           &sdp->srcu_barrier_head, 0))
+                                           &sdp->srcu_barrier_head, 0)) {
+                        debug_rcu_head_unqueue(&sdp->srcu_barrier_head);
                         atomic_dec(&sp->srcu_barrier_cpu_cnt);
-                spin_unlock_irq(&sdp->lock);
+                }
+                raw_spin_unlock_irq_rcu_node(sdp);
         }
 
         /* Remove the initial count, at which point reaching zero can happen. */
@@ -1009,17 +1072,17 @@ static void srcu_advance_state(struct srcu_struct *sp)
          */
         idx = rcu_seq_state(smp_load_acquire(&sp->srcu_gp_seq)); /* ^^^ */
         if (idx == SRCU_STATE_IDLE) {
-                spin_lock_irq(&sp->gp_lock);
+                raw_spin_lock_irq_rcu_node(sp);
                 if (ULONG_CMP_GE(sp->srcu_gp_seq, sp->srcu_gp_seq_needed)) {
                         WARN_ON_ONCE(rcu_seq_state(sp->srcu_gp_seq));
-                        spin_unlock_irq(&sp->gp_lock);
+                        raw_spin_unlock_irq_rcu_node(sp);
                         mutex_unlock(&sp->srcu_gp_mutex);
                         return;
                 }
                 idx = rcu_seq_state(READ_ONCE(sp->srcu_gp_seq));
                 if (idx == SRCU_STATE_IDLE)
                         srcu_gp_start(sp);
-                spin_unlock_irq(&sp->gp_lock);
+                raw_spin_unlock_irq_rcu_node(sp);
                 if (idx != SRCU_STATE_IDLE) {
                         mutex_unlock(&sp->srcu_gp_mutex);
                         return; /* Someone else started the grace period. */
@@ -1068,22 +1131,22 @@ static void srcu_invoke_callbacks(struct work_struct *work)
         sdp = container_of(work, struct srcu_data, work.work);
         sp = sdp->sp;
         rcu_cblist_init(&ready_cbs);
-        spin_lock_irq(&sdp->lock);
-        smp_mb(); /* Old grace periods before callback invocation! */
+        raw_spin_lock_irq_rcu_node(sdp);
         rcu_segcblist_advance(&sdp->srcu_cblist,
                               rcu_seq_current(&sp->srcu_gp_seq));
         if (sdp->srcu_cblist_invoking ||
             !rcu_segcblist_ready_cbs(&sdp->srcu_cblist)) {
-                spin_unlock_irq(&sdp->lock);
+                raw_spin_unlock_irq_rcu_node(sdp);
                 return;  /* Someone else on the job or nothing to do. */
         }
 
         /* We are on the job!  Extract and invoke ready callbacks. */
         sdp->srcu_cblist_invoking = true;
         rcu_segcblist_extract_done_cbs(&sdp->srcu_cblist, &ready_cbs);
-        spin_unlock_irq(&sdp->lock);
+        raw_spin_unlock_irq_rcu_node(sdp);
         rhp = rcu_cblist_dequeue(&ready_cbs);
         for (; rhp != NULL; rhp = rcu_cblist_dequeue(&ready_cbs)) {
+                debug_rcu_head_unqueue(rhp);
                 local_bh_disable();
                 rhp->func(rhp);
                 local_bh_enable();
@@ -1093,13 +1156,13 @@ static void srcu_invoke_callbacks(struct work_struct *work)
          * Update counts, accelerate new callbacks, and if needed,
          * schedule another round of callback invocation.
          */
-        spin_lock_irq(&sdp->lock);
+        raw_spin_lock_irq_rcu_node(sdp);
         rcu_segcblist_insert_count(&sdp->srcu_cblist, &ready_cbs);
         (void)rcu_segcblist_accelerate(&sdp->srcu_cblist,
                                        rcu_seq_snap(&sp->srcu_gp_seq));
         sdp->srcu_cblist_invoking = false;
         more = rcu_segcblist_ready_cbs(&sdp->srcu_cblist);
-        spin_unlock_irq(&sdp->lock);
+        raw_spin_unlock_irq_rcu_node(sdp);
         if (more)
                 srcu_schedule_cbs_sdp(sdp, 0);
 }
@@ -1112,7 +1175,7 @@ static void srcu_reschedule(struct srcu_struct *sp, unsigned long delay)
 {
         bool pushgp = true;
 
-        spin_lock_irq(&sp->gp_lock);
+        raw_spin_lock_irq_rcu_node(sp);
         if (ULONG_CMP_GE(sp->srcu_gp_seq, sp->srcu_gp_seq_needed)) {
                 if (!WARN_ON_ONCE(rcu_seq_state(sp->srcu_gp_seq))) {
                         /* All requests fulfilled, time to go idle. */
@@ -1122,7 +1185,7 @@ static void srcu_reschedule(struct srcu_struct *sp, unsigned long delay)
                 /* Outstanding request and no GP.  Start one. */
                 srcu_gp_start(sp);
         }
-        spin_unlock_irq(&sp->gp_lock);
+        raw_spin_unlock_irq_rcu_node(sp);
 
         if (pushgp)
                 queue_delayed_work(system_power_efficient_wq, &sp->work, delay);
@@ -1153,3 +1216,12 @@ void srcutorture_get_gp_data(enum rcutorture_type test_type,
         *gpnum = rcu_seq_ctr(sp->srcu_gp_seq_needed);
 }
 EXPORT_SYMBOL_GPL(srcutorture_get_gp_data);
+
+static int __init srcu_bootup_announce(void)
+{
+        pr_info("Hierarchical SRCU implementation.\n");
+        if (exp_holdoff != DEFAULT_SRCU_EXP_HOLDOFF)
+                pr_info("\tNon-default auto-expedite holdoff of %lu ns.\n", exp_holdoff);
+        return 0;
+}
+early_initcall(srcu_bootup_announce);
diff --git a/kernel/rcu/tiny.c b/kernel/rcu/tiny.c
index e5385731e391..f8488965250f 100644
--- a/kernel/rcu/tiny.c
+++ b/kernel/rcu/tiny.c
@@ -35,15 +35,26 @@
 #include <linux/time.h>
 #include <linux/cpu.h>
 #include <linux/prefetch.h>
-#include <linux/trace_events.h>
 
 #include "rcu.h"
 
-/* Forward declarations for tiny_plugin.h. */
-struct rcu_ctrlblk;
-static void __call_rcu(struct rcu_head *head,
-                       rcu_callback_t func,
-                       struct rcu_ctrlblk *rcp);
+/* Global control variables for rcupdate callback mechanism. */
+struct rcu_ctrlblk {
+        struct rcu_head *rcucblist;     /* List of pending callbacks (CBs). */
+        struct rcu_head **donetail;     /* ->next pointer of last "done" CB. */
+        struct rcu_head **curtail;      /* ->next pointer of last CB. */
+};
+
+/* Definition for rcupdate control block. */
+static struct rcu_ctrlblk rcu_sched_ctrlblk = {
+        .donetail       = &rcu_sched_ctrlblk.rcucblist,
+        .curtail        = &rcu_sched_ctrlblk.rcucblist,
+};
+
+static struct rcu_ctrlblk rcu_bh_ctrlblk = {
+        .donetail       = &rcu_bh_ctrlblk.rcucblist,
+        .curtail        = &rcu_bh_ctrlblk.rcucblist,
+};
 
 #include "tiny_plugin.h"
 
@@ -59,19 +70,6 @@ void rcu_barrier_sched(void)
 }
 EXPORT_SYMBOL(rcu_barrier_sched);
 
-#if defined(CONFIG_DEBUG_LOCK_ALLOC) || defined(CONFIG_RCU_TRACE)
-
-/*
- * Test whether RCU thinks that the current CPU is idle.
- */
-bool notrace __rcu_is_watching(void)
-{
-        return true;
-}
-EXPORT_SYMBOL(__rcu_is_watching);
-
-#endif /* defined(CONFIG_DEBUG_LOCK_ALLOC) || defined(CONFIG_RCU_TRACE) */
-
 /*
  * Helper function for rcu_sched_qs() and rcu_bh_qs().
  * Also irqs are disabled to avoid confusion due to interrupt handlers
@@ -79,7 +77,6 @@ EXPORT_SYMBOL(__rcu_is_watching);
  */
 static int rcu_qsctr_help(struct rcu_ctrlblk *rcp)
 {
-        RCU_TRACE(reset_cpu_stall_ticks(rcp);)
         if (rcp->donetail != rcp->curtail) {
                 rcp->donetail = rcp->curtail;
                 return 1;
@@ -125,7 +122,6 @@ void rcu_bh_qs(void)
  */
 void rcu_check_callbacks(int user)
 {
-        RCU_TRACE(check_cpu_stalls();)
         if (user)
                 rcu_sched_qs();
         else if (!in_softirq())
@@ -140,10 +136,8 @@ void rcu_check_callbacks(int user)
  */
 static void __rcu_process_callbacks(struct rcu_ctrlblk *rcp)
 {
-        const char *rn = NULL;
         struct rcu_head *next, *list;
         unsigned long flags;
-        RCU_TRACE(int cb_count = 0;)
 
         /* Move the ready-to-invoke callbacks to a local list. */
         local_irq_save(flags);
@@ -152,7 +146,6 @@ static void __rcu_process_callbacks(struct rcu_ctrlblk *rcp)
                 local_irq_restore(flags);
                 return;
         }
-        RCU_TRACE(trace_rcu_batch_start(rcp->name, 0, rcp->qlen, -1);)
         list = rcp->rcucblist;
         rcp->rcucblist = *rcp->donetail;
         *rcp->donetail = NULL;
@@ -162,22 +155,15 @@ static void __rcu_process_callbacks(struct rcu_ctrlblk *rcp)
         local_irq_restore(flags);
 
         /* Invoke the callbacks on the local list. */
-        RCU_TRACE(rn = rcp->name;)
         while (list) {
                 next = list->next;
                 prefetch(next);
                 debug_rcu_head_unqueue(list);
                 local_bh_disable();
-                __rcu_reclaim(rn, list);
+                __rcu_reclaim("", list);
                 local_bh_enable();
                 list = next;
-                RCU_TRACE(cb_count++;)
         }
-        RCU_TRACE(rcu_trace_sub_qlen(rcp, cb_count);)
-        RCU_TRACE(trace_rcu_batch_end(rcp->name,
-                                      cb_count, 0, need_resched(),
-                                      is_idle_task(current),
-                                      false));
 }
 
 static __latent_entropy void rcu_process_callbacks(struct softirq_action *unused)
@@ -221,7 +207,6 @@ static void __call_rcu(struct rcu_head *head,
         local_irq_save(flags);
         *rcp->curtail = head;
         rcp->curtail = &head->next;
-        RCU_TRACE(rcp->qlen++;)
         local_irq_restore(flags);
 
         if (unlikely(is_idle_task(current))) {
@@ -254,8 +239,5 @@ EXPORT_SYMBOL_GPL(call_rcu_bh);
 void __init rcu_init(void)
 {
         open_softirq(RCU_SOFTIRQ, rcu_process_callbacks);
-        RCU_TRACE(reset_cpu_stall_ticks(&rcu_sched_ctrlblk);)
-        RCU_TRACE(reset_cpu_stall_ticks(&rcu_bh_ctrlblk);)
-
         rcu_early_boot_tests();
 }
diff --git a/kernel/rcu/tiny_plugin.h b/kernel/rcu/tiny_plugin.h
index 371034e77f87..f0a01b2a3062 100644
--- a/kernel/rcu/tiny_plugin.h
+++ b/kernel/rcu/tiny_plugin.h
@@ -22,36 +22,6 @@
  * Author: Paul E. McKenney <paulmck@linux.vnet.ibm.com>
  */
 
-#include <linux/kthread.h>
-#include <linux/init.h>
-#include <linux/debugfs.h>
-#include <linux/seq_file.h>
-
-/* Global control variables for rcupdate callback mechanism. */
-struct rcu_ctrlblk {
-        struct rcu_head *rcucblist;     /* List of pending callbacks (CBs). */
-        struct rcu_head **donetail;     /* ->next pointer of last "done" CB. */
-        struct rcu_head **curtail;      /* ->next pointer of last CB. */
-        RCU_TRACE(long qlen);           /* Number of pending CBs. */
-        RCU_TRACE(unsigned long gp_start); /* Start time for stalls. */
-        RCU_TRACE(unsigned long ticks_this_gp); /* Statistic for stalls. */
-        RCU_TRACE(unsigned long jiffies_stall); /* Jiffies at next stall. */
-        RCU_TRACE(const char *name);    /* Name of RCU type. */
-};
-
-/* Definition for rcupdate control block. */
-static struct rcu_ctrlblk rcu_sched_ctrlblk = {
-        .donetail       = &rcu_sched_ctrlblk.rcucblist,
-        .curtail        = &rcu_sched_ctrlblk.rcucblist,
-        RCU_TRACE(.name = "rcu_sched")
-};
-
-static struct rcu_ctrlblk rcu_bh_ctrlblk = {
-        .donetail       = &rcu_bh_ctrlblk.rcucblist,
-        .curtail        = &rcu_bh_ctrlblk.rcucblist,
-        RCU_TRACE(.name = "rcu_bh")
-};
-
 #if defined(CONFIG_DEBUG_LOCK_ALLOC) || defined(CONFIG_SRCU)
 #include <linux/kernel_stat.h>
 
@@ -75,96 +45,3 @@ void __init rcu_scheduler_starting(void)
 }
 
 #endif /* #if defined(CONFIG_DEBUG_LOCK_ALLOC) || defined(CONFIG_SRCU) */
-
-#ifdef CONFIG_RCU_TRACE
-
-static void rcu_trace_sub_qlen(struct rcu_ctrlblk *rcp, int n)
-{
-        unsigned long flags;
-
-        local_irq_save(flags);
-        rcp->qlen -= n;
-        local_irq_restore(flags);
-}
-
-/*
- * Dump statistics for TINY_RCU, such as they are.
- */
-static int show_tiny_stats(struct seq_file *m, void *unused)
-{
-        seq_printf(m, "rcu_sched: qlen: %ld\n", rcu_sched_ctrlblk.qlen);
-        seq_printf(m, "rcu_bh: qlen: %ld\n", rcu_bh_ctrlblk.qlen);
-        return 0;
-}
-
-static int show_tiny_stats_open(struct inode *inode, struct file *file)
-{
-        return single_open(file, show_tiny_stats, NULL);
-}
-
-static const struct file_operations show_tiny_stats_fops = {
-        .owner = THIS_MODULE,
-        .open = show_tiny_stats_open,
-        .read = seq_read,
-        .llseek = seq_lseek,
-        .release = single_release,
-};
-
-static struct dentry *rcudir;
-
-static int __init rcutiny_trace_init(void)
-{
-        struct dentry *retval;
-
-        rcudir = debugfs_create_dir("rcu", NULL);
-        if (!rcudir)
-                goto free_out;
-        retval = debugfs_create_file("rcudata", 0444, rcudir,
-                                     NULL, &show_tiny_stats_fops);
-        if (!retval)
-                goto free_out;
-        return 0;
-free_out:
-        debugfs_remove_recursive(rcudir);
-        return 1;
-}
-device_initcall(rcutiny_trace_init);
-
-static void check_cpu_stall(struct rcu_ctrlblk *rcp)
-{
-        unsigned long j;
-        unsigned long js;
-
-        if (rcu_cpu_stall_suppress)
-                return;
-        rcp->ticks_this_gp++;
-        j = jiffies;
-        js = READ_ONCE(rcp->jiffies_stall);
-        if (rcp->rcucblist && ULONG_CMP_GE(j, js)) {
-                pr_err("INFO: %s stall on CPU (%lu ticks this GP) idle=%llx (t=%lu jiffies q=%ld)\n",
-                       rcp->name, rcp->ticks_this_gp, DYNTICK_TASK_EXIT_IDLE,
-                       jiffies - rcp->gp_start, rcp->qlen);
-                dump_stack();
-                WRITE_ONCE(rcp->jiffies_stall,
-                           jiffies + 3 * rcu_jiffies_till_stall_check() + 3);
-        } else if (ULONG_CMP_GE(j, js)) {
-                WRITE_ONCE(rcp->jiffies_stall,
-                           jiffies + rcu_jiffies_till_stall_check());
-        }
-}
-
-static void reset_cpu_stall_ticks(struct rcu_ctrlblk *rcp)
-{
-        rcp->ticks_this_gp = 0;
-        rcp->gp_start = jiffies;
-        WRITE_ONCE(rcp->jiffies_stall,
-                   jiffies + rcu_jiffies_till_stall_check());
-}
-
-static void check_cpu_stalls(void)
-{
-        RCU_TRACE(check_cpu_stall(&rcu_bh_ctrlblk);)
-        RCU_TRACE(check_cpu_stall(&rcu_sched_ctrlblk);)
-}
-
-#endif /* #ifdef CONFIG_RCU_TRACE */
diff --git a/kernel/rcu/tree.c b/kernel/rcu/tree.c
index e354e475e645..51d4c3acf32d 100644
--- a/kernel/rcu/tree.c
+++ b/kernel/rcu/tree.c
@@ -168,35 +168,17 @@ static void rcu_report_exp_rdp(struct rcu_state *rsp,
 static void sync_sched_exp_online_cleanup(int cpu);
 
 /* rcuc/rcub kthread realtime priority */
-#ifdef CONFIG_RCU_KTHREAD_PRIO
-static int kthread_prio = CONFIG_RCU_KTHREAD_PRIO;
-#else /* #ifdef CONFIG_RCU_KTHREAD_PRIO */
 static int kthread_prio = IS_ENABLED(CONFIG_RCU_BOOST) ? 1 : 0;
-#endif /* #else #ifdef CONFIG_RCU_KTHREAD_PRIO */
 module_param(kthread_prio, int, 0644);
 
 /* Delay in jiffies for grace-period initialization delays, debug only. */
 
-#ifdef CONFIG_RCU_TORTURE_TEST_SLOW_PREINIT
-static int gp_preinit_delay = CONFIG_RCU_TORTURE_TEST_SLOW_PREINIT_DELAY;
-module_param(gp_preinit_delay, int, 0644);
-#else /* #ifdef CONFIG_RCU_TORTURE_TEST_SLOW_PREINIT */
-static const int gp_preinit_delay;
-#endif /* #else #ifdef CONFIG_RCU_TORTURE_TEST_SLOW_PREINIT */
-
-#ifdef CONFIG_RCU_TORTURE_TEST_SLOW_INIT
-static int gp_init_delay = CONFIG_RCU_TORTURE_TEST_SLOW_INIT_DELAY;
-module_param(gp_init_delay, int, 0644);
-#else /* #ifdef CONFIG_RCU_TORTURE_TEST_SLOW_INIT */
-static const int gp_init_delay;
-#endif /* #else #ifdef CONFIG_RCU_TORTURE_TEST_SLOW_INIT */
-
-#ifdef CONFIG_RCU_TORTURE_TEST_SLOW_CLEANUP
-static int gp_cleanup_delay = CONFIG_RCU_TORTURE_TEST_SLOW_CLEANUP_DELAY;
-module_param(gp_cleanup_delay, int, 0644);
-#else /* #ifdef CONFIG_RCU_TORTURE_TEST_SLOW_CLEANUP */
-static const int gp_cleanup_delay;
-#endif /* #else #ifdef CONFIG_RCU_TORTURE_TEST_SLOW_CLEANUP */
+static int gp_preinit_delay;
+module_param(gp_preinit_delay, int, 0444);
+static int gp_init_delay;
+module_param(gp_init_delay, int, 0444);
+static int gp_cleanup_delay;
+module_param(gp_cleanup_delay, int, 0444);
 
 /*
  * Number of grace periods between delays, normalized by the duration of
@@ -250,6 +232,7 @@ static int rcu_gp_in_progress(struct rcu_state *rsp)
  */
 void rcu_sched_qs(void)
 {
+        RCU_LOCKDEP_WARN(preemptible(), "rcu_sched_qs() invoked with preemption enabled!!!");
         if (!__this_cpu_read(rcu_sched_data.cpu_no_qs.s))
                 return;
         trace_rcu_grace_period(TPS("rcu_sched"),
@@ -265,6 +248,7 @@ void rcu_sched_qs(void)
 
 void rcu_bh_qs(void)
 {
+        RCU_LOCKDEP_WARN(preemptible(), "rcu_bh_qs() invoked with preemption enabled!!!");
         if (__this_cpu_read(rcu_bh_data.cpu_no_qs.s)) {
                 trace_rcu_grace_period(TPS("rcu_bh"),
                                        __this_cpu_read(rcu_bh_data.gpnum),
@@ -286,10 +270,6 @@ void rcu_bh_qs(void)
 static DEFINE_PER_CPU(struct rcu_dynticks, rcu_dynticks) = {
         .dynticks_nesting = DYNTICK_TASK_EXIT_IDLE,
         .dynticks = ATOMIC_INIT(RCU_DYNTICK_CTRL_CTR),
-#ifdef CONFIG_NO_HZ_FULL_SYSIDLE
-        .dynticks_idle_nesting = DYNTICK_TASK_NEST_VALUE,
-        .dynticks_idle = ATOMIC_INIT(1),
-#endif /* #ifdef CONFIG_NO_HZ_FULL_SYSIDLE */
 };
 
 /*
@@ -478,7 +458,7 @@ void rcu_note_context_switch(bool preempt)
         barrier(); /* Avoid RCU read-side critical sections leaking down. */
         trace_rcu_utilization(TPS("Start context switch"));
         rcu_sched_qs();
-        rcu_preempt_note_context_switch();
+        rcu_preempt_note_context_switch(preempt);
         /* Load rcu_urgent_qs before other flags. */
         if (!smp_load_acquire(this_cpu_ptr(&rcu_dynticks.rcu_urgent_qs)))
                 goto out;
@@ -534,9 +514,12 @@ void rcu_all_qs(void)
 }
 EXPORT_SYMBOL_GPL(rcu_all_qs);
 
-static long blimit = 10;        /* Maximum callbacks per rcu_do_batch. */
-static long qhimark = 10000;    /* If this many pending, ignore blimit. */
-static long qlowmark = 100;     /* Once only this many pending, use blimit. */
+#define DEFAULT_RCU_BLIMIT 10     /* Maximum callbacks per rcu_do_batch. */
+static long blimit = DEFAULT_RCU_BLIMIT;
+#define DEFAULT_RCU_QHIMARK 10000 /* If this many pending, ignore blimit. */
+static long qhimark = DEFAULT_RCU_QHIMARK;
+#define DEFAULT_RCU_QLOMARK 100   /* Once only this many pending, use blimit. */
+static long qlowmark = DEFAULT_RCU_QLOMARK;
 
 module_param(blimit, long, 0444);
 module_param(qhimark, long, 0444);
@@ -559,10 +542,7 @@ module_param(jiffies_till_sched_qs, ulong, 0644);
 
 static bool rcu_start_gp_advanced(struct rcu_state *rsp, struct rcu_node *rnp,
                                   struct rcu_data *rdp);
-static void force_qs_rnp(struct rcu_state *rsp,
-                         int (*f)(struct rcu_data *rsp, bool *isidle,
-                                  unsigned long *maxj),
-                         bool *isidle, unsigned long *maxj);
+static void force_qs_rnp(struct rcu_state *rsp, int (*f)(struct rcu_data *rsp));
 static void force_quiescent_state(struct rcu_state *rsp);
 static int rcu_pending(void);
 
@@ -757,6 +737,7 @@ static int rcu_future_needs_gp(struct rcu_state *rsp)
         int idx = (READ_ONCE(rnp->completed) + 1) & 0x1;
         int *fp = &rnp->need_future_gp[idx];
 
+        RCU_LOCKDEP_WARN(!irqs_disabled(), "rcu_future_needs_gp() invoked with irqs enabled!!!");
         return READ_ONCE(*fp);
 }
 
@@ -768,6 +749,7 @@ static int rcu_future_needs_gp(struct rcu_state *rsp)
 static bool
 cpu_needs_another_gp(struct rcu_state *rsp, struct rcu_data *rdp)
 {
+        RCU_LOCKDEP_WARN(!irqs_disabled(), "cpu_needs_another_gp() invoked with irqs enabled!!!");
         if (rcu_gp_in_progress(rsp))
                 return false;  /* No, a grace period is already in progress. */
         if (rcu_future_needs_gp(rsp))
@@ -794,6 +776,7 @@ static void rcu_eqs_enter_common(bool user)
         struct rcu_data *rdp;
         struct rcu_dynticks *rdtp = this_cpu_ptr(&rcu_dynticks);
 
+        RCU_LOCKDEP_WARN(!irqs_disabled(), "rcu_eqs_enter_common() invoked with irqs enabled!!!");
         trace_rcu_dyntick(TPS("Start"), rdtp->dynticks_nesting, 0);
         if (IS_ENABLED(CONFIG_RCU_EQS_DEBUG) &&
             !user && !is_idle_task(current)) {
@@ -864,7 +847,6 @@ void rcu_idle_enter(void)
 
         local_irq_save(flags);
         rcu_eqs_enter(false);
-        rcu_sysidle_enter(0);
         local_irq_restore(flags);
 }
 EXPORT_SYMBOL_GPL(rcu_idle_enter);
@@ -914,7 +896,6 @@ void rcu_irq_exit(void)
                 trace_rcu_dyntick(TPS("--="), rdtp->dynticks_nesting, rdtp->dynticks_nesting - 1);
                 rdtp->dynticks_nesting--;
         }
-        rcu_sysidle_enter(1);
 }
 
 /*
@@ -967,6 +948,7 @@ static void rcu_eqs_exit(bool user)
         struct rcu_dynticks *rdtp;
         long long oldval;
 
+        RCU_LOCKDEP_WARN(!irqs_disabled(), "rcu_eqs_exit() invoked with irqs enabled!!!");
         rdtp = this_cpu_ptr(&rcu_dynticks);
         oldval = rdtp->dynticks_nesting;
         WARN_ON_ONCE(IS_ENABLED(CONFIG_RCU_EQS_DEBUG) && oldval < 0);
@@ -995,7 +977,6 @@ void rcu_idle_exit(void)
 
         local_irq_save(flags);
         rcu_eqs_exit(false);
-        rcu_sysidle_exit(0);
         local_irq_restore(flags);
 }
 EXPORT_SYMBOL_GPL(rcu_idle_exit);
@@ -1047,7 +1028,6 @@ void rcu_irq_enter(void)
                 trace_rcu_dyntick(TPS("++="), oldval, rdtp->dynticks_nesting);
         else
                 rcu_eqs_exit_common(oldval, true);
-        rcu_sysidle_exit(1);
 }
 
 /*
@@ -1130,22 +1110,11 @@ void rcu_nmi_exit(void)
 }
 
 /**
- * __rcu_is_watching - are RCU read-side critical sections safe?
- *
- * Return true if RCU is watching the running CPU, which means that
- * this CPU can safely enter RCU read-side critical sections.  Unlike
- * rcu_is_watching(), the caller of __rcu_is_watching() must have at
- * least disabled preemption.
- */
-bool notrace __rcu_is_watching(void)
-{
-        return !rcu_dynticks_curr_cpu_in_eqs();
-}
-
-/**
  * rcu_is_watching - see if RCU thinks that the current CPU is idle
  *
- * If the current CPU is in its idle loop and is neither in an interrupt
+ * Return true if RCU is watching the running CPU, which means that this
+ * CPU can safely enter RCU read-side critical sections.  In other words,
+ * if the current CPU is in its idle loop and is neither in an interrupt
  * or NMI handler, return true.
  */
 bool notrace rcu_is_watching(void)
@@ -1153,7 +1122,7 @@ bool notrace rcu_is_watching(void)
         bool ret;
 
         preempt_disable_notrace();
-        ret = __rcu_is_watching();
+        ret = !rcu_dynticks_curr_cpu_in_eqs();
         preempt_enable_notrace();
         return ret;
 }
@@ -1237,11 +1206,9 @@ static int rcu_is_cpu_rrupt_from_idle(void)
  * credit them with an implicit quiescent state.  Return 1 if this CPU
  * is in dynticks idle mode, which is an extended quiescent state.
  */
-static int dyntick_save_progress_counter(struct rcu_data *rdp,
-                                         bool *isidle, unsigned long *maxj)
+static int dyntick_save_progress_counter(struct rcu_data *rdp)
 {
         rdp->dynticks_snap = rcu_dynticks_snap(rdp->dynticks);
-        rcu_sysidle_check_cpu(rdp, isidle, maxj);
         if (rcu_dynticks_in_eqs(rdp->dynticks_snap)) {
                 trace_rcu_fqs(rdp->rsp->name, rdp->gpnum, rdp->cpu, TPS("dti"));
                 if (ULONG_CMP_LT(READ_ONCE(rdp->gpnum) + ULONG_MAX / 4,
@@ -1258,8 +1225,7 @@ static int dyntick_save_progress_counter(struct rcu_data *rdp,
  * idle state since the last call to dyntick_save_progress_counter()
  * for this same CPU, or by virtue of having been offline.
  */
-static int rcu_implicit_dynticks_qs(struct rcu_data *rdp,
-                                    bool *isidle, unsigned long *maxj)
+static int rcu_implicit_dynticks_qs(struct rcu_data *rdp)
 {
         unsigned long jtsq;
         bool *rnhqp;
@@ -1674,6 +1640,8 @@ void rcu_cpu_stall_reset(void)
 static unsigned long rcu_cbs_completed(struct rcu_state *rsp,
                                        struct rcu_node *rnp)
 {
+        lockdep_assert_held(&rnp->lock);
+
         /*
          * If RCU is idle, we just wait for the next grace period.
          * But we can only be sure that RCU is idle if we are looking
@@ -1719,6 +1687,8 @@ rcu_start_future_gp(struct rcu_node *rnp, struct rcu_data *rdp,
         bool ret = false;
         struct rcu_node *rnp_root = rcu_get_root(rdp->rsp);
 
+        lockdep_assert_held(&rnp->lock);
+
         /*
          * Pick up grace-period number for new callbacks.  If this
          * grace period is already marked as needed, return to the caller.
@@ -1845,6 +1815,8 @@ static bool rcu_accelerate_cbs(struct rcu_state *rsp, struct rcu_node *rnp,
 {
         bool ret = false;
 
+        lockdep_assert_held(&rnp->lock);
+
         /* If no pending (not yet ready to invoke) callbacks, nothing to do. */
         if (!rcu_segcblist_pend_cbs(&rdp->cblist))
                 return false;
@@ -1883,6 +1855,8 @@ static bool rcu_accelerate_cbs(struct rcu_state *rsp, struct rcu_node *rnp,
 static bool rcu_advance_cbs(struct rcu_state *rsp, struct rcu_node *rnp,
                             struct rcu_data *rdp)
 {
+        lockdep_assert_held(&rnp->lock);
+
         /* If no pending (not yet ready to invoke) callbacks, nothing to do. */
         if (!rcu_segcblist_pend_cbs(&rdp->cblist))
                 return false;
@@ -1909,6 +1883,8 @@ static bool __note_gp_changes(struct rcu_state *rsp, struct rcu_node *rnp,
         bool ret;
         bool need_gp;
 
+        lockdep_assert_held(&rnp->lock);
+
         /* Handle the ends of any preceding grace periods first. */
         if (rdp->completed == rnp->completed &&
             !unlikely(READ_ONCE(rdp->gpwrap))) {
@@ -2115,25 +2091,16 @@ static bool rcu_gp_fqs_check_wake(struct rcu_state *rsp, int *gfp)
  */
 static void rcu_gp_fqs(struct rcu_state *rsp, bool first_time)
 {
-        bool isidle = false;
-        unsigned long maxj;
         struct rcu_node *rnp = rcu_get_root(rsp);
 
         WRITE_ONCE(rsp->gp_activity, jiffies);
         rsp->n_force_qs++;
         if (first_time) {
                 /* Collect dyntick-idle snapshots. */
-                if (is_sysidle_rcu_state(rsp)) {
-                        isidle = true;
-                        maxj = jiffies - ULONG_MAX / 4;
-                }
-                force_qs_rnp(rsp, dyntick_save_progress_counter,
-                             &isidle, &maxj);
-                rcu_sysidle_report_gp(rsp, isidle, maxj);
+                force_qs_rnp(rsp, dyntick_save_progress_counter);
         } else {
                 /* Handle dyntick-idle and offline CPUs. */
-                isidle = true;
-                force_qs_rnp(rsp, rcu_implicit_dynticks_qs, &isidle, &maxj);
+                force_qs_rnp(rsp, rcu_implicit_dynticks_qs);
         }
         /* Clear flag to prevent immediate re-entry. */
         if (READ_ONCE(rsp->gp_flags) & RCU_GP_FLAG_FQS) {
@@ -2341,6 +2308,7 @@ static bool
 rcu_start_gp_advanced(struct rcu_state *rsp, struct rcu_node *rnp,
                       struct rcu_data *rdp)
 {
+        lockdep_assert_held(&rnp->lock);
         if (!rsp->gp_kthread || !cpu_needs_another_gp(rsp, rdp)) {
                 /*
                  * Either we have not yet spawned the grace-period
@@ -2402,6 +2370,7 @@ static bool rcu_start_gp(struct rcu_state *rsp)
 static void rcu_report_qs_rsp(struct rcu_state *rsp, unsigned long flags)
         __releases(rcu_get_root(rsp)->lock)
 {
+        lockdep_assert_held(&rcu_get_root(rsp)->lock);
         WARN_ON_ONCE(!rcu_gp_in_progress(rsp));
         WRITE_ONCE(rsp->gp_flags, READ_ONCE(rsp->gp_flags) | RCU_GP_FLAG_FQS);
         raw_spin_unlock_irqrestore_rcu_node(rcu_get_root(rsp), flags);
@@ -2426,6 +2395,8 @@ rcu_report_qs_rnp(unsigned long mask, struct rcu_state *rsp,
         unsigned long oldmask = 0;
         struct rcu_node *rnp_c;
 
+        lockdep_assert_held(&rnp->lock);
+
         /* Walk up the rcu_node hierarchy. */
         for (;;) {
                 if (!(rnp->qsmask & mask) || rnp->gpnum != gps) {
@@ -2486,6 +2457,7 @@ static void rcu_report_unblock_qs_rnp(struct rcu_state *rsp,
         unsigned long mask;
         struct rcu_node *rnp_p;
 
+        lockdep_assert_held(&rnp->lock);
         if (rcu_state_p == &rcu_sched_state || rsp != rcu_state_p ||
             rnp->qsmask != 0 || rcu_preempt_blocked_readers_cgp(rnp)) {
                 raw_spin_unlock_irqrestore_rcu_node(rnp, flags);
@@ -2599,6 +2571,8 @@ static void
 rcu_send_cbs_to_orphanage(int cpu, struct rcu_state *rsp,
                           struct rcu_node *rnp, struct rcu_data *rdp)
 {
+        lockdep_assert_held(&rsp->orphan_lock);
+
         /* No-CBs CPUs do not have orphanable callbacks. */
         if (!IS_ENABLED(CONFIG_HOTPLUG_CPU) || rcu_is_nocb_cpu(rdp->cpu))
                 return;
@@ -2639,6 +2613,8 @@ static void rcu_adopt_orphan_cbs(struct rcu_state *rsp, unsigned long flags)
 {
         struct rcu_data *rdp = raw_cpu_ptr(rsp->rda);
 
+        lockdep_assert_held(&rsp->orphan_lock);
+
         /* No-CBs CPUs are handled specially. */
         if (!IS_ENABLED(CONFIG_HOTPLUG_CPU) ||
             rcu_nocb_adopt_orphan_cbs(rsp, rdp, flags))
@@ -2705,6 +2681,7 @@ static void rcu_cleanup_dead_rnp(struct rcu_node *rnp_leaf)
         long mask;
         struct rcu_node *rnp = rnp_leaf;
 
+        lockdep_assert_held(&rnp->lock);
         if (!IS_ENABLED(CONFIG_HOTPLUG_CPU) ||
             rnp->qsmaskinit || rcu_preempt_has_tasks(rnp))
                 return;
@@ -2895,10 +2872,7 @@ void rcu_check_callbacks(int user)
  *
  * The caller must have suppressed start of new grace periods.
  */
-static void force_qs_rnp(struct rcu_state *rsp,
-                         int (*f)(struct rcu_data *rsp, bool *isidle,
-                                  unsigned long *maxj),
-                         bool *isidle, unsigned long *maxj)
+static void force_qs_rnp(struct rcu_state *rsp, int (*f)(struct rcu_data *rsp))
 {
         int cpu;
         unsigned long flags;
@@ -2937,7 +2911,7 @@ static void force_qs_rnp(struct rcu_state *rsp,
                 for_each_leaf_node_possible_cpu(rnp, cpu) {
                         unsigned long bit = leaf_node_cpu_bit(rnp, cpu);
                         if ((rnp->qsmask & bit) != 0) {
-                                if (f(per_cpu_ptr(rsp->rda, cpu), isidle, maxj))
+                                if (f(per_cpu_ptr(rsp->rda, cpu)))
                                         mask |= bit;
                         }
                 }
@@ -3143,9 +3117,14 @@ __call_rcu(struct rcu_head *head, rcu_callback_t func,
         WARN_ON_ONCE((unsigned long)head & (sizeof(void *) - 1));
 
         if (debug_rcu_head_queue(head)) {
-                /* Probable double call_rcu(), so leak the callback. */
+                /*
+                 * Probable double call_rcu(), so leak the callback.
+                 * Use rcu:rcu_callback trace event to find the previous
+                 * time callback was passed to __call_rcu().
+                 */
+                WARN_ONCE(1, "__call_rcu(): Double-freed CB %p->%pF()!!!\n",
+                          head, head->func);
                 WRITE_ONCE(head->func, rcu_leak_callback);
-                WARN_ONCE(1, "__call_rcu(): Leaked duplicate callback\n");
                 return;
         }
         head->func = func;
@@ -3194,8 +3173,24 @@ __call_rcu(struct rcu_head *head, rcu_callback_t func,
         local_irq_restore(flags);
 }
 
-/*
- * Queue an RCU-sched callback for invocation after a grace period.
+/**
+ * call_rcu_sched() - Queue an RCU for invocation after sched grace period.
+ * @head: structure to be used for queueing the RCU updates.
+ * @func: actual callback function to be invoked after the grace period
+ *
+ * The callback function will be invoked some time after a full grace
+ * period elapses, in other words after all currently executing RCU
+ * read-side critical sections have completed. call_rcu_sched() assumes
+ * that the read-side critical sections end on enabling of preemption
+ * or on voluntary preemption.
+ * RCU read-side critical sections are delimited by :
+ *  - rcu_read_lock_sched() and rcu_read_unlock_sched(), OR
+ *  - anything that disables preemption.
+ *
+ *  These may be nested.
+ *
+ * See the description of call_rcu() for more detailed information on
+ * memory ordering guarantees.
  */
 void call_rcu_sched(struct rcu_head *head, rcu_callback_t func)
 {
@@ -3203,8 +3198,26 @@ void call_rcu_sched(struct rcu_head *head, rcu_callback_t func)
 }
 EXPORT_SYMBOL_GPL(call_rcu_sched);
 
-/*
- * Queue an RCU callback for invocation after a quicker grace period.
+/**
+ * call_rcu_bh() - Queue an RCU for invocation after a quicker grace period.
+ * @head: structure to be used for queueing the RCU updates.
+ * @func: actual callback function to be invoked after the grace period
+ *
+ * The callback function will be invoked some time after a full grace
+ * period elapses, in other words after all currently executing RCU
+ * read-side critical sections have completed. call_rcu_bh() assumes
+ * that the read-side critical sections end on completion of a softirq
+ * handler. This means that read-side critical sections in process
+ * context must not be interrupted by softirqs. This interface is to be
+ * used when most of the read-side critical sections are in softirq context.
+ * RCU read-side critical sections are delimited by :
+ *  - rcu_read_lock() and  rcu_read_unlock(), if in interrupt context.
+ *  OR
+ *  - rcu_read_lock_bh() and rcu_read_unlock_bh(), if in process context.
+ *  These may be nested.
+ *
+ * See the description of call_rcu() for more detailed information on
+ * memory ordering guarantees.
  */
 void call_rcu_bh(struct rcu_head *head, rcu_callback_t func)
 {
@@ -3280,12 +3293,6 @@ static inline int rcu_blocking_is_gp(void)
  * to have executed a full memory barrier during the execution of
  * synchronize_sched() -- even if CPU A and CPU B are the same CPU (but
  * again only if the system has more than one CPU).
- *
- * This primitive provides the guarantees made by the (now removed)
- * synchronize_kernel() API.  In contrast, synchronize_rcu() only
- * guarantees that rcu_read_lock() sections will have completed.
- * In "classic RCU", these two guarantees happen to be one and
- * the same, but can differ in realtime RCU implementations.
  */
 void synchronize_sched(void)
 {
@@ -3578,8 +3585,14 @@ static void rcu_barrier_func(void *type)
         struct rcu_data *rdp = raw_cpu_ptr(rsp->rda);
 
         _rcu_barrier_trace(rsp, "IRQ", -1, rsp->barrier_sequence);
-        atomic_inc(&rsp->barrier_cpu_count);
-        rsp->call(&rdp->barrier_head, rcu_barrier_callback);
+        rdp->barrier_head.func = rcu_barrier_callback;
+        debug_rcu_head_queue(&rdp->barrier_head);
+        if (rcu_segcblist_entrain(&rdp->cblist, &rdp->barrier_head, 0)) {
+                atomic_inc(&rsp->barrier_cpu_count);
+        } else {
+                debug_rcu_head_unqueue(&rdp->barrier_head);
+                _rcu_barrier_trace(rsp, "IRQNQ", -1, rsp->barrier_sequence);
+        }
 }
 
 /*
@@ -3698,6 +3711,7 @@ static void rcu_init_new_rnp(struct rcu_node *rnp_leaf)
         long mask;
         struct rcu_node *rnp = rnp_leaf;
 
+        lockdep_assert_held(&rnp->lock);
         for (;;) {
                 mask = rnp->grpmask;
                 rnp = rnp->parent;
@@ -3753,7 +3767,6 @@ rcu_init_percpu_data(int cpu, struct rcu_state *rsp)
             !init_nocb_callback_list(rdp))
                 rcu_segcblist_init(&rdp->cblist);  /* Re-enable callbacks. */
         rdp->dynticks->dynticks_nesting = DYNTICK_TASK_EXIT_IDLE;
-        rcu_sysidle_init_percpu_data(rdp->dynticks);
         rcu_dynticks_eqs_online();
         raw_spin_unlock_rcu_node(rnp);          /* irqs remain disabled. */
 
diff --git a/kernel/rcu/tree.h b/kernel/rcu/tree.h
index ba38262c3554..9af0f31d6847 100644
--- a/kernel/rcu/tree.h
+++ b/kernel/rcu/tree.h
@@ -45,14 +45,6 @@ struct rcu_dynticks {
         bool rcu_need_heavy_qs;     /* GP old, need heavy quiescent state. */
         unsigned long rcu_qs_ctr;   /* Light universal quiescent state ctr. */
         bool rcu_urgent_qs;         /* GP old need light quiescent state. */
-#ifdef CONFIG_NO_HZ_FULL_SYSIDLE
-        long long dynticks_idle_nesting;
-                                    /* irq/process nesting level from idle. */
-        atomic_t dynticks_idle;     /* Even value for idle, else odd. */
-                                    /*  "Idle" excludes userspace execution. */
-        unsigned long dynticks_idle_jiffies;
-                                    /* End of last non-NMI non-idle period. */
-#endif /* #ifdef CONFIG_NO_HZ_FULL_SYSIDLE */
 #ifdef CONFIG_RCU_FAST_NO_HZ
         bool all_lazy;              /* Are all CPU's CBs lazy? */
         unsigned long nonlazy_posted;
@@ -160,19 +152,6 @@ struct rcu_node {
                                 /* Number of tasks boosted for expedited GP. */
         unsigned long n_normal_boosts;
                                 /* Number of tasks boosted for normal GP. */
-        unsigned long n_balk_blkd_tasks;
-                                /* Refused to boost: no blocked tasks. */
-        unsigned long n_balk_exp_gp_tasks;
-                                /* Refused to boost: nothing blocking GP. */
-        unsigned long n_balk_boost_tasks;
-                                /* Refused to boost: already boosting. */
-        unsigned long n_balk_notblocked;
-                                /* Refused to boost: RCU RS CS still running. */
-        unsigned long n_balk_notyet;
-                                /* Refused to boost: not yet time. */
-        unsigned long n_balk_nos;
-                                /* Refused to boost: not sure why, though. */
-                                /*  This can happen due to race conditions. */
 #ifdef CONFIG_RCU_NOCB_CPU
         struct swait_queue_head nocb_gp_wq[2];
                                 /* Place for rcu_nocb_kthread() to wait GP. */
@@ -312,9 +291,9 @@ struct rcu_data {
 };
 
 /* Values for nocb_defer_wakeup field in struct rcu_data. */
-#define RCU_NOGP_WAKE_NOT       0
-#define RCU_NOGP_WAKE           1
-#define RCU_NOGP_WAKE_FORCE     2
+#define RCU_NOCB_WAKE_NOT       0
+#define RCU_NOCB_WAKE           1
+#define RCU_NOCB_WAKE_FORCE     2
 
 #define RCU_JIFFIES_TILL_FORCE_QS (1 + (HZ > 250) + (HZ > 500))
                                         /* For jiffies_till_first_fqs and */
@@ -477,7 +456,7 @@ DECLARE_PER_CPU(char, rcu_cpu_has_work);
 
 /* Forward declarations for rcutree_plugin.h */
 static void rcu_bootup_announce(void);
-static void rcu_preempt_note_context_switch(void);
+static void rcu_preempt_note_context_switch(bool preempt);
 static int rcu_preempt_blocked_readers_cgp(struct rcu_node *rnp);
 #ifdef CONFIG_HOTPLUG_CPU
 static bool rcu_preempt_has_tasks(struct rcu_node *rnp);
@@ -529,15 +508,7 @@ static void __init rcu_organize_nocb_kthreads(struct rcu_state *rsp);
 #endif /* #ifdef CONFIG_RCU_NOCB_CPU */
 static void __maybe_unused rcu_kick_nohz_cpu(int cpu);
 static bool init_nocb_callback_list(struct rcu_data *rdp);
-static void rcu_sysidle_enter(int irq);
-static void rcu_sysidle_exit(int irq);
-static void rcu_sysidle_check_cpu(struct rcu_data *rdp, bool *isidle,
-                                  unsigned long *maxj);
-static bool is_sysidle_rcu_state(struct rcu_state *rsp);
-static void rcu_sysidle_report_gp(struct rcu_state *rsp, int isidle,
-                                  unsigned long maxj);
 static void rcu_bind_gp_kthread(void);
-static void rcu_sysidle_init_percpu_data(struct rcu_dynticks *rdtp);
 static bool rcu_nohz_full_cpu(struct rcu_state *rsp);
 static void rcu_dynticks_task_enter(void);
 static void rcu_dynticks_task_exit(void);
@@ -551,75 +522,3 @@ void srcu_offline_cpu(unsigned int cpu) { }
 #endif /* #else #ifdef CONFIG_SRCU */
 
 #endif /* #ifndef RCU_TREE_NONCORE */
-
-#ifdef CONFIG_RCU_TRACE
-/* Read out queue lengths for tracing. */
-static inline void rcu_nocb_q_lengths(struct rcu_data *rdp, long *ql, long *qll)
-{
-#ifdef CONFIG_RCU_NOCB_CPU
-        *ql = atomic_long_read(&rdp->nocb_q_count);
-        *qll = atomic_long_read(&rdp->nocb_q_count_lazy);
-#else /* #ifdef CONFIG_RCU_NOCB_CPU */
-        *ql = 0;
-        *qll = 0;
-#endif /* #else #ifdef CONFIG_RCU_NOCB_CPU */
-}
-#endif /* #ifdef CONFIG_RCU_TRACE */
-
-/*
- * Wrappers for the rcu_node::lock acquire and release.
- *
- * Because the rcu_nodes form a tree, the tree traversal locking will observe
- * different lock values, this in turn means that an UNLOCK of one level
- * followed by a LOCK of another level does not imply a full memory barrier;
- * and most importantly transitivity is lost.
- *
- * In order to restore full ordering between tree levels, augment the regular
- * lock acquire functions with smp_mb__after_unlock_lock().
- *
- * As ->lock of struct rcu_node is a __private field, therefore one should use
- * these wrappers rather than directly call raw_spin_{lock,unlock}* on ->lock.
- */
-static inline void raw_spin_lock_rcu_node(struct rcu_node *rnp)
-{
-        raw_spin_lock(&ACCESS_PRIVATE(rnp, lock));
-        smp_mb__after_unlock_lock();
-}
-
-static inline void raw_spin_unlock_rcu_node(struct rcu_node *rnp)
-{
-        raw_spin_unlock(&ACCESS_PRIVATE(rnp, lock));
-}
-
-static inline void raw_spin_lock_irq_rcu_node(struct rcu_node *rnp)
-{
-        raw_spin_lock_irq(&ACCESS_PRIVATE(rnp, lock));
-        smp_mb__after_unlock_lock();
-}
-
-static inline void raw_spin_unlock_irq_rcu_node(struct rcu_node *rnp)
-{
-        raw_spin_unlock_irq(&ACCESS_PRIVATE(rnp, lock));
-}
-
-#define raw_spin_lock_irqsave_rcu_node(rnp, flags)                      \
-do {                                                                    \
-        typecheck(unsigned long, flags);                                \
-        raw_spin_lock_irqsave(&ACCESS_PRIVATE(rnp, lock), flags);       \
-        smp_mb__after_unlock_lock();                                    \
-} while (0)
-
-#define raw_spin_unlock_irqrestore_rcu_node(rnp, flags)                 \
-do {                                                                    \
-        typecheck(unsigned long, flags);                                \
-        raw_spin_unlock_irqrestore(&ACCESS_PRIVATE(rnp, lock), flags);  \
-} while (0)
-
-static inline bool raw_spin_trylock_rcu_node(struct rcu_node *rnp)
-{
-        bool locked = raw_spin_trylock(&ACCESS_PRIVATE(rnp, lock));
-
-        if (locked)
-                smp_mb__after_unlock_lock();
-        return locked;
-}
diff --git a/kernel/rcu/tree_exp.h b/kernel/rcu/tree_exp.h
index e513b4ab1197..dd21ca47e4b4 100644
--- a/kernel/rcu/tree_exp.h
+++ b/kernel/rcu/tree_exp.h
@@ -147,7 +147,7 @@ static void __maybe_unused sync_exp_reset_tree(struct rcu_state *rsp)
  *
  * Caller must hold the rcu_state's exp_mutex.
  */
-static int sync_rcu_preempt_exp_done(struct rcu_node *rnp)
+static bool sync_rcu_preempt_exp_done(struct rcu_node *rnp)
 {
         return rnp->exp_tasks == NULL &&
                READ_ONCE(rnp->expmask) == 0;
diff --git a/kernel/rcu/tree_plugin.h b/kernel/rcu/tree_plugin.h
index c9a48657512a..908b309d60d7 100644
--- a/kernel/rcu/tree_plugin.h
+++ b/kernel/rcu/tree_plugin.h
@@ -70,7 +70,7 @@ static bool __read_mostly rcu_nocb_poll;    /* Offload kthread are to poll. */
 static void __init rcu_bootup_announce_oddness(void)
 {
         if (IS_ENABLED(CONFIG_RCU_TRACE))
-                pr_info("\tRCU debugfs-based tracing is enabled.\n");
+                pr_info("\tRCU event tracing is enabled.\n");
         if ((IS_ENABLED(CONFIG_64BIT) && RCU_FANOUT != 64) ||
             (!IS_ENABLED(CONFIG_64BIT) && RCU_FANOUT != 32))
                 pr_info("\tCONFIG_RCU_FANOUT set to non-default value of %d\n",
@@ -90,8 +90,32 @@ static void __init rcu_bootup_announce_oddness(void)
                 pr_info("\tBoot-time adjustment of leaf fanout to %d.\n", rcu_fanout_leaf);
         if (nr_cpu_ids != NR_CPUS)
                 pr_info("\tRCU restricting CPUs from NR_CPUS=%d to nr_cpu_ids=%d.\n", NR_CPUS, nr_cpu_ids);
-        if (IS_ENABLED(CONFIG_RCU_BOOST))
-                pr_info("\tRCU kthread priority: %d.\n", kthread_prio);
+#ifdef CONFIG_RCU_BOOST
+        pr_info("\tRCU priority boosting: priority %d delay %d ms.\n", kthread_prio, CONFIG_RCU_BOOST_DELAY);
+#endif
+        if (blimit != DEFAULT_RCU_BLIMIT)
+                pr_info("\tBoot-time adjustment of callback invocation limit to %ld.\n", blimit);
+        if (qhimark != DEFAULT_RCU_QHIMARK)
+                pr_info("\tBoot-time adjustment of callback high-water mark to %ld.\n", qhimark);
+        if (qlowmark != DEFAULT_RCU_QLOMARK)
+                pr_info("\tBoot-time adjustment of callback low-water mark to %ld.\n", qlowmark);
+        if (jiffies_till_first_fqs != ULONG_MAX)
+                pr_info("\tBoot-time adjustment of first FQS scan delay to %ld jiffies.\n", jiffies_till_first_fqs);
+        if (jiffies_till_next_fqs != ULONG_MAX)
+                pr_info("\tBoot-time adjustment of subsequent FQS scan delay to %ld jiffies.\n", jiffies_till_next_fqs);
+        if (rcu_kick_kthreads)
+                pr_info("\tKick kthreads if too-long grace period.\n");
+        if (IS_ENABLED(CONFIG_DEBUG_OBJECTS_RCU_HEAD))
+                pr_info("\tRCU callback double-/use-after-free debug enabled.\n");
+        if (gp_preinit_delay)
+                pr_info("\tRCU debug GP pre-init slowdown %d jiffies.\n", gp_preinit_delay);
+        if (gp_init_delay)
+                pr_info("\tRCU debug GP init slowdown %d jiffies.\n", gp_init_delay);
+        if (gp_cleanup_delay)
+                pr_info("\tRCU debug GP init slowdown %d jiffies.\n", gp_cleanup_delay);
+        if (IS_ENABLED(CONFIG_RCU_EQS_DEBUG))
+                pr_info("\tRCU debug extended QS entry/exit.\n");
+        rcupdate_announce_bootup_oddness();
 }
 
 #ifdef CONFIG_PREEMPT_RCU
@@ -155,6 +179,8 @@ static void rcu_preempt_ctxt_queue(struct rcu_node *rnp, struct rcu_data *rdp)
                          (rnp->expmask & rdp->grpmask ? RCU_EXP_BLKD : 0);
         struct task_struct *t = current;
 
+        lockdep_assert_held(&rnp->lock);
+
         /*
          * Decide where to queue the newly blocked task.  In theory,
          * this could be an if-statement.  In practice, when I tried
@@ -263,6 +289,7 @@ static void rcu_preempt_ctxt_queue(struct rcu_node *rnp, struct rcu_data *rdp)
  */
 static void rcu_preempt_qs(void)
 {
+        RCU_LOCKDEP_WARN(preemptible(), "rcu_preempt_qs() invoked with preemption enabled!!!\n");
         if (__this_cpu_read(rcu_data_p->cpu_no_qs.s)) {
                 trace_rcu_grace_period(TPS("rcu_preempt"),
                                        __this_cpu_read(rcu_data_p->gpnum),
@@ -286,12 +313,14 @@ static void rcu_preempt_qs(void)
  *
  * Caller must disable interrupts.
  */
-static void rcu_preempt_note_context_switch(void)
+static void rcu_preempt_note_context_switch(bool preempt)
 {
         struct task_struct *t = current;
         struct rcu_data *rdp;
         struct rcu_node *rnp;
 
+        RCU_LOCKDEP_WARN(!irqs_disabled(), "rcu_preempt_note_context_switch() invoked with interrupts enabled!!!\n");
+        WARN_ON_ONCE(!preempt && t->rcu_read_lock_nesting > 0);
         if (t->rcu_read_lock_nesting > 0 &&
             !t->rcu_read_unlock_special.b.blocked) {
 
@@ -607,6 +636,7 @@ static int rcu_print_task_exp_stall(struct rcu_node *rnp)
  */
 static void rcu_preempt_check_blocked_tasks(struct rcu_node *rnp)
 {
+        RCU_LOCKDEP_WARN(preemptible(), "rcu_preempt_check_blocked_tasks() invoked with preemption enabled!!!\n");
         WARN_ON_ONCE(rcu_preempt_blocked_readers_cgp(rnp));
         if (rcu_preempt_has_tasks(rnp))
                 rnp->gp_tasks = rnp->blkd_tasks.next;
@@ -643,8 +673,37 @@ static void rcu_preempt_do_callbacks(void)
 
 #endif /* #ifdef CONFIG_RCU_BOOST */
 
-/*
- * Queue a preemptible-RCU callback for invocation after a grace period.
+/**
+ * call_rcu() - Queue an RCU callback for invocation after a grace period.
+ * @head: structure to be used for queueing the RCU updates.
+ * @func: actual callback function to be invoked after the grace period
+ *
+ * The callback function will be invoked some time after a full grace
+ * period elapses, in other words after all pre-existing RCU read-side
+ * critical sections have completed.  However, the callback function
+ * might well execute concurrently with RCU read-side critical sections
+ * that started after call_rcu() was invoked.  RCU read-side critical
+ * sections are delimited by rcu_read_lock() and rcu_read_unlock(),
+ * and may be nested.
+ *
+ * Note that all CPUs must agree that the grace period extended beyond
+ * all pre-existing RCU read-side critical section.  On systems with more
+ * than one CPU, this means that when "func()" is invoked, each CPU is
+ * guaranteed to have executed a full memory barrier since the end of its
+ * last RCU read-side critical section whose beginning preceded the call
+ * to call_rcu().  It also means that each CPU executing an RCU read-side
+ * critical section that continues beyond the start of "func()" must have
+ * executed a memory barrier after the call_rcu() but before the beginning
+ * of that RCU read-side critical section.  Note that these guarantees
+ * include CPUs that are offline, idle, or executing in user mode, as
+ * well as CPUs that are executing in the kernel.
+ *
+ * Furthermore, if CPU A invoked call_rcu() and CPU B invoked the
+ * resulting RCU callback function "func()", then both CPU A and CPU B are
+ * guaranteed to execute a full memory barrier during the time interval
+ * between the call to call_rcu() and the invocation of "func()" -- even
+ * if CPU A and CPU B are the same CPU (but again only if the system has
+ * more than one CPU).
  */
 void call_rcu(struct rcu_head *head, rcu_callback_t func)
 {
@@ -663,8 +722,13 @@ EXPORT_SYMBOL_GPL(call_rcu);
  * synchronize_rcu() was waiting.  RCU read-side critical sections are
  * delimited by rcu_read_lock() and rcu_read_unlock(), and may be nested.
  *
- * See the description of synchronize_sched() for more detailed information
- * on memory ordering guarantees.
+ * See the description of synchronize_sched() for more detailed
+ * information on memory-ordering guarantees.  However, please note
+ * that -only- the memory-ordering guarantees apply.  For example,
+ * synchronize_rcu() is -not- guaranteed to wait on things like code
+ * protected by preempt_disable(), instead, synchronize_rcu() is -only-
+ * guaranteed to wait on RCU read-side critical sections, that is, sections
+ * of code protected by rcu_read_lock().
  */
 void synchronize_rcu(void)
 {
@@ -738,7 +802,7 @@ static void __init rcu_bootup_announce(void)
  * Because preemptible RCU does not exist, we never have to check for
  * CPUs being in quiescent states.
  */
-static void rcu_preempt_note_context_switch(void)
+static void rcu_preempt_note_context_switch(bool preempt)
 {
 }
 
@@ -835,33 +899,6 @@ void exit_rcu(void)
 
 #include "../locking/rtmutex_common.h"
 
-#ifdef CONFIG_RCU_TRACE
-
-static void rcu_initiate_boost_trace(struct rcu_node *rnp)
-{
-        if (!rcu_preempt_has_tasks(rnp))
-                rnp->n_balk_blkd_tasks++;
-        else if (rnp->exp_tasks == NULL && rnp->gp_tasks == NULL)
-                rnp->n_balk_exp_gp_tasks++;
-        else if (rnp->gp_tasks != NULL && rnp->boost_tasks != NULL)
-                rnp->n_balk_boost_tasks++;
-        else if (rnp->gp_tasks != NULL && rnp->qsmask != 0)
-                rnp->n_balk_notblocked++;
-        else if (rnp->gp_tasks != NULL &&
-                 ULONG_CMP_LT(jiffies, rnp->boost_time))
-                rnp->n_balk_notyet++;
-        else
-                rnp->n_balk_nos++;
-}
-
-#else /* #ifdef CONFIG_RCU_TRACE */
-
-static void rcu_initiate_boost_trace(struct rcu_node *rnp)
-{
-}
-
-#endif /* #else #ifdef CONFIG_RCU_TRACE */
-
 static void rcu_wake_cond(struct task_struct *t, int status)
 {
         /*
@@ -992,8 +1029,8 @@ static void rcu_initiate_boost(struct rcu_node *rnp, unsigned long flags)
 {
         struct task_struct *t;
 
+        lockdep_assert_held(&rnp->lock);
         if (!rcu_preempt_blocked_readers_cgp(rnp) && rnp->exp_tasks == NULL) {
-                rnp->n_balk_exp_gp_tasks++;
                 raw_spin_unlock_irqrestore_rcu_node(rnp, flags);
                 return;
         }
@@ -1009,7 +1046,6 @@ static void rcu_initiate_boost(struct rcu_node *rnp, unsigned long flags)
                 if (t)
                         rcu_wake_cond(t, rnp->boost_kthread_status);
         } else {
-                rcu_initiate_boost_trace(rnp);
                 raw_spin_unlock_irqrestore_rcu_node(rnp, flags);
         }
 }
@@ -1260,8 +1296,7 @@ static void rcu_prepare_kthreads(int cpu)
 int rcu_needs_cpu(u64 basemono, u64 *nextevt)
 {
         *nextevt = KTIME_MAX;
-        return IS_ENABLED(CONFIG_RCU_NOCB_CPU_ALL)
-               ? 0 : rcu_cpu_has_callbacks(NULL);
+        return rcu_cpu_has_callbacks(NULL);
 }
 
 /*
@@ -1372,10 +1407,7 @@ int rcu_needs_cpu(u64 basemono, u64 *nextevt)
         struct rcu_dynticks *rdtp = this_cpu_ptr(&rcu_dynticks);
         unsigned long dj;
 
-        if (IS_ENABLED(CONFIG_RCU_NOCB_CPU_ALL)) {
-                *nextevt = KTIME_MAX;
-                return 0;
-        }
+        RCU_LOCKDEP_WARN(!irqs_disabled(), "rcu_needs_cpu() invoked with irqs enabled!!!");
 
         /* Snapshot to detect later posting of non-lazy callback. */
         rdtp->nonlazy_posted_snap = rdtp->nonlazy_posted;
@@ -1424,8 +1456,8 @@ static void rcu_prepare_for_idle(void)
         struct rcu_state *rsp;
         int tne;
 
-        if (IS_ENABLED(CONFIG_RCU_NOCB_CPU_ALL) ||
-            rcu_is_nocb_cpu(smp_processor_id()))
+        RCU_LOCKDEP_WARN(!irqs_disabled(), "rcu_prepare_for_idle() invoked with irqs enabled!!!");
+        if (rcu_is_nocb_cpu(smp_processor_id()))
                 return;
 
         /* Handle nohz enablement switches conservatively. */
@@ -1479,8 +1511,8 @@ static void rcu_prepare_for_idle(void)
  */
 static void rcu_cleanup_after_idle(void)
 {
-        if (IS_ENABLED(CONFIG_RCU_NOCB_CPU_ALL) ||
-            rcu_is_nocb_cpu(smp_processor_id()))
+        RCU_LOCKDEP_WARN(!irqs_disabled(), "rcu_cleanup_after_idle() invoked with irqs enabled!!!");
+        if (rcu_is_nocb_cpu(smp_processor_id()))
                 return;
         if (rcu_try_advance_all_cbs())
                 invoke_rcu_core();
@@ -1747,7 +1779,6 @@ static void rcu_init_one_nocb(struct rcu_node *rnp)
         init_swait_queue_head(&rnp->nocb_gp_wq[1]);
 }
 
-#ifndef CONFIG_RCU_NOCB_CPU_ALL
 /* Is the specified CPU a no-CBs CPU? */
 bool rcu_is_nocb_cpu(int cpu)
 {
@@ -1755,7 +1786,6 @@ bool rcu_is_nocb_cpu(int cpu)
                 return cpumask_test_cpu(cpu, rcu_nocb_mask);
         return false;
 }
-#endif /* #ifndef CONFIG_RCU_NOCB_CPU_ALL */
 
 /*
  * Kick the leader kthread for this NOCB group.
@@ -1769,6 +1799,7 @@ static void wake_nocb_leader(struct rcu_data *rdp, bool force)
         if (READ_ONCE(rdp_leader->nocb_leader_sleep) || force) {
                 /* Prior smp_mb__after_atomic() orders against prior enqueue. */
                 WRITE_ONCE(rdp_leader->nocb_leader_sleep, false);
+                smp_mb(); /* ->nocb_leader_sleep before swake_up(). */
                 swake_up(&rdp_leader->nocb_wq);
         }
 }
@@ -1860,7 +1891,7 @@ static void __call_rcu_nocb_enqueue(struct rcu_data *rdp,
                         trace_rcu_nocb_wake(rdp->rsp->name, rdp->cpu,
                                             TPS("WakeEmpty"));
                 } else {
-                        WRITE_ONCE(rdp->nocb_defer_wakeup, RCU_NOGP_WAKE);
+                        WRITE_ONCE(rdp->nocb_defer_wakeup, RCU_NOCB_WAKE);
                         /* Store ->nocb_defer_wakeup before ->rcu_urgent_qs. */
                         smp_store_release(this_cpu_ptr(&rcu_dynticks.rcu_urgent_qs), true);
                         trace_rcu_nocb_wake(rdp->rsp->name, rdp->cpu,
@@ -1874,7 +1905,7 @@ static void __call_rcu_nocb_enqueue(struct rcu_data *rdp,
                         trace_rcu_nocb_wake(rdp->rsp->name, rdp->cpu,
                                             TPS("WakeOvf"));
                 } else {
-                        WRITE_ONCE(rdp->nocb_defer_wakeup, RCU_NOGP_WAKE_FORCE);
+                        WRITE_ONCE(rdp->nocb_defer_wakeup, RCU_NOCB_WAKE_FORCE);
                         /* Store ->nocb_defer_wakeup before ->rcu_urgent_qs. */
                         smp_store_release(this_cpu_ptr(&rcu_dynticks.rcu_urgent_qs), true);
                         trace_rcu_nocb_wake(rdp->rsp->name, rdp->cpu,
@@ -2023,6 +2054,7 @@ wait_again:
          * nocb_gp_head, where they await a grace period.
          */
         gotcbs = false;
+        smp_mb(); /* wakeup before ->nocb_head reads. */
         for (rdp = my_rdp; rdp; rdp = rdp->nocb_next_follower) {
                 rdp->nocb_gp_head = READ_ONCE(rdp->nocb_head);
                 if (!rdp->nocb_gp_head)
@@ -2201,8 +2233,8 @@ static void do_nocb_deferred_wakeup(struct rcu_data *rdp)
         if (!rcu_nocb_need_deferred_wakeup(rdp))
                 return;
         ndw = READ_ONCE(rdp->nocb_defer_wakeup);
-        WRITE_ONCE(rdp->nocb_defer_wakeup, RCU_NOGP_WAKE_NOT);
-        wake_nocb_leader(rdp, ndw == RCU_NOGP_WAKE_FORCE);
+        WRITE_ONCE(rdp->nocb_defer_wakeup, RCU_NOCB_WAKE_NOT);
+        wake_nocb_leader(rdp, ndw == RCU_NOCB_WAKE_FORCE);
         trace_rcu_nocb_wake(rdp->rsp->name, rdp->cpu, TPS("DeferredWake"));
 }
 
@@ -2212,10 +2244,6 @@ void __init rcu_init_nohz(void)
         bool need_rcu_nocb_mask = true;
         struct rcu_state *rsp;
 
-#ifdef CONFIG_RCU_NOCB_CPU_NONE
-        need_rcu_nocb_mask = false;
-#endif /* #ifndef CONFIG_RCU_NOCB_CPU_NONE */
-
 #if defined(CONFIG_NO_HZ_FULL)
         if (tick_nohz_full_running && cpumask_weight(tick_nohz_full_mask))
                 need_rcu_nocb_mask = true;
@@ -2231,14 +2259,6 @@ void __init rcu_init_nohz(void)
         if (!have_rcu_nocb_mask)
                 return;
 
-#ifdef CONFIG_RCU_NOCB_CPU_ZERO
-        pr_info("\tOffload RCU callbacks from CPU 0\n");
-        cpumask_set_cpu(0, rcu_nocb_mask);
-#endif /* #ifdef CONFIG_RCU_NOCB_CPU_ZERO */
-#ifdef CONFIG_RCU_NOCB_CPU_ALL
-        pr_info("\tOffload RCU callbacks from all CPUs\n");
-        cpumask_copy(rcu_nocb_mask, cpu_possible_mask);
-#endif /* #ifdef CONFIG_RCU_NOCB_CPU_ALL */
 #if defined(CONFIG_NO_HZ_FULL)
         if (tick_nohz_full_running)
                 cpumask_or(rcu_nocb_mask, rcu_nocb_mask, tick_nohz_full_mask);
@@ -2491,421 +2511,6 @@ static void __maybe_unused rcu_kick_nohz_cpu(int cpu)
 #endif /* #ifdef CONFIG_NO_HZ_FULL */
 }
 
-
-#ifdef CONFIG_NO_HZ_FULL_SYSIDLE
-
-static int full_sysidle_state;          /* Current system-idle state. */
-#define RCU_SYSIDLE_NOT         0       /* Some CPU is not idle. */
-#define RCU_SYSIDLE_SHORT       1       /* All CPUs idle for brief period. */
-#define RCU_SYSIDLE_LONG        2       /* All CPUs idle for long enough. */
-#define RCU_SYSIDLE_FULL        3       /* All CPUs idle, ready for sysidle. */
-#define RCU_SYSIDLE_FULL_NOTED  4       /* Actually entered sysidle state. */
-
-/*
- * Invoked to note exit from irq or task transition to idle.  Note that
- * usermode execution does -not- count as idle here!  After all, we want
- * to detect full-system idle states, not RCU quiescent states and grace
- * periods.  The caller must have disabled interrupts.
- */
-static void rcu_sysidle_enter(int irq)
-{
-        unsigned long j;
-        struct rcu_dynticks *rdtp = this_cpu_ptr(&rcu_dynticks);
-
-        /* If there are no nohz_full= CPUs, no need to track this. */
-        if (!tick_nohz_full_enabled())
-                return;
-
-        /* Adjust nesting, check for fully idle. */
-        if (irq) {
-                rdtp->dynticks_idle_nesting--;
-                WARN_ON_ONCE(rdtp->dynticks_idle_nesting < 0);
-                if (rdtp->dynticks_idle_nesting != 0)
-                        return;  /* Still not fully idle. */
-        } else {
-                if ((rdtp->dynticks_idle_nesting & DYNTICK_TASK_NEST_MASK) ==
-                    DYNTICK_TASK_NEST_VALUE) {
-                        rdtp->dynticks_idle_nesting = 0;
-                } else {
-                        rdtp->dynticks_idle_nesting -= DYNTICK_TASK_NEST_VALUE;
-                        WARN_ON_ONCE(rdtp->dynticks_idle_nesting < 0);
-                        return;  /* Still not fully idle. */
-                }
-        }
-
-        /* Record start of fully idle period. */
-        j = jiffies;
-        WRITE_ONCE(rdtp->dynticks_idle_jiffies, j);
-        smp_mb__before_atomic();
-        atomic_inc(&rdtp->dynticks_idle);
-        smp_mb__after_atomic();
-        WARN_ON_ONCE(atomic_read(&rdtp->dynticks_idle) & 0x1);
-}
-
-/*
- * Unconditionally force exit from full system-idle state.  This is
- * invoked when a normal CPU exits idle, but must be called separately
- * for the timekeeping CPU (tick_do_timer_cpu).  The reason for this
- * is that the timekeeping CPU is permitted to take scheduling-clock
- * interrupts while the system is in system-idle state, and of course
- * rcu_sysidle_exit() has no way of distinguishing a scheduling-clock
- * interrupt from any other type of interrupt.
- */
-void rcu_sysidle_force_exit(void)
-{
-        int oldstate = READ_ONCE(full_sysidle_state);
-        int newoldstate;
-
-        /*
-         * Each pass through the following loop attempts to exit full
-         * system-idle state.  If contention proves to be a problem,
-         * a trylock-based contention tree could be used here.
-         */
-        while (oldstate > RCU_SYSIDLE_SHORT) {
-                newoldstate = cmpxchg(&full_sysidle_state,
-                                      oldstate, RCU_SYSIDLE_NOT);
-                if (oldstate == newoldstate &&
-                    oldstate == RCU_SYSIDLE_FULL_NOTED) {
-                        rcu_kick_nohz_cpu(tick_do_timer_cpu);
-                        return; /* We cleared it, done! */
-                }
-                oldstate = newoldstate;
-        }
-        smp_mb(); /* Order initial oldstate fetch vs. later non-idle work. */
-}
-
-/*
- * Invoked to note entry to irq or task transition from idle.  Note that
- * usermode execution does -not- count as idle here!  The caller must
- * have disabled interrupts.
- */
-static void rcu_sysidle_exit(int irq)
-{
-        struct rcu_dynticks *rdtp = this_cpu_ptr(&rcu_dynticks);
-
-        /* If there are no nohz_full= CPUs, no need to track this. */
-        if (!tick_nohz_full_enabled())
-                return;
-
-        /* Adjust nesting, check for already non-idle. */
-        if (irq) {
-                rdtp->dynticks_idle_nesting++;
-                WARN_ON_ONCE(rdtp->dynticks_idle_nesting <= 0);
-                if (rdtp->dynticks_idle_nesting != 1)
-                        return; /* Already non-idle. */
-        } else {
-                /*
-                 * Allow for irq misnesting.  Yes, it really is possible
-                 * to enter an irq handler then never leave it, and maybe
-                 * also vice versa.  Handle both possibilities.
-                 */
-                if (rdtp->dynticks_idle_nesting & DYNTICK_TASK_NEST_MASK) {
-                        rdtp->dynticks_idle_nesting += DYNTICK_TASK_NEST_VALUE;
-                        WARN_ON_ONCE(rdtp->dynticks_idle_nesting <= 0);
-                        return; /* Already non-idle. */
-                } else {
-                        rdtp->dynticks_idle_nesting = DYNTICK_TASK_EXIT_IDLE;
-                }
-        }
-
-        /* Record end of idle period. */
-        smp_mb__before_atomic();
-        atomic_inc(&rdtp->dynticks_idle);
-        smp_mb__after_atomic();
-        WARN_ON_ONCE(!(atomic_read(&rdtp->dynticks_idle) & 0x1));
-
-        /*
-         * If we are the timekeeping CPU, we are permitted to be non-idle
-         * during a system-idle state.  This must be the case, because
-         * the timekeeping CPU has to take scheduling-clock interrupts
-         * during the time that the system is transitioning to full
-         * system-idle state.  This means that the timekeeping CPU must
-         * invoke rcu_sysidle_force_exit() directly if it does anything
-         * more than take a scheduling-clock interrupt.
-         */
-        if (smp_processor_id() == tick_do_timer_cpu)
-                return;
-
-        /* Update system-idle state: We are clearly no longer fully idle! */
-        rcu_sysidle_force_exit();
-}
-
-/*
- * Check to see if the current CPU is idle.  Note that usermode execution
- * does not count as idle.  The caller must have disabled interrupts,
- * and must be running on tick_do_timer_cpu.
- */
-static void rcu_sysidle_check_cpu(struct rcu_data *rdp, bool *isidle,
-                                  unsigned long *maxj)
-{
-        int cur;
-        unsigned long j;
-        struct rcu_dynticks *rdtp = rdp->dynticks;
-
-        /* If there are no nohz_full= CPUs, don't check system-wide idleness. */
-        if (!tick_nohz_full_enabled())
-                return;
-
-        /*
-         * If some other CPU has already reported non-idle, if this is
-         * not the flavor of RCU that tracks sysidle state, or if this
-         * is an offline or the timekeeping CPU, nothing to do.
-         */
-        if (!*isidle || rdp->rsp != rcu_state_p ||
-            cpu_is_offline(rdp->cpu) || rdp->cpu == tick_do_timer_cpu)
-                return;
-        /* Verify affinity of current kthread. */
-        WARN_ON_ONCE(smp_processor_id() != tick_do_timer_cpu);
-
-        /* Pick up current idle and NMI-nesting counter and check. */
-        cur = atomic_read(&rdtp->dynticks_idle);
-        if (cur & 0x1) {
-                *isidle = false; /* We are not idle! */
-                return;
-        }
-        smp_mb(); /* Read counters before timestamps. */
-
-        /* Pick up timestamps. */
-        j = READ_ONCE(rdtp->dynticks_idle_jiffies);
-        /* If this CPU entered idle more recently, update maxj timestamp. */
-        if (ULONG_CMP_LT(*maxj, j))
-                *maxj = j;
-}
-
-/*
- * Is this the flavor of RCU that is handling full-system idle?
- */
-static bool is_sysidle_rcu_state(struct rcu_state *rsp)
-{
-        return rsp == rcu_state_p;
-}
-
-/*
- * Return a delay in jiffies based on the number of CPUs, rcu_node
- * leaf fanout, and jiffies tick rate.  The idea is to allow larger
- * systems more time to transition to full-idle state in order to
- * avoid the cache thrashing that otherwise occur on the state variable.
- * Really small systems (less than a couple of tens of CPUs) should
- * instead use a single global atomically incremented counter, and later
- * versions of this will automatically reconfigure themselves accordingly.
- */
-static unsigned long rcu_sysidle_delay(void)
-{
-        if (nr_cpu_ids <= CONFIG_NO_HZ_FULL_SYSIDLE_SMALL)
-                return 0;
-        return DIV_ROUND_UP(nr_cpu_ids * HZ, rcu_fanout_leaf * 1000);
-}
-
-/*
- * Advance the full-system-idle state.  This is invoked when all of
- * the non-timekeeping CPUs are idle.
- */
-static void rcu_sysidle(unsigned long j)
-{
-        /* Check the current state. */
-        switch (READ_ONCE(full_sysidle_state)) {
-        case RCU_SYSIDLE_NOT:
-
-                /* First time all are idle, so note a short idle period. */
-                WRITE_ONCE(full_sysidle_state, RCU_SYSIDLE_SHORT);
-                break;
-
-        case RCU_SYSIDLE_SHORT:
-
-                /*
-                 * Idle for a bit, time to advance to next state?
-                 * cmpxchg failure means race with non-idle, let them win.
-                 */
-                if (ULONG_CMP_GE(jiffies, j + rcu_sysidle_delay()))
-                        (void)cmpxchg(&full_sysidle_state,
-                                      RCU_SYSIDLE_SHORT, RCU_SYSIDLE_LONG);
-                break;
-
-        case RCU_SYSIDLE_LONG:
-
-                /*
-                 * Do an additional check pass before advancing to full.
-                 * cmpxchg failure means race with non-idle, let them win.
-                 */
-                if (ULONG_CMP_GE(jiffies, j + rcu_sysidle_delay()))
-                        (void)cmpxchg(&full_sysidle_state,
-                                      RCU_SYSIDLE_LONG, RCU_SYSIDLE_FULL);
-                break;
-
-        default:
-                break;
-        }
-}
-
-/*
- * Found a non-idle non-timekeeping CPU, so kick the system-idle state
- * back to the beginning.
- */
-static void rcu_sysidle_cancel(void)
-{
-        smp_mb();
-        if (full_sysidle_state > RCU_SYSIDLE_SHORT)
-                WRITE_ONCE(full_sysidle_state, RCU_SYSIDLE_NOT);
-}
-
-/*
- * Update the sysidle state based on the results of a force-quiescent-state
- * scan of the CPUs' dyntick-idle state.
- */
-static void rcu_sysidle_report(struct rcu_state *rsp, int isidle,
-                               unsigned long maxj, bool gpkt)
-{
-        if (rsp != rcu_state_p)
-                return;  /* Wrong flavor, ignore. */
-        if (gpkt && nr_cpu_ids <= CONFIG_NO_HZ_FULL_SYSIDLE_SMALL)
-                return;  /* Running state machine from timekeeping CPU. */
-        if (isidle)
-                rcu_sysidle(maxj);    /* More idle! */
-        else
-                rcu_sysidle_cancel(); /* Idle is over. */
-}
-
-/*
- * Wrapper for rcu_sysidle_report() when called from the grace-period
- * kthread's context.
- */
-static void rcu_sysidle_report_gp(struct rcu_state *rsp, int isidle,
-                                  unsigned long maxj)
-{
-        /* If there are no nohz_full= CPUs, no need to track this. */
-        if (!tick_nohz_full_enabled())
-                return;
-
-        rcu_sysidle_report(rsp, isidle, maxj, true);
-}
-
-/* Callback and function for forcing an RCU grace period. */
-struct rcu_sysidle_head {
-        struct rcu_head rh;
-        int inuse;
-};
-
-static void rcu_sysidle_cb(struct rcu_head *rhp)
-{
-        struct rcu_sysidle_head *rshp;
-
-        /*
-         * The following memory barrier is needed to replace the
-         * memory barriers that would normally be in the memory
-         * allocator.
-         */
-        smp_mb();  /* grace period precedes setting inuse. */
-
-        rshp = container_of(rhp, struct rcu_sysidle_head, rh);
-        WRITE_ONCE(rshp->inuse, 0);
-}
-
-/*
- * Check to see if the system is fully idle, other than the timekeeping CPU.
- * The caller must have disabled interrupts.  This is not intended to be
- * called unless tick_nohz_full_enabled().
- */
-bool rcu_sys_is_idle(void)
-{
-        static struct rcu_sysidle_head rsh;
-        int rss = READ_ONCE(full_sysidle_state);
-
-        if (WARN_ON_ONCE(smp_processor_id() != tick_do_timer_cpu))
-                return false;
-
-        /* Handle small-system case by doing a full scan of CPUs. */
-        if (nr_cpu_ids <= CONFIG_NO_HZ_FULL_SYSIDLE_SMALL) {
-                int oldrss = rss - 1;
-
-                /*
-                 * One pass to advance to each state up to _FULL.
-                 * Give up if any pass fails to advance the state.
-                 */
-                while (rss < RCU_SYSIDLE_FULL && oldrss < rss) {
-                        int cpu;
-                        bool isidle = true;
-                        unsigned long maxj = jiffies - ULONG_MAX / 4;
-                        struct rcu_data *rdp;
-
-                        /* Scan all the CPUs looking for nonidle CPUs. */
-                        for_each_possible_cpu(cpu) {
-                                rdp = per_cpu_ptr(rcu_state_p->rda, cpu);
-                                rcu_sysidle_check_cpu(rdp, &isidle, &maxj);
-                                if (!isidle)
-                                        break;
-                        }
-                        rcu_sysidle_report(rcu_state_p, isidle, maxj, false);
-                        oldrss = rss;
-                        rss = READ_ONCE(full_sysidle_state);
-                }
-        }
-
-        /* If this is the first observation of an idle period, record it. */
-        if (rss == RCU_SYSIDLE_FULL) {
-                rss = cmpxchg(&full_sysidle_state,
-                              RCU_SYSIDLE_FULL, RCU_SYSIDLE_FULL_NOTED);
-                return rss == RCU_SYSIDLE_FULL;
-        }
-
-        smp_mb(); /* ensure rss load happens before later caller actions. */
-
-        /* If already fully idle, tell the caller (in case of races). */
-        if (rss == RCU_SYSIDLE_FULL_NOTED)
-                return true;
-
-        /*
-         * If we aren't there yet, and a grace period is not in flight,
-         * initiate a grace period.  Either way, tell the caller that
-         * we are not there yet.  We use an xchg() rather than an assignment
-         * to make up for the memory barriers that would otherwise be
-         * provided by the memory allocator.
-         */
-        if (nr_cpu_ids > CONFIG_NO_HZ_FULL_SYSIDLE_SMALL &&
-            !rcu_gp_in_progress(rcu_state_p) &&
-            !rsh.inuse && xchg(&rsh.inuse, 1) == 0)
-                call_rcu(&rsh.rh, rcu_sysidle_cb);
-        return false;
-}
-
-/*
- * Initialize dynticks sysidle state for CPUs coming online.
- */
-static void rcu_sysidle_init_percpu_data(struct rcu_dynticks *rdtp)
-{
-        rdtp->dynticks_idle_nesting = DYNTICK_TASK_NEST_VALUE;
-}
-
-#else /* #ifdef CONFIG_NO_HZ_FULL_SYSIDLE */
-
-static void rcu_sysidle_enter(int irq)
-{
-}
-
-static void rcu_sysidle_exit(int irq)
-{
-}
-
-static void rcu_sysidle_check_cpu(struct rcu_data *rdp, bool *isidle,
-                                  unsigned long *maxj)
-{
-}
-
-static bool is_sysidle_rcu_state(struct rcu_state *rsp)
-{
-        return false;
-}
-
-static void rcu_sysidle_report_gp(struct rcu_state *rsp, int isidle,
-                                  unsigned long maxj)
-{
-}
-
-static void rcu_sysidle_init_percpu_data(struct rcu_dynticks *rdtp)
-{
-}
-
-#endif /* #else #ifdef CONFIG_NO_HZ_FULL_SYSIDLE */
-
 /*
  * Is this CPU a NO_HZ_FULL CPU that should ignore RCU so that the
  * grace-period kthread will do force_quiescent_state() processing?
@@ -2936,13 +2541,7 @@ static void rcu_bind_gp_kthread(void)
 
         if (!tick_nohz_full_enabled())
                 return;
-#ifdef CONFIG_NO_HZ_FULL_SYSIDLE
-        cpu = tick_do_timer_cpu;
-        if (cpu >= 0 && cpu < nr_cpu_ids)
-                set_cpus_allowed_ptr(current, cpumask_of(cpu));
-#else /* #ifdef CONFIG_NO_HZ_FULL_SYSIDLE */
         housekeeping_affine(current);
-#endif /* #else #ifdef CONFIG_NO_HZ_FULL_SYSIDLE */
 }
 
 /* Record the current task on dyntick-idle entry. */
diff --git a/kernel/rcu/tree_trace.c b/kernel/rcu/tree_trace.c
deleted file mode 100644
index 6cea17a1ea30..000000000000
--- a/kernel/rcu/tree_trace.c
+++ /dev/null
@@ -1,494 +0,0 @@
-/*
- * Read-Copy Update tracing for hierarchical implementation.
- *
- * 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, you can access it online at
- * http://www.gnu.org/licenses/gpl-2.0.html.
- *
- * Copyright IBM Corporation, 2008
- * Author: Paul E. McKenney
- *
- * Papers:  http://www.rdrop.com/users/paulmck/RCU
- *
- * For detailed explanation of Read-Copy Update mechanism see -
- *              Documentation/RCU
- *
- */
-#include <linux/types.h>
-#include <linux/kernel.h>
-#include <linux/init.h>
-#include <linux/spinlock.h>
-#include <linux/smp.h>
-#include <linux/rcupdate.h>
-#include <linux/interrupt.h>
-#include <linux/sched.h>
-#include <linux/atomic.h>
-#include <linux/bitops.h>
-#include <linux/completion.h>
-#include <linux/percpu.h>
-#include <linux/notifier.h>
-#include <linux/cpu.h>
-#include <linux/mutex.h>
-#include <linux/debugfs.h>
-#include <linux/seq_file.h>
-#include <linux/prefetch.h>
-
-#define RCU_TREE_NONCORE
-#include "tree.h"
-#include "rcu.h"
-
-static int r_open(struct inode *inode, struct file *file,
-                                        const struct seq_operations *op)
-{
-        int ret = seq_open(file, op);
-        if (!ret) {
-                struct seq_file *m = (struct seq_file *)file->private_data;
-                m->private = inode->i_private;
-        }
-        return ret;
-}
-
-static void *r_start(struct seq_file *m, loff_t *pos)
-{
-        struct rcu_state *rsp = (struct rcu_state *)m->private;
-        *pos = cpumask_next(*pos - 1, cpu_possible_mask);
-        if ((*pos) < nr_cpu_ids)
-                return per_cpu_ptr(rsp->rda, *pos);
-        return NULL;
-}
-
-static void *r_next(struct seq_file *m, void *v, loff_t *pos)
-{
-        (*pos)++;
-        return r_start(m, pos);
-}
-
-static void r_stop(struct seq_file *m, void *v)
-{
-}
-
-static int show_rcubarrier(struct seq_file *m, void *v)
-{
-        struct rcu_state *rsp = (struct rcu_state *)m->private;
-        seq_printf(m, "bcc: %d bseq: %lu\n",
-                   atomic_read(&rsp->barrier_cpu_count),
-                   rsp->barrier_sequence);
-        return 0;
-}
-
-static int rcubarrier_open(struct inode *inode, struct file *file)
-{
-        return single_open(file, show_rcubarrier, inode->i_private);
-}
-
-static const struct file_operations rcubarrier_fops = {
-        .owner = THIS_MODULE,
-        .open = rcubarrier_open,
-        .read = seq_read,
-        .llseek = no_llseek,
-        .release = single_release,
-};
-
-#ifdef CONFIG_RCU_BOOST
-
-static char convert_kthread_status(unsigned int kthread_status)
-{
-        if (kthread_status > RCU_KTHREAD_MAX)
-                return '?';
-        return "SRWOY"[kthread_status];
-}
-
-#endif /* #ifdef CONFIG_RCU_BOOST */
-
-static void print_one_rcu_data(struct seq_file *m, struct rcu_data *rdp)
-{
-        long ql, qll;
-
-        if (!rdp->beenonline)
-                return;
-        seq_printf(m, "%3d%cc=%ld g=%ld cnq=%d/%d:%d",
-                   rdp->cpu,
-                   cpu_is_offline(rdp->cpu) ? '!' : ' ',
-                   ulong2long(rdp->completed), ulong2long(rdp->gpnum),
-                   rdp->cpu_no_qs.b.norm,
-                   rdp->rcu_qs_ctr_snap == per_cpu(rdp->dynticks->rcu_qs_ctr, rdp->cpu),
-                   rdp->core_needs_qs);
-        seq_printf(m, " dt=%d/%llx/%d df=%lu",
-                   rcu_dynticks_snap(rdp->dynticks),
-                   rdp->dynticks->dynticks_nesting,
-                   rdp->dynticks->dynticks_nmi_nesting,
-                   rdp->dynticks_fqs);
-        seq_printf(m, " of=%lu", rdp->offline_fqs);
-        rcu_nocb_q_lengths(rdp, &ql, &qll);
-        qll += rcu_segcblist_n_lazy_cbs(&rdp->cblist);
-        ql += rcu_segcblist_n_cbs(&rdp->cblist);
-        seq_printf(m, " ql=%ld/%ld qs=%c%c%c%c",
-                   qll, ql,
-                   ".N"[!rcu_segcblist_segempty(&rdp->cblist, RCU_NEXT_TAIL)],
-                   ".R"[!rcu_segcblist_segempty(&rdp->cblist,
-                                                RCU_NEXT_READY_TAIL)],
-                   ".W"[!rcu_segcblist_segempty(&rdp->cblist, RCU_WAIT_TAIL)],
-                   ".D"[!rcu_segcblist_segempty(&rdp->cblist, RCU_DONE_TAIL)]);
-#ifdef CONFIG_RCU_BOOST
-        seq_printf(m, " kt=%d/%c ktl=%x",
-                   per_cpu(rcu_cpu_has_work, rdp->cpu),
-                   convert_kthread_status(per_cpu(rcu_cpu_kthread_status,
-                                          rdp->cpu)),
-                   per_cpu(rcu_cpu_kthread_loops, rdp->cpu) & 0xffff);
-#endif /* #ifdef CONFIG_RCU_BOOST */
-        seq_printf(m, " b=%ld", rdp->blimit);
-        seq_printf(m, " ci=%lu nci=%lu co=%lu ca=%lu\n",
-                   rdp->n_cbs_invoked, rdp->n_nocbs_invoked,
-                   rdp->n_cbs_orphaned, rdp->n_cbs_adopted);
-}
-
-static int show_rcudata(struct seq_file *m, void *v)
-{
-        print_one_rcu_data(m, (struct rcu_data *)v);
-        return 0;
-}
-
-static const struct seq_operations rcudate_op = {
-        .start = r_start,
-        .next  = r_next,
-        .stop  = r_stop,
-        .show  = show_rcudata,
-};
-
-static int rcudata_open(struct inode *inode, struct file *file)
-{
-        return r_open(inode, file, &rcudate_op);
-}
-
-static const struct file_operations rcudata_fops = {
-        .owner = THIS_MODULE,
-        .open = rcudata_open,
-        .read = seq_read,
-        .llseek = no_llseek,
-        .release = seq_release,
-};
-
-static int show_rcuexp(struct seq_file *m, void *v)
-{
-        int cpu;
-        struct rcu_state *rsp = (struct rcu_state *)m->private;
-        struct rcu_data *rdp;
-        unsigned long s0 = 0, s1 = 0, s2 = 0, s3 = 0;
-
-        for_each_possible_cpu(cpu) {
-                rdp = per_cpu_ptr(rsp->rda, cpu);
-                s0 += atomic_long_read(&rdp->exp_workdone0);
-                s1 += atomic_long_read(&rdp->exp_workdone1);
-                s2 += atomic_long_read(&rdp->exp_workdone2);
-                s3 += atomic_long_read(&rdp->exp_workdone3);
-        }
-        seq_printf(m, "s=%lu wd0=%lu wd1=%lu wd2=%lu wd3=%lu enq=%d sc=%lu\n",
-                   rsp->expedited_sequence, s0, s1, s2, s3,
-                   atomic_read(&rsp->expedited_need_qs),
-                   rsp->expedited_sequence / 2);
-        return 0;
-}
-
-static int rcuexp_open(struct inode *inode, struct file *file)
-{
-        return single_open(file, show_rcuexp, inode->i_private);
-}
-
-static const struct file_operations rcuexp_fops = {
-        .owner = THIS_MODULE,
-        .open = rcuexp_open,
-        .read = seq_read,
-        .llseek = no_llseek,
-        .release = single_release,
-};
-
-#ifdef CONFIG_RCU_BOOST
-
-static void print_one_rcu_node_boost(struct seq_file *m, struct rcu_node *rnp)
-{
-        seq_printf(m, "%d:%d tasks=%c%c%c%c kt=%c ntb=%lu neb=%lu nnb=%lu ",
-                   rnp->grplo, rnp->grphi,
-                   "T."[list_empty(&rnp->blkd_tasks)],
-                   "N."[!rnp->gp_tasks],
-                   "E."[!rnp->exp_tasks],
-                   "B."[!rnp->boost_tasks],
-                   convert_kthread_status(rnp->boost_kthread_status),
-                   rnp->n_tasks_boosted, rnp->n_exp_boosts,
-                   rnp->n_normal_boosts);
-        seq_printf(m, "j=%04x bt=%04x\n",
-                   (int)(jiffies & 0xffff),
-                   (int)(rnp->boost_time & 0xffff));
-        seq_printf(m, "    balk: nt=%lu egt=%lu bt=%lu nb=%lu ny=%lu nos=%lu\n",
-                   rnp->n_balk_blkd_tasks,
-                   rnp->n_balk_exp_gp_tasks,
-                   rnp->n_balk_boost_tasks,
-                   rnp->n_balk_notblocked,
-                   rnp->n_balk_notyet,
-                   rnp->n_balk_nos);
-}
-
-static int show_rcu_node_boost(struct seq_file *m, void *unused)
-{
-        struct rcu_node *rnp;
-
-        rcu_for_each_leaf_node(&rcu_preempt_state, rnp)
-                print_one_rcu_node_boost(m, rnp);
-        return 0;
-}
-
-static int rcu_node_boost_open(struct inode *inode, struct file *file)
-{
-        return single_open(file, show_rcu_node_boost, NULL);
-}
-
-static const struct file_operations rcu_node_boost_fops = {
-        .owner = THIS_MODULE,
-        .open = rcu_node_boost_open,
-        .read = seq_read,
-        .llseek = no_llseek,
-        .release = single_release,
-};
-
-#endif /* #ifdef CONFIG_RCU_BOOST */
-
-static void print_one_rcu_state(struct seq_file *m, struct rcu_state *rsp)
-{
-        unsigned long gpnum;
-        int level = 0;
-        struct rcu_node *rnp;
-
-        gpnum = rsp->gpnum;
-        seq_printf(m, "c=%ld g=%ld s=%d jfq=%ld j=%x ",
-                   ulong2long(rsp->completed), ulong2long(gpnum),
-                   rsp->gp_state,
-                   (long)(rsp->jiffies_force_qs - jiffies),
-                   (int)(jiffies & 0xffff));
-        seq_printf(m, "nfqs=%lu/nfqsng=%lu(%lu) fqlh=%lu oqlen=%ld/%ld\n",
-                   rsp->n_force_qs, rsp->n_force_qs_ngp,
-                   rsp->n_force_qs - rsp->n_force_qs_ngp,
-                   READ_ONCE(rsp->n_force_qs_lh),
-                   rsp->orphan_done.len_lazy,
-                   rsp->orphan_done.len);
-        for (rnp = &rsp->node[0]; rnp - &rsp->node[0] < rcu_num_nodes; rnp++) {
-                if (rnp->level != level) {
-                        seq_puts(m, "\n");
-                        level = rnp->level;
-                }
-                seq_printf(m, "%lx/%lx->%lx %c%c>%c %d:%d ^%d    ",
-                           rnp->qsmask, rnp->qsmaskinit, rnp->qsmaskinitnext,
-                           ".G"[rnp->gp_tasks != NULL],
-                           ".E"[rnp->exp_tasks != NULL],
-                           ".T"[!list_empty(&rnp->blkd_tasks)],
-                           rnp->grplo, rnp->grphi, rnp->grpnum);
-        }
-        seq_puts(m, "\n");
-}
-
-static int show_rcuhier(struct seq_file *m, void *v)
-{
-        struct rcu_state *rsp = (struct rcu_state *)m->private;
-        print_one_rcu_state(m, rsp);
-        return 0;
-}
-
-static int rcuhier_open(struct inode *inode, struct file *file)
-{
-        return single_open(file, show_rcuhier, inode->i_private);
-}
-
-static const struct file_operations rcuhier_fops = {
-        .owner = THIS_MODULE,
-        .open = rcuhier_open,
-        .read = seq_read,
-        .llseek = no_llseek,
-        .release = single_release,
-};
-
-static void show_one_rcugp(struct seq_file *m, struct rcu_state *rsp)
-{
-        unsigned long flags;
-        unsigned long completed;
-        unsigned long gpnum;
-        unsigned long gpage;
-        unsigned long gpmax;
-        struct rcu_node *rnp = &rsp->node[0];
-
-        raw_spin_lock_irqsave_rcu_node(rnp, flags);
-        completed = READ_ONCE(rsp->completed);
-        gpnum = READ_ONCE(rsp->gpnum);
-        if (completed == gpnum)
-                gpage = 0;
-        else
-                gpage = jiffies - rsp->gp_start;
-        gpmax = rsp->gp_max;
-        raw_spin_unlock_irqrestore(&rnp->lock, flags);
-        seq_printf(m, "completed=%ld  gpnum=%ld  age=%ld  max=%ld\n",
-                   ulong2long(completed), ulong2long(gpnum), gpage, gpmax);
-}
-
-static int show_rcugp(struct seq_file *m, void *v)
-{
-        struct rcu_state *rsp = (struct rcu_state *)m->private;
-        show_one_rcugp(m, rsp);
-        return 0;
-}
-
-static int rcugp_open(struct inode *inode, struct file *file)
-{
-        return single_open(file, show_rcugp, inode->i_private);
-}
-
-static const struct file_operations rcugp_fops = {
-        .owner = THIS_MODULE,
-        .open = rcugp_open,
-        .read = seq_read,
-        .llseek = no_llseek,
-        .release = single_release,
-};
-
-static void print_one_rcu_pending(struct seq_file *m, struct rcu_data *rdp)
-{
-        if (!rdp->beenonline)
-                return;
-        seq_printf(m, "%3d%cnp=%ld ",
-                   rdp->cpu,
-                   cpu_is_offline(rdp->cpu) ? '!' : ' ',
-                   rdp->n_rcu_pending);
-        seq_printf(m, "qsp=%ld rpq=%ld cbr=%ld cng=%ld ",
-                   rdp->n_rp_core_needs_qs,
-                   rdp->n_rp_report_qs,
-                   rdp->n_rp_cb_ready,
-                   rdp->n_rp_cpu_needs_gp);
-        seq_printf(m, "gpc=%ld gps=%ld nn=%ld ndw%ld\n",
-                   rdp->n_rp_gp_completed,
-                   rdp->n_rp_gp_started,
-                   rdp->n_rp_nocb_defer_wakeup,
-                   rdp->n_rp_need_nothing);
-}
-
-static int show_rcu_pending(struct seq_file *m, void *v)
-{
-        print_one_rcu_pending(m, (struct rcu_data *)v);
-        return 0;
-}
-
-static const struct seq_operations rcu_pending_op = {
-        .start = r_start,
-        .next  = r_next,
-        .stop  = r_stop,
-        .show  = show_rcu_pending,
-};
-
-static int rcu_pending_open(struct inode *inode, struct file *file)
-{
-        return r_open(inode, file, &rcu_pending_op);
-}
-
-static const struct file_operations rcu_pending_fops = {
-        .owner = THIS_MODULE,
-        .open = rcu_pending_open,
-        .read = seq_read,
-        .llseek = no_llseek,
-        .release = seq_release,
-};
-
-static int show_rcutorture(struct seq_file *m, void *unused)
-{
-        seq_printf(m, "rcutorture test sequence: %lu %s\n",
-                   rcutorture_testseq >> 1,
-                   (rcutorture_testseq & 0x1) ? "(test in progress)" : "");
-        seq_printf(m, "rcutorture update version number: %lu\n",
-                   rcutorture_vernum);
-        return 0;
-}
-
-static int rcutorture_open(struct inode *inode, struct file *file)
-{
-        return single_open(file, show_rcutorture, NULL);
-}
-
-static const struct file_operations rcutorture_fops = {
-        .owner = THIS_MODULE,
-        .open = rcutorture_open,
-        .read = seq_read,
-        .llseek = seq_lseek,
-        .release = single_release,
-};
-
-static struct dentry *rcudir;
-
-static int __init rcutree_trace_init(void)
-{
-        struct rcu_state *rsp;
-        struct dentry *retval;
-        struct dentry *rspdir;
-
-        rcudir = debugfs_create_dir("rcu", NULL);
-        if (!rcudir)
-                goto free_out;
-
-        for_each_rcu_flavor(rsp) {
-                rspdir = debugfs_create_dir(rsp->name, rcudir);
-                if (!rspdir)
-                        goto free_out;
-
-                retval = debugfs_create_file("rcudata", 0444,
-                                rspdir, rsp, &rcudata_fops);
-                if (!retval)
-                        goto free_out;
-
-                retval = debugfs_create_file("rcuexp", 0444,
-                                rspdir, rsp, &rcuexp_fops);
-                if (!retval)
-                        goto free_out;
-
-                retval = debugfs_create_file("rcu_pending", 0444,
-                                rspdir, rsp, &rcu_pending_fops);
-                if (!retval)
-                        goto free_out;
-
-                retval = debugfs_create_file("rcubarrier", 0444,
-                                rspdir, rsp, &rcubarrier_fops);
-                if (!retval)
-                        goto free_out;
-
-#ifdef CONFIG_RCU_BOOST
-                if (rsp == &rcu_preempt_state) {
-                        retval = debugfs_create_file("rcuboost", 0444,
-                                rspdir, NULL, &rcu_node_boost_fops);
-                        if (!retval)
-                                goto free_out;
-                }
-#endif
-
-                retval = debugfs_create_file("rcugp", 0444,
-                                rspdir, rsp, &rcugp_fops);
-                if (!retval)
-                        goto free_out;
-
-                retval = debugfs_create_file("rcuhier", 0444,
-                                rspdir, rsp, &rcuhier_fops);
-                if (!retval)
-                        goto free_out;
-        }
-
-        retval = debugfs_create_file("rcutorture", 0444, rcudir,
-                                                NULL, &rcutorture_fops);
-        if (!retval)
-                goto free_out;
-        return 0;
-free_out:
-        debugfs_remove_recursive(rcudir);
-        return 1;
-}
-device_initcall(rcutree_trace_init);
diff --git a/kernel/rcu/update.c b/kernel/rcu/update.c
index 273e869ca21d..00e77c470017 100644
--- a/kernel/rcu/update.c
+++ b/kernel/rcu/update.c
@@ -62,7 +62,9 @@
 #define MODULE_PARAM_PREFIX "rcupdate."
 
 #ifndef CONFIG_TINY_RCU
+extern int rcu_expedited; /* from sysctl */
 module_param(rcu_expedited, int, 0);
+extern int rcu_normal; /* from sysctl */
 module_param(rcu_normal, int, 0);
 static int rcu_normal_after_boot;
 module_param(rcu_normal_after_boot, int, 0);
@@ -379,6 +381,7 @@ void __wait_rcu_gp(bool checktiny, int n, call_rcu_func_t *crcu_array,
                    struct rcu_synchronize *rs_array)
 {
         int i;
+        int j;
 
         /* Initialize and register callbacks for each flavor specified. */
         for (i = 0; i < n; i++) {
@@ -390,7 +393,11 @@ void __wait_rcu_gp(bool checktiny, int n, call_rcu_func_t *crcu_array,
                 }
                 init_rcu_head_on_stack(&rs_array[i].head);
                 init_completion(&rs_array[i].completion);
-                (crcu_array[i])(&rs_array[i].head, wakeme_after_rcu);
+                for (j = 0; j < i; j++)
+                        if (crcu_array[j] == crcu_array[i])
+                                break;
+                if (j == i)
+                        (crcu_array[i])(&rs_array[i].head, wakeme_after_rcu);
         }
 
         /* Wait for all callbacks to be invoked. */
@@ -399,7 +406,11 @@ void __wait_rcu_gp(bool checktiny, int n, call_rcu_func_t *crcu_array,
                     (crcu_array[i] == call_rcu ||
                      crcu_array[i] == call_rcu_bh))
                         continue;
-                wait_for_completion(&rs_array[i].completion);
+                for (j = 0; j < i; j++)
+                        if (crcu_array[j] == crcu_array[i])
+                                break;
+                if (j == i)
+                        wait_for_completion(&rs_array[i].completion);
                 destroy_rcu_head_on_stack(&rs_array[i].head);
         }
 }
@@ -560,15 +571,30 @@ static DEFINE_RAW_SPINLOCK(rcu_tasks_cbs_lock);
 DEFINE_SRCU(tasks_rcu_exit_srcu);
 
 /* Control stall timeouts.  Disable with <= 0, otherwise jiffies till stall. */
-static int rcu_task_stall_timeout __read_mostly = HZ * 60 * 10;
+#define RCU_TASK_STALL_TIMEOUT (HZ * 60 * 10)
+static int rcu_task_stall_timeout __read_mostly = RCU_TASK_STALL_TIMEOUT;
 module_param(rcu_task_stall_timeout, int, 0644);
 
 static void rcu_spawn_tasks_kthread(void);
 static struct task_struct *rcu_tasks_kthread_ptr;
 
-/*
- * Post an RCU-tasks callback.  First call must be from process context
- * after the scheduler if fully operational.
+/**
+ * call_rcu_tasks() - Queue an RCU for invocation task-based grace period
+ * @rhp: structure to be used for queueing the RCU updates.
+ * @func: actual callback function to be invoked after the grace period
+ *
+ * The callback function will be invoked some time after a full grace
+ * period elapses, in other words after all currently executing RCU
+ * read-side critical sections have completed. call_rcu_tasks() assumes
+ * that the read-side critical sections end at a voluntary context
+ * switch (not a preemption!), entry into idle, or transition to usermode
+ * execution.  As such, there are no read-side primitives analogous to
+ * rcu_read_lock() and rcu_read_unlock() because this primitive is intended
+ * to determine that all tasks have passed through a safe state, not so
+ * much for data-strcuture synchronization.
+ *
+ * See the description of call_rcu() for more detailed information on
+ * memory ordering guarantees.
  */
 void call_rcu_tasks(struct rcu_head *rhp, rcu_callback_t func)
 {
@@ -851,6 +877,23 @@ static void rcu_spawn_tasks_kthread(void)
 
 #endif /* #ifdef CONFIG_TASKS_RCU */
 
+#ifndef CONFIG_TINY_RCU
+
+/*
+ * Print any non-default Tasks RCU settings.
+ */
+static void __init rcu_tasks_bootup_oddness(void)
+{
+#ifdef CONFIG_TASKS_RCU
+        if (rcu_task_stall_timeout != RCU_TASK_STALL_TIMEOUT)
+                pr_info("\tTasks-RCU CPU stall warnings timeout set to %d (rcu_task_stall_timeout).\n", rcu_task_stall_timeout);
+        else
+                pr_info("\tTasks RCU enabled.\n");
+#endif /* #ifdef CONFIG_TASKS_RCU */
+}
+
+#endif /* #ifndef CONFIG_TINY_RCU */
+
 #ifdef CONFIG_PROVE_RCU
 
 /*
@@ -935,3 +978,25 @@ late_initcall(rcu_verify_early_boot_tests);
 #else
 void rcu_early_boot_tests(void) {}
 #endif /* CONFIG_PROVE_RCU */
+
+#ifndef CONFIG_TINY_RCU
+
+/*
+ * Print any significant non-default boot-time settings.
+ */
+void __init rcupdate_announce_bootup_oddness(void)
+{
+        if (rcu_normal)
+                pr_info("\tNo expedited grace period (rcu_normal).\n");
+        else if (rcu_normal_after_boot)
+                pr_info("\tNo expedited grace period (rcu_normal_after_boot).\n");
+        else if (rcu_expedited)
+                pr_info("\tAll grace periods are expedited (rcu_expedited).\n");
+        if (rcu_cpu_stall_suppress)
+                pr_info("\tRCU CPU stall warnings suppressed (rcu_cpu_stall_suppress).\n");
+        if (rcu_cpu_stall_timeout != CONFIG_RCU_CPU_STALL_TIMEOUT)
+                pr_info("\tRCU CPU stall warnings timeout set to %d (rcu_cpu_stall_timeout).\n", rcu_cpu_stall_timeout);
+        rcu_tasks_bootup_oddness();
+}
+
+#endif /* #ifndef CONFIG_TINY_RCU */
diff --git a/kernel/sched/Makefile b/kernel/sched/Makefile
index 89ab6758667b..53f0164ed362 100644
--- a/kernel/sched/Makefile
+++ b/kernel/sched/Makefile
@@ -16,9 +16,9 @@ CFLAGS_core.o := $(PROFILING) -fno-omit-frame-pointer
 endif
 
 obj-y += core.o loadavg.o clock.o cputime.o
-obj-y += idle_task.o fair.o rt.o deadline.o stop_task.o
-obj-y += wait.o swait.o completion.o idle.o
-obj-$(CONFIG_SMP) += cpupri.o cpudeadline.o topology.o
+obj-y += idle_task.o fair.o rt.o deadline.o
+obj-y += wait.o wait_bit.o swait.o completion.o idle.o
+obj-$(CONFIG_SMP) += cpupri.o cpudeadline.o topology.o stop_task.o
 obj-$(CONFIG_SCHED_AUTOGROUP) += autogroup.o
 obj-$(CONFIG_SCHEDSTATS) += stats.o
 obj-$(CONFIG_SCHED_DEBUG) += debug.o
diff --git a/kernel/sched/clock.c b/kernel/sched/clock.c
index 00a45c45beca..ca0f8fc945c6 100644
--- a/kernel/sched/clock.c
+++ b/kernel/sched/clock.c
@@ -64,6 +64,7 @@
 #include <linux/workqueue.h>
 #include <linux/compiler.h>
 #include <linux/tick.h>
+#include <linux/init.h>
 
 /*
  * Scheduler clock - returns current time in nanosec units.
@@ -124,14 +125,27 @@ int sched_clock_stable(void)
         return static_branch_likely(&__sched_clock_stable);
 }
 
+static void __scd_stamp(struct sched_clock_data *scd)
+{
+        scd->tick_gtod = ktime_get_ns();
+        scd->tick_raw = sched_clock();
+}
+
 static void __set_sched_clock_stable(void)
 {
-        struct sched_clock_data *scd = this_scd();
+        struct sched_clock_data *scd;
 
         /*
+         * Since we're still unstable and the tick is already running, we have
+         * to disable IRQs in order to get a consistent scd->tick* reading.
+         */
+        local_irq_disable();
+        scd = this_scd();
+        /*
          * Attempt to make the (initial) unstable->stable transition continuous.
          */
         __sched_clock_offset = (scd->tick_gtod + __gtod_offset) - (scd->tick_raw);
+        local_irq_enable();
 
         printk(KERN_INFO "sched_clock: Marking stable (%lld, %lld)->(%lld, %lld)\n",
                         scd->tick_gtod, __gtod_offset,
@@ -141,8 +155,38 @@ static void __set_sched_clock_stable(void)
         tick_dep_clear(TICK_DEP_BIT_CLOCK_UNSTABLE);
 }
 
+/*
+ * If we ever get here, we're screwed, because we found out -- typically after
+ * the fact -- that TSC wasn't good. This means all our clocksources (including
+ * ktime) could have reported wrong values.
+ *
+ * What we do here is an attempt to fix up and continue sort of where we left
+ * off in a coherent manner.
+ *
+ * The only way to fully avoid random clock jumps is to boot with:
+ * "tsc=unstable".
+ */
 static void __sched_clock_work(struct work_struct *work)
 {
+        struct sched_clock_data *scd;
+        int cpu;
+
+        /* take a current timestamp and set 'now' */
+        preempt_disable();
+        scd = this_scd();
+        __scd_stamp(scd);
+        scd->clock = scd->tick_gtod + __gtod_offset;
+        preempt_enable();
+
+        /* clone to all CPUs */
+        for_each_possible_cpu(cpu)
+                per_cpu(sched_clock_data, cpu) = *scd;
+
+        printk(KERN_WARNING "TSC found unstable after boot, most likely due to broken BIOS. Use 'tsc=unstable'.\n");
+        printk(KERN_INFO "sched_clock: Marking unstable (%lld, %lld)<-(%lld, %lld)\n",
+                        scd->tick_gtod, __gtod_offset,
+                        scd->tick_raw,  __sched_clock_offset);
+
         static_branch_disable(&__sched_clock_stable);
 }
 
@@ -150,27 +194,11 @@ static DECLARE_WORK(sched_clock_work, __sched_clock_work);
 
 static void __clear_sched_clock_stable(void)
 {
-        struct sched_clock_data *scd = this_scd();
-
-        /*
-         * Attempt to make the stable->unstable transition continuous.
-         *
-         * Trouble is, this is typically called from the TSC watchdog
-         * timer, which is late per definition. This means the tick
-         * values can already be screwy.
-         *
-         * Still do what we can.
-         */
-        __gtod_offset = (scd->tick_raw + __sched_clock_offset) - (scd->tick_gtod);
-
-        printk(KERN_INFO "sched_clock: Marking unstable (%lld, %lld)<-(%lld, %lld)\n",
-                        scd->tick_gtod, __gtod_offset,
-                        scd->tick_raw,  __sched_clock_offset);
+        if (!sched_clock_stable())
+                return;
 
         tick_dep_set(TICK_DEP_BIT_CLOCK_UNSTABLE);
-
-        if (sched_clock_stable())
-                schedule_work(&sched_clock_work);
+        schedule_work(&sched_clock_work);
 }
 
 void clear_sched_clock_stable(void)
@@ -183,7 +211,11 @@ void clear_sched_clock_stable(void)
                 __clear_sched_clock_stable();
 }
 
-void sched_clock_init_late(void)
+/*
+ * We run this as late_initcall() such that it runs after all built-in drivers,
+ * notably: acpi_processor and intel_idle, which can mark the TSC as unstable.
+ */
+static int __init sched_clock_init_late(void)
 {
         sched_clock_running = 2;
         /*
@@ -197,7 +229,10 @@ void sched_clock_init_late(void)
 
         if (__sched_clock_stable_early)
                 __set_sched_clock_stable();
+
+        return 0;
 }
+late_initcall(sched_clock_init_late);
 
 /*
  * min, max except they take wrapping into account
@@ -347,21 +382,38 @@ void sched_clock_tick(void)
 {
         struct sched_clock_data *scd;
 
+        if (sched_clock_stable())
+                return;
+
+        if (unlikely(!sched_clock_running))
+                return;
+
         WARN_ON_ONCE(!irqs_disabled());
 
+        scd = this_scd();
+        __scd_stamp(scd);
+        sched_clock_local(scd);
+}
+
+void sched_clock_tick_stable(void)
+{
+        u64 gtod, clock;
+
+        if (!sched_clock_stable())
+                return;
+
         /*
-         * Update these values even if sched_clock_stable(), because it can
-         * become unstable at any point in time at which point we need some
-         * values to fall back on.
+         * Called under watchdog_lock.
          *
-         * XXX arguably we can skip this if we expose tsc_clocksource_reliable
+         * The watchdog just found this TSC to (still) be stable, so now is a
+         * good moment to update our __gtod_offset. Because once we find the
+         * TSC to be unstable, any computation will be computing crap.
          */
-        scd = this_scd();
-        scd->tick_raw  = sched_clock();
-        scd->tick_gtod = ktime_get_ns();
-
-        if (!sched_clock_stable() && likely(sched_clock_running))
-                sched_clock_local(scd);
+        local_irq_disable();
+        gtod = ktime_get_ns();
+        clock = sched_clock();
+        __gtod_offset = (clock + __sched_clock_offset) - gtod;
+        local_irq_enable();
 }
 
 /*
@@ -374,15 +426,21 @@ void sched_clock_idle_sleep_event(void)
 EXPORT_SYMBOL_GPL(sched_clock_idle_sleep_event);
 
 /*
- * We just idled delta nanoseconds (called with irqs disabled):
+ * We just idled; resync with ktime.
  */
-void sched_clock_idle_wakeup_event(u64 delta_ns)
+void sched_clock_idle_wakeup_event(void)
 {
-        if (timekeeping_suspended)
+        unsigned long flags;
+
+        if (sched_clock_stable())
+                return;
+
+        if (unlikely(timekeeping_suspended))
                 return;
 
+        local_irq_save(flags);
         sched_clock_tick();
-        touch_softlockup_watchdog_sched();
+        local_irq_restore(flags);
 }
 EXPORT_SYMBOL_GPL(sched_clock_idle_wakeup_event);
 
diff --git a/kernel/sched/completion.c b/kernel/sched/completion.c
index 53f9558fa925..13fc5ae9bf2f 100644
--- a/kernel/sched/completion.c
+++ b/kernel/sched/completion.c
@@ -66,7 +66,7 @@ do_wait_for_common(struct completion *x,
         if (!x->done) {
                 DECLARE_WAITQUEUE(wait, current);
 
-                __add_wait_queue_tail_exclusive(&x->wait, &wait);
+                __add_wait_queue_entry_tail_exclusive(&x->wait, &wait);
                 do {
                         if (signal_pending_state(state, current)) {
                                 timeout = -ERESTARTSYS;
diff --git a/kernel/sched/core.c b/kernel/sched/core.c
index 803c3bc274c4..17c667b427b4 100644
--- a/kernel/sched/core.c
+++ b/kernel/sched/core.c
@@ -10,6 +10,7 @@
 #include <uapi/linux/sched/types.h>
 #include <linux/sched/loadavg.h>
 #include <linux/sched/hotplug.h>
+#include <linux/wait_bit.h>
 #include <linux/cpuset.h>
 #include <linux/delayacct.h>
 #include <linux/init_task.h>
@@ -788,36 +789,6 @@ void deactivate_task(struct rq *rq, struct task_struct *p, int flags)
         dequeue_task(rq, p, flags);
 }
 
-void sched_set_stop_task(int cpu, struct task_struct *stop)
-{
-        struct sched_param param = { .sched_priority = MAX_RT_PRIO - 1 };
-        struct task_struct *old_stop = cpu_rq(cpu)->stop;
-
-        if (stop) {
-                /*
-                 * Make it appear like a SCHED_FIFO task, its something
-                 * userspace knows about and won't get confused about.
-                 *
-                 * Also, it will make PI more or less work without too
-                 * much confusion -- but then, stop work should not
-                 * rely on PI working anyway.
-                 */
-                sched_setscheduler_nocheck(stop, SCHED_FIFO, &param);
-
-                stop->sched_class = &stop_sched_class;
-        }
-
-        cpu_rq(cpu)->stop = stop;
-
-        if (old_stop) {
-                /*
-                 * Reset it back to a normal scheduling class so that
-                 * it can die in pieces.
-                 */
-                old_stop->sched_class = &rt_sched_class;
-        }
-}
-
 /*
  * __normal_prio - return the priority that is based on the static prio
  */
@@ -1588,6 +1559,36 @@ static void update_avg(u64 *avg, u64 sample)
         *avg += diff >> 3;
 }
 
+void sched_set_stop_task(int cpu, struct task_struct *stop)
+{
+        struct sched_param param = { .sched_priority = MAX_RT_PRIO - 1 };
+        struct task_struct *old_stop = cpu_rq(cpu)->stop;
+
+        if (stop) {
+                /*
+                 * Make it appear like a SCHED_FIFO task, its something
+                 * userspace knows about and won't get confused about.
+                 *
+                 * Also, it will make PI more or less work without too
+                 * much confusion -- but then, stop work should not
+                 * rely on PI working anyway.
+                 */
+                sched_setscheduler_nocheck(stop, SCHED_FIFO, &param);
+
+                stop->sched_class = &stop_sched_class;
+        }
+
+        cpu_rq(cpu)->stop = stop;
+
+        if (old_stop) {
+                /*
+                 * Reset it back to a normal scheduling class so that
+                 * it can die in pieces.
+                 */
+                old_stop->sched_class = &rt_sched_class;
+        }
+}
+
 #else
 
 static inline int __set_cpus_allowed_ptr(struct task_struct *p,
@@ -1731,7 +1732,7 @@ void sched_ttwu_pending(void)
 {
         struct rq *rq = this_rq();
         struct llist_node *llist = llist_del_all(&rq->wake_list);
-        struct task_struct *p;
+        struct task_struct *p, *t;
         struct rq_flags rf;
 
         if (!llist)
@@ -1740,17 +1741,8 @@ void sched_ttwu_pending(void)
         rq_lock_irqsave(rq, &rf);
         update_rq_clock(rq);
 
-        while (llist) {
-                int wake_flags = 0;
-
-                p = llist_entry(llist, struct task_struct, wake_entry);
-                llist = llist_next(llist);
-
-                if (p->sched_remote_wakeup)
-                        wake_flags = WF_MIGRATED;
-
-                ttwu_do_activate(rq, p, wake_flags, &rf);
-        }
+        llist_for_each_entry_safe(p, t, llist, wake_entry)
+                ttwu_do_activate(rq, p, p->sched_remote_wakeup ? WF_MIGRATED : 0, &rf);
 
         rq_unlock_irqrestore(rq, &rf);
 }
@@ -2148,23 +2140,6 @@ int wake_up_state(struct task_struct *p, unsigned int state)
 }
 
 /*
- * This function clears the sched_dl_entity static params.
- */
-void __dl_clear_params(struct task_struct *p)
-{
-        struct sched_dl_entity *dl_se = &p->dl;
-
-        dl_se->dl_runtime = 0;
-        dl_se->dl_deadline = 0;
-        dl_se->dl_period = 0;
-        dl_se->flags = 0;
-        dl_se->dl_bw = 0;
-
-        dl_se->dl_throttled = 0;
-        dl_se->dl_yielded = 0;
-}
-
-/*
  * Perform scheduler related setup for a newly forked process p.
  * p is forked by current.
  *
@@ -2193,6 +2168,7 @@ static void __sched_fork(unsigned long clone_flags, struct task_struct *p)
 
         RB_CLEAR_NODE(&p->dl.rb_node);
         init_dl_task_timer(&p->dl);
+        init_dl_inactive_task_timer(&p->dl);
         __dl_clear_params(p);
 
         INIT_LIST_HEAD(&p->rt.run_list);
@@ -2430,7 +2406,7 @@ int sched_fork(unsigned long clone_flags, struct task_struct *p)
 unsigned long to_ratio(u64 period, u64 runtime)
 {
         if (runtime == RUNTIME_INF)
-                return 1ULL << 20;
+                return BW_UNIT;
 
         /*
          * Doing this here saves a lot of checks in all
@@ -2440,93 +2416,9 @@ unsigned long to_ratio(u64 period, u64 runtime)
         if (period == 0)
                 return 0;
 
-        return div64_u64(runtime << 20, period);
-}
-
-#ifdef CONFIG_SMP
-inline struct dl_bw *dl_bw_of(int i)
-{
-        RCU_LOCKDEP_WARN(!rcu_read_lock_sched_held(),
-                         "sched RCU must be held");
-        return &cpu_rq(i)->rd->dl_bw;
-}
-
-static inline int dl_bw_cpus(int i)
-{
-        struct root_domain *rd = cpu_rq(i)->rd;
-        int cpus = 0;
-
-        RCU_LOCKDEP_WARN(!rcu_read_lock_sched_held(),
-                         "sched RCU must be held");
-        for_each_cpu_and(i, rd->span, cpu_active_mask)
-                cpus++;
-
-        return cpus;
-}
-#else
-inline struct dl_bw *dl_bw_of(int i)
-{
-        return &cpu_rq(i)->dl.dl_bw;
-}
-
-static inline int dl_bw_cpus(int i)
-{
-        return 1;
-}
-#endif
-
-/*
- * We must be sure that accepting a new task (or allowing changing the
- * parameters of an existing one) is consistent with the bandwidth
- * constraints. If yes, this function also accordingly updates the currently
- * allocated bandwidth to reflect the new situation.
- *
- * This function is called while holding p's rq->lock.
- *
- * XXX we should delay bw change until the task's 0-lag point, see
- * __setparam_dl().
- */
-static int dl_overflow(struct task_struct *p, int policy,
-                       const struct sched_attr *attr)
-{
-
-        struct dl_bw *dl_b = dl_bw_of(task_cpu(p));
-        u64 period = attr->sched_period ?: attr->sched_deadline;
-        u64 runtime = attr->sched_runtime;
-        u64 new_bw = dl_policy(policy) ? to_ratio(period, runtime) : 0;
-        int cpus, err = -1;
-
-        /* !deadline task may carry old deadline bandwidth */
-        if (new_bw == p->dl.dl_bw && task_has_dl_policy(p))
-                return 0;
-
-        /*
-         * Either if a task, enters, leave, or stays -deadline but changes
-         * its parameters, we may need to update accordingly the total
-         * allocated bandwidth of the container.
-         */
-        raw_spin_lock(&dl_b->lock);
-        cpus = dl_bw_cpus(task_cpu(p));
-        if (dl_policy(policy) && !task_has_dl_policy(p) &&
-            !__dl_overflow(dl_b, cpus, 0, new_bw)) {
-                __dl_add(dl_b, new_bw);
-                err = 0;
-        } else if (dl_policy(policy) && task_has_dl_policy(p) &&
-                   !__dl_overflow(dl_b, cpus, p->dl.dl_bw, new_bw)) {
-                __dl_clear(dl_b, p->dl.dl_bw);
-                __dl_add(dl_b, new_bw);
-                err = 0;
-        } else if (!dl_policy(policy) && task_has_dl_policy(p)) {
-                __dl_clear(dl_b, p->dl.dl_bw);
-                err = 0;
-        }
-        raw_spin_unlock(&dl_b->lock);
-
-        return err;
+        return div64_u64(runtime << BW_SHIFT, period);
 }
 
-extern void init_dl_bw(struct dl_bw *dl_b);
-
 /*
  * wake_up_new_task - wake up a newly created task for the first time.
  *
@@ -3687,7 +3579,7 @@ asmlinkage __visible void __sched preempt_schedule_irq(void)
         exception_exit(prev_state);
 }
 
-int default_wake_function(wait_queue_t *curr, unsigned mode, int wake_flags,
+int default_wake_function(wait_queue_entry_t *curr, unsigned mode, int wake_flags,
                           void *key)
 {
         return try_to_wake_up(curr->private, mode, wake_flags);
@@ -4009,46 +3901,6 @@ static struct task_struct *find_process_by_pid(pid_t pid)
 }
 
 /*
- * This function initializes the sched_dl_entity of a newly becoming
- * SCHED_DEADLINE task.
- *
- * Only the static values are considered here, the actual runtime and the
- * absolute deadline will be properly calculated when the task is enqueued
- * for the first time with its new policy.
- */
-static void
-__setparam_dl(struct task_struct *p, const struct sched_attr *attr)
-{
-        struct sched_dl_entity *dl_se = &p->dl;
-
-        dl_se->dl_runtime = attr->sched_runtime;
-        dl_se->dl_deadline = attr->sched_deadline;
-        dl_se->dl_period = attr->sched_period ?: dl_se->dl_deadline;
-        dl_se->flags = attr->sched_flags;
-        dl_se->dl_bw = to_ratio(dl_se->dl_period, dl_se->dl_runtime);
-
-        /*
-         * Changing the parameters of a task is 'tricky' and we're not doing
-         * the correct thing -- also see task_dead_dl() and switched_from_dl().
-         *
-         * What we SHOULD do is delay the bandwidth release until the 0-lag
-         * point. This would include retaining the task_struct until that time
-         * and change dl_overflow() to not immediately decrement the current
-         * amount.
-         *
-         * Instead we retain the current runtime/deadline and let the new
-         * parameters take effect after the current reservation period lapses.
-         * This is safe (albeit pessimistic) because the 0-lag point is always
-         * before the current scheduling deadline.
-         *
-         * We can still have temporary overloads because we do not delay the
-         * change in bandwidth until that time; so admission control is
-         * not on the safe side. It does however guarantee tasks will never
-         * consume more than promised.
-         */
-}
-
-/*
  * sched_setparam() passes in -1 for its policy, to let the functions
  * it calls know not to change it.
  */
@@ -4101,59 +3953,6 @@ static void __setscheduler(struct rq *rq, struct task_struct *p,
                 p->sched_class = &fair_sched_class;
 }
 
-static void
-__getparam_dl(struct task_struct *p, struct sched_attr *attr)
-{
-        struct sched_dl_entity *dl_se = &p->dl;
-
-        attr->sched_priority = p->rt_priority;
-        attr->sched_runtime = dl_se->dl_runtime;
-        attr->sched_deadline = dl_se->dl_deadline;
-        attr->sched_period = dl_se->dl_period;
-        attr->sched_flags = dl_se->flags;
-}
-
-/*
- * This function validates the new parameters of a -deadline task.
- * We ask for the deadline not being zero, and greater or equal
- * than the runtime, as well as the period of being zero or
- * greater than deadline. Furthermore, we have to be sure that
- * user parameters are above the internal resolution of 1us (we
- * check sched_runtime only since it is always the smaller one) and
- * below 2^63 ns (we have to check both sched_deadline and
- * sched_period, as the latter can be zero).
- */
-static bool
-__checkparam_dl(const struct sched_attr *attr)
-{
-        /* deadline != 0 */
-        if (attr->sched_deadline == 0)
-                return false;
-
-        /*
-         * Since we truncate DL_SCALE bits, make sure we're at least
-         * that big.
-         */
-        if (attr->sched_runtime < (1ULL << DL_SCALE))
-                return false;
-
-        /*
-         * Since we use the MSB for wrap-around and sign issues, make
-         * sure it's not set (mind that period can be equal to zero).
-         */
-        if (attr->sched_deadline & (1ULL << 63) ||
-            attr->sched_period & (1ULL << 63))
-                return false;
-
-        /* runtime <= deadline <= period (if period != 0) */
-        if ((attr->sched_period != 0 &&
-             attr->sched_period < attr->sched_deadline) ||
-            attr->sched_deadline < attr->sched_runtime)
-                return false;
-
-        return true;
-}
-
 /*
  * Check the target process has a UID that matches the current process's:
  */
@@ -4170,19 +3969,6 @@ static bool check_same_owner(struct task_struct *p)
         return match;
 }
 
-static bool dl_param_changed(struct task_struct *p, const struct sched_attr *attr)
-{
-        struct sched_dl_entity *dl_se = &p->dl;
-
-        if (dl_se->dl_runtime != attr->sched_runtime ||
-                dl_se->dl_deadline != attr->sched_deadline ||
-                dl_se->dl_period != attr->sched_period ||
-                dl_se->flags != attr->sched_flags)
-                return true;
-
-        return false;
-}
-
 static int __sched_setscheduler(struct task_struct *p,
                                 const struct sched_attr *attr,
                                 bool user, bool pi)
@@ -4197,8 +3983,8 @@ static int __sched_setscheduler(struct task_struct *p,
         int queue_flags = DEQUEUE_SAVE | DEQUEUE_MOVE | DEQUEUE_NOCLOCK;
         struct rq *rq;
 
-        /* May grab non-irq protected spin_locks: */
-        BUG_ON(in_interrupt());
+        /* The pi code expects interrupts enabled */
+        BUG_ON(pi && in_interrupt());
 recheck:
         /* Double check policy once rq lock held: */
         if (policy < 0) {
@@ -4211,7 +3997,8 @@ recheck:
                         return -EINVAL;
         }
 
-        if (attr->sched_flags & ~(SCHED_FLAG_RESET_ON_FORK))
+        if (attr->sched_flags &
+                ~(SCHED_FLAG_RESET_ON_FORK | SCHED_FLAG_RECLAIM))
                 return -EINVAL;
 
         /*
@@ -4362,7 +4149,7 @@ change:
          * of a SCHED_DEADLINE task) we need to check if enough bandwidth
          * is available.
          */
-        if ((dl_policy(policy) || dl_task(p)) && dl_overflow(p, policy, attr)) {
+        if ((dl_policy(policy) || dl_task(p)) && sched_dl_overflow(p, policy, attr)) {
                 task_rq_unlock(rq, p, &rf);
                 return -EBUSY;
         }
@@ -5463,26 +5250,17 @@ void init_idle(struct task_struct *idle, int cpu)
 #endif
 }
 
+#ifdef CONFIG_SMP
+
 int cpuset_cpumask_can_shrink(const struct cpumask *cur,
                               const struct cpumask *trial)
 {
-        int ret = 1, trial_cpus;
-        struct dl_bw *cur_dl_b;
-        unsigned long flags;
+        int ret = 1;
 
         if (!cpumask_weight(cur))
                 return ret;
 
-        rcu_read_lock_sched();
-        cur_dl_b = dl_bw_of(cpumask_any(cur));
-        trial_cpus = cpumask_weight(trial);
-
-        raw_spin_lock_irqsave(&cur_dl_b->lock, flags);
-        if (cur_dl_b->bw != -1 &&
-            cur_dl_b->bw * trial_cpus < cur_dl_b->total_bw)
-                ret = 0;
-        raw_spin_unlock_irqrestore(&cur_dl_b->lock, flags);
-        rcu_read_unlock_sched();
+        ret = dl_cpuset_cpumask_can_shrink(cur, trial);
 
         return ret;
 }
@@ -5506,43 +5284,14 @@ int task_can_attach(struct task_struct *p,
                 goto out;
         }
 
-#ifdef CONFIG_SMP
         if (dl_task(p) && !cpumask_intersects(task_rq(p)->rd->span,
-                                              cs_cpus_allowed)) {
-                unsigned int dest_cpu = cpumask_any_and(cpu_active_mask,
-                                                        cs_cpus_allowed);
-                struct dl_bw *dl_b;
-                bool overflow;
-                int cpus;
-                unsigned long flags;
-
-                rcu_read_lock_sched();
-                dl_b = dl_bw_of(dest_cpu);
-                raw_spin_lock_irqsave(&dl_b->lock, flags);
-                cpus = dl_bw_cpus(dest_cpu);
-                overflow = __dl_overflow(dl_b, cpus, 0, p->dl.dl_bw);
-                if (overflow)
-                        ret = -EBUSY;
-                else {
-                        /*
-                         * We reserve space for this task in the destination
-                         * root_domain, as we can't fail after this point.
-                         * We will free resources in the source root_domain
-                         * later on (see set_cpus_allowed_dl()).
-                         */
-                        __dl_add(dl_b, p->dl.dl_bw);
-                }
-                raw_spin_unlock_irqrestore(&dl_b->lock, flags);
-                rcu_read_unlock_sched();
+                                              cs_cpus_allowed))
+                ret = dl_task_can_attach(p, cs_cpus_allowed);
 
-        }
-#endif
 out:
         return ret;
 }
 
-#ifdef CONFIG_SMP
-
 bool sched_smp_initialized __read_mostly;
 
 #ifdef CONFIG_NUMA_BALANCING
@@ -5605,7 +5354,7 @@ void idle_task_exit(void)
         BUG_ON(cpu_online(smp_processor_id()));
 
         if (mm != &init_mm) {
-                switch_mm_irqs_off(mm, &init_mm, current);
+                switch_mm(mm, &init_mm, current);
                 finish_arch_post_lock_switch();
         }
         mmdrop(mm);
@@ -5805,23 +5554,8 @@ static void cpuset_cpu_active(void)
 
 static int cpuset_cpu_inactive(unsigned int cpu)
 {
-        unsigned long flags;
-        struct dl_bw *dl_b;
-        bool overflow;
-        int cpus;
-
         if (!cpuhp_tasks_frozen) {
-                rcu_read_lock_sched();
-                dl_b = dl_bw_of(cpu);
-
-                raw_spin_lock_irqsave(&dl_b->lock, flags);
-                cpus = dl_bw_cpus(cpu);
-                overflow = __dl_overflow(dl_b, cpus, 0, 0);
-                raw_spin_unlock_irqrestore(&dl_b->lock, flags);
-
-                rcu_read_unlock_sched();
-
-                if (overflow)
+                if (dl_cpu_busy(cpu))
                         return -EBUSY;
                 cpuset_update_active_cpus();
         } else {
@@ -5874,15 +5608,9 @@ int sched_cpu_deactivate(unsigned int cpu)
          * users of this state to go away such that all new such users will
          * observe it.
          *
-         * For CONFIG_PREEMPT we have preemptible RCU and its sync_rcu() might
-         * not imply sync_sched(), so wait for both.
-         *
          * Do sync before park smpboot threads to take care the rcu boost case.
          */
-        if (IS_ENABLED(CONFIG_PREEMPT))
-                synchronize_rcu_mult(call_rcu, call_rcu_sched);
-        else
-                synchronize_rcu();
+        synchronize_rcu_mult(call_rcu, call_rcu_sched);
 
         if (!sched_smp_initialized)
                 return 0;
@@ -5958,7 +5686,6 @@ void __init sched_init_smp(void)
         cpumask_var_t non_isolated_cpus;
 
         alloc_cpumask_var(&non_isolated_cpus, GFP_KERNEL);
-        alloc_cpumask_var(&fallback_doms, GFP_KERNEL);
 
         sched_init_numa();
 
@@ -5968,7 +5695,7 @@ void __init sched_init_smp(void)
          * happen.
          */
         mutex_lock(&sched_domains_mutex);
-        init_sched_domains(cpu_active_mask);
+        sched_init_domains(cpu_active_mask);
         cpumask_andnot(non_isolated_cpus, cpu_possible_mask, cpu_isolated_map);
         if (cpumask_empty(non_isolated_cpus))
                 cpumask_set_cpu(smp_processor_id(), non_isolated_cpus);
@@ -5984,7 +5711,6 @@ void __init sched_init_smp(void)
         init_sched_dl_class();
 
         sched_init_smt();
-        sched_clock_init_late();
 
         sched_smp_initialized = true;
 }
@@ -6000,7 +5726,6 @@ early_initcall(migration_init);
 void __init sched_init_smp(void)
 {
         sched_init_granularity();
-        sched_clock_init_late();
 }
 #endif /* CONFIG_SMP */
 
@@ -6026,28 +5751,13 @@ static struct kmem_cache *task_group_cache __read_mostly;
 DECLARE_PER_CPU(cpumask_var_t, load_balance_mask);
 DECLARE_PER_CPU(cpumask_var_t, select_idle_mask);
 
-#define WAIT_TABLE_BITS 8
-#define WAIT_TABLE_SIZE (1 << WAIT_TABLE_BITS)
-static wait_queue_head_t bit_wait_table[WAIT_TABLE_SIZE] __cacheline_aligned;
-
-wait_queue_head_t *bit_waitqueue(void *word, int bit)
-{
-        const int shift = BITS_PER_LONG == 32 ? 5 : 6;
-        unsigned long val = (unsigned long)word << shift | bit;
-
-        return bit_wait_table + hash_long(val, WAIT_TABLE_BITS);
-}
-EXPORT_SYMBOL(bit_waitqueue);
-
 void __init sched_init(void)
 {
         int i, j;
         unsigned long alloc_size = 0, ptr;
 
         sched_clock_init();
-
-        for (i = 0; i < WAIT_TABLE_SIZE; i++)
-                init_waitqueue_head(bit_wait_table + i);
+        wait_bit_init();
 
 #ifdef CONFIG_FAIR_GROUP_SCHED
         alloc_size += 2 * nr_cpu_ids * sizeof(void **);
@@ -6199,7 +5909,6 @@ void __init sched_init(void)
         calc_load_update = jiffies + LOAD_FREQ;
 
 #ifdef CONFIG_SMP
-        zalloc_cpumask_var(&sched_domains_tmpmask, GFP_NOWAIT);
         /* May be allocated at isolcpus cmdline parse time */
         if (cpu_isolated_map == NULL)
                 zalloc_cpumask_var(&cpu_isolated_map, GFP_NOWAIT);
@@ -6251,8 +5960,10 @@ void ___might_sleep(const char *file, int line, int preempt_offset)
 
         if ((preempt_count_equals(preempt_offset) && !irqs_disabled() &&
              !is_idle_task(current)) ||
-            system_state != SYSTEM_RUNNING || oops_in_progress)
+            system_state == SYSTEM_BOOTING || system_state > SYSTEM_RUNNING ||
+            oops_in_progress)
                 return;
+
         if (time_before(jiffies, prev_jiffy + HZ) && prev_jiffy)
                 return;
         prev_jiffy = jiffies;
@@ -6507,385 +6218,6 @@ void sched_move_task(struct task_struct *tsk)
 
         task_rq_unlock(rq, tsk, &rf);
 }
-#endif /* CONFIG_CGROUP_SCHED */
-
-#ifdef CONFIG_RT_GROUP_SCHED
-/*
- * Ensure that the real time constraints are schedulable.
- */
-static DEFINE_MUTEX(rt_constraints_mutex);
-
-/* Must be called with tasklist_lock held */
-static inline int tg_has_rt_tasks(struct task_group *tg)
-{
-        struct task_struct *g, *p;
-
-        /*
-         * Autogroups do not have RT tasks; see autogroup_create().
-         */
-        if (task_group_is_autogroup(tg))
-                return 0;
-
-        for_each_process_thread(g, p) {
-                if (rt_task(p) && task_group(p) == tg)
-                        return 1;
-        }
-
-        return 0;
-}
-
-struct rt_schedulable_data {
-        struct task_group *tg;
-        u64 rt_period;
-        u64 rt_runtime;
-};
-
-static int tg_rt_schedulable(struct task_group *tg, void *data)
-{
-        struct rt_schedulable_data *d = data;
-        struct task_group *child;
-        unsigned long total, sum = 0;
-        u64 period, runtime;
-
-        period = ktime_to_ns(tg->rt_bandwidth.rt_period);
-        runtime = tg->rt_bandwidth.rt_runtime;
-
-        if (tg == d->tg) {
-                period = d->rt_period;
-                runtime = d->rt_runtime;
-        }
-
-        /*
-         * Cannot have more runtime than the period.
-         */
-        if (runtime > period && runtime != RUNTIME_INF)
-                return -EINVAL;
-
-        /*
-         * Ensure we don't starve existing RT tasks.
-         */
-        if (rt_bandwidth_enabled() && !runtime && tg_has_rt_tasks(tg))
-                return -EBUSY;
-
-        total = to_ratio(period, runtime);
-
-        /*
-         * Nobody can have more than the global setting allows.
-         */
-        if (total > to_ratio(global_rt_period(), global_rt_runtime()))
-                return -EINVAL;
-
-        /*
-         * The sum of our children's runtime should not exceed our own.
-         */
-        list_for_each_entry_rcu(child, &tg->children, siblings) {
-                period = ktime_to_ns(child->rt_bandwidth.rt_period);
-                runtime = child->rt_bandwidth.rt_runtime;
-
-                if (child == d->tg) {
-                        period = d->rt_period;
-                        runtime = d->rt_runtime;
-                }
-
-                sum += to_ratio(period, runtime);
-        }
-
-        if (sum > total)
-                return -EINVAL;
-
-        return 0;
-}
-
-static int __rt_schedulable(struct task_group *tg, u64 period, u64 runtime)
-{
-        int ret;
-
-        struct rt_schedulable_data data = {
-                .tg = tg,
-                .rt_period = period,
-                .rt_runtime = runtime,
-        };
-
-        rcu_read_lock();
-        ret = walk_tg_tree(tg_rt_schedulable, tg_nop, &data);
-        rcu_read_unlock();
-
-        return ret;
-}
-
-static int tg_set_rt_bandwidth(struct task_group *tg,
-                u64 rt_period, u64 rt_runtime)
-{
-        int i, err = 0;
-
-        /*
-         * Disallowing the root group RT runtime is BAD, it would disallow the
-         * kernel creating (and or operating) RT threads.
-         */
-        if (tg == &root_task_group && rt_runtime == 0)
-                return -EINVAL;
-
-        /* No period doesn't make any sense. */
-        if (rt_period == 0)
-                return -EINVAL;
-
-        mutex_lock(&rt_constraints_mutex);
-        read_lock(&tasklist_lock);
-        err = __rt_schedulable(tg, rt_period, rt_runtime);
-        if (err)
-                goto unlock;
-
-        raw_spin_lock_irq(&tg->rt_bandwidth.rt_runtime_lock);
-        tg->rt_bandwidth.rt_period = ns_to_ktime(rt_period);
-        tg->rt_bandwidth.rt_runtime = rt_runtime;
-
-        for_each_possible_cpu(i) {
-                struct rt_rq *rt_rq = tg->rt_rq[i];
-
-                raw_spin_lock(&rt_rq->rt_runtime_lock);
-                rt_rq->rt_runtime = rt_runtime;
-                raw_spin_unlock(&rt_rq->rt_runtime_lock);
-        }
-        raw_spin_unlock_irq(&tg->rt_bandwidth.rt_runtime_lock);
-unlock:
-        read_unlock(&tasklist_lock);
-        mutex_unlock(&rt_constraints_mutex);
-
-        return err;
-}
-
-static int sched_group_set_rt_runtime(struct task_group *tg, long rt_runtime_us)
-{
-        u64 rt_runtime, rt_period;
-
-        rt_period = ktime_to_ns(tg->rt_bandwidth.rt_period);
-        rt_runtime = (u64)rt_runtime_us * NSEC_PER_USEC;
-        if (rt_runtime_us < 0)
-                rt_runtime = RUNTIME_INF;
-
-        return tg_set_rt_bandwidth(tg, rt_period, rt_runtime);
-}
-
-static long sched_group_rt_runtime(struct task_group *tg)
-{
-        u64 rt_runtime_us;
-
-        if (tg->rt_bandwidth.rt_runtime == RUNTIME_INF)
-                return -1;
-
-        rt_runtime_us = tg->rt_bandwidth.rt_runtime;
-        do_div(rt_runtime_us, NSEC_PER_USEC);
-        return rt_runtime_us;
-}
-
-static int sched_group_set_rt_period(struct task_group *tg, u64 rt_period_us)
-{
-        u64 rt_runtime, rt_period;
-
-        rt_period = rt_period_us * NSEC_PER_USEC;
-        rt_runtime = tg->rt_bandwidth.rt_runtime;
-
-        return tg_set_rt_bandwidth(tg, rt_period, rt_runtime);
-}
-
-static long sched_group_rt_period(struct task_group *tg)
-{
-        u64 rt_period_us;
-
-        rt_period_us = ktime_to_ns(tg->rt_bandwidth.rt_period);
-        do_div(rt_period_us, NSEC_PER_USEC);
-        return rt_period_us;
-}
-#endif /* CONFIG_RT_GROUP_SCHED */
-
-#ifdef CONFIG_RT_GROUP_SCHED
-static int sched_rt_global_constraints(void)
-{
-        int ret = 0;
-
-        mutex_lock(&rt_constraints_mutex);
-        read_lock(&tasklist_lock);
-        ret = __rt_schedulable(NULL, 0, 0);
-        read_unlock(&tasklist_lock);
-        mutex_unlock(&rt_constraints_mutex);
-
-        return ret;
-}
-
-static int sched_rt_can_attach(struct task_group *tg, struct task_struct *tsk)
-{
-        /* Don't accept realtime tasks when there is no way for them to run */
-        if (rt_task(tsk) && tg->rt_bandwidth.rt_runtime == 0)
-                return 0;
-
-        return 1;
-}
-
-#else /* !CONFIG_RT_GROUP_SCHED */
-static int sched_rt_global_constraints(void)
-{
-        unsigned long flags;
-        int i;
-
-        raw_spin_lock_irqsave(&def_rt_bandwidth.rt_runtime_lock, flags);
-        for_each_possible_cpu(i) {
-                struct rt_rq *rt_rq = &cpu_rq(i)->rt;
-
-                raw_spin_lock(&rt_rq->rt_runtime_lock);
-                rt_rq->rt_runtime = global_rt_runtime();
-                raw_spin_unlock(&rt_rq->rt_runtime_lock);
-        }
-        raw_spin_unlock_irqrestore(&def_rt_bandwidth.rt_runtime_lock, flags);
-
-        return 0;
-}
-#endif /* CONFIG_RT_GROUP_SCHED */
-
-static int sched_dl_global_validate(void)
-{
-        u64 runtime = global_rt_runtime();
-        u64 period = global_rt_period();
-        u64 new_bw = to_ratio(period, runtime);
-        struct dl_bw *dl_b;
-        int cpu, ret = 0;
-        unsigned long flags;
-
-        /*
-         * Here we want to check the bandwidth not being set to some
-         * value smaller than the currently allocated bandwidth in
-         * any of the root_domains.
-         *
-         * FIXME: Cycling on all the CPUs is overdoing, but simpler than
-         * cycling on root_domains... Discussion on different/better
-         * solutions is welcome!
-         */
-        for_each_possible_cpu(cpu) {
-                rcu_read_lock_sched();
-                dl_b = dl_bw_of(cpu);
-
-                raw_spin_lock_irqsave(&dl_b->lock, flags);
-                if (new_bw < dl_b->total_bw)
-                        ret = -EBUSY;
-                raw_spin_unlock_irqrestore(&dl_b->lock, flags);
-
-                rcu_read_unlock_sched();
-
-                if (ret)
-                        break;
-        }
-
-        return ret;
-}
-
-static void sched_dl_do_global(void)
-{
-        u64 new_bw = -1;
-        struct dl_bw *dl_b;
-        int cpu;
-        unsigned long flags;
-
-        def_dl_bandwidth.dl_period = global_rt_period();
-        def_dl_bandwidth.dl_runtime = global_rt_runtime();
-
-        if (global_rt_runtime() != RUNTIME_INF)
-                new_bw = to_ratio(global_rt_period(), global_rt_runtime());
-
-        /*
-         * FIXME: As above...
-         */
-        for_each_possible_cpu(cpu) {
-                rcu_read_lock_sched();
-                dl_b = dl_bw_of(cpu);
-
-                raw_spin_lock_irqsave(&dl_b->lock, flags);
-                dl_b->bw = new_bw;
-                raw_spin_unlock_irqrestore(&dl_b->lock, flags);
-
-                rcu_read_unlock_sched();
-        }
-}
-
-static int sched_rt_global_validate(void)
-{
-        if (sysctl_sched_rt_period <= 0)
-                return -EINVAL;
-
-        if ((sysctl_sched_rt_runtime != RUNTIME_INF) &&
-                (sysctl_sched_rt_runtime > sysctl_sched_rt_period))
-                return -EINVAL;
-
-        return 0;
-}
-
-static void sched_rt_do_global(void)
-{
-        def_rt_bandwidth.rt_runtime = global_rt_runtime();
-        def_rt_bandwidth.rt_period = ns_to_ktime(global_rt_period());
-}
-
-int sched_rt_handler(struct ctl_table *table, int write,
-                void __user *buffer, size_t *lenp,
-                loff_t *ppos)
-{
-        int old_period, old_runtime;
-        static DEFINE_MUTEX(mutex);
-        int ret;
-
-        mutex_lock(&mutex);
-        old_period = sysctl_sched_rt_period;
-        old_runtime = sysctl_sched_rt_runtime;
-
-        ret = proc_dointvec(table, write, buffer, lenp, ppos);
-
-        if (!ret && write) {
-                ret = sched_rt_global_validate();
-                if (ret)
-                        goto undo;
-
-                ret = sched_dl_global_validate();
-                if (ret)
-                        goto undo;
-
-                ret = sched_rt_global_constraints();
-                if (ret)
-                        goto undo;
-
-                sched_rt_do_global();
-                sched_dl_do_global();
-        }
-        if (0) {
-undo:
-                sysctl_sched_rt_period = old_period;
-                sysctl_sched_rt_runtime = old_runtime;
-        }
-        mutex_unlock(&mutex);
-
-        return ret;
-}
-
-int sched_rr_handler(struct ctl_table *table, int write,
-                void __user *buffer, size_t *lenp,
-                loff_t *ppos)
-{
-        int ret;
-        static DEFINE_MUTEX(mutex);
-
-        mutex_lock(&mutex);
-        ret = proc_dointvec(table, write, buffer, lenp, ppos);
-        /*
-         * Make sure that internally we keep jiffies.
-         * Also, writing zero resets the timeslice to default:
-         */
-        if (!ret && write) {
-                sched_rr_timeslice =
-                        sysctl_sched_rr_timeslice <= 0 ? RR_TIMESLICE :
-                        msecs_to_jiffies(sysctl_sched_rr_timeslice);
-        }
-        mutex_unlock(&mutex);
-        return ret;
-}
-
-#ifdef CONFIG_CGROUP_SCHED
 
 static inline struct task_group *css_tg(struct cgroup_subsys_state *css)
 {
diff --git a/kernel/sched/cpufreq_schedutil.c b/kernel/sched/cpufreq_schedutil.c
index 76877a62b5fa..29a397067ffa 100644
--- a/kernel/sched/cpufreq_schedutil.c
+++ b/kernel/sched/cpufreq_schedutil.c
@@ -101,9 +101,6 @@ static void sugov_update_commit(struct sugov_policy *sg_policy, u64 time,
         if (sg_policy->next_freq == next_freq)
                 return;
 
-        if (sg_policy->next_freq > next_freq)
-                next_freq = (sg_policy->next_freq + next_freq) >> 1;
-
         sg_policy->next_freq = next_freq;
         sg_policy->last_freq_update_time = time;
 
@@ -245,11 +242,10 @@ static void sugov_update_single(struct update_util_data *hook, u64 time,
         sugov_update_commit(sg_policy, time, next_f);
 }
 
-static unsigned int sugov_next_freq_shared(struct sugov_cpu *sg_cpu)
+static unsigned int sugov_next_freq_shared(struct sugov_cpu *sg_cpu, u64 time)
 {
         struct sugov_policy *sg_policy = sg_cpu->sg_policy;
         struct cpufreq_policy *policy = sg_policy->policy;
-        u64 last_freq_update_time = sg_policy->last_freq_update_time;
         unsigned long util = 0, max = 1;
         unsigned int j;
 
@@ -265,7 +261,7 @@ static unsigned int sugov_next_freq_shared(struct sugov_cpu *sg_cpu)
                  * enough, don't take the CPU into account as it probably is
                  * idle now (and clear iowait_boost for it).
                  */
-                delta_ns = last_freq_update_time - j_sg_cpu->last_update;
+                delta_ns = time - j_sg_cpu->last_update;
                 if (delta_ns > TICK_NSEC) {
                         j_sg_cpu->iowait_boost = 0;
                         continue;
@@ -309,7 +305,7 @@ static void sugov_update_shared(struct update_util_data *hook, u64 time,
                 if (flags & SCHED_CPUFREQ_RT_DL)
                         next_f = sg_policy->policy->cpuinfo.max_freq;
                 else
-                        next_f = sugov_next_freq_shared(sg_cpu);
+                        next_f = sugov_next_freq_shared(sg_cpu, time);
 
                 sugov_update_commit(sg_policy, time, next_f);
         }
@@ -614,6 +610,11 @@ static int sugov_start(struct cpufreq_policy *policy)
                 sg_cpu->sg_policy = sg_policy;
                 sg_cpu->flags = SCHED_CPUFREQ_RT;
                 sg_cpu->iowait_boost_max = policy->cpuinfo.max_freq;
+        }
+
+        for_each_cpu(cpu, policy->cpus) {
+                struct sugov_cpu *sg_cpu = &per_cpu(sugov_cpu, cpu);
+
                 cpufreq_add_update_util_hook(cpu, &sg_cpu->update_util,
                                              policy_is_shared(policy) ?
                                                         sugov_update_shared :
diff --git a/kernel/sched/cputime.c b/kernel/sched/cputime.c
index aea3135c5d90..14d2dbf97c53 100644
--- a/kernel/sched/cputime.c
+++ b/kernel/sched/cputime.c
@@ -611,9 +611,9 @@ static void cputime_adjust(struct task_cputime *curr,
         utime = curr->utime;
 
         /*
-         * If either stime or both stime and utime are 0, assume all runtime is
-         * userspace. Once a task gets some ticks, the monotonicy code at
-         * 'update' will ensure things converge to the observed ratio.
+         * If either stime or utime are 0, assume all runtime is userspace.
+         * Once a task gets some ticks, the monotonicy code at 'update:'
+         * will ensure things converge to the observed ratio.
          */
         if (stime == 0) {
                 utime = rtime;
@@ -679,20 +679,21 @@ void thread_group_cputime_adjusted(struct task_struct *p, u64 *ut, u64 *st)
 #endif /* !CONFIG_VIRT_CPU_ACCOUNTING_NATIVE */
 
 #ifdef CONFIG_VIRT_CPU_ACCOUNTING_GEN
-static u64 vtime_delta(struct task_struct *tsk)
+static u64 vtime_delta(struct vtime *vtime)
 {
-        unsigned long now = READ_ONCE(jiffies);
+        unsigned long long clock;
 
-        if (time_before(now, (unsigned long)tsk->vtime_snap))
+        clock = sched_clock();
+        if (clock < vtime->starttime)
                 return 0;
 
-        return jiffies_to_nsecs(now - tsk->vtime_snap);
+        return clock - vtime->starttime;
 }
 
-static u64 get_vtime_delta(struct task_struct *tsk)
+static u64 get_vtime_delta(struct vtime *vtime)
 {
-        unsigned long now = READ_ONCE(jiffies);
-        u64 delta, other;
+        u64 delta = vtime_delta(vtime);
+        u64 other;
 
         /*
          * Unlike tick based timing, vtime based timing never has lost
@@ -701,104 +702,138 @@ static u64 get_vtime_delta(struct task_struct *tsk)
          * elapsed time. Limit account_other_time to prevent rounding
          * errors from causing elapsed vtime to go negative.
          */
-        delta = jiffies_to_nsecs(now - tsk->vtime_snap);
         other = account_other_time(delta);
-        WARN_ON_ONCE(tsk->vtime_snap_whence == VTIME_INACTIVE);
-        tsk->vtime_snap = now;
+        WARN_ON_ONCE(vtime->state == VTIME_INACTIVE);
+        vtime->starttime += delta;
 
         return delta - other;
 }
 
-static void __vtime_account_system(struct task_struct *tsk)
+static void __vtime_account_system(struct task_struct *tsk,
+                                   struct vtime *vtime)
 {
-        account_system_time(tsk, irq_count(), get_vtime_delta(tsk));
+        vtime->stime += get_vtime_delta(vtime);
+        if (vtime->stime >= TICK_NSEC) {
+                account_system_time(tsk, irq_count(), vtime->stime);
+                vtime->stime = 0;
+        }
+}
+
+static void vtime_account_guest(struct task_struct *tsk,
+                                struct vtime *vtime)
+{
+        vtime->gtime += get_vtime_delta(vtime);
+        if (vtime->gtime >= TICK_NSEC) {
+                account_guest_time(tsk, vtime->gtime);
+                vtime->gtime = 0;
+        }
 }
 
 void vtime_account_system(struct task_struct *tsk)
 {
-        if (!vtime_delta(tsk))
+        struct vtime *vtime = &tsk->vtime;
+
+        if (!vtime_delta(vtime))
                 return;
 
-        write_seqcount_begin(&tsk->vtime_seqcount);
-        __vtime_account_system(tsk);
-        write_seqcount_end(&tsk->vtime_seqcount);
+        write_seqcount_begin(&vtime->seqcount);
+        /* We might have scheduled out from guest path */
+        if (current->flags & PF_VCPU)
+                vtime_account_guest(tsk, vtime);
+        else
+                __vtime_account_system(tsk, vtime);
+        write_seqcount_end(&vtime->seqcount);
 }
 
-void vtime_account_user(struct task_struct *tsk)
+void vtime_user_enter(struct task_struct *tsk)
 {
-        write_seqcount_begin(&tsk->vtime_seqcount);
-        tsk->vtime_snap_whence = VTIME_SYS;
-        if (vtime_delta(tsk))
-                account_user_time(tsk, get_vtime_delta(tsk));
-        write_seqcount_end(&tsk->vtime_seqcount);
+        struct vtime *vtime = &tsk->vtime;
+
+        write_seqcount_begin(&vtime->seqcount);
+        __vtime_account_system(tsk, vtime);
+        vtime->state = VTIME_USER;
+        write_seqcount_end(&vtime->seqcount);
 }
 
-void vtime_user_enter(struct task_struct *tsk)
+void vtime_user_exit(struct task_struct *tsk)
 {
-        write_seqcount_begin(&tsk->vtime_seqcount);
-        if (vtime_delta(tsk))
-                __vtime_account_system(tsk);
-        tsk->vtime_snap_whence = VTIME_USER;
-        write_seqcount_end(&tsk->vtime_seqcount);
+        struct vtime *vtime = &tsk->vtime;
+
+        write_seqcount_begin(&vtime->seqcount);
+        vtime->utime += get_vtime_delta(vtime);
+        if (vtime->utime >= TICK_NSEC) {
+                account_user_time(tsk, vtime->utime);
+                vtime->utime = 0;
+        }
+        vtime->state = VTIME_SYS;
+        write_seqcount_end(&vtime->seqcount);
 }
 
 void vtime_guest_enter(struct task_struct *tsk)
 {
+        struct vtime *vtime = &tsk->vtime;
         /*
          * The flags must be updated under the lock with
-         * the vtime_snap flush and update.
+         * the vtime_starttime flush and update.
          * That enforces a right ordering and update sequence
          * synchronization against the reader (task_gtime())
          * that can thus safely catch up with a tickless delta.
          */
-        write_seqcount_begin(&tsk->vtime_seqcount);
-        if (vtime_delta(tsk))
-                __vtime_account_system(tsk);
+        write_seqcount_begin(&vtime->seqcount);
+        __vtime_account_system(tsk, vtime);
         current->flags |= PF_VCPU;
-        write_seqcount_end(&tsk->vtime_seqcount);
+        write_seqcount_end(&vtime->seqcount);
 }
 EXPORT_SYMBOL_GPL(vtime_guest_enter);
 
 void vtime_guest_exit(struct task_struct *tsk)
 {
-        write_seqcount_begin(&tsk->vtime_seqcount);
-        __vtime_account_system(tsk);
+        struct vtime *vtime = &tsk->vtime;
+
+        write_seqcount_begin(&vtime->seqcount);
+        vtime_account_guest(tsk, vtime);
         current->flags &= ~PF_VCPU;
-        write_seqcount_end(&tsk->vtime_seqcount);
+        write_seqcount_end(&vtime->seqcount);
 }
 EXPORT_SYMBOL_GPL(vtime_guest_exit);
 
 void vtime_account_idle(struct task_struct *tsk)
 {
-        account_idle_time(get_vtime_delta(tsk));
+        account_idle_time(get_vtime_delta(&tsk->vtime));
 }
 
 void arch_vtime_task_switch(struct task_struct *prev)
 {
-        write_seqcount_begin(&prev->vtime_seqcount);
-        prev->vtime_snap_whence = VTIME_INACTIVE;
-        write_seqcount_end(&prev->vtime_seqcount);
+        struct vtime *vtime = &prev->vtime;
 
-        write_seqcount_begin(&current->vtime_seqcount);
-        current->vtime_snap_whence = VTIME_SYS;
-        current->vtime_snap = jiffies;
-        write_seqcount_end(&current->vtime_seqcount);
+        write_seqcount_begin(&vtime->seqcount);
+        vtime->state = VTIME_INACTIVE;
+        write_seqcount_end(&vtime->seqcount);
+
+        vtime = &current->vtime;
+
+        write_seqcount_begin(&vtime->seqcount);
+        vtime->state = VTIME_SYS;
+        vtime->starttime = sched_clock();
+        write_seqcount_end(&vtime->seqcount);
 }
 
 void vtime_init_idle(struct task_struct *t, int cpu)
 {
+        struct vtime *vtime = &t->vtime;
         unsigned long flags;
 
         local_irq_save(flags);
-        write_seqcount_begin(&t->vtime_seqcount);
-        t->vtime_snap_whence = VTIME_SYS;
-        t->vtime_snap = jiffies;
-        write_seqcount_end(&t->vtime_seqcount);
+        write_seqcount_begin(&vtime->seqcount);
+        vtime->state = VTIME_SYS;
+        vtime->starttime = sched_clock();
+        write_seqcount_end(&vtime->seqcount);
         local_irq_restore(flags);
 }
 
 u64 task_gtime(struct task_struct *t)
 {
+        struct vtime *vtime = &t->vtime;
         unsigned int seq;
         u64 gtime;
 
@@ -806,13 +841,13 @@ u64 task_gtime(struct task_struct *t)
                 return t->gtime;
 
         do {
-                seq = read_seqcount_begin(&t->vtime_seqcount);
+                seq = read_seqcount_begin(&vtime->seqcount);
 
                 gtime = t->gtime;
-                if (t->vtime_snap_whence == VTIME_SYS && t->flags & PF_VCPU)
-                        gtime += vtime_delta(t);
+                if (vtime->state == VTIME_SYS && t->flags & PF_VCPU)
+                        gtime += vtime->gtime + vtime_delta(vtime);
 
-        } while (read_seqcount_retry(&t->vtime_seqcount, seq));
+        } while (read_seqcount_retry(&vtime->seqcount, seq));
 
         return gtime;
 }
@@ -824,8 +859,9 @@ u64 task_gtime(struct task_struct *t)
  */
 void task_cputime(struct task_struct *t, u64 *utime, u64 *stime)
 {
-        u64 delta;
+        struct vtime *vtime = &t->vtime;
         unsigned int seq;
+        u64 delta;
 
         if (!vtime_accounting_enabled()) {
                 *utime = t->utime;
@@ -834,25 +870,25 @@ void task_cputime(struct task_struct *t, u64 *utime, u64 *stime)
         }
 
         do {
-                seq = read_seqcount_begin(&t->vtime_seqcount);
+                seq = read_seqcount_begin(&vtime->seqcount);
 
                 *utime = t->utime;
                 *stime = t->stime;
 
                 /* Task is sleeping, nothing to add */
-                if (t->vtime_snap_whence == VTIME_INACTIVE || is_idle_task(t))
+                if (vtime->state == VTIME_INACTIVE || is_idle_task(t))
                         continue;
 
-                delta = vtime_delta(t);
+                delta = vtime_delta(vtime);
 
                 /*
                  * Task runs either in user or kernel space, add pending nohz time to
                  * the right place.
                  */
-                if (t->vtime_snap_whence == VTIME_USER || t->flags & PF_VCPU)
-                        *utime += delta;
-                else if (t->vtime_snap_whence == VTIME_SYS)
-                        *stime += delta;
-        } while (read_seqcount_retry(&t->vtime_seqcount, seq));
+                if (vtime->state == VTIME_USER || t->flags & PF_VCPU)
+                        *utime += vtime->utime + delta;
+                else if (vtime->state == VTIME_SYS)
+                        *stime += vtime->stime + delta;
+        } while (read_seqcount_retry(&vtime->seqcount, seq));
 }
 #endif /* CONFIG_VIRT_CPU_ACCOUNTING_GEN */
diff --git a/kernel/sched/deadline.c b/kernel/sched/deadline.c
index a2ce59015642..755bd3f1a1a9 100644
--- a/kernel/sched/deadline.c
+++ b/kernel/sched/deadline.c
@@ -17,6 +17,7 @@
 #include "sched.h"
 
 #include <linux/slab.h>
+#include <uapi/linux/sched/types.h>
 
 struct dl_bandwidth def_dl_bandwidth;
 
@@ -43,6 +44,254 @@ static inline int on_dl_rq(struct sched_dl_entity *dl_se)
         return !RB_EMPTY_NODE(&dl_se->rb_node);
 }
 
+#ifdef CONFIG_SMP
+static inline struct dl_bw *dl_bw_of(int i)
+{
+        RCU_LOCKDEP_WARN(!rcu_read_lock_sched_held(),
+                         "sched RCU must be held");
+        return &cpu_rq(i)->rd->dl_bw;
+}
+
+static inline int dl_bw_cpus(int i)
+{
+        struct root_domain *rd = cpu_rq(i)->rd;
+        int cpus = 0;
+
+        RCU_LOCKDEP_WARN(!rcu_read_lock_sched_held(),
+                         "sched RCU must be held");
+        for_each_cpu_and(i, rd->span, cpu_active_mask)
+                cpus++;
+
+        return cpus;
+}
+#else
+static inline struct dl_bw *dl_bw_of(int i)
+{
+        return &cpu_rq(i)->dl.dl_bw;
+}
+
+static inline int dl_bw_cpus(int i)
+{
+        return 1;
+}
+#endif
+
+static inline
+void add_running_bw(u64 dl_bw, struct dl_rq *dl_rq)
+{
+        u64 old = dl_rq->running_bw;
+
+        lockdep_assert_held(&(rq_of_dl_rq(dl_rq))->lock);
+        dl_rq->running_bw += dl_bw;
+        SCHED_WARN_ON(dl_rq->running_bw < old); /* overflow */
+        SCHED_WARN_ON(dl_rq->running_bw > dl_rq->this_bw);
+}
+
+static inline
+void sub_running_bw(u64 dl_bw, struct dl_rq *dl_rq)
+{
+        u64 old = dl_rq->running_bw;
+
+        lockdep_assert_held(&(rq_of_dl_rq(dl_rq))->lock);
+        dl_rq->running_bw -= dl_bw;
+        SCHED_WARN_ON(dl_rq->running_bw > old); /* underflow */
+        if (dl_rq->running_bw > old)
+                dl_rq->running_bw = 0;
+}
+
+static inline
+void add_rq_bw(u64 dl_bw, struct dl_rq *dl_rq)
+{
+        u64 old = dl_rq->this_bw;
+
+        lockdep_assert_held(&(rq_of_dl_rq(dl_rq))->lock);
+        dl_rq->this_bw += dl_bw;
+        SCHED_WARN_ON(dl_rq->this_bw < old); /* overflow */
+}
+
+static inline
+void sub_rq_bw(u64 dl_bw, struct dl_rq *dl_rq)
+{
+        u64 old = dl_rq->this_bw;
+
+        lockdep_assert_held(&(rq_of_dl_rq(dl_rq))->lock);
+        dl_rq->this_bw -= dl_bw;
+        SCHED_WARN_ON(dl_rq->this_bw > old); /* underflow */
+        if (dl_rq->this_bw > old)
+                dl_rq->this_bw = 0;
+        SCHED_WARN_ON(dl_rq->running_bw > dl_rq->this_bw);
+}
+
+void dl_change_utilization(struct task_struct *p, u64 new_bw)
+{
+        struct rq *rq;
+
+        if (task_on_rq_queued(p))
+                return;
+
+        rq = task_rq(p);
+        if (p->dl.dl_non_contending) {
+                sub_running_bw(p->dl.dl_bw, &rq->dl);
+                p->dl.dl_non_contending = 0;
+                /*
+                 * If the timer handler is currently running and the
+                 * timer cannot be cancelled, inactive_task_timer()
+                 * will see that dl_not_contending is not set, and
+                 * will not touch the rq's active utilization,
+                 * so we are still safe.
+                 */
+                if (hrtimer_try_to_cancel(&p->dl.inactive_timer) == 1)
+                        put_task_struct(p);
+        }
+        sub_rq_bw(p->dl.dl_bw, &rq->dl);
+        add_rq_bw(new_bw, &rq->dl);
+}
+
+/*
+ * The utilization of a task cannot be immediately removed from
+ * the rq active utilization (running_bw) when the task blocks.
+ * Instead, we have to wait for the so called "0-lag time".
+ *
+ * If a task blocks before the "0-lag time", a timer (the inactive
+ * timer) is armed, and running_bw is decreased when the timer
+ * fires.
+ *
+ * If the task wakes up again before the inactive timer fires,
+ * the timer is cancelled, whereas if the task wakes up after the
+ * inactive timer fired (and running_bw has been decreased) the
+ * task's utilization has to be added to running_bw again.
+ * A flag in the deadline scheduling entity (dl_non_contending)
+ * is used to avoid race conditions between the inactive timer handler
+ * and task wakeups.
+ *
+ * The following diagram shows how running_bw is updated. A task is
+ * "ACTIVE" when its utilization contributes to running_bw; an
+ * "ACTIVE contending" task is in the TASK_RUNNING state, while an
+ * "ACTIVE non contending" task is a blocked task for which the "0-lag time"
+ * has not passed yet. An "INACTIVE" task is a task for which the "0-lag"
+ * time already passed, which does not contribute to running_bw anymore.
+ *                              +------------------+
+ *             wakeup           |    ACTIVE        |
+ *          +------------------>+   contending     |
+ *          | add_running_bw    |                  |
+ *          |                   +----+------+------+
+ *          |                        |      ^
+ *          |                dequeue |      |
+ * +--------+-------+                |      |
+ * |                |   t >= 0-lag   |      | wakeup
+ * |    INACTIVE    |<---------------+      |
+ * |                | sub_running_bw |      |
+ * +--------+-------+                |      |
+ *          ^                        |      |
+ *          |              t < 0-lag |      |
+ *          |                        |      |
+ *          |                        V      |
+ *          |                   +----+------+------+
+ *          | sub_running_bw    |    ACTIVE        |
+ *          +-------------------+                  |
+ *            inactive timer    |  non contending  |
+ *            fired             +------------------+
+ *
+ * The task_non_contending() function is invoked when a task
+ * blocks, and checks if the 0-lag time already passed or
+ * not (in the first case, it directly updates running_bw;
+ * in the second case, it arms the inactive timer).
+ *
+ * The task_contending() function is invoked when a task wakes
+ * up, and checks if the task is still in the "ACTIVE non contending"
+ * state or not (in the second case, it updates running_bw).
+ */
+static void task_non_contending(struct task_struct *p)
+{
+        struct sched_dl_entity *dl_se = &p->dl;
+        struct hrtimer *timer = &dl_se->inactive_timer;
+        struct dl_rq *dl_rq = dl_rq_of_se(dl_se);
+        struct rq *rq = rq_of_dl_rq(dl_rq);
+        s64 zerolag_time;
+
+        /*
+         * If this is a non-deadline task that has been boosted,
+         * do nothing
+         */
+        if (dl_se->dl_runtime == 0)
+                return;
+
+        WARN_ON(hrtimer_active(&dl_se->inactive_timer));
+        WARN_ON(dl_se->dl_non_contending);
+
+        zerolag_time = dl_se->deadline -
+                 div64_long((dl_se->runtime * dl_se->dl_period),
+                        dl_se->dl_runtime);
+
+        /*
+         * Using relative times instead of the absolute "0-lag time"
+         * allows to simplify the code
+         */
+        zerolag_time -= rq_clock(rq);
+
+        /*
+         * If the "0-lag time" already passed, decrease the active
+         * utilization now, instead of starting a timer
+         */
+        if (zerolag_time < 0) {
+                if (dl_task(p))
+                        sub_running_bw(dl_se->dl_bw, dl_rq);
+                if (!dl_task(p) || p->state == TASK_DEAD) {
+                        struct dl_bw *dl_b = dl_bw_of(task_cpu(p));
+
+                        if (p->state == TASK_DEAD)
+                                sub_rq_bw(p->dl.dl_bw, &rq->dl);
+                        raw_spin_lock(&dl_b->lock);
+                        __dl_clear(dl_b, p->dl.dl_bw, dl_bw_cpus(task_cpu(p)));
+                        __dl_clear_params(p);
+                        raw_spin_unlock(&dl_b->lock);
+                }
+
+                return;
+        }
+
+        dl_se->dl_non_contending = 1;
+        get_task_struct(p);
+        hrtimer_start(timer, ns_to_ktime(zerolag_time), HRTIMER_MODE_REL);
+}
+
+static void task_contending(struct sched_dl_entity *dl_se, int flags)
+{
+        struct dl_rq *dl_rq = dl_rq_of_se(dl_se);
+
+        /*
+         * If this is a non-deadline task that has been boosted,
+         * do nothing
+         */
+        if (dl_se->dl_runtime == 0)
+                return;
+
+        if (flags & ENQUEUE_MIGRATED)
+                add_rq_bw(dl_se->dl_bw, dl_rq);
+
+        if (dl_se->dl_non_contending) {
+                dl_se->dl_non_contending = 0;
+                /*
+                 * If the timer handler is currently running and the
+                 * timer cannot be cancelled, inactive_task_timer()
+                 * will see that dl_not_contending is not set, and
+                 * will not touch the rq's active utilization,
+                 * so we are still safe.
+                 */
+                if (hrtimer_try_to_cancel(&dl_se->inactive_timer) == 1)
+                        put_task_struct(dl_task_of(dl_se));
+        } else {
+                /*
+                 * Since "dl_non_contending" is not set, the
+                 * task's utilization has already been removed from
+                 * active utilization (either when the task blocked,
+                 * when the "inactive timer" fired).
+                 * So, add it back.
+                 */
+                add_running_bw(dl_se->dl_bw, dl_rq);
+        }
+}
+
 static inline int is_leftmost(struct task_struct *p, struct dl_rq *dl_rq)
 {
         struct sched_dl_entity *dl_se = &p->dl;
@@ -83,6 +332,10 @@ void init_dl_rq(struct dl_rq *dl_rq)
 #else
         init_dl_bw(&dl_rq->dl_bw);
 #endif
+
+        dl_rq->running_bw = 0;
+        dl_rq->this_bw = 0;
+        init_dl_rq_bw_ratio(dl_rq);
 }
 
 #ifdef CONFIG_SMP
@@ -484,13 +737,84 @@ static bool dl_entity_overflow(struct sched_dl_entity *dl_se,
 }
 
 /*
- * When a -deadline entity is queued back on the runqueue, its runtime and
- * deadline might need updating.
+ * Revised wakeup rule [1]: For self-suspending tasks, rather then
+ * re-initializing task's runtime and deadline, the revised wakeup
+ * rule adjusts the task's runtime to avoid the task to overrun its
+ * density.
+ *
+ * Reasoning: a task may overrun the density if:
+ *    runtime / (deadline - t) > dl_runtime / dl_deadline
+ *
+ * Therefore, runtime can be adjusted to:
+ *     runtime = (dl_runtime / dl_deadline) * (deadline - t)
+ *
+ * In such way that runtime will be equal to the maximum density
+ * the task can use without breaking any rule.
+ *
+ * [1] Luca Abeni, Giuseppe Lipari, and Juri Lelli. 2015. Constant
+ * bandwidth server revisited. SIGBED Rev. 11, 4 (January 2015), 19-24.
+ */
+static void
+update_dl_revised_wakeup(struct sched_dl_entity *dl_se, struct rq *rq)
+{
+        u64 laxity = dl_se->deadline - rq_clock(rq);
+
+        /*
+         * If the task has deadline < period, and the deadline is in the past,
+         * it should already be throttled before this check.
+         *
+         * See update_dl_entity() comments for further details.
+         */
+        WARN_ON(dl_time_before(dl_se->deadline, rq_clock(rq)));
+
+        dl_se->runtime = (dl_se->dl_density * laxity) >> BW_SHIFT;
+}
+
+/*
+ * Regarding the deadline, a task with implicit deadline has a relative
+ * deadline == relative period. A task with constrained deadline has a
+ * relative deadline <= relative period.
+ *
+ * We support constrained deadline tasks. However, there are some restrictions
+ * applied only for tasks which do not have an implicit deadline. See
+ * update_dl_entity() to know more about such restrictions.
+ *
+ * The dl_is_implicit() returns true if the task has an implicit deadline.
+ */
+static inline bool dl_is_implicit(struct sched_dl_entity *dl_se)
+{
+        return dl_se->dl_deadline == dl_se->dl_period;
+}
+
+/*
+ * When a deadline entity is placed in the runqueue, its runtime and deadline
+ * might need to be updated. This is done by a CBS wake up rule. There are two
+ * different rules: 1) the original CBS; and 2) the Revisited CBS.
+ *
+ * When the task is starting a new period, the Original CBS is used. In this
+ * case, the runtime is replenished and a new absolute deadline is set.
+ *
+ * When a task is queued before the begin of the next period, using the
+ * remaining runtime and deadline could make the entity to overflow, see
+ * dl_entity_overflow() to find more about runtime overflow. When such case
+ * is detected, the runtime and deadline need to be updated.
+ *
+ * If the task has an implicit deadline, i.e., deadline == period, the Original
+ * CBS is applied. the runtime is replenished and a new absolute deadline is
+ * set, as in the previous cases.
+ *
+ * However, the Original CBS does not work properly for tasks with
+ * deadline < period, which are said to have a constrained deadline. By
+ * applying the Original CBS, a constrained deadline task would be able to run
+ * runtime/deadline in a period. With deadline < period, the task would
+ * overrun the runtime/period allowed bandwidth, breaking the admission test.
  *
- * The policy here is that we update the deadline of the entity only if:
- *  - the current deadline is in the past,
- *  - using the remaining runtime with the current deadline would make
- *    the entity exceed its bandwidth.
+ * In order to prevent this misbehave, the Revisited CBS is used for
+ * constrained deadline tasks when a runtime overflow is detected. In the
+ * Revisited CBS, rather than replenishing & setting a new absolute deadline,
+ * the remaining runtime of the task is reduced to avoid runtime overflow.
+ * Please refer to the comments update_dl_revised_wakeup() function to find
+ * more about the Revised CBS rule.
  */
 static void update_dl_entity(struct sched_dl_entity *dl_se,
                              struct sched_dl_entity *pi_se)
@@ -500,6 +824,14 @@ static void update_dl_entity(struct sched_dl_entity *dl_se,
 
         if (dl_time_before(dl_se->deadline, rq_clock(rq)) ||
             dl_entity_overflow(dl_se, pi_se, rq_clock(rq))) {
+
+                if (unlikely(!dl_is_implicit(dl_se) &&
+                             !dl_time_before(dl_se->deadline, rq_clock(rq)) &&
+                             !dl_se->dl_boosted)){
+                        update_dl_revised_wakeup(dl_se, rq);
+                        return;
+                }
+
                 dl_se->deadline = rq_clock(rq) + pi_se->dl_deadline;
                 dl_se->runtime = pi_se->dl_runtime;
         }
@@ -593,10 +925,8 @@ static enum hrtimer_restart dl_task_timer(struct hrtimer *timer)
          * The task might have changed its scheduling policy to something
          * different than SCHED_DEADLINE (through switched_from_dl()).
          */
-        if (!dl_task(p)) {
-                __dl_clear_params(p);
+        if (!dl_task(p))
                 goto unlock;
-        }
 
         /*
          * The task might have been boosted by someone else and might be in the
@@ -723,6 +1053,8 @@ static inline void dl_check_constrained_dl(struct sched_dl_entity *dl_se)
                 if (unlikely(dl_se->dl_boosted || !start_dl_timer(p)))
                         return;
                 dl_se->dl_throttled = 1;
+                if (dl_se->runtime > 0)
+                        dl_se->runtime = 0;
         }
 }
 
@@ -735,6 +1067,47 @@ int dl_runtime_exceeded(struct sched_dl_entity *dl_se)
 extern bool sched_rt_bandwidth_account(struct rt_rq *rt_rq);
 
 /*
+ * This function implements the GRUB accounting rule:
+ * according to the GRUB reclaiming algorithm, the runtime is
+ * not decreased as "dq = -dt", but as
+ * "dq = -max{u / Umax, (1 - Uinact - Uextra)} dt",
+ * where u is the utilization of the task, Umax is the maximum reclaimable
+ * utilization, Uinact is the (per-runqueue) inactive utilization, computed
+ * as the difference between the "total runqueue utilization" and the
+ * runqueue active utilization, and Uextra is the (per runqueue) extra
+ * reclaimable utilization.
+ * Since rq->dl.running_bw and rq->dl.this_bw contain utilizations
+ * multiplied by 2^BW_SHIFT, the result has to be shifted right by
+ * BW_SHIFT.
+ * Since rq->dl.bw_ratio contains 1 / Umax multipled by 2^RATIO_SHIFT,
+ * dl_bw is multiped by rq->dl.bw_ratio and shifted right by RATIO_SHIFT.
+ * Since delta is a 64 bit variable, to have an overflow its value
+ * should be larger than 2^(64 - 20 - 8), which is more than 64 seconds.
+ * So, overflow is not an issue here.
+ */
+u64 grub_reclaim(u64 delta, struct rq *rq, struct sched_dl_entity *dl_se)
+{
+        u64 u_inact = rq->dl.this_bw - rq->dl.running_bw; /* Utot - Uact */
+        u64 u_act;
+        u64 u_act_min = (dl_se->dl_bw * rq->dl.bw_ratio) >> RATIO_SHIFT;
+
+        /*
+         * Instead of computing max{u * bw_ratio, (1 - u_inact - u_extra)},
+         * we compare u_inact + rq->dl.extra_bw with
+         * 1 - (u * rq->dl.bw_ratio >> RATIO_SHIFT), because
+         * u_inact + rq->dl.extra_bw can be larger than
+         * 1 * (so, 1 - u_inact - rq->dl.extra_bw would be negative
+         * leading to wrong results)
+         */
+        if (u_inact + rq->dl.extra_bw > BW_UNIT - u_act_min)
+                u_act = u_act_min;
+        else
+                u_act = BW_UNIT - u_inact - rq->dl.extra_bw;
+
+        return (delta * u_act) >> BW_SHIFT;
+}
+
+/*
  * Update the current task's runtime statistics (provided it is still
  * a -deadline task and has not been removed from the dl_rq).
  */
@@ -776,6 +1149,8 @@ static void update_curr_dl(struct rq *rq)
 
         sched_rt_avg_update(rq, delta_exec);
 
+        if (unlikely(dl_se->flags & SCHED_FLAG_RECLAIM))
+                delta_exec = grub_reclaim(delta_exec, rq, &curr->dl);
         dl_se->runtime -= delta_exec;
 
 throttle:
@@ -815,6 +1190,56 @@ throttle:
         }
 }
 
+static enum hrtimer_restart inactive_task_timer(struct hrtimer *timer)
+{
+        struct sched_dl_entity *dl_se = container_of(timer,
+                                                     struct sched_dl_entity,
+                                                     inactive_timer);
+        struct task_struct *p = dl_task_of(dl_se);
+        struct rq_flags rf;
+        struct rq *rq;
+
+        rq = task_rq_lock(p, &rf);
+
+        if (!dl_task(p) || p->state == TASK_DEAD) {
+                struct dl_bw *dl_b = dl_bw_of(task_cpu(p));
+
+                if (p->state == TASK_DEAD && dl_se->dl_non_contending) {
+                        sub_running_bw(p->dl.dl_bw, dl_rq_of_se(&p->dl));
+                        sub_rq_bw(p->dl.dl_bw, dl_rq_of_se(&p->dl));
+                        dl_se->dl_non_contending = 0;
+                }
+
+                raw_spin_lock(&dl_b->lock);
+                __dl_clear(dl_b, p->dl.dl_bw, dl_bw_cpus(task_cpu(p)));
+                raw_spin_unlock(&dl_b->lock);
+                __dl_clear_params(p);
+
+                goto unlock;
+        }
+        if (dl_se->dl_non_contending == 0)
+                goto unlock;
+
+        sched_clock_tick();
+        update_rq_clock(rq);
+
+        sub_running_bw(dl_se->dl_bw, &rq->dl);
+        dl_se->dl_non_contending = 0;
+unlock:
+        task_rq_unlock(rq, p, &rf);
+        put_task_struct(p);
+
+        return HRTIMER_NORESTART;
+}
+
+void init_dl_inactive_task_timer(struct sched_dl_entity *dl_se)
+{
+        struct hrtimer *timer = &dl_se->inactive_timer;
+
+        hrtimer_init(timer, CLOCK_MONOTONIC, HRTIMER_MODE_REL);
+        timer->function = inactive_task_timer;
+}
+
 #ifdef CONFIG_SMP
 
 static void inc_dl_deadline(struct dl_rq *dl_rq, u64 deadline)
@@ -946,10 +1371,12 @@ enqueue_dl_entity(struct sched_dl_entity *dl_se,
          * parameters of the task might need updating. Otherwise,
          * we want a replenishment of its runtime.
          */
-        if (flags & ENQUEUE_WAKEUP)
+        if (flags & ENQUEUE_WAKEUP) {
+                task_contending(dl_se, flags);
                 update_dl_entity(dl_se, pi_se);
-        else if (flags & ENQUEUE_REPLENISH)
+        } else if (flags & ENQUEUE_REPLENISH) {
                 replenish_dl_entity(dl_se, pi_se);
+        }
 
         __enqueue_dl_entity(dl_se);
 }
@@ -959,28 +1386,25 @@ static void dequeue_dl_entity(struct sched_dl_entity *dl_se)
         __dequeue_dl_entity(dl_se);
 }
 
-static inline bool dl_is_constrained(struct sched_dl_entity *dl_se)
-{
-        return dl_se->dl_deadline < dl_se->dl_period;
-}
-
 static void enqueue_task_dl(struct rq *rq, struct task_struct *p, int flags)
 {
         struct task_struct *pi_task = rt_mutex_get_top_task(p);
         struct sched_dl_entity *pi_se = &p->dl;
 
         /*
-         * Use the scheduling parameters of the top pi-waiter
-         * task if we have one and its (absolute) deadline is
-         * smaller than our one... OTW we keep our runtime and
-         * deadline.
+         * Use the scheduling parameters of the top pi-waiter task if:
+         * - we have a top pi-waiter which is a SCHED_DEADLINE task AND
+         * - our dl_boosted is set (i.e. the pi-waiter's (absolute) deadline is
+         *   smaller than our deadline OR we are a !SCHED_DEADLINE task getting
+         *   boosted due to a SCHED_DEADLINE pi-waiter).
+         * Otherwise we keep our runtime and deadline.
          */
-        if (pi_task && p->dl.dl_boosted && dl_prio(pi_task->normal_prio)) {
+        if (pi_task && dl_prio(pi_task->normal_prio) && p->dl.dl_boosted) {
                 pi_se = &pi_task->dl;
         } else if (!dl_prio(p->normal_prio)) {
                 /*
                  * Special case in which we have a !SCHED_DEADLINE task
-                 * that is going to be deboosted, but exceedes its
+                 * that is going to be deboosted, but exceeds its
                  * runtime while doing so. No point in replenishing
                  * it, as it's going to return back to its original
                  * scheduling class after this.
@@ -995,17 +1419,32 @@ static void enqueue_task_dl(struct rq *rq, struct task_struct *p, int flags)
          * If that is the case, the task will be throttled and
          * the replenishment timer will be set to the next period.
          */
-        if (!p->dl.dl_throttled && dl_is_constrained(&p->dl))
+        if (!p->dl.dl_throttled && !dl_is_implicit(&p->dl))
                 dl_check_constrained_dl(&p->dl);
 
+        if (p->on_rq == TASK_ON_RQ_MIGRATING || flags & ENQUEUE_RESTORE) {
+                add_rq_bw(p->dl.dl_bw, &rq->dl);
+                add_running_bw(p->dl.dl_bw, &rq->dl);
+        }
+
         /*
-         * If p is throttled, we do nothing. In fact, if it exhausted
+         * If p is throttled, we do not enqueue it. In fact, if it exhausted
          * its budget it needs a replenishment and, since it now is on
          * its rq, the bandwidth timer callback (which clearly has not
          * run yet) will take care of this.
+         * However, the active utilization does not depend on the fact
+         * that the task is on the runqueue or not (but depends on the
+         * task's state - in GRUB parlance, "inactive" vs "active contending").
+         * In other words, even if a task is throttled its utilization must
+         * be counted in the active utilization; hence, we need to call
+         * add_running_bw().
          */
-        if (p->dl.dl_throttled && !(flags & ENQUEUE_REPLENISH))
+        if (p->dl.dl_throttled && !(flags & ENQUEUE_REPLENISH)) {
+                if (flags & ENQUEUE_WAKEUP)
+                        task_contending(&p->dl, flags);
+
                 return;
+        }
 
         enqueue_dl_entity(&p->dl, pi_se, flags);
 
@@ -1023,6 +1462,23 @@ static void dequeue_task_dl(struct rq *rq, struct task_struct *p, int flags)
 {
         update_curr_dl(rq);
         __dequeue_task_dl(rq, p, flags);
+
+        if (p->on_rq == TASK_ON_RQ_MIGRATING || flags & DEQUEUE_SAVE) {
+                sub_running_bw(p->dl.dl_bw, &rq->dl);
+                sub_rq_bw(p->dl.dl_bw, &rq->dl);
+        }
+
+        /*
+         * This check allows to start the inactive timer (or to immediately
+         * decrease the active utilization, if needed) in two cases:
+         * when the task blocks and when it is terminating
+         * (p->state == TASK_DEAD). We can handle the two cases in the same
+         * way, because from GRUB's point of view the same thing is happening
+         * (the task moves from "active contending" to "active non contending"
+         * or "inactive")
+         */
+        if (flags & DEQUEUE_SLEEP)
+                task_non_contending(p);
 }
 
 /*
@@ -1100,6 +1556,37 @@ out:
         return cpu;
 }
 
+static void migrate_task_rq_dl(struct task_struct *p)
+{
+        struct rq *rq;
+
+        if (p->state != TASK_WAKING)
+                return;
+
+        rq = task_rq(p);
+        /*
+         * Since p->state == TASK_WAKING, set_task_cpu() has been called
+         * from try_to_wake_up(). Hence, p->pi_lock is locked, but
+         * rq->lock is not... So, lock it
+         */
+        raw_spin_lock(&rq->lock);
+        if (p->dl.dl_non_contending) {
+                sub_running_bw(p->dl.dl_bw, &rq->dl);
+                p->dl.dl_non_contending = 0;
+                /*
+                 * If the timer handler is currently running and the
+                 * timer cannot be cancelled, inactive_task_timer()
+                 * will see that dl_not_contending is not set, and
+                 * will not touch the rq's active utilization,
+                 * so we are still safe.
+                 */
+                if (hrtimer_try_to_cancel(&p->dl.inactive_timer) == 1)
+                        put_task_struct(p);
+        }
+        sub_rq_bw(p->dl.dl_bw, &rq->dl);
+        raw_spin_unlock(&rq->lock);
+}
+
 static void check_preempt_equal_dl(struct rq *rq, struct task_struct *p)
 {
         /*
@@ -1255,19 +1742,6 @@ static void task_fork_dl(struct task_struct *p)
          */
 }
 
-static void task_dead_dl(struct task_struct *p)
-{
-        struct dl_bw *dl_b = dl_bw_of(task_cpu(p));
-
-        /*
-         * Since we are TASK_DEAD we won't slip out of the domain!
-         */
-        raw_spin_lock_irq(&dl_b->lock);
-        /* XXX we should retain the bw until 0-lag */
-        dl_b->total_bw -= p->dl.dl_bw;
-        raw_spin_unlock_irq(&dl_b->lock);
-}
-
 static void set_curr_task_dl(struct rq *rq)
 {
         struct task_struct *p = rq->curr;
@@ -1533,7 +2007,7 @@ retry:
                  * then possible that next_task has migrated.
                  */
                 task = pick_next_pushable_dl_task(rq);
-                if (task_cpu(next_task) == rq->cpu && task == next_task) {
+                if (task == next_task) {
                         /*
                          * The task is still there. We don't try
                          * again, some other cpu will pull it when ready.
@@ -1551,7 +2025,11 @@ retry:
         }
 
         deactivate_task(rq, next_task, 0);
+        sub_running_bw(next_task->dl.dl_bw, &rq->dl);
+        sub_rq_bw(next_task->dl.dl_bw, &rq->dl);
         set_task_cpu(next_task, later_rq->cpu);
+        add_rq_bw(next_task->dl.dl_bw, &later_rq->dl);
+        add_running_bw(next_task->dl.dl_bw, &later_rq->dl);
         activate_task(later_rq, next_task, 0);
         ret = 1;
 
@@ -1639,7 +2117,11 @@ static void pull_dl_task(struct rq *this_rq)
                         resched = true;
 
                         deactivate_task(src_rq, p, 0);
+                        sub_running_bw(p->dl.dl_bw, &src_rq->dl);
+                        sub_rq_bw(p->dl.dl_bw, &src_rq->dl);
                         set_task_cpu(p, this_cpu);
+                        add_rq_bw(p->dl.dl_bw, &this_rq->dl);
+                        add_running_bw(p->dl.dl_bw, &this_rq->dl);
                         activate_task(this_rq, p, 0);
                         dmin = p->dl.deadline;
 
@@ -1695,7 +2177,7 @@ static void set_cpus_allowed_dl(struct task_struct *p,
                  * until we complete the update.
                  */
                 raw_spin_lock(&src_dl_b->lock);
-                __dl_clear(src_dl_b, p->dl.dl_bw);
+                __dl_clear(src_dl_b, p->dl.dl_bw, dl_bw_cpus(task_cpu(p)));
                 raw_spin_unlock(&src_dl_b->lock);
         }
 
@@ -1737,13 +2219,26 @@ void __init init_sched_dl_class(void)
 static void switched_from_dl(struct rq *rq, struct task_struct *p)
 {
         /*
-         * Start the deadline timer; if we switch back to dl before this we'll
-         * continue consuming our current CBS slice. If we stay outside of
-         * SCHED_DEADLINE until the deadline passes, the timer will reset the
-         * task.
+         * task_non_contending() can start the "inactive timer" (if the 0-lag
+         * time is in the future). If the task switches back to dl before
+         * the "inactive timer" fires, it can continue to consume its current
+         * runtime using its current deadline. If it stays outside of
+         * SCHED_DEADLINE until the 0-lag time passes, inactive_task_timer()
+         * will reset the task parameters.
          */
-        if (!start_dl_timer(p))
-                __dl_clear_params(p);
+        if (task_on_rq_queued(p) && p->dl.dl_runtime)
+                task_non_contending(p);
+
+        if (!task_on_rq_queued(p))
+                sub_rq_bw(p->dl.dl_bw, &rq->dl);
+
+        /*
+         * We cannot use inactive_task_timer() to invoke sub_running_bw()
+         * at the 0-lag time, because the task could have been migrated
+         * while SCHED_OTHER in the meanwhile.
+         */
+        if (p->dl.dl_non_contending)
+                p->dl.dl_non_contending = 0;
 
         /*
          * Since this might be the only -deadline task on the rq,
@@ -1762,11 +2257,15 @@ static void switched_from_dl(struct rq *rq, struct task_struct *p)
  */
 static void switched_to_dl(struct rq *rq, struct task_struct *p)
 {
+        if (hrtimer_try_to_cancel(&p->dl.inactive_timer) == 1)
+                put_task_struct(p);
 
         /* If p is not queued we will update its parameters at next wakeup. */
-        if (!task_on_rq_queued(p))
-                return;
+        if (!task_on_rq_queued(p)) {
+                add_rq_bw(p->dl.dl_bw, &rq->dl);
 
+                return;
+        }
         /*
          * If p is boosted we already updated its params in
          * rt_mutex_setprio()->enqueue_task(..., ENQUEUE_REPLENISH),
@@ -1836,6 +2335,7 @@ const struct sched_class dl_sched_class = {
 
 #ifdef CONFIG_SMP
         .select_task_rq         = select_task_rq_dl,
+        .migrate_task_rq        = migrate_task_rq_dl,
         .set_cpus_allowed       = set_cpus_allowed_dl,
         .rq_online              = rq_online_dl,
         .rq_offline             = rq_offline_dl,
@@ -1845,7 +2345,6 @@ const struct sched_class dl_sched_class = {
         .set_curr_task          = set_curr_task_dl,
         .task_tick              = task_tick_dl,
         .task_fork              = task_fork_dl,
-        .task_dead              = task_dead_dl,
 
         .prio_changed           = prio_changed_dl,
         .switched_from          = switched_from_dl,
@@ -1854,6 +2353,317 @@ const struct sched_class dl_sched_class = {
         .update_curr            = update_curr_dl,
 };
 
+int sched_dl_global_validate(void)
+{
+        u64 runtime = global_rt_runtime();
+        u64 period = global_rt_period();
+        u64 new_bw = to_ratio(period, runtime);
+        struct dl_bw *dl_b;
+        int cpu, ret = 0;
+        unsigned long flags;
+
+        /*
+         * Here we want to check the bandwidth not being set to some
+         * value smaller than the currently allocated bandwidth in
+         * any of the root_domains.
+         *
+         * FIXME: Cycling on all the CPUs is overdoing, but simpler than
+         * cycling on root_domains... Discussion on different/better
+         * solutions is welcome!
+         */
+        for_each_possible_cpu(cpu) {
+                rcu_read_lock_sched();
+                dl_b = dl_bw_of(cpu);
+
+                raw_spin_lock_irqsave(&dl_b->lock, flags);
+                if (new_bw < dl_b->total_bw)
+                        ret = -EBUSY;
+                raw_spin_unlock_irqrestore(&dl_b->lock, flags);
+
+                rcu_read_unlock_sched();
+
+                if (ret)
+                        break;
+        }
+
+        return ret;
+}
+
+void init_dl_rq_bw_ratio(struct dl_rq *dl_rq)
+{
+        if (global_rt_runtime() == RUNTIME_INF) {
+                dl_rq->bw_ratio = 1 << RATIO_SHIFT;
+                dl_rq->extra_bw = 1 << BW_SHIFT;
+        } else {
+                dl_rq->bw_ratio = to_ratio(global_rt_runtime(),
+                          global_rt_period()) >> (BW_SHIFT - RATIO_SHIFT);
+                dl_rq->extra_bw = to_ratio(global_rt_period(),
+                                                    global_rt_runtime());
+        }
+}
+
+void sched_dl_do_global(void)
+{
+        u64 new_bw = -1;
+        struct dl_bw *dl_b;
+        int cpu;
+        unsigned long flags;
+
+        def_dl_bandwidth.dl_period = global_rt_period();
+        def_dl_bandwidth.dl_runtime = global_rt_runtime();
+
+        if (global_rt_runtime() != RUNTIME_INF)
+                new_bw = to_ratio(global_rt_period(), global_rt_runtime());
+
+        /*
+         * FIXME: As above...
+         */
+        for_each_possible_cpu(cpu) {
+                rcu_read_lock_sched();
+                dl_b = dl_bw_of(cpu);
+
+                raw_spin_lock_irqsave(&dl_b->lock, flags);
+                dl_b->bw = new_bw;
+                raw_spin_unlock_irqrestore(&dl_b->lock, flags);
+
+                rcu_read_unlock_sched();
+                init_dl_rq_bw_ratio(&cpu_rq(cpu)->dl);
+        }
+}
+
+/*
+ * We must be sure that accepting a new task (or allowing changing the
+ * parameters of an existing one) is consistent with the bandwidth
+ * constraints. If yes, this function also accordingly updates the currently
+ * allocated bandwidth to reflect the new situation.
+ *
+ * This function is called while holding p's rq->lock.
+ */
+int sched_dl_overflow(struct task_struct *p, int policy,
+                      const struct sched_attr *attr)
+{
+        struct dl_bw *dl_b = dl_bw_of(task_cpu(p));
+        u64 period = attr->sched_period ?: attr->sched_deadline;
+        u64 runtime = attr->sched_runtime;
+        u64 new_bw = dl_policy(policy) ? to_ratio(period, runtime) : 0;
+        int cpus, err = -1;
+
+        /* !deadline task may carry old deadline bandwidth */
+        if (new_bw == p->dl.dl_bw && task_has_dl_policy(p))
+                return 0;
+
+        /*
+         * Either if a task, enters, leave, or stays -deadline but changes
+         * its parameters, we may need to update accordingly the total
+         * allocated bandwidth of the container.
+         */
+        raw_spin_lock(&dl_b->lock);
+        cpus = dl_bw_cpus(task_cpu(p));
+        if (dl_policy(policy) && !task_has_dl_policy(p) &&
+            !__dl_overflow(dl_b, cpus, 0, new_bw)) {
+                if (hrtimer_active(&p->dl.inactive_timer))
+                        __dl_clear(dl_b, p->dl.dl_bw, cpus);
+                __dl_add(dl_b, new_bw, cpus);
+                err = 0;
+        } else if (dl_policy(policy) && task_has_dl_policy(p) &&
+                   !__dl_overflow(dl_b, cpus, p->dl.dl_bw, new_bw)) {
+                /*
+                 * XXX this is slightly incorrect: when the task
+                 * utilization decreases, we should delay the total
+                 * utilization change until the task's 0-lag point.
+                 * But this would require to set the task's "inactive
+                 * timer" when the task is not inactive.
+                 */
+                __dl_clear(dl_b, p->dl.dl_bw, cpus);
+                __dl_add(dl_b, new_bw, cpus);
+                dl_change_utilization(p, new_bw);
+                err = 0;
+        } else if (!dl_policy(policy) && task_has_dl_policy(p)) {
+                /*
+                 * Do not decrease the total deadline utilization here,
+                 * switched_from_dl() will take care to do it at the correct
+                 * (0-lag) time.
+                 */
+                err = 0;
+        }
+        raw_spin_unlock(&dl_b->lock);
+
+        return err;
+}
+
+/*
+ * This function initializes the sched_dl_entity of a newly becoming
+ * SCHED_DEADLINE task.
+ *
+ * Only the static values are considered here, the actual runtime and the
+ * absolute deadline will be properly calculated when the task is enqueued
+ * for the first time with its new policy.
+ */
+void __setparam_dl(struct task_struct *p, const struct sched_attr *attr)
+{
+        struct sched_dl_entity *dl_se = &p->dl;
+
+        dl_se->dl_runtime = attr->sched_runtime;
+        dl_se->dl_deadline = attr->sched_deadline;
+        dl_se->dl_period = attr->sched_period ?: dl_se->dl_deadline;
+        dl_se->flags = attr->sched_flags;
+        dl_se->dl_bw = to_ratio(dl_se->dl_period, dl_se->dl_runtime);
+        dl_se->dl_density = to_ratio(dl_se->dl_deadline, dl_se->dl_runtime);
+}
+
+void __getparam_dl(struct task_struct *p, struct sched_attr *attr)
+{
+        struct sched_dl_entity *dl_se = &p->dl;
+
+        attr->sched_priority = p->rt_priority;
+        attr->sched_runtime = dl_se->dl_runtime;
+        attr->sched_deadline = dl_se->dl_deadline;
+        attr->sched_period = dl_se->dl_period;
+        attr->sched_flags = dl_se->flags;
+}
+
+/*
+ * This function validates the new parameters of a -deadline task.
+ * We ask for the deadline not being zero, and greater or equal
+ * than the runtime, as well as the period of being zero or
+ * greater than deadline. Furthermore, we have to be sure that
+ * user parameters are above the internal resolution of 1us (we
+ * check sched_runtime only since it is always the smaller one) and
+ * below 2^63 ns (we have to check both sched_deadline and
+ * sched_period, as the latter can be zero).
+ */
+bool __checkparam_dl(const struct sched_attr *attr)
+{
+        /* deadline != 0 */
+        if (attr->sched_deadline == 0)
+                return false;
+
+        /*
+         * Since we truncate DL_SCALE bits, make sure we're at least
+         * that big.
+         */
+        if (attr->sched_runtime < (1ULL << DL_SCALE))
+                return false;
+
+        /*
+         * Since we use the MSB for wrap-around and sign issues, make
+         * sure it's not set (mind that period can be equal to zero).
+         */
+        if (attr->sched_deadline & (1ULL << 63) ||
+            attr->sched_period & (1ULL << 63))
+                return false;
+
+        /* runtime <= deadline <= period (if period != 0) */
+        if ((attr->sched_period != 0 &&
+             attr->sched_period < attr->sched_deadline) ||
+            attr->sched_deadline < attr->sched_runtime)
+                return false;
+
+        return true;
+}
+
+/*
+ * This function clears the sched_dl_entity static params.
+ */
+void __dl_clear_params(struct task_struct *p)
+{
+        struct sched_dl_entity *dl_se = &p->dl;
+
+        dl_se->dl_runtime = 0;
+        dl_se->dl_deadline = 0;
+        dl_se->dl_period = 0;
+        dl_se->flags = 0;
+        dl_se->dl_bw = 0;
+        dl_se->dl_density = 0;
+
+        dl_se->dl_throttled = 0;
+        dl_se->dl_yielded = 0;
+        dl_se->dl_non_contending = 0;
+}
+
+bool dl_param_changed(struct task_struct *p, const struct sched_attr *attr)
+{
+        struct sched_dl_entity *dl_se = &p->dl;
+
+        if (dl_se->dl_runtime != attr->sched_runtime ||
+            dl_se->dl_deadline != attr->sched_deadline ||
+            dl_se->dl_period != attr->sched_period ||
+            dl_se->flags != attr->sched_flags)
+                return true;
+
+        return false;
+}
+
+#ifdef CONFIG_SMP
+int dl_task_can_attach(struct task_struct *p, const struct cpumask *cs_cpus_allowed)
+{
+        unsigned int dest_cpu = cpumask_any_and(cpu_active_mask,
+                                                        cs_cpus_allowed);
+        struct dl_bw *dl_b;
+        bool overflow;
+        int cpus, ret;
+        unsigned long flags;
+
+        rcu_read_lock_sched();
+        dl_b = dl_bw_of(dest_cpu);
+        raw_spin_lock_irqsave(&dl_b->lock, flags);
+        cpus = dl_bw_cpus(dest_cpu);
+        overflow = __dl_overflow(dl_b, cpus, 0, p->dl.dl_bw);
+        if (overflow)
+                ret = -EBUSY;
+        else {
+                /*
+                 * We reserve space for this task in the destination
+                 * root_domain, as we can't fail after this point.
+                 * We will free resources in the source root_domain
+                 * later on (see set_cpus_allowed_dl()).
+                 */
+                __dl_add(dl_b, p->dl.dl_bw, cpus);
+                ret = 0;
+        }
+        raw_spin_unlock_irqrestore(&dl_b->lock, flags);
+        rcu_read_unlock_sched();
+        return ret;
+}
+
+int dl_cpuset_cpumask_can_shrink(const struct cpumask *cur,
+                                 const struct cpumask *trial)
+{
+        int ret = 1, trial_cpus;
+        struct dl_bw *cur_dl_b;
+        unsigned long flags;
+
+        rcu_read_lock_sched();
+        cur_dl_b = dl_bw_of(cpumask_any(cur));
+        trial_cpus = cpumask_weight(trial);
+
+        raw_spin_lock_irqsave(&cur_dl_b->lock, flags);
+        if (cur_dl_b->bw != -1 &&
+            cur_dl_b->bw * trial_cpus < cur_dl_b->total_bw)
+                ret = 0;
+        raw_spin_unlock_irqrestore(&cur_dl_b->lock, flags);
+        rcu_read_unlock_sched();
+        return ret;
+}
+
+bool dl_cpu_busy(unsigned int cpu)
+{
+        unsigned long flags;
+        struct dl_bw *dl_b;
+        bool overflow;
+        int cpus;
+
+        rcu_read_lock_sched();
+        dl_b = dl_bw_of(cpu);
+        raw_spin_lock_irqsave(&dl_b->lock, flags);
+        cpus = dl_bw_cpus(cpu);
+        overflow = __dl_overflow(dl_b, cpus, 0, 0);
+        raw_spin_unlock_irqrestore(&dl_b->lock, flags);
+        rcu_read_unlock_sched();
+        return overflow;
+}
+#endif
+
 #ifdef CONFIG_SCHED_DEBUG
 extern void print_dl_rq(struct seq_file *m, int cpu, struct dl_rq *dl_rq);
 
diff --git a/kernel/sched/debug.c b/kernel/sched/debug.c
index 38f019324f1a..4fa66de52bd6 100644
--- a/kernel/sched/debug.c
+++ b/kernel/sched/debug.c
@@ -552,15 +552,21 @@ void print_rt_rq(struct seq_file *m, int cpu, struct rt_rq *rt_rq)
 
 #define P(x) \
         SEQ_printf(m, "  .%-30s: %Ld\n", #x, (long long)(rt_rq->x))
+#define PU(x) \
+        SEQ_printf(m, "  .%-30s: %lu\n", #x, (unsigned long)(rt_rq->x))
 #define PN(x) \
         SEQ_printf(m, "  .%-30s: %Ld.%06ld\n", #x, SPLIT_NS(rt_rq->x))
 
-        P(rt_nr_running);
+        PU(rt_nr_running);
+#ifdef CONFIG_SMP
+        PU(rt_nr_migratory);
+#endif
         P(rt_throttled);
         PN(rt_time);
         PN(rt_runtime);
 
 #undef PN
+#undef PU
 #undef P
 }
 
@@ -569,14 +575,21 @@ void print_dl_rq(struct seq_file *m, int cpu, struct dl_rq *dl_rq)
         struct dl_bw *dl_bw;
 
         SEQ_printf(m, "\ndl_rq[%d]:\n", cpu);
-        SEQ_printf(m, "  .%-30s: %ld\n", "dl_nr_running", dl_rq->dl_nr_running);
+
+#define PU(x) \
+        SEQ_printf(m, "  .%-30s: %lu\n", #x, (unsigned long)(dl_rq->x))
+
+        PU(dl_nr_running);
 #ifdef CONFIG_SMP
+        PU(dl_nr_migratory);
         dl_bw = &cpu_rq(cpu)->rd->dl_bw;
 #else
         dl_bw = &dl_rq->dl_bw;
 #endif
         SEQ_printf(m, "  .%-30s: %lld\n", "dl_bw->bw", dl_bw->bw);
         SEQ_printf(m, "  .%-30s: %lld\n", "dl_bw->total_bw", dl_bw->total_bw);
+
+#undef PU
 }
 
 extern __read_mostly int sched_clock_running;
diff --git a/kernel/sched/fair.c b/kernel/sched/fair.c
index d71109321841..c95880e216f6 100644
--- a/kernel/sched/fair.c
+++ b/kernel/sched/fair.c
@@ -369,8 +369,9 @@ static inline void list_del_leaf_cfs_rq(struct cfs_rq *cfs_rq)
 }
 
 /* Iterate thr' all leaf cfs_rq's on a runqueue */
-#define for_each_leaf_cfs_rq(rq, cfs_rq) \
-        list_for_each_entry_rcu(cfs_rq, &rq->leaf_cfs_rq_list, leaf_cfs_rq_list)
+#define for_each_leaf_cfs_rq_safe(rq, cfs_rq, pos)                      \
+        list_for_each_entry_safe(cfs_rq, pos, &rq->leaf_cfs_rq_list,    \
+                                 leaf_cfs_rq_list)
 
 /* Do the two (enqueued) entities belong to the same group ? */
 static inline struct cfs_rq *
@@ -463,8 +464,8 @@ static inline void list_del_leaf_cfs_rq(struct cfs_rq *cfs_rq)
 {
 }
 
-#define for_each_leaf_cfs_rq(rq, cfs_rq) \
-                for (cfs_rq = &rq->cfs; cfs_rq; cfs_rq = NULL)
+#define for_each_leaf_cfs_rq_safe(rq, cfs_rq, pos)      \
+                for (cfs_rq = &rq->cfs, pos = NULL; cfs_rq; cfs_rq = pos)
 
 static inline struct sched_entity *parent_entity(struct sched_entity *se)
 {
@@ -1381,7 +1382,6 @@ static unsigned long weighted_cpuload(const int cpu);
 static unsigned long source_load(int cpu, int type);
 static unsigned long target_load(int cpu, int type);
 static unsigned long capacity_of(int cpu);
-static long effective_load(struct task_group *tg, int cpu, long wl, long wg);
 
 /* Cached statistics for all CPUs within a node */
 struct numa_stats {
@@ -2469,7 +2469,8 @@ void task_numa_work(struct callback_head *work)
                 return;
 
 
-        down_read(&mm->mmap_sem);
+        if (!down_read_trylock(&mm->mmap_sem))
+                return;
         vma = find_vma(mm, start);
         if (!vma) {
                 reset_ptenuma_scan(p);
@@ -2584,6 +2585,60 @@ void task_tick_numa(struct rq *rq, struct task_struct *curr)
                 }
         }
 }
+
+/*
+ * Can a task be moved from prev_cpu to this_cpu without causing a load
+ * imbalance that would trigger the load balancer?
+ */
+static inline bool numa_wake_affine(struct sched_domain *sd,
+                                    struct task_struct *p, int this_cpu,
+                                    int prev_cpu, int sync)
+{
+        struct numa_stats prev_load, this_load;
+        s64 this_eff_load, prev_eff_load;
+
+        update_numa_stats(&prev_load, cpu_to_node(prev_cpu));
+        update_numa_stats(&this_load, cpu_to_node(this_cpu));
+
+        /*
+         * If sync wakeup then subtract the (maximum possible)
+         * effect of the currently running task from the load
+         * of the current CPU:
+         */
+        if (sync) {
+                unsigned long current_load = task_h_load(current);
+
+                if (this_load.load > current_load)
+                        this_load.load -= current_load;
+                else
+                        this_load.load = 0;
+        }
+
+        /*
+         * In low-load situations, where this_cpu's node is idle due to the
+         * sync cause above having dropped this_load.load to 0, move the task.
+         * Moving to an idle socket will not create a bad imbalance.
+         *
+         * Otherwise check if the nodes are near enough in load to allow this
+         * task to be woken on this_cpu's node.
+         */
+        if (this_load.load > 0) {
+                unsigned long task_load = task_h_load(p);
+
+                this_eff_load = 100;
+                this_eff_load *= prev_load.compute_capacity;
+
+                prev_eff_load = 100 + (sd->imbalance_pct - 100) / 2;
+                prev_eff_load *= this_load.compute_capacity;
+
+                this_eff_load *= this_load.load + task_load;
+                prev_eff_load *= prev_load.load - task_load;
+
+                return this_eff_load <= prev_eff_load;
+        }
+
+        return true;
+}
 #else
 static void task_tick_numa(struct rq *rq, struct task_struct *curr)
 {
@@ -2596,6 +2651,15 @@ static inline void account_numa_enqueue(struct rq *rq, struct task_struct *p)
 static inline void account_numa_dequeue(struct rq *rq, struct task_struct *p)
 {
 }
+
+#ifdef CONFIG_SMP
+static inline bool numa_wake_affine(struct sched_domain *sd,
+                                    struct task_struct *p, int this_cpu,
+                                    int prev_cpu, int sync)
+{
+        return true;
+}
+#endif /* !SMP */
 #endif /* CONFIG_NUMA_BALANCING */
 
 static void
@@ -2916,12 +2980,12 @@ ___update_load_avg(u64 now, int cpu, struct sched_avg *sa,
         /*
          * Step 2: update *_avg.
          */
-        sa->load_avg = div_u64(sa->load_sum, LOAD_AVG_MAX);
+        sa->load_avg = div_u64(sa->load_sum, LOAD_AVG_MAX - 1024 + sa->period_contrib);
         if (cfs_rq) {
                 cfs_rq->runnable_load_avg =
-                        div_u64(cfs_rq->runnable_load_sum, LOAD_AVG_MAX);
+                        div_u64(cfs_rq->runnable_load_sum, LOAD_AVG_MAX - 1024 + sa->period_contrib);
         }
-        sa->util_avg = sa->util_sum / LOAD_AVG_MAX;
+        sa->util_avg = sa->util_sum / (LOAD_AVG_MAX - 1024 + sa->period_contrib);
 
         return 1;
 }
@@ -2982,8 +3046,7 @@ __update_load_avg_cfs_rq(u64 now, int cpu, struct cfs_rq *cfs_rq)
  * differential update where we store the last value we propagated. This in
  * turn allows skipping updates if the differential is 'small'.
  *
- * Updating tg's load_avg is necessary before update_cfs_share() (which is
- * done) and effective_load() (which is not done because it is too costly).
+ * Updating tg's load_avg is necessary before update_cfs_share().
  */
 static inline void update_tg_load_avg(struct cfs_rq *cfs_rq, int force)
 {
@@ -3563,7 +3626,7 @@ static inline void check_schedstat_required(void)
                         trace_sched_stat_runtime_enabled())  {
                 printk_deferred_once("Scheduler tracepoints stat_sleep, stat_iowait, "
                              "stat_blocked and stat_runtime require the "
-                             "kernel parameter schedstats=enabled or "
+                             "kernel parameter schedstats=enable or "
                              "kernel.sched_schedstats=1\n");
         }
 #endif
@@ -4642,24 +4705,43 @@ static void destroy_cfs_bandwidth(struct cfs_bandwidth *cfs_b)
         hrtimer_cancel(&cfs_b->slack_timer);
 }
 
+/*
+ * Both these cpu hotplug callbacks race against unregister_fair_sched_group()
+ *
+ * The race is harmless, since modifying bandwidth settings of unhooked group
+ * bits doesn't do much.
+ */
+
+/* cpu online calback */
 static void __maybe_unused update_runtime_enabled(struct rq *rq)
 {
-        struct cfs_rq *cfs_rq;
+        struct task_group *tg;
+
+        lockdep_assert_held(&rq->lock);
 
-        for_each_leaf_cfs_rq(rq, cfs_rq) {
-                struct cfs_bandwidth *cfs_b = &cfs_rq->tg->cfs_bandwidth;
+        rcu_read_lock();
+        list_for_each_entry_rcu(tg, &task_groups, list) {
+                struct cfs_bandwidth *cfs_b = &tg->cfs_bandwidth;
+                struct cfs_rq *cfs_rq = tg->cfs_rq[cpu_of(rq)];
 
                 raw_spin_lock(&cfs_b->lock);
                 cfs_rq->runtime_enabled = cfs_b->quota != RUNTIME_INF;
                 raw_spin_unlock(&cfs_b->lock);
         }
+        rcu_read_unlock();
 }
 
+/* cpu offline callback */
 static void __maybe_unused unthrottle_offline_cfs_rqs(struct rq *rq)
 {
-        struct cfs_rq *cfs_rq;
+        struct task_group *tg;
+
+        lockdep_assert_held(&rq->lock);
+
+        rcu_read_lock();
+        list_for_each_entry_rcu(tg, &task_groups, list) {
+                struct cfs_rq *cfs_rq = tg->cfs_rq[cpu_of(rq)];
 
-        for_each_leaf_cfs_rq(rq, cfs_rq) {
                 if (!cfs_rq->runtime_enabled)
                         continue;
 
@@ -4677,6 +4759,7 @@ static void __maybe_unused unthrottle_offline_cfs_rqs(struct rq *rq)
                 if (cfs_rq_throttled(cfs_rq))
                         unthrottle_cfs_rq(cfs_rq);
         }
+        rcu_read_unlock();
 }
 
 #else /* CONFIG_CFS_BANDWIDTH */
@@ -5215,126 +5298,6 @@ static unsigned long cpu_avg_load_per_task(int cpu)
         return 0;
 }
 
-#ifdef CONFIG_FAIR_GROUP_SCHED
-/*
- * effective_load() calculates the load change as seen from the root_task_group
- *
- * Adding load to a group doesn't make a group heavier, but can cause movement
- * of group shares between cpus. Assuming the shares were perfectly aligned one
- * can calculate the shift in shares.
- *
- * Calculate the effective load difference if @wl is added (subtracted) to @tg
- * on this @cpu and results in a total addition (subtraction) of @wg to the
- * total group weight.
- *
- * Given a runqueue weight distribution (rw_i) we can compute a shares
- * distribution (s_i) using:
- *
- *   s_i = rw_i / \Sum rw_j                                             (1)
- *
- * Suppose we have 4 CPUs and our @tg is a direct child of the root group and
- * has 7 equal weight tasks, distributed as below (rw_i), with the resulting
- * shares distribution (s_i):
- *
- *   rw_i = {   2,   4,   1,   0 }
- *   s_i  = { 2/7, 4/7, 1/7,   0 }
- *
- * As per wake_affine() we're interested in the load of two CPUs (the CPU the
- * task used to run on and the CPU the waker is running on), we need to
- * compute the effect of waking a task on either CPU and, in case of a sync
- * wakeup, compute the effect of the current task going to sleep.
- *
- * So for a change of @wl to the local @cpu with an overall group weight change
- * of @wl we can compute the new shares distribution (s'_i) using:
- *
- *   s'_i = (rw_i + @wl) / (@wg + \Sum rw_j)                            (2)
- *
- * Suppose we're interested in CPUs 0 and 1, and want to compute the load
- * differences in waking a task to CPU 0. The additional task changes the
- * weight and shares distributions like:
- *
- *   rw'_i = {   3,   4,   1,   0 }
- *   s'_i  = { 3/8, 4/8, 1/8,   0 }
- *
- * We can then compute the difference in effective weight by using:
- *
- *   dw_i = S * (s'_i - s_i)                                            (3)
- *
- * Where 'S' is the group weight as seen by its parent.
- *
- * Therefore the effective change in loads on CPU 0 would be 5/56 (3/8 - 2/7)
- * times the weight of the group. The effect on CPU 1 would be -4/56 (4/8 -
- * 4/7) times the weight of the group.
- */
-static long effective_load(struct task_group *tg, int cpu, long wl, long wg)
-{
-        struct sched_entity *se = tg->se[cpu];
-
-        if (!tg->parent)        /* the trivial, non-cgroup case */
-                return wl;
-
-        for_each_sched_entity(se) {
-                struct cfs_rq *cfs_rq = se->my_q;
-                long W, w = cfs_rq_load_avg(cfs_rq);
-
-                tg = cfs_rq->tg;
-
-                /*
-                 * W = @wg + \Sum rw_j
-                 */
-                W = wg + atomic_long_read(&tg->load_avg);
-
-                /* Ensure \Sum rw_j >= rw_i */
-                W -= cfs_rq->tg_load_avg_contrib;
-                W += w;
-
-                /*
-                 * w = rw_i + @wl
-                 */
-                w += wl;
-
-                /*
-                 * wl = S * s'_i; see (2)
-                 */
-                if (W > 0 && w < W)
-                        wl = (w * (long)scale_load_down(tg->shares)) / W;
-                else
-                        wl = scale_load_down(tg->shares);
-
-                /*
-                 * Per the above, wl is the new se->load.weight value; since
-                 * those are clipped to [MIN_SHARES, ...) do so now. See
-                 * calc_cfs_shares().
-                 */
-                if (wl < MIN_SHARES)
-                        wl = MIN_SHARES;
-
-                /*
-                 * wl = dw_i = S * (s'_i - s_i); see (3)
-                 */
-                wl -= se->avg.load_avg;
-
-                /*
-                 * Recursively apply this logic to all parent groups to compute
-                 * the final effective load change on the root group. Since
-                 * only the @tg group gets extra weight, all parent groups can
-                 * only redistribute existing shares. @wl is the shift in shares
-                 * resulting from this level per the above.
-                 */
-                wg = 0;
-        }
-
-        return wl;
-}
-#else
-
-static long effective_load(struct task_group *tg, int cpu, long wl, long wg)
-{
-        return wl;
-}
-
-#endif
-
 static void record_wakee(struct task_struct *p)
 {
         /*
@@ -5385,67 +5348,25 @@ static int wake_wide(struct task_struct *p)
 static int wake_affine(struct sched_domain *sd, struct task_struct *p,
                        int prev_cpu, int sync)
 {
-        s64 this_load, load;
-        s64 this_eff_load, prev_eff_load;
-        int idx, this_cpu;
-        struct task_group *tg;
-        unsigned long weight;
-        int balanced;
-
-        idx       = sd->wake_idx;
-        this_cpu  = smp_processor_id();
-        load      = source_load(prev_cpu, idx);
-        this_load = target_load(this_cpu, idx);
+        int this_cpu = smp_processor_id();
+        bool affine = false;
 
         /*
-         * If sync wakeup then subtract the (maximum possible)
-         * effect of the currently running task from the load
-         * of the current CPU:
-         */
-        if (sync) {
-                tg = task_group(current);
-                weight = current->se.avg.load_avg;
-
-                this_load += effective_load(tg, this_cpu, -weight, -weight);
-                load += effective_load(tg, prev_cpu, 0, -weight);
-        }
-
-        tg = task_group(p);
-        weight = p->se.avg.load_avg;
-
-        /*
-         * In low-load situations, where prev_cpu is idle and this_cpu is idle
-         * due to the sync cause above having dropped this_load to 0, we'll
-         * always have an imbalance, but there's really nothing you can do
-         * about that, so that's good too.
-         *
-         * Otherwise check if either cpus are near enough in load to allow this
-         * task to be woken on this_cpu.
+         * Common case: CPUs are in the same socket, and select_idle_sibling()
+         * will do its thing regardless of what we return:
          */
-        this_eff_load = 100;
-        this_eff_load *= capacity_of(prev_cpu);
-
-        prev_eff_load = 100 + (sd->imbalance_pct - 100) / 2;
-        prev_eff_load *= capacity_of(this_cpu);
-
-        if (this_load > 0) {
-                this_eff_load *= this_load +
-                        effective_load(tg, this_cpu, weight, weight);
-
-                prev_eff_load *= load + effective_load(tg, prev_cpu, 0, weight);
-        }
-
-        balanced = this_eff_load <= prev_eff_load;
+        if (cpus_share_cache(prev_cpu, this_cpu))
+                affine = true;
+        else
+                affine = numa_wake_affine(sd, p, this_cpu, prev_cpu, sync);
 
         schedstat_inc(p->se.statistics.nr_wakeups_affine_attempts);
+        if (affine) {
+                schedstat_inc(sd->ttwu_move_affine);
+                schedstat_inc(p->se.statistics.nr_wakeups_affine);
+        }
 
-        if (!balanced)
-                return 0;
-
-        schedstat_inc(sd->ttwu_move_affine);
-        schedstat_inc(p->se.statistics.nr_wakeups_affine);
-
-        return 1;
+        return affine;
 }
 
 static inline int task_util(struct task_struct *p);
@@ -5484,12 +5405,12 @@ find_idlest_group(struct sched_domain *sd, struct task_struct *p,
                 int i;
 
                 /* Skip over this group if it has no CPUs allowed */
-                if (!cpumask_intersects(sched_group_cpus(group),
+                if (!cpumask_intersects(sched_group_span(group),
                                         &p->cpus_allowed))
                         continue;
 
                 local_group = cpumask_test_cpu(this_cpu,
-                                               sched_group_cpus(group));
+                                               sched_group_span(group));
 
                 /*
                  * Tally up the load of all CPUs in the group and find
@@ -5499,7 +5420,7 @@ find_idlest_group(struct sched_domain *sd, struct task_struct *p,
                 runnable_load = 0;
                 max_spare_cap = 0;
 
-                for_each_cpu(i, sched_group_cpus(group)) {
+                for_each_cpu(i, sched_group_span(group)) {
                         /* Bias balancing toward cpus of our domain */
                         if (local_group)
                                 load = source_load(i, load_idx);
@@ -5602,10 +5523,10 @@ find_idlest_cpu(struct sched_group *group, struct task_struct *p, int this_cpu)
 
         /* Check if we have any choice: */
         if (group->group_weight == 1)
-                return cpumask_first(sched_group_cpus(group));
+                return cpumask_first(sched_group_span(group));
 
         /* Traverse only the allowed CPUs */
-        for_each_cpu_and(i, sched_group_cpus(group), &p->cpus_allowed) {
+        for_each_cpu_and(i, sched_group_span(group), &p->cpus_allowed) {
                 if (idle_cpu(i)) {
                         struct rq *rq = cpu_rq(i);
                         struct cpuidle_state *idle = idle_get_state(rq);
@@ -5640,43 +5561,6 @@ find_idlest_cpu(struct sched_group *group, struct task_struct *p, int this_cpu)
         return shallowest_idle_cpu != -1 ? shallowest_idle_cpu : least_loaded_cpu;
 }
 
-/*
- * Implement a for_each_cpu() variant that starts the scan at a given cpu
- * (@start), and wraps around.
- *
- * This is used to scan for idle CPUs; such that not all CPUs looking for an
- * idle CPU find the same CPU. The down-side is that tasks tend to cycle
- * through the LLC domain.
- *
- * Especially tbench is found sensitive to this.
- */
-
-static int cpumask_next_wrap(int n, const struct cpumask *mask, int start, int *wrapped)
-{
-        int next;
-
-again:
-        next = find_next_bit(cpumask_bits(mask), nr_cpumask_bits, n+1);
-
-        if (*wrapped) {
-                if (next >= start)
-                        return nr_cpumask_bits;
-        } else {
-                if (next >= nr_cpumask_bits) {
-                        *wrapped = 1;
-                        n = -1;
-                        goto again;
-                }
-        }
-
-        return next;
-}
-
-#define for_each_cpu_wrap(cpu, mask, start, wrap)                               \
-        for ((wrap) = 0, (cpu) = (start)-1;                                     \
-                (cpu) = cpumask_next_wrap((cpu), (mask), (start), &(wrap)),     \
-                (cpu) < nr_cpumask_bits; )
-
 #ifdef CONFIG_SCHED_SMT
 
 static inline void set_idle_cores(int cpu, int val)
@@ -5736,7 +5620,7 @@ unlock:
 static int select_idle_core(struct task_struct *p, struct sched_domain *sd, int target)
 {
         struct cpumask *cpus = this_cpu_cpumask_var_ptr(select_idle_mask);
-        int core, cpu, wrap;
+        int core, cpu;
 
         if (!static_branch_likely(&sched_smt_present))
                 return -1;
@@ -5746,7 +5630,7 @@ static int select_idle_core(struct task_struct *p, struct sched_domain *sd, int
 
         cpumask_and(cpus, sched_domain_span(sd), &p->cpus_allowed);
 
-        for_each_cpu_wrap(core, cpus, target, wrap) {
+        for_each_cpu_wrap(core, cpus, target) {
                 bool idle = true;
 
                 for_each_cpu(cpu, cpu_smt_mask(core)) {
@@ -5809,27 +5693,38 @@ static inline int select_idle_smt(struct task_struct *p, struct sched_domain *sd
 static int select_idle_cpu(struct task_struct *p, struct sched_domain *sd, int target)
 {
         struct sched_domain *this_sd;
-        u64 avg_cost, avg_idle = this_rq()->avg_idle;
+        u64 avg_cost, avg_idle;
         u64 time, cost;
         s64 delta;
-        int cpu, wrap;
+        int cpu, nr = INT_MAX;
 
         this_sd = rcu_dereference(*this_cpu_ptr(&sd_llc));
         if (!this_sd)
                 return -1;
 
-        avg_cost = this_sd->avg_scan_cost;
-
         /*
          * Due to large variance we need a large fuzz factor; hackbench in
          * particularly is sensitive here.
          */
-        if (sched_feat(SIS_AVG_CPU) && (avg_idle / 512) < avg_cost)
+        avg_idle = this_rq()->avg_idle / 512;
+        avg_cost = this_sd->avg_scan_cost + 1;
+
+        if (sched_feat(SIS_AVG_CPU) && avg_idle < avg_cost)
                 return -1;
 
+        if (sched_feat(SIS_PROP)) {
+                u64 span_avg = sd->span_weight * avg_idle;
+                if (span_avg > 4*avg_cost)
+                        nr = div_u64(span_avg, avg_cost);
+                else
+                        nr = 4;
+        }
+
         time = local_clock();
 
-        for_each_cpu_wrap(cpu, sched_domain_span(sd), target, wrap) {
+        for_each_cpu_wrap(cpu, sched_domain_span(sd), target) {
+                if (!--nr)
+                        return -1;
                 if (!cpumask_test_cpu(cpu, &p->cpus_allowed))
                         continue;
                 if (idle_cpu(cpu))
@@ -6011,11 +5906,15 @@ select_task_rq_fair(struct task_struct *p, int prev_cpu, int sd_flag, int wake_f
 
         if (affine_sd) {
                 sd = NULL; /* Prefer wake_affine over balance flags */
-                if (cpu != prev_cpu && wake_affine(affine_sd, p, prev_cpu, sync))
+                if (cpu == prev_cpu)
+                        goto pick_cpu;
+
+                if (wake_affine(affine_sd, p, prev_cpu, sync))
                         new_cpu = cpu;
         }
 
         if (!sd) {
+ pick_cpu:
                 if (sd_flag & SD_BALANCE_WAKE) /* XXX always ? */
                         new_cpu = select_idle_sibling(p, prev_cpu, new_cpu);
 
@@ -6168,8 +6067,11 @@ static void set_last_buddy(struct sched_entity *se)
         if (entity_is_task(se) && unlikely(task_of(se)->policy == SCHED_IDLE))
                 return;
 
-        for_each_sched_entity(se)
+        for_each_sched_entity(se) {
+                if (SCHED_WARN_ON(!se->on_rq))
+                        return;
                 cfs_rq_of(se)->last = se;
+        }
 }
 
 static void set_next_buddy(struct sched_entity *se)
@@ -6177,8 +6079,11 @@ static void set_next_buddy(struct sched_entity *se)
         if (entity_is_task(se) && unlikely(task_of(se)->policy == SCHED_IDLE))
                 return;
 
-        for_each_sched_entity(se)
+        for_each_sched_entity(se) {
+                if (SCHED_WARN_ON(!se->on_rq))
+                        return;
                 cfs_rq_of(se)->next = se;
+        }
 }
 
 static void set_skip_buddy(struct sched_entity *se)
@@ -6686,6 +6591,10 @@ static int migrate_degrades_locality(struct task_struct *p, struct lb_env *env)
         if (dst_nid == p->numa_preferred_nid)
                 return 0;
 
+        /* Leaving a core idle is often worse than degrading locality. */
+        if (env->idle != CPU_NOT_IDLE)
+                return -1;
+
         if (numa_group) {
                 src_faults = group_faults(p, src_nid);
                 dst_faults = group_faults(p, dst_nid);
@@ -6737,10 +6646,10 @@ int can_migrate_task(struct task_struct *p, struct lb_env *env)
                  * our sched_group. We may want to revisit it if we couldn't
                  * meet load balance goals by pulling other tasks on src_cpu.
                  *
-                 * Also avoid computing new_dst_cpu if we have already computed
-                 * one in current iteration.
+                 * Avoid computing new_dst_cpu for NEWLY_IDLE or if we have
+                 * already computed one in current iteration.
                  */
-                if (!env->dst_grpmask || (env->flags & LBF_DST_PINNED))
+                if (env->idle == CPU_NEWLY_IDLE || (env->flags & LBF_DST_PINNED))
                         return 0;
 
                 /* Prevent to re-select dst_cpu via env's cpus */
@@ -6970,10 +6879,28 @@ static void attach_tasks(struct lb_env *env)
 }
 
 #ifdef CONFIG_FAIR_GROUP_SCHED
+
+static inline bool cfs_rq_is_decayed(struct cfs_rq *cfs_rq)
+{
+        if (cfs_rq->load.weight)
+                return false;
+
+        if (cfs_rq->avg.load_sum)
+                return false;
+
+        if (cfs_rq->avg.util_sum)
+                return false;
+
+        if (cfs_rq->runnable_load_sum)
+                return false;
+
+        return true;
+}
+
 static void update_blocked_averages(int cpu)
 {
         struct rq *rq = cpu_rq(cpu);
-        struct cfs_rq *cfs_rq;
+        struct cfs_rq *cfs_rq, *pos;
         struct rq_flags rf;
 
         rq_lock_irqsave(rq, &rf);
@@ -6983,7 +6910,7 @@ static void update_blocked_averages(int cpu)
          * Iterates the task_group tree in a bottom up fashion, see
          * list_add_leaf_cfs_rq() for details.
          */
-        for_each_leaf_cfs_rq(rq, cfs_rq) {
+        for_each_leaf_cfs_rq_safe(rq, cfs_rq, pos) {
                 struct sched_entity *se;
 
                 /* throttled entities do not contribute to load */
@@ -6997,6 +6924,13 @@ static void update_blocked_averages(int cpu)
                 se = cfs_rq->tg->se[cpu];
                 if (se && !skip_blocked_update(se))
                         update_load_avg(se, 0);
+
+                /*
+                 * There can be a lot of idle CPU cgroups.  Don't let fully
+                 * decayed cfs_rqs linger on the list.
+                 */
+                if (cfs_rq_is_decayed(cfs_rq))
+                        list_del_leaf_cfs_rq(cfs_rq);
         }
         rq_unlock_irqrestore(rq, &rf);
 }
@@ -7229,7 +7163,7 @@ void update_group_capacity(struct sched_domain *sd, int cpu)
                  * span the current group.
                  */
 
-                for_each_cpu(cpu, sched_group_cpus(sdg)) {
+                for_each_cpu(cpu, sched_group_span(sdg)) {
                         struct sched_group_capacity *sgc;
                         struct rq *rq = cpu_rq(cpu);
 
@@ -7408,7 +7342,7 @@ static inline void update_sg_lb_stats(struct lb_env *env,
 
         memset(sgs, 0, sizeof(*sgs));
 
-        for_each_cpu_and(i, sched_group_cpus(group), env->cpus) {
+        for_each_cpu_and(i, sched_group_span(group), env->cpus) {
                 struct rq *rq = cpu_rq(i);
 
                 /* Bias balancing toward cpus of our domain */
@@ -7572,7 +7506,7 @@ static inline void update_sd_lb_stats(struct lb_env *env, struct sd_lb_stats *sd
                 struct sg_lb_stats *sgs = &tmp_sgs;
                 int local_group;
 
-                local_group = cpumask_test_cpu(env->dst_cpu, sched_group_cpus(sg));
+                local_group = cpumask_test_cpu(env->dst_cpu, sched_group_span(sg));
                 if (local_group) {
                         sds->local = sg;
                         sgs = local;
@@ -7927,7 +7861,7 @@ static struct rq *find_busiest_queue(struct lb_env *env,
         unsigned long busiest_load = 0, busiest_capacity = 1;
         int i;
 
-        for_each_cpu_and(i, sched_group_cpus(group), env->cpus) {
+        for_each_cpu_and(i, sched_group_span(group), env->cpus) {
                 unsigned long capacity, wl;
                 enum fbq_type rt;
 
@@ -8033,7 +7967,6 @@ static int active_load_balance_cpu_stop(void *data);
 static int should_we_balance(struct lb_env *env)
 {
         struct sched_group *sg = env->sd->groups;
-        struct cpumask *sg_cpus, *sg_mask;
         int cpu, balance_cpu = -1;
 
         /*
@@ -8043,11 +7976,9 @@ static int should_we_balance(struct lb_env *env)
         if (env->idle == CPU_NEWLY_IDLE)
                 return 1;
 
-        sg_cpus = sched_group_cpus(sg);
-        sg_mask = sched_group_mask(sg);
         /* Try to find first idle cpu */
-        for_each_cpu_and(cpu, sg_cpus, env->cpus) {
-                if (!cpumask_test_cpu(cpu, sg_mask) || !idle_cpu(cpu))
+        for_each_cpu_and(cpu, group_balance_mask(sg), env->cpus) {
+                if (!idle_cpu(cpu))
                         continue;
 
                 balance_cpu = cpu;
@@ -8083,7 +8014,7 @@ static int load_balance(int this_cpu, struct rq *this_rq,
                 .sd             = sd,
                 .dst_cpu        = this_cpu,
                 .dst_rq         = this_rq,
-                .dst_grpmask    = sched_group_cpus(sd->groups),
+                .dst_grpmask    = sched_group_span(sd->groups),
                 .idle           = idle,
                 .loop_break     = sched_nr_migrate_break,
                 .cpus           = cpus,
@@ -8091,14 +8022,7 @@ static int load_balance(int this_cpu, struct rq *this_rq,
                 .tasks          = LIST_HEAD_INIT(env.tasks),
         };
 
-        /*
-         * For NEWLY_IDLE load_balancing, we don't need to consider
-         * other cpus in our group
-         */
-        if (idle == CPU_NEWLY_IDLE)
-                env.dst_grpmask = NULL;
-
-        cpumask_copy(cpus, cpu_active_mask);
+        cpumask_and(cpus, sched_domain_span(sd), cpu_active_mask);
 
         schedstat_inc(sd->lb_count[idle]);
 
@@ -8220,7 +8144,15 @@ more_balance:
                 /* All tasks on this runqueue were pinned by CPU affinity */
                 if (unlikely(env.flags & LBF_ALL_PINNED)) {
                         cpumask_clear_cpu(cpu_of(busiest), cpus);
-                        if (!cpumask_empty(cpus)) {
+                        /*
+                         * Attempting to continue load balancing at the current
+                         * sched_domain level only makes sense if there are
+                         * active CPUs remaining as possible busiest CPUs to
+                         * pull load from which are not contained within the
+                         * destination group that is receiving any migrated
+                         * load.
+                         */
+                        if (!cpumask_subset(cpus, env.dst_grpmask)) {
                                 env.loop = 0;
                                 env.loop_break = sched_nr_migrate_break;
                                 goto redo;
@@ -8516,6 +8448,13 @@ static int active_load_balance_cpu_stop(void *data)
                         .src_cpu        = busiest_rq->cpu,
                         .src_rq         = busiest_rq,
                         .idle           = CPU_IDLE,
+                        /*
+                         * can_migrate_task() doesn't need to compute new_dst_cpu
+                         * for active balancing. Since we have CPU_IDLE, but no
+                         * @dst_grpmask we need to make that test go away with lying
+                         * about DST_PINNED.
+                         */
+                        .flags          = LBF_DST_PINNED,
                 };
 
                 schedstat_inc(sd->alb_count);
@@ -8659,6 +8598,10 @@ void nohz_balance_enter_idle(int cpu)
         if (!cpu_active(cpu))
                 return;
 
+        /* Spare idle load balancing on CPUs that don't want to be disturbed: */
+        if (!is_housekeeping_cpu(cpu))
+                return;
+
         if (test_bit(NOHZ_TICK_STOPPED, nohz_flags(cpu)))
                 return;
 
@@ -9523,10 +9466,10 @@ const struct sched_class fair_sched_class = {
 #ifdef CONFIG_SCHED_DEBUG
 void print_cfs_stats(struct seq_file *m, int cpu)
 {
-        struct cfs_rq *cfs_rq;
+        struct cfs_rq *cfs_rq, *pos;
 
         rcu_read_lock();
-        for_each_leaf_cfs_rq(cpu_rq(cpu), cfs_rq)
+        for_each_leaf_cfs_rq_safe(cpu_rq(cpu), cfs_rq, pos)
                 print_cfs_rq(m, cpu, cfs_rq);
         rcu_read_unlock();
 }
diff --git a/kernel/sched/features.h b/kernel/sched/features.h
index 11192e0cb122..d3fb15555291 100644
--- a/kernel/sched/features.h
+++ b/kernel/sched/features.h
@@ -55,6 +55,7 @@ SCHED_FEAT(TTWU_QUEUE, true)
  * When doing wakeups, attempt to limit superfluous scans of the LLC domain.
  */
 SCHED_FEAT(SIS_AVG_CPU, false)
+SCHED_FEAT(SIS_PROP, true)
 
 /*
  * Issue a WARN when we do multiple update_rq_clock() calls
@@ -76,7 +77,6 @@ SCHED_FEAT(WARN_DOUBLE_CLOCK, false)
 SCHED_FEAT(RT_PUSH_IPI, true)
 #endif
 
-SCHED_FEAT(FORCE_SD_OVERLAP, false)
 SCHED_FEAT(RT_RUNTIME_SHARE, true)
 SCHED_FEAT(LB_MIN, false)
 SCHED_FEAT(ATTACH_AGE_LOAD, true)
diff --git a/kernel/sched/idle.c b/kernel/sched/idle.c
index ef63adce0c9c..6c23e30c0e5c 100644
--- a/kernel/sched/idle.c
+++ b/kernel/sched/idle.c
@@ -219,6 +219,7 @@ static void do_idle(void)
          */
 
         __current_set_polling();
+        quiet_vmstat();
         tick_nohz_idle_enter();
 
         while (!need_resched()) {
diff --git a/kernel/sched/loadavg.c b/kernel/sched/loadavg.c
index f15fb2bdbc0d..f14716a3522f 100644
--- a/kernel/sched/loadavg.c
+++ b/kernel/sched/loadavg.c
@@ -117,7 +117,7 @@ calc_load(unsigned long load, unsigned long exp, unsigned long active)
  * load-average relies on per-cpu sampling from the tick, it is affected by
  * NO_HZ.
  *
- * The basic idea is to fold the nr_active delta into a global idle-delta upon
+ * The basic idea is to fold the nr_active delta into a global NO_HZ-delta upon
  * entering NO_HZ state such that we can include this as an 'extra' cpu delta
  * when we read the global state.
  *
@@ -126,7 +126,7 @@ calc_load(unsigned long load, unsigned long exp, unsigned long active)
  *  - When we go NO_HZ idle during the window, we can negate our sample
  *    contribution, causing under-accounting.
  *
- *    We avoid this by keeping two idle-delta counters and flipping them
+ *    We avoid this by keeping two NO_HZ-delta counters and flipping them
  *    when the window starts, thus separating old and new NO_HZ load.
  *
  *    The only trick is the slight shift in index flip for read vs write.
@@ -137,22 +137,22 @@ calc_load(unsigned long load, unsigned long exp, unsigned long active)
  *    r:0 0 1           1 0           0 1           1 0
  *    w:0 1 1           0 0           1 1           0 0
  *
- *    This ensures we'll fold the old idle contribution in this window while
+ *    This ensures we'll fold the old NO_HZ contribution in this window while
  *    accumlating the new one.
  *
- *  - When we wake up from NO_HZ idle during the window, we push up our
+ *  - When we wake up from NO_HZ during the window, we push up our
  *    contribution, since we effectively move our sample point to a known
  *    busy state.
  *
  *    This is solved by pushing the window forward, and thus skipping the
- *    sample, for this cpu (effectively using the idle-delta for this cpu which
+ *    sample, for this cpu (effectively using the NO_HZ-delta for this cpu which
  *    was in effect at the time the window opened). This also solves the issue
- *    of having to deal with a cpu having been in NOHZ idle for multiple
- *    LOAD_FREQ intervals.
+ *    of having to deal with a cpu having been in NO_HZ for multiple LOAD_FREQ
+ *    intervals.
  *
  * When making the ILB scale, we should try to pull this in as well.
  */
-static atomic_long_t calc_load_idle[2];
+static atomic_long_t calc_load_nohz[2];
 static int calc_load_idx;
 
 static inline int calc_load_write_idx(void)
@@ -167,7 +167,7 @@ static inline int calc_load_write_idx(void)
 
         /*
          * If the folding window started, make sure we start writing in the
-         * next idle-delta.
+         * next NO_HZ-delta.
          */
         if (!time_before(jiffies, READ_ONCE(calc_load_update)))
                 idx++;
@@ -180,24 +180,24 @@ static inline int calc_load_read_idx(void)
         return calc_load_idx & 1;
 }
 
-void calc_load_enter_idle(void)
+void calc_load_nohz_start(void)
 {
         struct rq *this_rq = this_rq();
         long delta;
 
         /*
-         * We're going into NOHZ mode, if there's any pending delta, fold it
-         * into the pending idle delta.
+         * We're going into NO_HZ mode, if there's any pending delta, fold it
+         * into the pending NO_HZ delta.
          */
         delta = calc_load_fold_active(this_rq, 0);
         if (delta) {
                 int idx = calc_load_write_idx();
 
-                atomic_long_add(delta, &calc_load_idle[idx]);
+                atomic_long_add(delta, &calc_load_nohz[idx]);
         }
 }
 
-void calc_load_exit_idle(void)
+void calc_load_nohz_stop(void)
 {
         struct rq *this_rq = this_rq();
 
@@ -217,13 +217,13 @@ void calc_load_exit_idle(void)
                 this_rq->calc_load_update += LOAD_FREQ;
 }
 
-static long calc_load_fold_idle(void)
+static long calc_load_nohz_fold(void)
 {
         int idx = calc_load_read_idx();
         long delta = 0;
 
-        if (atomic_long_read(&calc_load_idle[idx]))
-                delta = atomic_long_xchg(&calc_load_idle[idx], 0);
+        if (atomic_long_read(&calc_load_nohz[idx]))
+                delta = atomic_long_xchg(&calc_load_nohz[idx], 0);
 
         return delta;
 }
@@ -299,9 +299,9 @@ calc_load_n(unsigned long load, unsigned long exp,
 
 /*
  * NO_HZ can leave us missing all per-cpu ticks calling
- * calc_load_account_active(), but since an idle CPU folds its delta into
- * calc_load_tasks_idle per calc_load_account_idle(), all we need to do is fold
- * in the pending idle delta if our idle period crossed a load cycle boundary.
+ * calc_load_fold_active(), but since a NO_HZ CPU folds its delta into
+ * calc_load_nohz per calc_load_nohz_start(), all we need to do is fold
+ * in the pending NO_HZ delta if our NO_HZ period crossed a load cycle boundary.
  *
  * Once we've updated the global active value, we need to apply the exponential
  * weights adjusted to the number of cycles missed.
@@ -330,7 +330,7 @@ static void calc_global_nohz(void)
         }
 
         /*
-         * Flip the idle index...
+         * Flip the NO_HZ index...
          *
          * Make sure we first write the new time then flip the index, so that
          * calc_load_write_idx() will see the new time when it reads the new
@@ -341,7 +341,7 @@ static void calc_global_nohz(void)
 }
 #else /* !CONFIG_NO_HZ_COMMON */
 
-static inline long calc_load_fold_idle(void) { return 0; }
+static inline long calc_load_nohz_fold(void) { return 0; }
 static inline void calc_global_nohz(void) { }
 
 #endif /* CONFIG_NO_HZ_COMMON */
@@ -362,9 +362,9 @@ void calc_global_load(unsigned long ticks)
                 return;
 
         /*
-         * Fold the 'old' idle-delta to include all NO_HZ cpus.
+         * Fold the 'old' NO_HZ-delta to include all NO_HZ cpus.
          */
-        delta = calc_load_fold_idle();
+        delta = calc_load_nohz_fold();
         if (delta)
                 atomic_long_add(delta, &calc_load_tasks);
 
@@ -378,7 +378,8 @@ void calc_global_load(unsigned long ticks)
         WRITE_ONCE(calc_load_update, sample_window + LOAD_FREQ);
 
         /*
-         * In case we idled for multiple LOAD_FREQ intervals, catch up in bulk.
+         * In case we went to NO_HZ for multiple LOAD_FREQ intervals
+         * catch up in bulk.
          */
         calc_global_nohz();
 }
diff --git a/kernel/sched/rt.c b/kernel/sched/rt.c
index 979b7341008a..45caf937ef90 100644
--- a/kernel/sched/rt.c
+++ b/kernel/sched/rt.c
@@ -840,6 +840,17 @@ static int do_sched_rt_period_timer(struct rt_bandwidth *rt_b, int overrun)
                 int enqueue = 0;
                 struct rt_rq *rt_rq = sched_rt_period_rt_rq(rt_b, i);
                 struct rq *rq = rq_of_rt_rq(rt_rq);
+                int skip;
+
+                /*
+                 * When span == cpu_online_mask, taking each rq->lock
+                 * can be time-consuming. Try to avoid it when possible.
+                 */
+                raw_spin_lock(&rt_rq->rt_runtime_lock);
+                skip = !rt_rq->rt_time && !rt_rq->rt_nr_running;
+                raw_spin_unlock(&rt_rq->rt_runtime_lock);
+                if (skip)
+                        continue;
 
                 raw_spin_lock(&rq->lock);
                 if (rt_rq->rt_time) {
@@ -1819,7 +1830,7 @@ retry:
                  * pushing.
                  */
                 task = pick_next_pushable_task(rq);
-                if (task_cpu(next_task) == rq->cpu && task == next_task) {
+                if (task == next_task) {
                         /*
                          * The task hasn't migrated, and is still the next
                          * eligible task, but we failed to find a run-queue
@@ -2438,6 +2449,316 @@ const struct sched_class rt_sched_class = {
         .update_curr            = update_curr_rt,
 };
 
+#ifdef CONFIG_RT_GROUP_SCHED
+/*
+ * Ensure that the real time constraints are schedulable.
+ */
+static DEFINE_MUTEX(rt_constraints_mutex);
+
+/* Must be called with tasklist_lock held */
+static inline int tg_has_rt_tasks(struct task_group *tg)
+{
+        struct task_struct *g, *p;
+
+        /*
+         * Autogroups do not have RT tasks; see autogroup_create().
+         */
+        if (task_group_is_autogroup(tg))
+                return 0;
+
+        for_each_process_thread(g, p) {
+                if (rt_task(p) && task_group(p) == tg)
+                        return 1;
+        }
+
+        return 0;
+}
+
+struct rt_schedulable_data {
+        struct task_group *tg;
+        u64 rt_period;
+        u64 rt_runtime;
+};
+
+static int tg_rt_schedulable(struct task_group *tg, void *data)
+{
+        struct rt_schedulable_data *d = data;
+        struct task_group *child;
+        unsigned long total, sum = 0;
+        u64 period, runtime;
+
+        period = ktime_to_ns(tg->rt_bandwidth.rt_period);
+        runtime = tg->rt_bandwidth.rt_runtime;
+
+        if (tg == d->tg) {
+                period = d->rt_period;
+                runtime = d->rt_runtime;
+        }
+
+        /*
+         * Cannot have more runtime than the period.
+         */
+        if (runtime > period && runtime != RUNTIME_INF)
+                return -EINVAL;
+
+        /*
+         * Ensure we don't starve existing RT tasks.
+         */
+        if (rt_bandwidth_enabled() && !runtime && tg_has_rt_tasks(tg))
+                return -EBUSY;
+
+        total = to_ratio(period, runtime);
+
+        /*
+         * Nobody can have more than the global setting allows.
+         */
+        if (total > to_ratio(global_rt_period(), global_rt_runtime()))
+                return -EINVAL;
+
+        /*
+         * The sum of our children's runtime should not exceed our own.
+         */
+        list_for_each_entry_rcu(child, &tg->children, siblings) {
+                period = ktime_to_ns(child->rt_bandwidth.rt_period);
+                runtime = child->rt_bandwidth.rt_runtime;
+
+                if (child == d->tg) {
+                        period = d->rt_period;
+                        runtime = d->rt_runtime;
+                }
+
+                sum += to_ratio(period, runtime);
+        }
+
+        if (sum > total)
+                return -EINVAL;
+
+        return 0;
+}
+
+static int __rt_schedulable(struct task_group *tg, u64 period, u64 runtime)
+{
+        int ret;
+
+        struct rt_schedulable_data data = {
+                .tg = tg,
+                .rt_period = period,
+                .rt_runtime = runtime,
+        };
+
+        rcu_read_lock();
+        ret = walk_tg_tree(tg_rt_schedulable, tg_nop, &data);
+        rcu_read_unlock();
+
+        return ret;
+}
+
+static int tg_set_rt_bandwidth(struct task_group *tg,
+                u64 rt_period, u64 rt_runtime)
+{
+        int i, err = 0;
+
+        /*
+         * Disallowing the root group RT runtime is BAD, it would disallow the
+         * kernel creating (and or operating) RT threads.
+         */
+        if (tg == &root_task_group && rt_runtime == 0)
+                return -EINVAL;
+
+        /* No period doesn't make any sense. */
+        if (rt_period == 0)
+                return -EINVAL;
+
+        mutex_lock(&rt_constraints_mutex);
+        read_lock(&tasklist_lock);
+        err = __rt_schedulable(tg, rt_period, rt_runtime);
+        if (err)
+                goto unlock;
+
+        raw_spin_lock_irq(&tg->rt_bandwidth.rt_runtime_lock);
+        tg->rt_bandwidth.rt_period = ns_to_ktime(rt_period);
+        tg->rt_bandwidth.rt_runtime = rt_runtime;
+
+        for_each_possible_cpu(i) {
+                struct rt_rq *rt_rq = tg->rt_rq[i];
+
+                raw_spin_lock(&rt_rq->rt_runtime_lock);
+                rt_rq->rt_runtime = rt_runtime;
+                raw_spin_unlock(&rt_rq->rt_runtime_lock);
+        }
+        raw_spin_unlock_irq(&tg->rt_bandwidth.rt_runtime_lock);
+unlock:
+        read_unlock(&tasklist_lock);
+        mutex_unlock(&rt_constraints_mutex);
+
+        return err;
+}
+
+int sched_group_set_rt_runtime(struct task_group *tg, long rt_runtime_us)
+{
+        u64 rt_runtime, rt_period;
+
+        rt_period = ktime_to_ns(tg->rt_bandwidth.rt_period);
+        rt_runtime = (u64)rt_runtime_us * NSEC_PER_USEC;
+        if (rt_runtime_us < 0)
+                rt_runtime = RUNTIME_INF;
+
+        return tg_set_rt_bandwidth(tg, rt_period, rt_runtime);
+}
+
+long sched_group_rt_runtime(struct task_group *tg)
+{
+        u64 rt_runtime_us;
+
+        if (tg->rt_bandwidth.rt_runtime == RUNTIME_INF)
+                return -1;
+
+        rt_runtime_us = tg->rt_bandwidth.rt_runtime;
+        do_div(rt_runtime_us, NSEC_PER_USEC);
+        return rt_runtime_us;
+}
+
+int sched_group_set_rt_period(struct task_group *tg, u64 rt_period_us)
+{
+        u64 rt_runtime, rt_period;
+
+        rt_period = rt_period_us * NSEC_PER_USEC;
+        rt_runtime = tg->rt_bandwidth.rt_runtime;
+
+        return tg_set_rt_bandwidth(tg, rt_period, rt_runtime);
+}
+
+long sched_group_rt_period(struct task_group *tg)
+{
+        u64 rt_period_us;
+
+        rt_period_us = ktime_to_ns(tg->rt_bandwidth.rt_period);
+        do_div(rt_period_us, NSEC_PER_USEC);
+        return rt_period_us;
+}
+
+static int sched_rt_global_constraints(void)
+{
+        int ret = 0;
+
+        mutex_lock(&rt_constraints_mutex);
+        read_lock(&tasklist_lock);
+        ret = __rt_schedulable(NULL, 0, 0);
+        read_unlock(&tasklist_lock);
+        mutex_unlock(&rt_constraints_mutex);
+
+        return ret;
+}
+
+int sched_rt_can_attach(struct task_group *tg, struct task_struct *tsk)
+{
+        /* Don't accept realtime tasks when there is no way for them to run */
+        if (rt_task(tsk) && tg->rt_bandwidth.rt_runtime == 0)
+                return 0;
+
+        return 1;
+}
+
+#else /* !CONFIG_RT_GROUP_SCHED */
+static int sched_rt_global_constraints(void)
+{
+        unsigned long flags;
+        int i;
+
+        raw_spin_lock_irqsave(&def_rt_bandwidth.rt_runtime_lock, flags);
+        for_each_possible_cpu(i) {
+                struct rt_rq *rt_rq = &cpu_rq(i)->rt;
+
+                raw_spin_lock(&rt_rq->rt_runtime_lock);
+                rt_rq->rt_runtime = global_rt_runtime();
+                raw_spin_unlock(&rt_rq->rt_runtime_lock);
+        }
+        raw_spin_unlock_irqrestore(&def_rt_bandwidth.rt_runtime_lock, flags);
+
+        return 0;
+}
+#endif /* CONFIG_RT_GROUP_SCHED */
+
+static int sched_rt_global_validate(void)
+{
+        if (sysctl_sched_rt_period <= 0)
+                return -EINVAL;
+
+        if ((sysctl_sched_rt_runtime != RUNTIME_INF) &&
+                (sysctl_sched_rt_runtime > sysctl_sched_rt_period))
+                return -EINVAL;
+
+        return 0;
+}
+
+static void sched_rt_do_global(void)
+{
+        def_rt_bandwidth.rt_runtime = global_rt_runtime();
+        def_rt_bandwidth.rt_period = ns_to_ktime(global_rt_period());
+}
+
+int sched_rt_handler(struct ctl_table *table, int write,
+                void __user *buffer, size_t *lenp,
+                loff_t *ppos)
+{
+        int old_period, old_runtime;
+        static DEFINE_MUTEX(mutex);
+        int ret;
+
+        mutex_lock(&mutex);
+        old_period = sysctl_sched_rt_period;
+        old_runtime = sysctl_sched_rt_runtime;
+
+        ret = proc_dointvec(table, write, buffer, lenp, ppos);
+
+        if (!ret && write) {
+                ret = sched_rt_global_validate();
+                if (ret)
+                        goto undo;
+
+                ret = sched_dl_global_validate();
+                if (ret)
+                        goto undo;
+
+                ret = sched_rt_global_constraints();
+                if (ret)
+                        goto undo;
+
+                sched_rt_do_global();
+                sched_dl_do_global();
+        }
+        if (0) {
+undo:
+                sysctl_sched_rt_period = old_period;
+                sysctl_sched_rt_runtime = old_runtime;
+        }
+        mutex_unlock(&mutex);
+
+        return ret;
+}
+
+int sched_rr_handler(struct ctl_table *table, int write,
+                void __user *buffer, size_t *lenp,
+                loff_t *ppos)
+{
+        int ret;
+        static DEFINE_MUTEX(mutex);
+
+        mutex_lock(&mutex);
+        ret = proc_dointvec(table, write, buffer, lenp, ppos);
+        /*
+         * Make sure that internally we keep jiffies.
+         * Also, writing zero resets the timeslice to default:
+         */
+        if (!ret && write) {
+                sched_rr_timeslice =
+                        sysctl_sched_rr_timeslice <= 0 ? RR_TIMESLICE :
+                        msecs_to_jiffies(sysctl_sched_rr_timeslice);
+        }
+        mutex_unlock(&mutex);
+        return ret;
+}
+
 #ifdef CONFIG_SCHED_DEBUG
 extern void print_rt_rq(struct seq_file *m, int cpu, struct rt_rq *rt_rq);
 
diff --git a/kernel/sched/sched.h b/kernel/sched/sched.h
index 6dda2aab731e..eeef1a3086d1 100644
--- a/kernel/sched/sched.h
+++ b/kernel/sched/sched.h
@@ -39,9 +39,9 @@
 #include "cpuacct.h"
 
 #ifdef CONFIG_SCHED_DEBUG
-#define SCHED_WARN_ON(x)        WARN_ONCE(x, #x)
+# define SCHED_WARN_ON(x)       WARN_ONCE(x, #x)
 #else
-#define SCHED_WARN_ON(x)        ((void)(x))
+# define SCHED_WARN_ON(x)       ({ (void)(x), 0; })
 #endif
 
 struct rq;
@@ -218,23 +218,25 @@ static inline int dl_bandwidth_enabled(void)
         return sysctl_sched_rt_runtime >= 0;
 }
 
-extern struct dl_bw *dl_bw_of(int i);
-
 struct dl_bw {
         raw_spinlock_t lock;
         u64 bw, total_bw;
 };
 
+static inline void __dl_update(struct dl_bw *dl_b, s64 bw);
+
 static inline
-void __dl_clear(struct dl_bw *dl_b, u64 tsk_bw)
+void __dl_clear(struct dl_bw *dl_b, u64 tsk_bw, int cpus)
 {
         dl_b->total_bw -= tsk_bw;
+        __dl_update(dl_b, (s32)tsk_bw / cpus);
 }
 
 static inline
-void __dl_add(struct dl_bw *dl_b, u64 tsk_bw)
+void __dl_add(struct dl_bw *dl_b, u64 tsk_bw, int cpus)
 {
         dl_b->total_bw += tsk_bw;
+        __dl_update(dl_b, -((s32)tsk_bw / cpus));
 }
 
 static inline
@@ -244,7 +246,22 @@ bool __dl_overflow(struct dl_bw *dl_b, int cpus, u64 old_bw, u64 new_bw)
                dl_b->bw * cpus < dl_b->total_bw - old_bw + new_bw;
 }
 
+void dl_change_utilization(struct task_struct *p, u64 new_bw);
 extern void init_dl_bw(struct dl_bw *dl_b);
+extern int sched_dl_global_validate(void);
+extern void sched_dl_do_global(void);
+extern int sched_dl_overflow(struct task_struct *p, int policy,
+                             const struct sched_attr *attr);
+extern void __setparam_dl(struct task_struct *p, const struct sched_attr *attr);
+extern void __getparam_dl(struct task_struct *p, struct sched_attr *attr);
+extern bool __checkparam_dl(const struct sched_attr *attr);
+extern void __dl_clear_params(struct task_struct *p);
+extern bool dl_param_changed(struct task_struct *p, const struct sched_attr *attr);
+extern int dl_task_can_attach(struct task_struct *p,
+                              const struct cpumask *cs_cpus_allowed);
+extern int dl_cpuset_cpumask_can_shrink(const struct cpumask *cur,
+                                        const struct cpumask *trial);
+extern bool dl_cpu_busy(unsigned int cpu);
 
 #ifdef CONFIG_CGROUP_SCHED
 
@@ -366,6 +383,11 @@ extern int alloc_rt_sched_group(struct task_group *tg, struct task_group *parent
 extern void init_tg_rt_entry(struct task_group *tg, struct rt_rq *rt_rq,
                 struct sched_rt_entity *rt_se, int cpu,
                 struct sched_rt_entity *parent);
+extern int sched_group_set_rt_runtime(struct task_group *tg, long rt_runtime_us);
+extern int sched_group_set_rt_period(struct task_group *tg, u64 rt_period_us);
+extern long sched_group_rt_runtime(struct task_group *tg);
+extern long sched_group_rt_period(struct task_group *tg);
+extern int sched_rt_can_attach(struct task_group *tg, struct task_struct *tsk);
 
 extern struct task_group *sched_create_group(struct task_group *parent);
 extern void sched_online_group(struct task_group *tg,
@@ -558,6 +580,30 @@ struct dl_rq {
 #else
         struct dl_bw dl_bw;
 #endif
+        /*
+         * "Active utilization" for this runqueue: increased when a
+         * task wakes up (becomes TASK_RUNNING) and decreased when a
+         * task blocks
+         */
+        u64 running_bw;
+
+        /*
+         * Utilization of the tasks "assigned" to this runqueue (including
+         * the tasks that are in runqueue and the tasks that executed on this
+         * CPU and blocked). Increased when a task moves to this runqueue, and
+         * decreased when the task moves away (migrates, changes scheduling
+         * policy, or terminates).
+         * This is needed to compute the "inactive utilization" for the
+         * runqueue (inactive utilization = this_bw - running_bw).
+         */
+        u64 this_bw;
+        u64 extra_bw;
+
+        /*
+         * Inverse of the fraction of CPU utilization that can be reclaimed
+         * by the GRUB algorithm.
+         */
+        u64 bw_ratio;
 };
 
 #ifdef CONFIG_SMP
@@ -606,11 +652,9 @@ struct root_domain {
 
 extern struct root_domain def_root_domain;
 extern struct mutex sched_domains_mutex;
-extern cpumask_var_t fallback_doms;
-extern cpumask_var_t sched_domains_tmpmask;
 
 extern void init_defrootdomain(void);
-extern int init_sched_domains(const struct cpumask *cpu_map);
+extern int sched_init_domains(const struct cpumask *cpu_map);
 extern void rq_attach_root(struct rq *rq, struct root_domain *rd);
 
 #endif /* CONFIG_SMP */
@@ -1025,7 +1069,11 @@ struct sched_group_capacity {
         unsigned long next_update;
         int imbalance; /* XXX unrelated to capacity but shared group state */
 
-        unsigned long cpumask[0]; /* iteration mask */
+#ifdef CONFIG_SCHED_DEBUG
+        int id;
+#endif
+
+        unsigned long cpumask[0]; /* balance mask */
 };
 
 struct sched_group {
@@ -1046,16 +1094,15 @@ struct sched_group {
         unsigned long cpumask[0];
 };
 
-static inline struct cpumask *sched_group_cpus(struct sched_group *sg)
+static inline struct cpumask *sched_group_span(struct sched_group *sg)
 {
         return to_cpumask(sg->cpumask);
 }
 
 /*
- * cpumask masking which cpus in the group are allowed to iterate up the domain
- * tree.
+ * See build_balance_mask().
  */
-static inline struct cpumask *sched_group_mask(struct sched_group *sg)
+static inline struct cpumask *group_balance_mask(struct sched_group *sg)
 {
         return to_cpumask(sg->sgc->cpumask);
 }
@@ -1066,7 +1113,7 @@ static inline struct cpumask *sched_group_mask(struct sched_group *sg)
  */
 static inline unsigned int group_first_cpu(struct sched_group *group)
 {
-        return cpumask_first(sched_group_cpus(group));
+        return cpumask_first(sched_group_span(group));
 }
 
 extern int group_balance_cpu(struct sched_group *sg);
@@ -1422,7 +1469,11 @@ static inline void set_curr_task(struct rq *rq, struct task_struct *curr)
         curr->sched_class->set_curr_task(rq);
 }
 
+#ifdef CONFIG_SMP
 #define sched_class_highest (&stop_sched_class)
+#else
+#define sched_class_highest (&dl_sched_class)
+#endif
 #define for_each_class(class) \
    for (class = sched_class_highest; class; class = class->next)
 
@@ -1486,7 +1537,12 @@ extern void init_rt_bandwidth(struct rt_bandwidth *rt_b, u64 period, u64 runtime
 extern struct dl_bandwidth def_dl_bandwidth;
 extern void init_dl_bandwidth(struct dl_bandwidth *dl_b, u64 period, u64 runtime);
 extern void init_dl_task_timer(struct sched_dl_entity *dl_se);
+extern void init_dl_inactive_task_timer(struct sched_dl_entity *dl_se);
+extern void init_dl_rq_bw_ratio(struct dl_rq *dl_rq);
 
+#define BW_SHIFT        20
+#define BW_UNIT         (1 << BW_SHIFT)
+#define RATIO_SHIFT     8
 unsigned long to_ratio(u64 period, u64 runtime);
 
 extern void init_entity_runnable_average(struct sched_entity *se);
@@ -1928,6 +1984,33 @@ extern void nohz_balance_exit_idle(unsigned int cpu);
 static inline void nohz_balance_exit_idle(unsigned int cpu) { }
 #endif
 
+
+#ifdef CONFIG_SMP
+static inline
+void __dl_update(struct dl_bw *dl_b, s64 bw)
+{
+        struct root_domain *rd = container_of(dl_b, struct root_domain, dl_bw);
+        int i;
+
+        RCU_LOCKDEP_WARN(!rcu_read_lock_sched_held(),
+                         "sched RCU must be held");
+        for_each_cpu_and(i, rd->span, cpu_active_mask) {
+                struct rq *rq = cpu_rq(i);
+
+                rq->dl.extra_bw += bw;
+        }
+}
+#else
+static inline
+void __dl_update(struct dl_bw *dl_b, s64 bw)
+{
+        struct dl_rq *dl = container_of(dl_b, struct dl_rq, dl_bw);
+
+        dl->extra_bw += bw;
+}
+#endif
+
+
 #ifdef CONFIG_IRQ_TIME_ACCOUNTING
 struct irqtime {
         u64                     total;
diff --git a/kernel/sched/topology.c b/kernel/sched/topology.c
index 1b0b4fb12837..79895aec281e 100644
--- a/kernel/sched/topology.c
+++ b/kernel/sched/topology.c
@@ -10,6 +10,7 @@ DEFINE_MUTEX(sched_domains_mutex);
 
 /* Protected by sched_domains_mutex: */
 cpumask_var_t sched_domains_tmpmask;
+cpumask_var_t sched_domains_tmpmask2;
 
 #ifdef CONFIG_SCHED_DEBUG
 
@@ -35,7 +36,7 @@ static int sched_domain_debug_one(struct sched_domain *sd, int cpu, int level,
 
         cpumask_clear(groupmask);
 
-        printk(KERN_DEBUG "%*s domain %d: ", level, "", level);
+        printk(KERN_DEBUG "%*s domain-%d: ", level, "", level);
 
         if (!(sd->flags & SD_LOAD_BALANCE)) {
                 printk("does not load-balance\n");
@@ -45,14 +46,14 @@ static int sched_domain_debug_one(struct sched_domain *sd, int cpu, int level,
                 return -1;
         }
 
-        printk(KERN_CONT "span %*pbl level %s\n",
+        printk(KERN_CONT "span=%*pbl level=%s\n",
                cpumask_pr_args(sched_domain_span(sd)), sd->name);
 
         if (!cpumask_test_cpu(cpu, sched_domain_span(sd))) {
                 printk(KERN_ERR "ERROR: domain->span does not contain "
                                 "CPU%d\n", cpu);
         }
-        if (!cpumask_test_cpu(cpu, sched_group_cpus(group))) {
+        if (!cpumask_test_cpu(cpu, sched_group_span(group))) {
                 printk(KERN_ERR "ERROR: domain->groups does not contain"
                                 " CPU%d\n", cpu);
         }
@@ -65,29 +66,47 @@ static int sched_domain_debug_one(struct sched_domain *sd, int cpu, int level,
                         break;
                 }
 
-                if (!cpumask_weight(sched_group_cpus(group))) {
+                if (!cpumask_weight(sched_group_span(group))) {
                         printk(KERN_CONT "\n");
                         printk(KERN_ERR "ERROR: empty group\n");
                         break;
                 }
 
                 if (!(sd->flags & SD_OVERLAP) &&
-                    cpumask_intersects(groupmask, sched_group_cpus(group))) {
+                    cpumask_intersects(groupmask, sched_group_span(group))) {
                         printk(KERN_CONT "\n");
                         printk(KERN_ERR "ERROR: repeated CPUs\n");
                         break;
                 }
 
-                cpumask_or(groupmask, groupmask, sched_group_cpus(group));
+                cpumask_or(groupmask, groupmask, sched_group_span(group));
 
-                printk(KERN_CONT " %*pbl",
-                       cpumask_pr_args(sched_group_cpus(group)));
-                if (group->sgc->capacity != SCHED_CAPACITY_SCALE) {
-                        printk(KERN_CONT " (cpu_capacity = %lu)",
-                                group->sgc->capacity);
+                printk(KERN_CONT " %d:{ span=%*pbl",
+                                group->sgc->id,
+                                cpumask_pr_args(sched_group_span(group)));
+
+                if ((sd->flags & SD_OVERLAP) &&
+                    !cpumask_equal(group_balance_mask(group), sched_group_span(group))) {
+                        printk(KERN_CONT " mask=%*pbl",
+                                cpumask_pr_args(group_balance_mask(group)));
+                }
+
+                if (group->sgc->capacity != SCHED_CAPACITY_SCALE)
+                        printk(KERN_CONT " cap=%lu", group->sgc->capacity);
+
+                if (group == sd->groups && sd->child &&
+                    !cpumask_equal(sched_domain_span(sd->child),
+                                   sched_group_span(group))) {
+                        printk(KERN_ERR "ERROR: domain->groups does not match domain->child\n");
                 }
 
+                printk(KERN_CONT " }");
+
                 group = group->next;
+
+                if (group != sd->groups)
+                        printk(KERN_CONT ",");
+
         } while (group != sd->groups);
         printk(KERN_CONT "\n");
 
@@ -113,7 +132,7 @@ static void sched_domain_debug(struct sched_domain *sd, int cpu)
                 return;
         }
 
-        printk(KERN_DEBUG "CPU%d attaching sched-domain:\n", cpu);
+        printk(KERN_DEBUG "CPU%d attaching sched-domain(s):\n", cpu);
 
         for (;;) {
                 if (sched_domain_debug_one(sd, cpu, level, sched_domains_tmpmask))
@@ -477,46 +496,214 @@ enum s_alloc {
 };
 
 /*
- * Build an iteration mask that can exclude certain CPUs from the upwards
- * domain traversal.
+ * Return the canonical balance CPU for this group, this is the first CPU
+ * of this group that's also in the balance mask.
  *
- * Asymmetric node setups can result in situations where the domain tree is of
- * unequal depth, make sure to skip domains that already cover the entire
- * range.
+ * The balance mask are all those CPUs that could actually end up at this
+ * group. See build_balance_mask().
  *
- * In that case build_sched_domains() will have terminated the iteration early
- * and our sibling sd spans will be empty. Domains should always include the
- * CPU they're built on, so check that.
+ * Also see should_we_balance().
  */
-static void build_group_mask(struct sched_domain *sd, struct sched_group *sg)
+int group_balance_cpu(struct sched_group *sg)
 {
-        const struct cpumask *span = sched_domain_span(sd);
+        return cpumask_first(group_balance_mask(sg));
+}
+
+
+/*
+ * NUMA topology (first read the regular topology blurb below)
+ *
+ * Given a node-distance table, for example:
+ *
+ *   node   0   1   2   3
+ *     0:  10  20  30  20
+ *     1:  20  10  20  30
+ *     2:  30  20  10  20
+ *     3:  20  30  20  10
+ *
+ * which represents a 4 node ring topology like:
+ *
+ *   0 ----- 1
+ *   |       |
+ *   |       |
+ *   |       |
+ *   3 ----- 2
+ *
+ * We want to construct domains and groups to represent this. The way we go
+ * about doing this is to build the domains on 'hops'. For each NUMA level we
+ * construct the mask of all nodes reachable in @level hops.
+ *
+ * For the above NUMA topology that gives 3 levels:
+ *
+ * NUMA-2       0-3             0-3             0-3             0-3
+ *  groups:     {0-1,3},{1-3}   {0-2},{0,2-3}   {1-3},{0-1,3}   {0,2-3},{0-2}
+ *
+ * NUMA-1       0-1,3           0-2             1-3             0,2-3
+ *  groups:     {0},{1},{3}     {0},{1},{2}     {1},{2},{3}     {0},{2},{3}
+ *
+ * NUMA-0       0               1               2               3
+ *
+ *
+ * As can be seen; things don't nicely line up as with the regular topology.
+ * When we iterate a domain in child domain chunks some nodes can be
+ * represented multiple times -- hence the "overlap" naming for this part of
+ * the topology.
+ *
+ * In order to minimize this overlap, we only build enough groups to cover the
+ * domain. For instance Node-0 NUMA-2 would only get groups: 0-1,3 and 1-3.
+ *
+ * Because:
+ *
+ *  - the first group of each domain is its child domain; this
+ *    gets us the first 0-1,3
+ *  - the only uncovered node is 2, who's child domain is 1-3.
+ *
+ * However, because of the overlap, computing a unique CPU for each group is
+ * more complicated. Consider for instance the groups of NODE-1 NUMA-2, both
+ * groups include the CPUs of Node-0, while those CPUs would not in fact ever
+ * end up at those groups (they would end up in group: 0-1,3).
+ *
+ * To correct this we have to introduce the group balance mask. This mask
+ * will contain those CPUs in the group that can reach this group given the
+ * (child) domain tree.
+ *
+ * With this we can once again compute balance_cpu and sched_group_capacity
+ * relations.
+ *
+ * XXX include words on how balance_cpu is unique and therefore can be
+ * used for sched_group_capacity links.
+ *
+ *
+ * Another 'interesting' topology is:
+ *
+ *   node   0   1   2   3
+ *     0:  10  20  20  30
+ *     1:  20  10  20  20
+ *     2:  20  20  10  20
+ *     3:  30  20  20  10
+ *
+ * Which looks a little like:
+ *
+ *   0 ----- 1
+ *   |     / |
+ *   |   /   |
+ *   | /     |
+ *   2 ----- 3
+ *
+ * This topology is asymmetric, nodes 1,2 are fully connected, but nodes 0,3
+ * are not.
+ *
+ * This leads to a few particularly weird cases where the sched_domain's are
+ * not of the same number for each cpu. Consider:
+ *
+ * NUMA-2       0-3                                             0-3
+ *  groups:     {0-2},{1-3}                                     {1-3},{0-2}
+ *
+ * NUMA-1       0-2             0-3             0-3             1-3
+ *
+ * NUMA-0       0               1               2               3
+ *
+ */
+
+
+/*
+ * Build the balance mask; it contains only those CPUs that can arrive at this
+ * group and should be considered to continue balancing.
+ *
+ * We do this during the group creation pass, therefore the group information
+ * isn't complete yet, however since each group represents a (child) domain we
+ * can fully construct this using the sched_domain bits (which are already
+ * complete).
+ */
+static void
+build_balance_mask(struct sched_domain *sd, struct sched_group *sg, struct cpumask *mask)
+{
+        const struct cpumask *sg_span = sched_group_span(sg);
         struct sd_data *sdd = sd->private;
         struct sched_domain *sibling;
         int i;
 
-        for_each_cpu(i, span) {
+        cpumask_clear(mask);
+
+        for_each_cpu(i, sg_span) {
                 sibling = *per_cpu_ptr(sdd->sd, i);
-                if (!cpumask_test_cpu(i, sched_domain_span(sibling)))
+
+                /*
+                 * Can happen in the asymmetric case, where these siblings are
+                 * unused. The mask will not be empty because those CPUs that
+                 * do have the top domain _should_ span the domain.
+                 */
+                if (!sibling->child)
                         continue;
 
-                cpumask_set_cpu(i, sched_group_mask(sg));
+                /* If we would not end up here, we can't continue from here */
+                if (!cpumask_equal(sg_span, sched_domain_span(sibling->child)))
+                        continue;
+
+                cpumask_set_cpu(i, mask);
         }
+
+        /* We must not have empty masks here */
+        WARN_ON_ONCE(cpumask_empty(mask));
 }
 
 /*
- * Return the canonical balance CPU for this group, this is the first CPU
- * of this group that's also in the iteration mask.
+ * XXX: This creates per-node group entries; since the load-balancer will
+ * immediately access remote memory to construct this group's load-balance
+ * statistics having the groups node local is of dubious benefit.
  */
-int group_balance_cpu(struct sched_group *sg)
+static struct sched_group *
+build_group_from_child_sched_domain(struct sched_domain *sd, int cpu)
 {
-        return cpumask_first_and(sched_group_cpus(sg), sched_group_mask(sg));
+        struct sched_group *sg;
+        struct cpumask *sg_span;
+
+        sg = kzalloc_node(sizeof(struct sched_group) + cpumask_size(),
+                        GFP_KERNEL, cpu_to_node(cpu));
+
+        if (!sg)
+                return NULL;
+
+        sg_span = sched_group_span(sg);
+        if (sd->child)
+                cpumask_copy(sg_span, sched_domain_span(sd->child));
+        else
+                cpumask_copy(sg_span, sched_domain_span(sd));
+
+        return sg;
+}
+
+static void init_overlap_sched_group(struct sched_domain *sd,
+                                     struct sched_group *sg)
+{
+        struct cpumask *mask = sched_domains_tmpmask2;
+        struct sd_data *sdd = sd->private;
+        struct cpumask *sg_span;
+        int cpu;
+
+        build_balance_mask(sd, sg, mask);
+        cpu = cpumask_first_and(sched_group_span(sg), mask);
+
+        sg->sgc = *per_cpu_ptr(sdd->sgc, cpu);
+        if (atomic_inc_return(&sg->sgc->ref) == 1)
+                cpumask_copy(group_balance_mask(sg), mask);
+        else
+                WARN_ON_ONCE(!cpumask_equal(group_balance_mask(sg), mask));
+
+        /*
+         * Initialize sgc->capacity such that even if we mess up the
+         * domains and no possible iteration will get us here, we won't
+         * die on a /0 trap.
+         */
+        sg_span = sched_group_span(sg);
+        sg->sgc->capacity = SCHED_CAPACITY_SCALE * cpumask_weight(sg_span);
+        sg->sgc->min_capacity = SCHED_CAPACITY_SCALE;
 }
 
 static int
 build_overlap_sched_groups(struct sched_domain *sd, int cpu)
 {
-        struct sched_group *first = NULL, *last = NULL, *groups = NULL, *sg;
+        struct sched_group *first = NULL, *last = NULL, *sg;
         const struct cpumask *span = sched_domain_span(sd);
         struct cpumask *covered = sched_domains_tmpmask;
         struct sd_data *sdd = sd->private;
@@ -525,7 +712,7 @@ build_overlap_sched_groups(struct sched_domain *sd, int cpu)
 
         cpumask_clear(covered);
 
-        for_each_cpu(i, span) {
+        for_each_cpu_wrap(i, span, cpu) {
                 struct cpumask *sg_span;
 
                 if (cpumask_test_cpu(i, covered))
@@ -533,44 +720,27 @@ build_overlap_sched_groups(struct sched_domain *sd, int cpu)
 
                 sibling = *per_cpu_ptr(sdd->sd, i);
 
-                /* See the comment near build_group_mask(). */
+                /*
+                 * Asymmetric node setups can result in situations where the
+                 * domain tree is of unequal depth, make sure to skip domains
+                 * that already cover the entire range.
+                 *
+                 * In that case build_sched_domains() will have terminated the
+                 * iteration early and our sibling sd spans will be empty.
+                 * Domains should always include the CPU they're built on, so
+                 * check that.
+                 */
                 if (!cpumask_test_cpu(i, sched_domain_span(sibling)))
                         continue;
 
-                sg = kzalloc_node(sizeof(struct sched_group) + cpumask_size(),
-                                GFP_KERNEL, cpu_to_node(cpu));
-
+                sg = build_group_from_child_sched_domain(sibling, cpu);
                 if (!sg)
                         goto fail;
 
-                sg_span = sched_group_cpus(sg);
-                if (sibling->child)
-                        cpumask_copy(sg_span, sched_domain_span(sibling->child));
-                else
-                        cpumask_set_cpu(i, sg_span);
-
+                sg_span = sched_group_span(sg);
                 cpumask_or(covered, covered, sg_span);
 
-                sg->sgc = *per_cpu_ptr(sdd->sgc, i);
-                if (atomic_inc_return(&sg->sgc->ref) == 1)
-                        build_group_mask(sd, sg);
-
-                /*
-                 * Initialize sgc->capacity such that even if we mess up the
-                 * domains and no possible iteration will get us here, we won't
-                 * die on a /0 trap.
-                 */
-                sg->sgc->capacity = SCHED_CAPACITY_SCALE * cpumask_weight(sg_span);
-                sg->sgc->min_capacity = SCHED_CAPACITY_SCALE;
-
-                /*
-                 * Make sure the first group of this domain contains the
-                 * canonical balance CPU. Otherwise the sched_domain iteration
-                 * breaks. See update_sg_lb_stats().
-                 */
-                if ((!groups && cpumask_test_cpu(cpu, sg_span)) ||
-                    group_balance_cpu(sg) == cpu)
-                        groups = sg;
+                init_overlap_sched_group(sd, sg);
 
                 if (!first)
                         first = sg;
@@ -579,7 +749,7 @@ build_overlap_sched_groups(struct sched_domain *sd, int cpu)
                 last = sg;
                 last->next = first;
         }
-        sd->groups = groups;
+        sd->groups = first;
 
         return 0;
 
@@ -589,23 +759,106 @@ fail:
         return -ENOMEM;
 }
 
-static int get_group(int cpu, struct sd_data *sdd, struct sched_group **sg)
+
+/*
+ * Package topology (also see the load-balance blurb in fair.c)
+ *
+ * The scheduler builds a tree structure to represent a number of important
+ * topology features. By default (default_topology[]) these include:
+ *
+ *  - Simultaneous multithreading (SMT)
+ *  - Multi-Core Cache (MC)
+ *  - Package (DIE)
+ *
+ * Where the last one more or less denotes everything up to a NUMA node.
+ *
+ * The tree consists of 3 primary data structures:
+ *
+ *      sched_domain -> sched_group -> sched_group_capacity
+ *          ^ ^             ^ ^
+ *          `-'             `-'
+ *
+ * The sched_domains are per-cpu and have a two way link (parent & child) and
+ * denote the ever growing mask of CPUs belonging to that level of topology.
+ *
+ * Each sched_domain has a circular (double) linked list of sched_group's, each
+ * denoting the domains of the level below (or individual CPUs in case of the
+ * first domain level). The sched_group linked by a sched_domain includes the
+ * CPU of that sched_domain [*].
+ *
+ * Take for instance a 2 threaded, 2 core, 2 cache cluster part:
+ *
+ * CPU   0   1   2   3   4   5   6   7
+ *
+ * DIE  [                             ]
+ * MC   [             ] [             ]
+ * SMT  [     ] [     ] [     ] [     ]
+ *
+ *  - or -
+ *
+ * DIE  0-7 0-7 0-7 0-7 0-7 0-7 0-7 0-7
+ * MC   0-3 0-3 0-3 0-3 4-7 4-7 4-7 4-7
+ * SMT  0-1 0-1 2-3 2-3 4-5 4-5 6-7 6-7
+ *
+ * CPU   0   1   2   3   4   5   6   7
+ *
+ * One way to think about it is: sched_domain moves you up and down among these
+ * topology levels, while sched_group moves you sideways through it, at child
+ * domain granularity.
+ *
+ * sched_group_capacity ensures each unique sched_group has shared storage.
+ *
+ * There are two related construction problems, both require a CPU that
+ * uniquely identify each group (for a given domain):
+ *
+ *  - The first is the balance_cpu (see should_we_balance() and the
+ *    load-balance blub in fair.c); for each group we only want 1 CPU to
+ *    continue balancing at a higher domain.
+ *
+ *  - The second is the sched_group_capacity; we want all identical groups
+ *    to share a single sched_group_capacity.
+ *
+ * Since these topologies are exclusive by construction. That is, its
+ * impossible for an SMT thread to belong to multiple cores, and cores to
+ * be part of multiple caches. There is a very clear and unique location
+ * for each CPU in the hierarchy.
+ *
+ * Therefore computing a unique CPU for each group is trivial (the iteration
+ * mask is redundant and set all 1s; all CPUs in a group will end up at _that_
+ * group), we can simply pick the first CPU in each group.
+ *
+ *
+ * [*] in other words, the first group of each domain is its child domain.
+ */
+
+static struct sched_group *get_group(int cpu, struct sd_data *sdd)
 {
         struct sched_domain *sd = *per_cpu_ptr(sdd->sd, cpu);
         struct sched_domain *child = sd->child;
+        struct sched_group *sg;
 
         if (child)
                 cpu = cpumask_first(sched_domain_span(child));
 
-        if (sg) {
-                *sg = *per_cpu_ptr(sdd->sg, cpu);
-                (*sg)->sgc = *per_cpu_ptr(sdd->sgc, cpu);
+        sg = *per_cpu_ptr(sdd->sg, cpu);
+        sg->sgc = *per_cpu_ptr(sdd->sgc, cpu);
+
+        /* For claim_allocations: */
+        atomic_inc(&sg->ref);
+        atomic_inc(&sg->sgc->ref);
 
-                /* For claim_allocations: */
-                atomic_set(&(*sg)->sgc->ref, 1);
+        if (child) {
+                cpumask_copy(sched_group_span(sg), sched_domain_span(child));
+                cpumask_copy(group_balance_mask(sg), sched_group_span(sg));
+        } else {
+                cpumask_set_cpu(cpu, sched_group_span(sg));
+                cpumask_set_cpu(cpu, group_balance_mask(sg));
         }
 
-        return cpu;
+        sg->sgc->capacity = SCHED_CAPACITY_SCALE * cpumask_weight(sched_group_span(sg));
+        sg->sgc->min_capacity = SCHED_CAPACITY_SCALE;
+
+        return sg;
 }
 
 /*
@@ -624,34 +877,20 @@ build_sched_groups(struct sched_domain *sd, int cpu)
         struct cpumask *covered;
         int i;
 
-        get_group(cpu, sdd, &sd->groups);
-        atomic_inc(&sd->groups->ref);
-
-        if (cpu != cpumask_first(span))
-                return 0;
-
         lockdep_assert_held(&sched_domains_mutex);
         covered = sched_domains_tmpmask;
 
         cpumask_clear(covered);
 
-        for_each_cpu(i, span) {
+        for_each_cpu_wrap(i, span, cpu) {
                 struct sched_group *sg;
-                int group, j;
 
                 if (cpumask_test_cpu(i, covered))
                         continue;
 
-                group = get_group(i, sdd, &sg);
-                cpumask_setall(sched_group_mask(sg));
+                sg = get_group(i, sdd);
 
-                for_each_cpu(j, span) {
-                        if (get_group(j, sdd, NULL) != group)
-                                continue;
-
-                        cpumask_set_cpu(j, covered);
-                        cpumask_set_cpu(j, sched_group_cpus(sg));
-                }
+                cpumask_or(covered, covered, sched_group_span(sg));
 
                 if (!first)
                         first = sg;
@@ -660,6 +899,7 @@ build_sched_groups(struct sched_domain *sd, int cpu)
                 last = sg;
         }
         last->next = first;
+        sd->groups = first;
 
         return 0;
 }
@@ -683,12 +923,12 @@ static void init_sched_groups_capacity(int cpu, struct sched_domain *sd)
         do {
                 int cpu, max_cpu = -1;
 
-                sg->group_weight = cpumask_weight(sched_group_cpus(sg));
+                sg->group_weight = cpumask_weight(sched_group_span(sg));
 
                 if (!(sd->flags & SD_ASYM_PACKING))
                         goto next;
 
-                for_each_cpu(cpu, sched_group_cpus(sg)) {
+                for_each_cpu(cpu, sched_group_span(sg)) {
                         if (max_cpu < 0)
                                 max_cpu = cpu;
                         else if (sched_asym_prefer(cpu, max_cpu))
@@ -1308,6 +1548,10 @@ static int __sdt_alloc(const struct cpumask *cpu_map)
                         if (!sgc)
                                 return -ENOMEM;
 
+#ifdef CONFIG_SCHED_DEBUG
+                        sgc->id = j;
+#endif
+
                         *per_cpu_ptr(sdd->sgc, j) = sgc;
                 }
         }
@@ -1407,7 +1651,7 @@ build_sched_domains(const struct cpumask *cpu_map, struct sched_domain_attr *att
                         sd = build_sched_domain(tl, cpu_map, attr, sd, i);
                         if (tl == sched_domain_topology)
                                 *per_cpu_ptr(d.sd, i) = sd;
-                        if (tl->flags & SDTL_OVERLAP || sched_feat(FORCE_SD_OVERLAP))
+                        if (tl->flags & SDTL_OVERLAP)
                                 sd->flags |= SD_OVERLAP;
                         if (cpumask_equal(cpu_map, sched_domain_span(sd)))
                                 break;
@@ -1478,7 +1722,7 @@ static struct sched_domain_attr		*dattr_cur;
  * cpumask) fails, then fallback to a single sched domain,
  * as determined by the single cpumask fallback_doms.
  */
-cpumask_var_t                           fallback_doms;
+static cpumask_var_t                    fallback_doms;
 
 /*
  * arch_update_cpu_topology lets virtualized architectures update the
@@ -1520,10 +1764,14 @@ void free_sched_domains(cpumask_var_t doms[], unsigned int ndoms)
  * For now this just excludes isolated CPUs, but could be used to
  * exclude other special cases in the future.
  */
-int init_sched_domains(const struct cpumask *cpu_map)
+int sched_init_domains(const struct cpumask *cpu_map)
 {
         int err;
 
+        zalloc_cpumask_var(&sched_domains_tmpmask, GFP_KERNEL);
+        zalloc_cpumask_var(&sched_domains_tmpmask2, GFP_KERNEL);
+        zalloc_cpumask_var(&fallback_doms, GFP_KERNEL);
+
         arch_update_cpu_topology();
         ndoms_cur = 1;
         doms_cur = alloc_sched_domains(ndoms_cur);
diff --git a/kernel/sched/wait.c b/kernel/sched/wait.c
index b8c84c6dee64..17f11c6b0a9f 100644
--- a/kernel/sched/wait.c
+++ b/kernel/sched/wait.c
@@ -12,44 +12,44 @@
 #include <linux/hash.h>
 #include <linux/kthread.h>
 
-void __init_waitqueue_head(wait_queue_head_t *q, const char *name, struct lock_class_key *key)
+void __init_waitqueue_head(struct wait_queue_head *wq_head, const char *name, struct lock_class_key *key)
 {
-        spin_lock_init(&q->lock);
-        lockdep_set_class_and_name(&q->lock, key, name);
-        INIT_LIST_HEAD(&q->task_list);
+        spin_lock_init(&wq_head->lock);
+        lockdep_set_class_and_name(&wq_head->lock, key, name);
+        INIT_LIST_HEAD(&wq_head->head);
 }
 
 EXPORT_SYMBOL(__init_waitqueue_head);
 
-void add_wait_queue(wait_queue_head_t *q, wait_queue_t *wait)
+void add_wait_queue(struct wait_queue_head *wq_head, struct wait_queue_entry *wq_entry)
 {
         unsigned long flags;
 
-        wait->flags &= ~WQ_FLAG_EXCLUSIVE;
-        spin_lock_irqsave(&q->lock, flags);
-        __add_wait_queue(q, wait);
-        spin_unlock_irqrestore(&q->lock, flags);
+        wq_entry->flags &= ~WQ_FLAG_EXCLUSIVE;
+        spin_lock_irqsave(&wq_head->lock, flags);
+        __add_wait_queue_entry_tail(wq_head, wq_entry);
+        spin_unlock_irqrestore(&wq_head->lock, flags);
 }
 EXPORT_SYMBOL(add_wait_queue);
 
-void add_wait_queue_exclusive(wait_queue_head_t *q, wait_queue_t *wait)
+void add_wait_queue_exclusive(struct wait_queue_head *wq_head, struct wait_queue_entry *wq_entry)
 {
         unsigned long flags;
 
-        wait->flags |= WQ_FLAG_EXCLUSIVE;
-        spin_lock_irqsave(&q->lock, flags);
-        __add_wait_queue_tail(q, wait);
-        spin_unlock_irqrestore(&q->lock, flags);
+        wq_entry->flags |= WQ_FLAG_EXCLUSIVE;
+        spin_lock_irqsave(&wq_head->lock, flags);
+        __add_wait_queue_entry_tail(wq_head, wq_entry);
+        spin_unlock_irqrestore(&wq_head->lock, flags);
 }
 EXPORT_SYMBOL(add_wait_queue_exclusive);
 
-void remove_wait_queue(wait_queue_head_t *q, wait_queue_t *wait)
+void remove_wait_queue(struct wait_queue_head *wq_head, struct wait_queue_entry *wq_entry)
 {
         unsigned long flags;
 
-        spin_lock_irqsave(&q->lock, flags);
-        __remove_wait_queue(q, wait);
-        spin_unlock_irqrestore(&q->lock, flags);
+        spin_lock_irqsave(&wq_head->lock, flags);
+        __remove_wait_queue(wq_head, wq_entry);
+        spin_unlock_irqrestore(&wq_head->lock, flags);
 }
 EXPORT_SYMBOL(remove_wait_queue);
 
@@ -63,12 +63,12 @@ EXPORT_SYMBOL(remove_wait_queue);
  * started to run but is not in state TASK_RUNNING. try_to_wake_up() returns
  * zero in this (rare) case, and we handle it by continuing to scan the queue.
  */
-static void __wake_up_common(wait_queue_head_t *q, unsigned int mode,
+static void __wake_up_common(struct wait_queue_head *wq_head, unsigned int mode,
                         int nr_exclusive, int wake_flags, void *key)
 {
-        wait_queue_t *curr, *next;
+        wait_queue_entry_t *curr, *next;
 
-        list_for_each_entry_safe(curr, next, &q->task_list, task_list) {
+        list_for_each_entry_safe(curr, next, &wq_head->head, entry) {
                 unsigned flags = curr->flags;
 
                 if (curr->func(curr, mode, wake_flags, key) &&
@@ -79,7 +79,7 @@ static void __wake_up_common(wait_queue_head_t *q, unsigned int mode,
 
 /**
  * __wake_up - wake up threads blocked on a waitqueue.
- * @q: the waitqueue
+ * @wq_head: the waitqueue
  * @mode: which threads
  * @nr_exclusive: how many wake-one or wake-many threads to wake up
  * @key: is directly passed to the wakeup function
@@ -87,35 +87,35 @@ static void __wake_up_common(wait_queue_head_t *q, unsigned int mode,
  * It may be assumed that this function implies a write memory barrier before
  * changing the task state if and only if any tasks are woken up.
  */
-void __wake_up(wait_queue_head_t *q, unsigned int mode,
+void __wake_up(struct wait_queue_head *wq_head, unsigned int mode,
                         int nr_exclusive, void *key)
 {
         unsigned long flags;
 
-        spin_lock_irqsave(&q->lock, flags);
-        __wake_up_common(q, mode, nr_exclusive, 0, key);
-        spin_unlock_irqrestore(&q->lock, flags);
+        spin_lock_irqsave(&wq_head->lock, flags);
+        __wake_up_common(wq_head, mode, nr_exclusive, 0, key);
+        spin_unlock_irqrestore(&wq_head->lock, flags);
 }
 EXPORT_SYMBOL(__wake_up);
 
 /*
  * Same as __wake_up but called with the spinlock in wait_queue_head_t held.
  */
-void __wake_up_locked(wait_queue_head_t *q, unsigned int mode, int nr)
+void __wake_up_locked(struct wait_queue_head *wq_head, unsigned int mode, int nr)
 {
-        __wake_up_common(q, mode, nr, 0, NULL);
+        __wake_up_common(wq_head, mode, nr, 0, NULL);
 }
 EXPORT_SYMBOL_GPL(__wake_up_locked);
 
-void __wake_up_locked_key(wait_queue_head_t *q, unsigned int mode, void *key)
+void __wake_up_locked_key(struct wait_queue_head *wq_head, unsigned int mode, void *key)
 {
-        __wake_up_common(q, mode, 1, 0, key);
+        __wake_up_common(wq_head, mode, 1, 0, key);
 }
 EXPORT_SYMBOL_GPL(__wake_up_locked_key);
 
 /**
  * __wake_up_sync_key - wake up threads blocked on a waitqueue.
- * @q: the waitqueue
+ * @wq_head: the waitqueue
  * @mode: which threads
  * @nr_exclusive: how many wake-one or wake-many threads to wake up
  * @key: opaque value to be passed to wakeup targets
@@ -130,30 +130,30 @@ EXPORT_SYMBOL_GPL(__wake_up_locked_key);
  * It may be assumed that this function implies a write memory barrier before
  * changing the task state if and only if any tasks are woken up.
  */
-void __wake_up_sync_key(wait_queue_head_t *q, unsigned int mode,
+void __wake_up_sync_key(struct wait_queue_head *wq_head, unsigned int mode,
                         int nr_exclusive, void *key)
 {
         unsigned long flags;
         int wake_flags = 1; /* XXX WF_SYNC */
 
-        if (unlikely(!q))
+        if (unlikely(!wq_head))
                 return;
 
         if (unlikely(nr_exclusive != 1))
                 wake_flags = 0;
 
-        spin_lock_irqsave(&q->lock, flags);
-        __wake_up_common(q, mode, nr_exclusive, wake_flags, key);
-        spin_unlock_irqrestore(&q->lock, flags);
+        spin_lock_irqsave(&wq_head->lock, flags);
+        __wake_up_common(wq_head, mode, nr_exclusive, wake_flags, key);
+        spin_unlock_irqrestore(&wq_head->lock, flags);
 }
 EXPORT_SYMBOL_GPL(__wake_up_sync_key);
 
 /*
  * __wake_up_sync - see __wake_up_sync_key()
  */
-void __wake_up_sync(wait_queue_head_t *q, unsigned int mode, int nr_exclusive)
+void __wake_up_sync(struct wait_queue_head *wq_head, unsigned int mode, int nr_exclusive)
 {
-        __wake_up_sync_key(q, mode, nr_exclusive, NULL);
+        __wake_up_sync_key(wq_head, mode, nr_exclusive, NULL);
 }
 EXPORT_SYMBOL_GPL(__wake_up_sync);      /* For internal use only */
 
@@ -170,48 +170,48 @@ EXPORT_SYMBOL_GPL(__wake_up_sync);	/* For internal use only */
  * loads to move into the critical region).
  */
 void
-prepare_to_wait(wait_queue_head_t *q, wait_queue_t *wait, int state)
+prepare_to_wait(struct wait_queue_head *wq_head, struct wait_queue_entry *wq_entry, int state)
 {
         unsigned long flags;
 
-        wait->flags &= ~WQ_FLAG_EXCLUSIVE;
-        spin_lock_irqsave(&q->lock, flags);
-        if (list_empty(&wait->task_list))
-                __add_wait_queue(q, wait);
+        wq_entry->flags &= ~WQ_FLAG_EXCLUSIVE;
+        spin_lock_irqsave(&wq_head->lock, flags);
+        if (list_empty(&wq_entry->entry))
+                __add_wait_queue(wq_head, wq_entry);
         set_current_state(state);
-        spin_unlock_irqrestore(&q->lock, flags);
+        spin_unlock_irqrestore(&wq_head->lock, flags);
 }
 EXPORT_SYMBOL(prepare_to_wait);
 
 void
-prepare_to_wait_exclusive(wait_queue_head_t *q, wait_queue_t *wait, int state)
+prepare_to_wait_exclusive(struct wait_queue_head *wq_head, struct wait_queue_entry *wq_entry, int state)
 {
         unsigned long flags;
 
-        wait->flags |= WQ_FLAG_EXCLUSIVE;
-        spin_lock_irqsave(&q->lock, flags);
-        if (list_empty(&wait->task_list))
-                __add_wait_queue_tail(q, wait);
+        wq_entry->flags |= WQ_FLAG_EXCLUSIVE;
+        spin_lock_irqsave(&wq_head->lock, flags);
+        if (list_empty(&wq_entry->entry))
+                __add_wait_queue_entry_tail(wq_head, wq_entry);
         set_current_state(state);
-        spin_unlock_irqrestore(&q->lock, flags);
+        spin_unlock_irqrestore(&wq_head->lock, flags);
 }
 EXPORT_SYMBOL(prepare_to_wait_exclusive);
 
-void init_wait_entry(wait_queue_t *wait, int flags)
+void init_wait_entry(struct wait_queue_entry *wq_entry, int flags)
 {
-        wait->flags = flags;
-        wait->private = current;
-        wait->func = autoremove_wake_function;
-        INIT_LIST_HEAD(&wait->task_list);
+        wq_entry->flags = flags;
+        wq_entry->private = current;
+        wq_entry->func = autoremove_wake_function;
+        INIT_LIST_HEAD(&wq_entry->entry);
 }
 EXPORT_SYMBOL(init_wait_entry);
 
-long prepare_to_wait_event(wait_queue_head_t *q, wait_queue_t *wait, int state)
+long prepare_to_wait_event(struct wait_queue_head *wq_head, struct wait_queue_entry *wq_entry, int state)
 {
         unsigned long flags;
         long ret = 0;
 
-        spin_lock_irqsave(&q->lock, flags);
+        spin_lock_irqsave(&wq_head->lock, flags);
         if (unlikely(signal_pending_state(state, current))) {
                 /*
                  * Exclusive waiter must not fail if it was selected by wakeup,
@@ -219,24 +219,24 @@ long prepare_to_wait_event(wait_queue_head_t *q, wait_queue_t *wait, int state)
                  *
                  * The caller will recheck the condition and return success if
                  * we were already woken up, we can not miss the event because
-                 * wakeup locks/unlocks the same q->lock.
+                 * wakeup locks/unlocks the same wq_head->lock.
                  *
                  * But we need to ensure that set-condition + wakeup after that
                  * can't see us, it should wake up another exclusive waiter if
                  * we fail.
                  */
-                list_del_init(&wait->task_list);
+                list_del_init(&wq_entry->entry);
                 ret = -ERESTARTSYS;
         } else {
-                if (list_empty(&wait->task_list)) {
-                        if (wait->flags & WQ_FLAG_EXCLUSIVE)
-                                __add_wait_queue_tail(q, wait);
+                if (list_empty(&wq_entry->entry)) {
+                        if (wq_entry->flags & WQ_FLAG_EXCLUSIVE)
+                                __add_wait_queue_entry_tail(wq_head, wq_entry);
                         else
-                                __add_wait_queue(q, wait);
+                                __add_wait_queue(wq_head, wq_entry);
                 }
                 set_current_state(state);
         }
-        spin_unlock_irqrestore(&q->lock, flags);
+        spin_unlock_irqrestore(&wq_head->lock, flags);
 
         return ret;
 }
@@ -249,10 +249,10 @@ EXPORT_SYMBOL(prepare_to_wait_event);
  * condition in the caller before they add the wait
  * entry to the wake queue.
  */
-int do_wait_intr(wait_queue_head_t *wq, wait_queue_t *wait)
+int do_wait_intr(wait_queue_head_t *wq, wait_queue_entry_t *wait)
 {
-        if (likely(list_empty(&wait->task_list)))
-                __add_wait_queue_tail(wq, wait);
+        if (likely(list_empty(&wait->entry)))
+                __add_wait_queue_entry_tail(wq, wait);
 
         set_current_state(TASK_INTERRUPTIBLE);
         if (signal_pending(current))
@@ -265,10 +265,10 @@ int do_wait_intr(wait_queue_head_t *wq, wait_queue_t *wait)
 }
 EXPORT_SYMBOL(do_wait_intr);
 
-int do_wait_intr_irq(wait_queue_head_t *wq, wait_queue_t *wait)
+int do_wait_intr_irq(wait_queue_head_t *wq, wait_queue_entry_t *wait)
 {
-        if (likely(list_empty(&wait->task_list)))
-                __add_wait_queue_tail(wq, wait);
+        if (likely(list_empty(&wait->entry)))
+                __add_wait_queue_entry_tail(wq, wait);
 
         set_current_state(TASK_INTERRUPTIBLE);
         if (signal_pending(current))
@@ -283,14 +283,14 @@ EXPORT_SYMBOL(do_wait_intr_irq);
 
 /**
  * finish_wait - clean up after waiting in a queue
- * @q: waitqueue waited on
- * @wait: wait descriptor
+ * @wq_head: waitqueue waited on
+ * @wq_entry: wait descriptor
  *
  * Sets current thread back to running state and removes
  * the wait descriptor from the given waitqueue if still
  * queued.
  */
-void finish_wait(wait_queue_head_t *q, wait_queue_t *wait)
+void finish_wait(struct wait_queue_head *wq_head, struct wait_queue_entry *wq_entry)
 {
         unsigned long flags;
 
@@ -308,20 +308,20 @@ void finish_wait(wait_queue_head_t *q, wait_queue_t *wait)
          *    have _one_ other CPU that looks at or modifies
          *    the list).
          */
-        if (!list_empty_careful(&wait->task_list)) {
-                spin_lock_irqsave(&q->lock, flags);
-                list_del_init(&wait->task_list);
-                spin_unlock_irqrestore(&q->lock, flags);
+        if (!list_empty_careful(&wq_entry->entry)) {
+                spin_lock_irqsave(&wq_head->lock, flags);
+                list_del_init(&wq_entry->entry);
+                spin_unlock_irqrestore(&wq_head->lock, flags);
         }
 }
 EXPORT_SYMBOL(finish_wait);
 
-int autoremove_wake_function(wait_queue_t *wait, unsigned mode, int sync, void *key)
+int autoremove_wake_function(struct wait_queue_entry *wq_entry, unsigned mode, int sync, void *key)
 {
-        int ret = default_wake_function(wait, mode, sync, key);
+        int ret = default_wake_function(wq_entry, mode, sync, key);
 
         if (ret)
-                list_del_init(&wait->task_list);
+                list_del_init(&wq_entry->entry);
         return ret;
 }
 EXPORT_SYMBOL(autoremove_wake_function);
@@ -334,24 +334,24 @@ static inline bool is_kthread_should_stop(void)
 /*
  * DEFINE_WAIT_FUNC(wait, woken_wake_func);
  *
- * add_wait_queue(&wq, &wait);
+ * add_wait_queue(&wq_head, &wait);
  * for (;;) {
  *     if (condition)
  *         break;
  *
  *     p->state = mode;                         condition = true;
  *     smp_mb(); // A                           smp_wmb(); // C
- *     if (!wait->flags & WQ_FLAG_WOKEN)        wait->flags |= WQ_FLAG_WOKEN;
+ *     if (!wq_entry->flags & WQ_FLAG_WOKEN)    wq_entry->flags |= WQ_FLAG_WOKEN;
  *         schedule()                           try_to_wake_up();
  *     p->state = TASK_RUNNING;             ~~~~~~~~~~~~~~~~~~
- *     wait->flags &= ~WQ_FLAG_WOKEN;           condition = true;
+ *     wq_entry->flags &= ~WQ_FLAG_WOKEN;               condition = true;
  *     smp_mb() // B                            smp_wmb(); // C
- *                                              wait->flags |= WQ_FLAG_WOKEN;
+ *                                              wq_entry->flags |= WQ_FLAG_WOKEN;
  * }
- * remove_wait_queue(&wq, &wait);
+ * remove_wait_queue(&wq_head, &wait);
  *
  */
-long wait_woken(wait_queue_t *wait, unsigned mode, long timeout)
+long wait_woken(struct wait_queue_entry *wq_entry, unsigned mode, long timeout)
 {
         set_current_state(mode); /* A */
         /*
@@ -359,7 +359,7 @@ long wait_woken(wait_queue_t *wait, unsigned mode, long timeout)
          * woken_wake_function() such that if we observe WQ_FLAG_WOKEN we must
          * also observe all state before the wakeup.
          */
-        if (!(wait->flags & WQ_FLAG_WOKEN) && !is_kthread_should_stop())
+        if (!(wq_entry->flags & WQ_FLAG_WOKEN) && !is_kthread_should_stop())
                 timeout = schedule_timeout(timeout);
         __set_current_state(TASK_RUNNING);
 
@@ -369,13 +369,13 @@ long wait_woken(wait_queue_t *wait, unsigned mode, long timeout)
          * condition being true _OR_ WQ_FLAG_WOKEN such that we will not miss
          * an event.
          */
-        smp_store_mb(wait->flags, wait->flags & ~WQ_FLAG_WOKEN); /* B */
+        smp_store_mb(wq_entry->flags, wq_entry->flags & ~WQ_FLAG_WOKEN); /* B */
 
         return timeout;
 }
 EXPORT_SYMBOL(wait_woken);
 
-int woken_wake_function(wait_queue_t *wait, unsigned mode, int sync, void *key)
+int woken_wake_function(struct wait_queue_entry *wq_entry, unsigned mode, int sync, void *key)
 {
         /*
          * Although this function is called under waitqueue lock, LOCK
@@ -385,267 +385,8 @@ int woken_wake_function(wait_queue_t *wait, unsigned mode, int sync, void *key)
          * and is paired with smp_store_mb() in wait_woken().
          */
         smp_wmb(); /* C */
-        wait->flags |= WQ_FLAG_WOKEN;
+        wq_entry->flags |= WQ_FLAG_WOKEN;
 
-        return default_wake_function(wait, mode, sync, key);
+        return default_wake_function(wq_entry, mode, sync, key);
 }
 EXPORT_SYMBOL(woken_wake_function);
-
-int wake_bit_function(wait_queue_t *wait, unsigned mode, int sync, void *arg)
-{
-        struct wait_bit_key *key = arg;
-        struct wait_bit_queue *wait_bit
-                = container_of(wait, struct wait_bit_queue, wait);
-
-        if (wait_bit->key.flags != key->flags ||
-                        wait_bit->key.bit_nr != key->bit_nr ||
-                        test_bit(key->bit_nr, key->flags))
-                return 0;
-        else
-                return autoremove_wake_function(wait, mode, sync, key);
-}
-EXPORT_SYMBOL(wake_bit_function);
-
-/*
- * To allow interruptible waiting and asynchronous (i.e. nonblocking)
- * waiting, the actions of __wait_on_bit() and __wait_on_bit_lock() are
- * permitted return codes. Nonzero return codes halt waiting and return.
- */
-int __sched
-__wait_on_bit(wait_queue_head_t *wq, struct wait_bit_queue *q,
-              wait_bit_action_f *action, unsigned mode)
-{
-        int ret = 0;
-
-        do {
-                prepare_to_wait(wq, &q->wait, mode);
-                if (test_bit(q->key.bit_nr, q->key.flags))
-                        ret = (*action)(&q->key, mode);
-        } while (test_bit(q->key.bit_nr, q->key.flags) && !ret);
-        finish_wait(wq, &q->wait);
-        return ret;
-}
-EXPORT_SYMBOL(__wait_on_bit);
-
-int __sched out_of_line_wait_on_bit(void *word, int bit,
-                                    wait_bit_action_f *action, unsigned mode)
-{
-        wait_queue_head_t *wq = bit_waitqueue(word, bit);
-        DEFINE_WAIT_BIT(wait, word, bit);
-
-        return __wait_on_bit(wq, &wait, action, mode);
-}
-EXPORT_SYMBOL(out_of_line_wait_on_bit);
-
-int __sched out_of_line_wait_on_bit_timeout(
-        void *word, int bit, wait_bit_action_f *action,
-        unsigned mode, unsigned long timeout)
-{
-        wait_queue_head_t *wq = bit_waitqueue(word, bit);
-        DEFINE_WAIT_BIT(wait, word, bit);
-
-        wait.key.timeout = jiffies + timeout;
-        return __wait_on_bit(wq, &wait, action, mode);
-}
-EXPORT_SYMBOL_GPL(out_of_line_wait_on_bit_timeout);
-
-int __sched
-__wait_on_bit_lock(wait_queue_head_t *wq, struct wait_bit_queue *q,
-                        wait_bit_action_f *action, unsigned mode)
-{
-        int ret = 0;
-
-        for (;;) {
-                prepare_to_wait_exclusive(wq, &q->wait, mode);
-                if (test_bit(q->key.bit_nr, q->key.flags)) {
-                        ret = action(&q->key, mode);
-                        /*
-                         * See the comment in prepare_to_wait_event().
-                         * finish_wait() does not necessarily takes wq->lock,
-                         * but test_and_set_bit() implies mb() which pairs with
-                         * smp_mb__after_atomic() before wake_up_page().
-                         */
-                        if (ret)
-                                finish_wait(wq, &q->wait);
-                }
-                if (!test_and_set_bit(q->key.bit_nr, q->key.flags)) {
-                        if (!ret)
-                                finish_wait(wq, &q->wait);
-                        return 0;
-                } else if (ret) {
-                        return ret;
-                }
-        }
-}
-EXPORT_SYMBOL(__wait_on_bit_lock);
-
-int __sched out_of_line_wait_on_bit_lock(void *word, int bit,
-                                         wait_bit_action_f *action, unsigned mode)
-{
-        wait_queue_head_t *wq = bit_waitqueue(word, bit);
-        DEFINE_WAIT_BIT(wait, word, bit);
-
-        return __wait_on_bit_lock(wq, &wait, action, mode);
-}
-EXPORT_SYMBOL(out_of_line_wait_on_bit_lock);
-
-void __wake_up_bit(wait_queue_head_t *wq, void *word, int bit)
-{
-        struct wait_bit_key key = __WAIT_BIT_KEY_INITIALIZER(word, bit);
-        if (waitqueue_active(wq))
-                __wake_up(wq, TASK_NORMAL, 1, &key);
-}
-EXPORT_SYMBOL(__wake_up_bit);
-
-/**
- * wake_up_bit - wake up a waiter on a bit
- * @word: the word being waited on, a kernel virtual address
- * @bit: the bit of the word being waited on
- *
- * There is a standard hashed waitqueue table for generic use. This
- * is the part of the hashtable's accessor API that wakes up waiters
- * on a bit. For instance, if one were to have waiters on a bitflag,
- * one would call wake_up_bit() after clearing the bit.
- *
- * In order for this to function properly, as it uses waitqueue_active()
- * internally, some kind of memory barrier must be done prior to calling
- * this. Typically, this will be smp_mb__after_atomic(), but in some
- * cases where bitflags are manipulated non-atomically under a lock, one
- * may need to use a less regular barrier, such fs/inode.c's smp_mb(),
- * because spin_unlock() does not guarantee a memory barrier.
- */
-void wake_up_bit(void *word, int bit)
-{
-        __wake_up_bit(bit_waitqueue(word, bit), word, bit);
-}
-EXPORT_SYMBOL(wake_up_bit);
-
-/*
- * Manipulate the atomic_t address to produce a better bit waitqueue table hash
- * index (we're keying off bit -1, but that would produce a horrible hash
- * value).
- */
-static inline wait_queue_head_t *atomic_t_waitqueue(atomic_t *p)
-{
-        if (BITS_PER_LONG == 64) {
-                unsigned long q = (unsigned long)p;
-                return bit_waitqueue((void *)(q & ~1), q & 1);
-        }
-        return bit_waitqueue(p, 0);
-}
-
-static int wake_atomic_t_function(wait_queue_t *wait, unsigned mode, int sync,
-                                  void *arg)
-{
-        struct wait_bit_key *key = arg;
-        struct wait_bit_queue *wait_bit
-                = container_of(wait, struct wait_bit_queue, wait);
-        atomic_t *val = key->flags;
-
-        if (wait_bit->key.flags != key->flags ||
-            wait_bit->key.bit_nr != key->bit_nr ||
-            atomic_read(val) != 0)
-                return 0;
-        return autoremove_wake_function(wait, mode, sync, key);
-}
-
-/*
- * To allow interruptible waiting and asynchronous (i.e. nonblocking) waiting,
- * the actions of __wait_on_atomic_t() are permitted return codes.  Nonzero
- * return codes halt waiting and return.
- */
-static __sched
-int __wait_on_atomic_t(wait_queue_head_t *wq, struct wait_bit_queue *q,
-                       int (*action)(atomic_t *), unsigned mode)
-{
-        atomic_t *val;
-        int ret = 0;
-
-        do {
-                prepare_to_wait(wq, &q->wait, mode);
-                val = q->key.flags;
-                if (atomic_read(val) == 0)
-                        break;
-                ret = (*action)(val);
-        } while (!ret && atomic_read(val) != 0);
-        finish_wait(wq, &q->wait);
-        return ret;
-}
-
-#define DEFINE_WAIT_ATOMIC_T(name, p)                                   \
-        struct wait_bit_queue name = {                                  \
-                .key = __WAIT_ATOMIC_T_KEY_INITIALIZER(p),              \
-                .wait   = {                                             \
-                        .private        = current,                      \
-                        .func           = wake_atomic_t_function,       \
-                        .task_list      =                               \
-                                LIST_HEAD_INIT((name).wait.task_list),  \
-                },                                                      \
-        }
-
-__sched int out_of_line_wait_on_atomic_t(atomic_t *p, int (*action)(atomic_t *),
-                                         unsigned mode)
-{
-        wait_queue_head_t *wq = atomic_t_waitqueue(p);
-        DEFINE_WAIT_ATOMIC_T(wait, p);
-
-        return __wait_on_atomic_t(wq, &wait, action, mode);
-}
-EXPORT_SYMBOL(out_of_line_wait_on_atomic_t);
-
-/**
- * wake_up_atomic_t - Wake up a waiter on a atomic_t
- * @p: The atomic_t being waited on, a kernel virtual address
- *
- * Wake up anyone waiting for the atomic_t to go to zero.
- *
- * Abuse the bit-waker function and its waitqueue hash table set (the atomic_t
- * check is done by the waiter's wake function, not the by the waker itself).
- */
-void wake_up_atomic_t(atomic_t *p)
-{
-        __wake_up_bit(atomic_t_waitqueue(p), p, WAIT_ATOMIC_T_BIT_NR);
-}
-EXPORT_SYMBOL(wake_up_atomic_t);
-
-__sched int bit_wait(struct wait_bit_key *word, int mode)
-{
-        schedule();
-        if (signal_pending_state(mode, current))
-                return -EINTR;
-        return 0;
-}
-EXPORT_SYMBOL(bit_wait);
-
-__sched int bit_wait_io(struct wait_bit_key *word, int mode)
-{
-        io_schedule();
-        if (signal_pending_state(mode, current))
-                return -EINTR;
-        return 0;
-}
-EXPORT_SYMBOL(bit_wait_io);
-
-__sched int bit_wait_timeout(struct wait_bit_key *word, int mode)
-{
-        unsigned long now = READ_ONCE(jiffies);
-        if (time_after_eq(now, word->timeout))
-                return -EAGAIN;
-        schedule_timeout(word->timeout - now);
-        if (signal_pending_state(mode, current))
-                return -EINTR;
-        return 0;
-}
-EXPORT_SYMBOL_GPL(bit_wait_timeout);
-
-__sched int bit_wait_io_timeout(struct wait_bit_key *word, int mode)
-{
-        unsigned long now = READ_ONCE(jiffies);
-        if (time_after_eq(now, word->timeout))
-                return -EAGAIN;
-        io_schedule_timeout(word->timeout - now);
-        if (signal_pending_state(mode, current))
-                return -EINTR;
-        return 0;
-}
-EXPORT_SYMBOL_GPL(bit_wait_io_timeout);
diff --git a/kernel/sched/wait_bit.c b/kernel/sched/wait_bit.c
new file mode 100644
index 000000000000..f8159698aa4d
--- /dev/null
+++ b/kernel/sched/wait_bit.c
@@ -0,0 +1,286 @@
+/*
+ * The implementation of the wait_bit*() and related waiting APIs:
+ */
+#include <linux/wait_bit.h>
+#include <linux/sched/signal.h>
+#include <linux/sched/debug.h>
+#include <linux/hash.h>
+
+#define WAIT_TABLE_BITS 8
+#define WAIT_TABLE_SIZE (1 << WAIT_TABLE_BITS)
+
+static wait_queue_head_t bit_wait_table[WAIT_TABLE_SIZE] __cacheline_aligned;
+
+wait_queue_head_t *bit_waitqueue(void *word, int bit)
+{
+        const int shift = BITS_PER_LONG == 32 ? 5 : 6;
+        unsigned long val = (unsigned long)word << shift | bit;
+
+        return bit_wait_table + hash_long(val, WAIT_TABLE_BITS);
+}
+EXPORT_SYMBOL(bit_waitqueue);
+
+int wake_bit_function(struct wait_queue_entry *wq_entry, unsigned mode, int sync, void *arg)
+{
+        struct wait_bit_key *key = arg;
+        struct wait_bit_queue_entry *wait_bit = container_of(wq_entry, struct wait_bit_queue_entry, wq_entry);
+
+        if (wait_bit->key.flags != key->flags ||
+                        wait_bit->key.bit_nr != key->bit_nr ||
+                        test_bit(key->bit_nr, key->flags))
+                return 0;
+        else
+                return autoremove_wake_function(wq_entry, mode, sync, key);
+}
+EXPORT_SYMBOL(wake_bit_function);
+
+/*
+ * To allow interruptible waiting and asynchronous (i.e. nonblocking)
+ * waiting, the actions of __wait_on_bit() and __wait_on_bit_lock() are
+ * permitted return codes. Nonzero return codes halt waiting and return.
+ */
+int __sched
+__wait_on_bit(struct wait_queue_head *wq_head, struct wait_bit_queue_entry *wbq_entry,
+              wait_bit_action_f *action, unsigned mode)
+{
+        int ret = 0;
+
+        do {
+                prepare_to_wait(wq_head, &wbq_entry->wq_entry, mode);
+                if (test_bit(wbq_entry->key.bit_nr, wbq_entry->key.flags))
+                        ret = (*action)(&wbq_entry->key, mode);
+        } while (test_bit(wbq_entry->key.bit_nr, wbq_entry->key.flags) && !ret);
+        finish_wait(wq_head, &wbq_entry->wq_entry);
+        return ret;
+}
+EXPORT_SYMBOL(__wait_on_bit);
+
+int __sched out_of_line_wait_on_bit(void *word, int bit,
+                                    wait_bit_action_f *action, unsigned mode)
+{
+        struct wait_queue_head *wq_head = bit_waitqueue(word, bit);
+        DEFINE_WAIT_BIT(wq_entry, word, bit);
+
+        return __wait_on_bit(wq_head, &wq_entry, action, mode);
+}
+EXPORT_SYMBOL(out_of_line_wait_on_bit);
+
+int __sched out_of_line_wait_on_bit_timeout(
+        void *word, int bit, wait_bit_action_f *action,
+        unsigned mode, unsigned long timeout)
+{
+        struct wait_queue_head *wq_head = bit_waitqueue(word, bit);
+        DEFINE_WAIT_BIT(wq_entry, word, bit);
+
+        wq_entry.key.timeout = jiffies + timeout;
+        return __wait_on_bit(wq_head, &wq_entry, action, mode);
+}
+EXPORT_SYMBOL_GPL(out_of_line_wait_on_bit_timeout);
+
+int __sched
+__wait_on_bit_lock(struct wait_queue_head *wq_head, struct wait_bit_queue_entry *wbq_entry,
+                        wait_bit_action_f *action, unsigned mode)
+{
+        int ret = 0;
+
+        for (;;) {
+                prepare_to_wait_exclusive(wq_head, &wbq_entry->wq_entry, mode);
+                if (test_bit(wbq_entry->key.bit_nr, wbq_entry->key.flags)) {
+                        ret = action(&wbq_entry->key, mode);
+                        /*
+                         * See the comment in prepare_to_wait_event().
+                         * finish_wait() does not necessarily takes wwq_head->lock,
+                         * but test_and_set_bit() implies mb() which pairs with
+                         * smp_mb__after_atomic() before wake_up_page().
+                         */
+                        if (ret)
+                                finish_wait(wq_head, &wbq_entry->wq_entry);
+                }
+                if (!test_and_set_bit(wbq_entry->key.bit_nr, wbq_entry->key.flags)) {
+                        if (!ret)
+                                finish_wait(wq_head, &wbq_entry->wq_entry);
+                        return 0;
+                } else if (ret) {
+                        return ret;
+                }
+        }
+}
+EXPORT_SYMBOL(__wait_on_bit_lock);
+
+int __sched out_of_line_wait_on_bit_lock(void *word, int bit,
+                                         wait_bit_action_f *action, unsigned mode)
+{
+        struct wait_queue_head *wq_head = bit_waitqueue(word, bit);
+        DEFINE_WAIT_BIT(wq_entry, word, bit);
+
+        return __wait_on_bit_lock(wq_head, &wq_entry, action, mode);
+}
+EXPORT_SYMBOL(out_of_line_wait_on_bit_lock);
+
+void __wake_up_bit(struct wait_queue_head *wq_head, void *word, int bit)
+{
+        struct wait_bit_key key = __WAIT_BIT_KEY_INITIALIZER(word, bit);
+        if (waitqueue_active(wq_head))
+                __wake_up(wq_head, TASK_NORMAL, 1, &key);
+}
+EXPORT_SYMBOL(__wake_up_bit);
+
+/**
+ * wake_up_bit - wake up a waiter on a bit
+ * @word: the word being waited on, a kernel virtual address
+ * @bit: the bit of the word being waited on
+ *
+ * There is a standard hashed waitqueue table for generic use. This
+ * is the part of the hashtable's accessor API that wakes up waiters
+ * on a bit. For instance, if one were to have waiters on a bitflag,
+ * one would call wake_up_bit() after clearing the bit.
+ *
+ * In order for this to function properly, as it uses waitqueue_active()
+ * internally, some kind of memory barrier must be done prior to calling
+ * this. Typically, this will be smp_mb__after_atomic(), but in some
+ * cases where bitflags are manipulated non-atomically under a lock, one
+ * may need to use a less regular barrier, such fs/inode.c's smp_mb(),
+ * because spin_unlock() does not guarantee a memory barrier.
+ */
+void wake_up_bit(void *word, int bit)
+{
+        __wake_up_bit(bit_waitqueue(word, bit), word, bit);
+}
+EXPORT_SYMBOL(wake_up_bit);
+
+/*
+ * Manipulate the atomic_t address to produce a better bit waitqueue table hash
+ * index (we're keying off bit -1, but that would produce a horrible hash
+ * value).
+ */
+static inline wait_queue_head_t *atomic_t_waitqueue(atomic_t *p)
+{
+        if (BITS_PER_LONG == 64) {
+                unsigned long q = (unsigned long)p;
+                return bit_waitqueue((void *)(q & ~1), q & 1);
+        }
+        return bit_waitqueue(p, 0);
+}
+
+static int wake_atomic_t_function(struct wait_queue_entry *wq_entry, unsigned mode, int sync,
+                                  void *arg)
+{
+        struct wait_bit_key *key = arg;
+        struct wait_bit_queue_entry *wait_bit = container_of(wq_entry, struct wait_bit_queue_entry, wq_entry);
+        atomic_t *val = key->flags;
+
+        if (wait_bit->key.flags != key->flags ||
+            wait_bit->key.bit_nr != key->bit_nr ||
+            atomic_read(val) != 0)
+                return 0;
+        return autoremove_wake_function(wq_entry, mode, sync, key);
+}
+
+/*
+ * To allow interruptible waiting and asynchronous (i.e. nonblocking) waiting,
+ * the actions of __wait_on_atomic_t() are permitted return codes.  Nonzero
+ * return codes halt waiting and return.
+ */
+static __sched
+int __wait_on_atomic_t(struct wait_queue_head *wq_head, struct wait_bit_queue_entry *wbq_entry,
+                       int (*action)(atomic_t *), unsigned mode)
+{
+        atomic_t *val;
+        int ret = 0;
+
+        do {
+                prepare_to_wait(wq_head, &wbq_entry->wq_entry, mode);
+                val = wbq_entry->key.flags;
+                if (atomic_read(val) == 0)
+                        break;
+                ret = (*action)(val);
+        } while (!ret && atomic_read(val) != 0);
+        finish_wait(wq_head, &wbq_entry->wq_entry);
+        return ret;
+}
+
+#define DEFINE_WAIT_ATOMIC_T(name, p)                                   \
+        struct wait_bit_queue_entry name = {                            \
+                .key = __WAIT_ATOMIC_T_KEY_INITIALIZER(p),              \
+                .wq_entry = {                                           \
+                        .private        = current,                      \
+                        .func           = wake_atomic_t_function,       \
+                        .entry          =                               \
+                                LIST_HEAD_INIT((name).wq_entry.entry),  \
+                },                                                      \
+        }
+
+__sched int out_of_line_wait_on_atomic_t(atomic_t *p, int (*action)(atomic_t *),
+                                         unsigned mode)
+{
+        struct wait_queue_head *wq_head = atomic_t_waitqueue(p);
+        DEFINE_WAIT_ATOMIC_T(wq_entry, p);
+
+        return __wait_on_atomic_t(wq_head, &wq_entry, action, mode);
+}
+EXPORT_SYMBOL(out_of_line_wait_on_atomic_t);
+
+/**
+ * wake_up_atomic_t - Wake up a waiter on a atomic_t
+ * @p: The atomic_t being waited on, a kernel virtual address
+ *
+ * Wake up anyone waiting for the atomic_t to go to zero.
+ *
+ * Abuse the bit-waker function and its waitqueue hash table set (the atomic_t
+ * check is done by the waiter's wake function, not the by the waker itself).
+ */
+void wake_up_atomic_t(atomic_t *p)
+{
+        __wake_up_bit(atomic_t_waitqueue(p), p, WAIT_ATOMIC_T_BIT_NR);
+}
+EXPORT_SYMBOL(wake_up_atomic_t);
+
+__sched int bit_wait(struct wait_bit_key *word, int mode)
+{
+        schedule();
+        if (signal_pending_state(mode, current))
+                return -EINTR;
+        return 0;
+}
+EXPORT_SYMBOL(bit_wait);
+
+__sched int bit_wait_io(struct wait_bit_key *word, int mode)
+{
+        io_schedule();
+        if (signal_pending_state(mode, current))
+                return -EINTR;
+        return 0;
+}
+EXPORT_SYMBOL(bit_wait_io);
+
+__sched int bit_wait_timeout(struct wait_bit_key *word, int mode)
+{
+        unsigned long now = READ_ONCE(jiffies);
+        if (time_after_eq(now, word->timeout))
+                return -EAGAIN;
+        schedule_timeout(word->timeout - now);
+        if (signal_pending_state(mode, current))
+                return -EINTR;
+        return 0;
+}
+EXPORT_SYMBOL_GPL(bit_wait_timeout);
+
+__sched int bit_wait_io_timeout(struct wait_bit_key *word, int mode)
+{
+        unsigned long now = READ_ONCE(jiffies);
+        if (time_after_eq(now, word->timeout))
+                return -EAGAIN;
+        io_schedule_timeout(word->timeout - now);
+        if (signal_pending_state(mode, current))
+                return -EINTR;
+        return 0;
+}
+EXPORT_SYMBOL_GPL(bit_wait_io_timeout);
+
+void __init wait_bit_init(void)
+{
+        int i;
+
+        for (i = 0; i < WAIT_TABLE_SIZE; i++)
+                init_waitqueue_head(bit_wait_table + i);
+}
diff --git a/kernel/signal.c b/kernel/signal.c
index ca92bcfeb322..caed9133ae52 100644
--- a/kernel/signal.c
+++ b/kernel/signal.c
@@ -39,6 +39,7 @@
 #include <linux/compat.h>
 #include <linux/cn_proc.h>
 #include <linux/compiler.h>
+#include <linux/posix-timers.h>
 
 #define CREATE_TRACE_POINTS
 #include <trace/events/signal.h>
@@ -510,7 +511,8 @@ int unhandled_signal(struct task_struct *tsk, int sig)
         return !tsk->ptrace;
 }
 
-static void collect_signal(int sig, struct sigpending *list, siginfo_t *info)
+static void collect_signal(int sig, struct sigpending *list, siginfo_t *info,
+                           bool *resched_timer)
 {
         struct sigqueue *q, *first = NULL;
 
@@ -532,6 +534,12 @@ static void collect_signal(int sig, struct sigpending *list, siginfo_t *info)
 still_pending:
                 list_del_init(&first->list);
                 copy_siginfo(info, &first->info);
+
+                *resched_timer =
+                        (first->flags & SIGQUEUE_PREALLOC) &&
+                        (info->si_code == SI_TIMER) &&
+                        (info->si_sys_private);
+
                 __sigqueue_free(first);
         } else {
                 /*
@@ -548,12 +556,12 @@ still_pending:
 }
 
 static int __dequeue_signal(struct sigpending *pending, sigset_t *mask,
-                        siginfo_t *info)
+                        siginfo_t *info, bool *resched_timer)
 {
         int sig = next_signal(pending, mask);
 
         if (sig)
-                collect_signal(sig, pending, info);
+                collect_signal(sig, pending, info, resched_timer);
         return sig;
 }
 
@@ -565,15 +573,16 @@ static int __dequeue_signal(struct sigpending *pending, sigset_t *mask,
  */
 int dequeue_signal(struct task_struct *tsk, sigset_t *mask, siginfo_t *info)
 {
+        bool resched_timer = false;
         int signr;
 
         /* We only dequeue private signals from ourselves, we don't let
          * signalfd steal them
          */
-        signr = __dequeue_signal(&tsk->pending, mask, info);
+        signr = __dequeue_signal(&tsk->pending, mask, info, &resched_timer);
         if (!signr) {
                 signr = __dequeue_signal(&tsk->signal->shared_pending,
-                                         mask, info);
+                                         mask, info, &resched_timer);
 #ifdef CONFIG_POSIX_TIMERS
                 /*
                  * itimer signal ?
@@ -621,7 +630,7 @@ int dequeue_signal(struct task_struct *tsk, sigset_t *mask, siginfo_t *info)
                 current->jobctl |= JOBCTL_STOP_DEQUEUED;
         }
 #ifdef CONFIG_POSIX_TIMERS
-        if ((info->si_code & __SI_MASK) == __SI_TIMER && info->si_sys_private) {
+        if (resched_timer) {
                 /*
                  * Release the siglock to ensure proper locking order
                  * of timer locks outside of siglocks.  Note, we leave
@@ -629,7 +638,7 @@ int dequeue_signal(struct task_struct *tsk, sigset_t *mask, siginfo_t *info)
                  * about to disable them again anyway.
                  */
                 spin_unlock(&tsk->sighand->siglock);
-                do_schedule_next_timer(info);
+                posixtimer_rearm(info);
                 spin_lock(&tsk->sighand->siglock);
         }
 #endif
@@ -1393,6 +1402,10 @@ static int kill_something_info(int sig, struct siginfo *info, pid_t pid)
                 return ret;
         }
 
+        /* -INT_MIN is undefined.  Exclude this case to avoid a UBSAN warning */
+        if (pid == INT_MIN)
+                return -ESRCH;
+
         read_lock(&tasklist_lock);
         if (pid != -1) {
                 ret = __kill_pgrp_info(sig, info,
@@ -2092,7 +2105,6 @@ static void do_jobctl_trap(void)
 
 static int ptrace_signal(int signr, siginfo_t *info)
 {
-        ptrace_signal_deliver();
         /*
          * We do not check sig_kernel_stop(signr) but set this marker
          * unconditionally because we do not know whether debugger will
@@ -2768,7 +2780,7 @@ int copy_siginfo_to_user(siginfo_t __user *to, const siginfo_t *from)
  *  @info: if non-null, the signal's siginfo is returned here
  *  @ts: upper bound on process time suspension
  */
-int do_sigtimedwait(const sigset_t *which, siginfo_t *info,
+static int do_sigtimedwait(const sigset_t *which, siginfo_t *info,
                     const struct timespec *ts)
 {
         ktime_t *to = NULL, timeout = KTIME_MAX;
@@ -2857,6 +2869,40 @@ SYSCALL_DEFINE4(rt_sigtimedwait, const sigset_t __user *, uthese,
         return ret;
 }
 
+#ifdef CONFIG_COMPAT
+COMPAT_SYSCALL_DEFINE4(rt_sigtimedwait, compat_sigset_t __user *, uthese,
+                struct compat_siginfo __user *, uinfo,
+                struct compat_timespec __user *, uts, compat_size_t, sigsetsize)
+{
+        compat_sigset_t s32;
+        sigset_t s;
+        struct timespec t;
+        siginfo_t info;
+        long ret;
+
+        if (sigsetsize != sizeof(sigset_t))
+                return -EINVAL;
+
+        if (copy_from_user(&s32, uthese, sizeof(compat_sigset_t)))
+                return -EFAULT;
+        sigset_from_compat(&s, &s32);
+
+        if (uts) {
+                if (compat_get_timespec(&t, uts))
+                        return -EFAULT;
+        }
+
+        ret = do_sigtimedwait(&s, &info, uts ? &t : NULL);
+
+        if (ret > 0 && uinfo) {
+                if (copy_siginfo_to_user32(uinfo, &info))
+                        ret = -EFAULT;
+        }
+
+        return ret;
+}
+#endif
+
 /**
  *  sys_kill - send a signal to a process
  *  @pid: the PID of the process
@@ -3113,78 +3159,68 @@ int do_sigaction(int sig, struct k_sigaction *act, struct k_sigaction *oact)
 }
 
 static int
-do_sigaltstack (const stack_t __user *uss, stack_t __user *uoss, unsigned long sp)
+do_sigaltstack (const stack_t *ss, stack_t *oss, unsigned long sp)
 {
-        stack_t oss;
-        int error;
+        struct task_struct *t = current;
 
-        oss.ss_sp = (void __user *) current->sas_ss_sp;
-        oss.ss_size = current->sas_ss_size;
-        oss.ss_flags = sas_ss_flags(sp) |
-                (current->sas_ss_flags & SS_FLAG_BITS);
+        if (oss) {
+                memset(oss, 0, sizeof(stack_t));
+                oss->ss_sp = (void __user *) t->sas_ss_sp;
+                oss->ss_size = t->sas_ss_size;
+                oss->ss_flags = sas_ss_flags(sp) |
+                        (current->sas_ss_flags & SS_FLAG_BITS);
+        }
 
-        if (uss) {
-                void __user *ss_sp;
-                size_t ss_size;
-                unsigned ss_flags;
+        if (ss) {
+                void __user *ss_sp = ss->ss_sp;
+                size_t ss_size = ss->ss_size;
+                unsigned ss_flags = ss->ss_flags;
                 int ss_mode;
 
-                error = -EFAULT;
-                if (!access_ok(VERIFY_READ, uss, sizeof(*uss)))
-                        goto out;
-                error = __get_user(ss_sp, &uss->ss_sp) |
-                        __get_user(ss_flags, &uss->ss_flags) |
-                        __get_user(ss_size, &uss->ss_size);
-                if (error)
-                        goto out;
-
-                error = -EPERM;
-                if (on_sig_stack(sp))
-                        goto out;
+                if (unlikely(on_sig_stack(sp)))
+                        return -EPERM;
 
                 ss_mode = ss_flags & ~SS_FLAG_BITS;
-                error = -EINVAL;
-                if (ss_mode != SS_DISABLE && ss_mode != SS_ONSTACK &&
-                                ss_mode != 0)
-                        goto out;
+                if (unlikely(ss_mode != SS_DISABLE && ss_mode != SS_ONSTACK &&
+                                ss_mode != 0))
+                        return -EINVAL;
 
                 if (ss_mode == SS_DISABLE) {
                         ss_size = 0;
                         ss_sp = NULL;
                 } else {
-                        error = -ENOMEM;
-                        if (ss_size < MINSIGSTKSZ)
-                                goto out;
+                        if (unlikely(ss_size < MINSIGSTKSZ))
+                                return -ENOMEM;
                 }
 
-                current->sas_ss_sp = (unsigned long) ss_sp;
-                current->sas_ss_size = ss_size;
-                current->sas_ss_flags = ss_flags;
+                t->sas_ss_sp = (unsigned long) ss_sp;
+                t->sas_ss_size = ss_size;
+                t->sas_ss_flags = ss_flags;
         }
-
-        error = 0;
-        if (uoss) {
-                error = -EFAULT;
-                if (!access_ok(VERIFY_WRITE, uoss, sizeof(*uoss)))
-                        goto out;
-                error = __put_user(oss.ss_sp, &uoss->ss_sp) |
-                        __put_user(oss.ss_size, &uoss->ss_size) |
-                        __put_user(oss.ss_flags, &uoss->ss_flags);
-        }
-
-out:
-        return error;
+        return 0;
 }
+
 SYSCALL_DEFINE2(sigaltstack,const stack_t __user *,uss, stack_t __user *,uoss)
 {
-        return do_sigaltstack(uss, uoss, current_user_stack_pointer());
+        stack_t new, old;
+        int err;
+        if (uss && copy_from_user(&new, uss, sizeof(stack_t)))
+                return -EFAULT;
+        err = do_sigaltstack(uss ? &new : NULL, uoss ? &old : NULL,
+                              current_user_stack_pointer());
+        if (!err && uoss && copy_to_user(uoss, &old, sizeof(stack_t)))
+                err = -EFAULT;
+        return err;
 }
 
 int restore_altstack(const stack_t __user *uss)
 {
-        int err = do_sigaltstack(uss, NULL, current_user_stack_pointer());
+        stack_t new;
+        if (copy_from_user(&new, uss, sizeof(stack_t)))
+                return -EFAULT;
+        (void)do_sigaltstack(&new, NULL, current_user_stack_pointer());
         /* squash all but EFAULT for now */
-        return err == -EFAULT ? err : 0;
+        return 0;
 }
 
 int __save_altstack(stack_t __user *uss, unsigned long sp)
@@ -3207,29 +3243,24 @@ COMPAT_SYSCALL_DEFINE2(sigaltstack,
 {
         stack_t uss, uoss;
         int ret;
-        mm_segment_t seg;
 
         if (uss_ptr) {
                 compat_stack_t uss32;
-
-                memset(&uss, 0, sizeof(stack_t));
                 if (copy_from_user(&uss32, uss_ptr, sizeof(compat_stack_t)))
                         return -EFAULT;
                 uss.ss_sp = compat_ptr(uss32.ss_sp);
                 uss.ss_flags = uss32.ss_flags;
                 uss.ss_size = uss32.ss_size;
         }
-        seg = get_fs();
-        set_fs(KERNEL_DS);
-        ret = do_sigaltstack((stack_t __force __user *) (uss_ptr ? &uss : NULL),
-                             (stack_t __force __user *) &uoss,
+        ret = do_sigaltstack(uss_ptr ? &uss : NULL, &uoss,
                              compat_user_stack_pointer());
-        set_fs(seg);
         if (ret >= 0 && uoss_ptr)  {
-                if (!access_ok(VERIFY_WRITE, uoss_ptr, sizeof(compat_stack_t)) ||
-                    __put_user(ptr_to_compat(uoss.ss_sp), &uoss_ptr->ss_sp) ||
-                    __put_user(uoss.ss_flags, &uoss_ptr->ss_flags) ||
-                    __put_user(uoss.ss_size, &uoss_ptr->ss_size))
+                compat_stack_t old;
+                memset(&old, 0, sizeof(old));
+                old.ss_sp = ptr_to_compat(uoss.ss_sp);
+                old.ss_flags = uoss.ss_flags;
+                old.ss_size = uoss.ss_size;
+                if (copy_to_user(uoss_ptr, &old, sizeof(compat_stack_t)))
                         ret = -EFAULT;
         }
         return ret;
@@ -3269,6 +3300,18 @@ SYSCALL_DEFINE1(sigpending, old_sigset_t __user *, set)
         return sys_rt_sigpending((sigset_t __user *)set, sizeof(old_sigset_t)); 
 }
 
+#ifdef CONFIG_COMPAT
+COMPAT_SYSCALL_DEFINE1(sigpending, compat_old_sigset_t __user *, set32)
+{
+        sigset_t set;
+        int err = do_sigpending(&set, sizeof(old_sigset_t)); 
+        if (err == 0)
+                if (copy_to_user(set32, &set, sizeof(old_sigset_t)))
+                        err = -EFAULT;
+        return err;
+}
+#endif
+
 #endif
 
 #ifdef __ARCH_WANT_SYS_SIGPROCMASK
diff --git a/kernel/smp.c b/kernel/smp.c
index a817769b53c0..3061483cb3ad 100644
--- a/kernel/smp.c
+++ b/kernel/smp.c
@@ -30,6 +30,7 @@ enum {
 struct call_function_data {
         struct call_single_data __percpu *csd;
         cpumask_var_t           cpumask;
+        cpumask_var_t           cpumask_ipi;
 };
 
 static DEFINE_PER_CPU_SHARED_ALIGNED(struct call_function_data, cfd_data);
@@ -45,9 +46,15 @@ int smpcfd_prepare_cpu(unsigned int cpu)
         if (!zalloc_cpumask_var_node(&cfd->cpumask, GFP_KERNEL,
                                      cpu_to_node(cpu)))
                 return -ENOMEM;
+        if (!zalloc_cpumask_var_node(&cfd->cpumask_ipi, GFP_KERNEL,
+                                     cpu_to_node(cpu))) {
+                free_cpumask_var(cfd->cpumask);
+                return -ENOMEM;
+        }
         cfd->csd = alloc_percpu(struct call_single_data);
         if (!cfd->csd) {
                 free_cpumask_var(cfd->cpumask);
+                free_cpumask_var(cfd->cpumask_ipi);
                 return -ENOMEM;
         }
 
@@ -59,6 +66,7 @@ int smpcfd_dead_cpu(unsigned int cpu)
         struct call_function_data *cfd = &per_cpu(cfd_data, cpu);
 
         free_cpumask_var(cfd->cpumask);
+        free_cpumask_var(cfd->cpumask_ipi);
         free_percpu(cfd->csd);
         return 0;
 }
@@ -428,12 +436,13 @@ void smp_call_function_many(const struct cpumask *mask,
         cfd = this_cpu_ptr(&cfd_data);
 
         cpumask_and(cfd->cpumask, mask, cpu_online_mask);
-        cpumask_clear_cpu(this_cpu, cfd->cpumask);
+        __cpumask_clear_cpu(this_cpu, cfd->cpumask);
 
         /* Some callers race with other cpus changing the passed mask */
         if (unlikely(!cpumask_weight(cfd->cpumask)))
                 return;
 
+        cpumask_clear(cfd->cpumask_ipi);
         for_each_cpu(cpu, cfd->cpumask) {
                 struct call_single_data *csd = per_cpu_ptr(cfd->csd, cpu);
 
@@ -442,11 +451,12 @@ void smp_call_function_many(const struct cpumask *mask,
                         csd->flags |= CSD_FLAG_SYNCHRONOUS;
                 csd->func = func;
                 csd->info = info;
-                llist_add(&csd->llist, &per_cpu(call_single_queue, cpu));
+                if (llist_add(&csd->llist, &per_cpu(call_single_queue, cpu)))
+                        __cpumask_set_cpu(cpu, cfd->cpumask_ipi);
         }
 
         /* Send a message to all CPUs in the map */
-        arch_send_call_function_ipi_mask(cfd->cpumask);
+        arch_send_call_function_ipi_mask(cfd->cpumask_ipi);
 
         if (wait) {
                 for_each_cpu(cpu, cfd->cpumask) {
diff --git a/kernel/stop_machine.c b/kernel/stop_machine.c
index 1eb82661ecdb..b7591261652d 100644
--- a/kernel/stop_machine.c
+++ b/kernel/stop_machine.c
@@ -552,7 +552,8 @@ static int __init cpu_stop_init(void)
 }
 early_initcall(cpu_stop_init);
 
-static int __stop_machine(cpu_stop_fn_t fn, void *data, const struct cpumask *cpus)
+int stop_machine_cpuslocked(cpu_stop_fn_t fn, void *data,
+                            const struct cpumask *cpus)
 {
         struct multi_stop_data msdata = {
                 .fn = fn,
@@ -561,6 +562,8 @@ static int __stop_machine(cpu_stop_fn_t fn, void *data, const struct cpumask *cp
                 .active_cpus = cpus,
         };
 
+        lockdep_assert_cpus_held();
+
         if (!stop_machine_initialized) {
                 /*
                  * Handle the case where stop_machine() is called
@@ -590,9 +593,9 @@ int stop_machine(cpu_stop_fn_t fn, void *data, const struct cpumask *cpus)
         int ret;
 
         /* No CPUs can come up or down during this. */
-        get_online_cpus();
-        ret = __stop_machine(fn, data, cpus);
-        put_online_cpus();
+        cpus_read_lock();
+        ret = stop_machine_cpuslocked(fn, data, cpus);
+        cpus_read_unlock();
         return ret;
 }
 EXPORT_SYMBOL_GPL(stop_machine);
diff --git a/kernel/sys.c b/kernel/sys.c
index 8a94b4eabcaa..2855ee73acd0 100644
--- a/kernel/sys.c
+++ b/kernel/sys.c
@@ -886,7 +886,7 @@ SYSCALL_DEFINE0(getegid)
         return from_kgid_munged(current_user_ns(), current_egid());
 }
 
-void do_sys_times(struct tms *tms)
+static void do_sys_times(struct tms *tms)
 {
         u64 tgutime, tgstime, cutime, cstime;
 
@@ -912,6 +912,32 @@ SYSCALL_DEFINE1(times, struct tms __user *, tbuf)
         return (long) jiffies_64_to_clock_t(get_jiffies_64());
 }
 
+#ifdef CONFIG_COMPAT
+static compat_clock_t clock_t_to_compat_clock_t(clock_t x)
+{
+        return compat_jiffies_to_clock_t(clock_t_to_jiffies(x));
+}
+
+COMPAT_SYSCALL_DEFINE1(times, struct compat_tms __user *, tbuf)
+{
+        if (tbuf) {
+                struct tms tms;
+                struct compat_tms tmp;
+
+                do_sys_times(&tms);
+                /* Convert our struct tms to the compat version. */
+                tmp.tms_utime = clock_t_to_compat_clock_t(tms.tms_utime);
+                tmp.tms_stime = clock_t_to_compat_clock_t(tms.tms_stime);
+                tmp.tms_cutime = clock_t_to_compat_clock_t(tms.tms_cutime);
+                tmp.tms_cstime = clock_t_to_compat_clock_t(tms.tms_cstime);
+                if (copy_to_user(tbuf, &tmp, sizeof(tmp)))
+                        return -EFAULT;
+        }
+        force_successful_syscall_return();
+        return compat_jiffies_to_clock_t(jiffies);
+}
+#endif
+
 /*
  * This needs some heavy checking ...
  * I just haven't the stomach for it. I also don't fully
@@ -1306,6 +1332,54 @@ SYSCALL_DEFINE2(getrlimit, unsigned int, resource, struct rlimit __user *, rlim)
         return ret;
 }
 
+#ifdef CONFIG_COMPAT
+
+COMPAT_SYSCALL_DEFINE2(setrlimit, unsigned int, resource,
+                       struct compat_rlimit __user *, rlim)
+{
+        struct rlimit r;
+        struct compat_rlimit r32;
+
+        if (copy_from_user(&r32, rlim, sizeof(struct compat_rlimit)))
+                return -EFAULT;
+
+        if (r32.rlim_cur == COMPAT_RLIM_INFINITY)
+                r.rlim_cur = RLIM_INFINITY;
+        else
+                r.rlim_cur = r32.rlim_cur;
+        if (r32.rlim_max == COMPAT_RLIM_INFINITY)
+                r.rlim_max = RLIM_INFINITY;
+        else
+                r.rlim_max = r32.rlim_max;
+        return do_prlimit(current, resource, &r, NULL);
+}
+
+COMPAT_SYSCALL_DEFINE2(getrlimit, unsigned int, resource,
+                       struct compat_rlimit __user *, rlim)
+{
+        struct rlimit r;
+        int ret;
+
+        ret = do_prlimit(current, resource, NULL, &r);
+        if (!ret) {
+                struct compat_rlimit r32;
+                if (r.rlim_cur > COMPAT_RLIM_INFINITY)
+                        r32.rlim_cur = COMPAT_RLIM_INFINITY;
+                else
+                        r32.rlim_cur = r.rlim_cur;
+                if (r.rlim_max > COMPAT_RLIM_INFINITY)
+                        r32.rlim_max = COMPAT_RLIM_INFINITY;
+                else
+                        r32.rlim_max = r.rlim_max;
+
+                if (copy_to_user(rlim, &r32, sizeof(struct compat_rlimit)))
+                        return -EFAULT;
+        }
+        return ret;
+}
+
+#endif
+
 #ifdef __ARCH_WANT_SYS_OLD_GETRLIMIT
 
 /*
@@ -1328,6 +1402,30 @@ SYSCALL_DEFINE2(old_getrlimit, unsigned int, resource,
         return copy_to_user(rlim, &x, sizeof(x)) ? -EFAULT : 0;
 }
 
+#ifdef CONFIG_COMPAT
+COMPAT_SYSCALL_DEFINE2(old_getrlimit, unsigned int, resource,
+                       struct compat_rlimit __user *, rlim)
+{
+        struct rlimit r;
+
+        if (resource >= RLIM_NLIMITS)
+                return -EINVAL;
+
+        task_lock(current->group_leader);
+        r = current->signal->rlim[resource];
+        task_unlock(current->group_leader);
+        if (r.rlim_cur > 0x7FFFFFFF)
+                r.rlim_cur = 0x7FFFFFFF;
+        if (r.rlim_max > 0x7FFFFFFF)
+                r.rlim_max = 0x7FFFFFFF;
+
+        if (put_user(r.rlim_cur, &rlim->rlim_cur) ||
+            put_user(r.rlim_max, &rlim->rlim_max))
+                return -EFAULT;
+        return 0;
+}
+#endif
+
 #endif
 
 static inline bool rlim64_is_infinity(__u64 rlim64)
@@ -1552,7 +1650,7 @@ static void accumulate_thread_rusage(struct task_struct *t, struct rusage *r)
         r->ru_oublock += task_io_get_oublock(t);
 }
 
-static void k_getrusage(struct task_struct *p, int who, struct rusage *r)
+void getrusage(struct task_struct *p, int who, struct rusage *r)
 {
         struct task_struct *t;
         unsigned long flags;
@@ -1626,20 +1724,16 @@ out:
         r->ru_maxrss = maxrss * (PAGE_SIZE / 1024); /* convert pages to KBs */
 }
 
-int getrusage(struct task_struct *p, int who, struct rusage __user *ru)
+SYSCALL_DEFINE2(getrusage, int, who, struct rusage __user *, ru)
 {
         struct rusage r;
 
-        k_getrusage(p, who, &r);
-        return copy_to_user(ru, &r, sizeof(r)) ? -EFAULT : 0;
-}
-
-SYSCALL_DEFINE2(getrusage, int, who, struct rusage __user *, ru)
-{
         if (who != RUSAGE_SELF && who != RUSAGE_CHILDREN &&
             who != RUSAGE_THREAD)
                 return -EINVAL;
-        return getrusage(current, who, ru);
+
+        getrusage(current, who, &r);
+        return copy_to_user(ru, &r, sizeof(r)) ? -EFAULT : 0;
 }
 
 #ifdef CONFIG_COMPAT
@@ -1651,7 +1745,7 @@ COMPAT_SYSCALL_DEFINE2(getrusage, int, who, struct compat_rusage __user *, ru)
             who != RUSAGE_THREAD)
                 return -EINVAL;
 
-        k_getrusage(current, who, &r);
+        getrusage(current, who, &r);
         return put_compat_rusage(&r, ru);
 }
 #endif
@@ -2266,7 +2360,7 @@ SYSCALL_DEFINE5(prctl, int, option, unsigned long, arg2, unsigned long, arg3,
         case PR_GET_THP_DISABLE:
                 if (arg2 || arg3 || arg4 || arg5)
                         return -EINVAL;
-                error = !!(me->mm->def_flags & VM_NOHUGEPAGE);
+                error = !!test_bit(MMF_DISABLE_THP, &me->mm->flags);
                 break;
         case PR_SET_THP_DISABLE:
                 if (arg3 || arg4 || arg5)
@@ -2274,9 +2368,9 @@ SYSCALL_DEFINE5(prctl, int, option, unsigned long, arg2, unsigned long, arg3,
                 if (down_write_killable(&me->mm->mmap_sem))
                         return -EINTR;
                 if (arg2)
-                        me->mm->def_flags |= VM_NOHUGEPAGE;
+                        set_bit(MMF_DISABLE_THP, &me->mm->flags);
                 else
-                        me->mm->def_flags &= ~VM_NOHUGEPAGE;
+                        clear_bit(MMF_DISABLE_THP, &me->mm->flags);
                 up_write(&me->mm->mmap_sem);
                 break;
         case PR_MPX_ENABLE_MANAGEMENT:
diff --git a/kernel/sysctl.c b/kernel/sysctl.c
index 4dfba1a76cc3..6648fbbb8157 100644
--- a/kernel/sysctl.c
+++ b/kernel/sysctl.c
@@ -174,11 +174,32 @@ extern int no_unaligned_warning;
 
 #ifdef CONFIG_PROC_SYSCTL
 
-#define SYSCTL_WRITES_LEGACY    -1
-#define SYSCTL_WRITES_WARN       0
-#define SYSCTL_WRITES_STRICT     1
+/**
+ * enum sysctl_writes_mode - supported sysctl write modes
+ *
+ * @SYSCTL_WRITES_LEGACY: each write syscall must fully contain the sysctl value
+ *      to be written, and multiple writes on the same sysctl file descriptor
+ *      will rewrite the sysctl value, regardless of file position. No warning
+ *      is issued when the initial position is not 0.
+ * @SYSCTL_WRITES_WARN: same as above but warn when the initial file position is
+ *      not 0.
+ * @SYSCTL_WRITES_STRICT: writes to numeric sysctl entries must always be at
+ *      file position 0 and the value must be fully contained in the buffer
+ *      sent to the write syscall. If dealing with strings respect the file
+ *      position, but restrict this to the max length of the buffer, anything
+ *      passed the max lenght will be ignored. Multiple writes will append
+ *      to the buffer.
+ *
+ * These write modes control how current file position affects the behavior of
+ * updating sysctl values through the proc interface on each write.
+ */
+enum sysctl_writes_mode {
+        SYSCTL_WRITES_LEGACY            = -1,
+        SYSCTL_WRITES_WARN              = 0,
+        SYSCTL_WRITES_STRICT            = 1,
+};
 
-static int sysctl_writes_strict = SYSCTL_WRITES_STRICT;
+static enum sysctl_writes_mode sysctl_writes_strict = SYSCTL_WRITES_STRICT;
 
 static int proc_do_cad_pid(struct ctl_table *table, int write,
                   void __user *buffer, size_t *lenp, loff_t *ppos);
@@ -880,6 +901,14 @@ static struct ctl_table kern_table[] = {
 #endif
         },
         {
+                .procname       = "watchdog_cpumask",
+                .data           = &watchdog_cpumask_bits,
+                .maxlen         = NR_CPUS,
+                .mode           = 0644,
+                .proc_handler   = proc_watchdog_cpumask,
+        },
+#ifdef CONFIG_SOFTLOCKUP_DETECTOR
+        {
                 .procname       = "soft_watchdog",
                 .data           = &soft_watchdog_enabled,
                 .maxlen         = sizeof (int),
@@ -889,13 +918,6 @@ static struct ctl_table kern_table[] = {
                 .extra2         = &one,
         },
         {
-                .procname       = "watchdog_cpumask",
-                .data           = &watchdog_cpumask_bits,
-                .maxlen         = NR_CPUS,
-                .mode           = 0644,
-                .proc_handler   = proc_watchdog_cpumask,
-        },
-        {
                 .procname       = "softlockup_panic",
                 .data           = &softlockup_panic,
                 .maxlen         = sizeof(int),
@@ -904,27 +926,29 @@ static struct ctl_table kern_table[] = {
                 .extra1         = &zero,
                 .extra2         = &one,
         },
-#ifdef CONFIG_HARDLOCKUP_DETECTOR
+#ifdef CONFIG_SMP
         {
-                .procname       = "hardlockup_panic",
-                .data           = &hardlockup_panic,
+                .procname       = "softlockup_all_cpu_backtrace",
+                .data           = &sysctl_softlockup_all_cpu_backtrace,
                 .maxlen         = sizeof(int),
                 .mode           = 0644,
                 .proc_handler   = proc_dointvec_minmax,
                 .extra1         = &zero,
                 .extra2         = &one,
         },
+#endif /* CONFIG_SMP */
 #endif
-#ifdef CONFIG_SMP
+#ifdef CONFIG_HARDLOCKUP_DETECTOR
         {
-                .procname       = "softlockup_all_cpu_backtrace",
-                .data           = &sysctl_softlockup_all_cpu_backtrace,
+                .procname       = "hardlockup_panic",
+                .data           = &hardlockup_panic,
                 .maxlen         = sizeof(int),
                 .mode           = 0644,
                 .proc_handler   = proc_dointvec_minmax,
                 .extra1         = &zero,
                 .extra2         = &one,
         },
+#ifdef CONFIG_SMP
         {
                 .procname       = "hardlockup_all_cpu_backtrace",
                 .data           = &sysctl_hardlockup_all_cpu_backtrace,
@@ -936,6 +960,8 @@ static struct ctl_table kern_table[] = {
         },
 #endif /* CONFIG_SMP */
 #endif
+#endif
+
 #if defined(CONFIG_X86_LOCAL_APIC) && defined(CONFIG_X86)
         {
                 .procname       = "unknown_nmi_panic",
@@ -1950,6 +1976,32 @@ static void warn_sysctl_write(struct ctl_table *table)
 }
 
 /**
+ * proc_first_pos_non_zero_ignore - check if firs position is allowed
+ * @ppos: file position
+ * @table: the sysctl table
+ *
+ * Returns true if the first position is non-zero and the sysctl_writes_strict
+ * mode indicates this is not allowed for numeric input types. String proc
+ * hadlers can ignore the return value.
+ */
+static bool proc_first_pos_non_zero_ignore(loff_t *ppos,
+                                           struct ctl_table *table)
+{
+        if (!*ppos)
+                return false;
+
+        switch (sysctl_writes_strict) {
+        case SYSCTL_WRITES_STRICT:
+                return true;
+        case SYSCTL_WRITES_WARN:
+                warn_sysctl_write(table);
+                return false;
+        default:
+                return false;
+        }
+}
+
+/**
  * proc_dostring - read a string sysctl
  * @table: the sysctl table
  * @write: %TRUE if this is a write to the sysctl file
@@ -1969,8 +2021,8 @@ static void warn_sysctl_write(struct ctl_table *table)
 int proc_dostring(struct ctl_table *table, int write,
                   void __user *buffer, size_t *lenp, loff_t *ppos)
 {
-        if (write && *ppos && sysctl_writes_strict == SYSCTL_WRITES_WARN)
-                warn_sysctl_write(table);
+        if (write)
+                proc_first_pos_non_zero_ignore(ppos, table);
 
         return _proc_do_string((char *)(table->data), table->maxlen, write,
                                (char __user *)buffer, lenp, ppos);
@@ -2128,19 +2180,18 @@ static int do_proc_dointvec_conv(bool *negp, unsigned long *lvalp,
         return 0;
 }
 
-static int do_proc_douintvec_conv(bool *negp, unsigned long *lvalp,
-                                 int *valp,
-                                 int write, void *data)
+static int do_proc_douintvec_conv(unsigned long *lvalp,
+                                  unsigned int *valp,
+                                  int write, void *data)
 {
         if (write) {
-                if (*negp)
+                if (*lvalp > UINT_MAX)
                         return -EINVAL;
                 if (*lvalp > UINT_MAX)
                         return -EINVAL;
                 *valp = *lvalp;
         } else {
                 unsigned int val = *valp;
-                *negp = false;
                 *lvalp = (unsigned long)val;
         }
         return 0;
@@ -2172,17 +2223,8 @@ static int __do_proc_dointvec(void *tbl_data, struct ctl_table *table,
                 conv = do_proc_dointvec_conv;
 
         if (write) {
-                if (*ppos) {
-                        switch (sysctl_writes_strict) {
-                        case SYSCTL_WRITES_STRICT:
-                                goto out;
-                        case SYSCTL_WRITES_WARN:
-                                warn_sysctl_write(table);
-                                break;
-                        default:
-                                break;
-                        }
-                }
+                if (proc_first_pos_non_zero_ignore(ppos, table))
+                        goto out;
 
                 if (left > PAGE_SIZE - 1)
                         left = PAGE_SIZE - 1;
@@ -2249,6 +2291,146 @@ static int do_proc_dointvec(struct ctl_table *table, int write,
                         buffer, lenp, ppos, conv, data);
 }
 
+static int do_proc_douintvec_w(unsigned int *tbl_data,
+                               struct ctl_table *table,
+                               void __user *buffer,
+                               size_t *lenp, loff_t *ppos,
+                               int (*conv)(unsigned long *lvalp,
+                                           unsigned int *valp,
+                                           int write, void *data),
+                               void *data)
+{
+        unsigned long lval;
+        int err = 0;
+        size_t left;
+        bool neg;
+        char *kbuf = NULL, *p;
+
+        left = *lenp;
+
+        if (proc_first_pos_non_zero_ignore(ppos, table))
+                goto bail_early;
+
+        if (left > PAGE_SIZE - 1)
+                left = PAGE_SIZE - 1;
+
+        p = kbuf = memdup_user_nul(buffer, left);
+        if (IS_ERR(kbuf))
+                return -EINVAL;
+
+        left -= proc_skip_spaces(&p);
+        if (!left) {
+                err = -EINVAL;
+                goto out_free;
+        }
+
+        err = proc_get_long(&p, &left, &lval, &neg,
+                             proc_wspace_sep,
+                             sizeof(proc_wspace_sep), NULL);
+        if (err || neg) {
+                err = -EINVAL;
+                goto out_free;
+        }
+
+        if (conv(&lval, tbl_data, 1, data)) {
+                err = -EINVAL;
+                goto out_free;
+        }
+
+        if (!err && left)
+                left -= proc_skip_spaces(&p);
+
+out_free:
+        kfree(kbuf);
+        if (err)
+                return -EINVAL;
+
+        return 0;
+
+        /* This is in keeping with old __do_proc_dointvec() */
+bail_early:
+        *ppos += *lenp;
+        return err;
+}
+
+static int do_proc_douintvec_r(unsigned int *tbl_data, void __user *buffer,
+                               size_t *lenp, loff_t *ppos,
+                               int (*conv)(unsigned long *lvalp,
+                                           unsigned int *valp,
+                                           int write, void *data),
+                               void *data)
+{
+        unsigned long lval;
+        int err = 0;
+        size_t left;
+
+        left = *lenp;
+
+        if (conv(&lval, tbl_data, 0, data)) {
+                err = -EINVAL;
+                goto out;
+        }
+
+        err = proc_put_long(&buffer, &left, lval, false);
+        if (err || !left)
+                goto out;
+
+        err = proc_put_char(&buffer, &left, '\n');
+
+out:
+        *lenp -= left;
+        *ppos += *lenp;
+
+        return err;
+}
+
+static int __do_proc_douintvec(void *tbl_data, struct ctl_table *table,
+                               int write, void __user *buffer,
+                               size_t *lenp, loff_t *ppos,
+                               int (*conv)(unsigned long *lvalp,
+                                           unsigned int *valp,
+                                           int write, void *data),
+                               void *data)
+{
+        unsigned int *i, vleft;
+
+        if (!tbl_data || !table->maxlen || !*lenp || (*ppos && !write)) {
+                *lenp = 0;
+                return 0;
+        }
+
+        i = (unsigned int *) tbl_data;
+        vleft = table->maxlen / sizeof(*i);
+
+        /*
+         * Arrays are not supported, keep this simple. *Do not* add
+         * support for them.
+         */
+        if (vleft != 1) {
+                *lenp = 0;
+                return -EINVAL;
+        }
+
+        if (!conv)
+                conv = do_proc_douintvec_conv;
+
+        if (write)
+                return do_proc_douintvec_w(i, table, buffer, lenp, ppos,
+                                           conv, data);
+        return do_proc_douintvec_r(i, buffer, lenp, ppos, conv, data);
+}
+
+static int do_proc_douintvec(struct ctl_table *table, int write,
+                             void __user *buffer, size_t *lenp, loff_t *ppos,
+                             int (*conv)(unsigned long *lvalp,
+                                         unsigned int *valp,
+                                         int write, void *data),
+                             void *data)
+{
+        return __do_proc_douintvec(table->data, table, write,
+                                   buffer, lenp, ppos, conv, data);
+}
+
 /**
  * proc_dointvec - read a vector of integers
  * @table: the sysctl table
@@ -2284,8 +2466,8 @@ int proc_dointvec(struct ctl_table *table, int write,
 int proc_douintvec(struct ctl_table *table, int write,
                      void __user *buffer, size_t *lenp, loff_t *ppos)
 {
-        return do_proc_dointvec(table, write, buffer, lenp, ppos,
-                                do_proc_douintvec_conv, NULL);
+        return do_proc_douintvec(table, write, buffer, lenp, ppos,
+                                 do_proc_douintvec_conv, NULL);
 }
 
 /*
@@ -2390,6 +2572,65 @@ int proc_dointvec_minmax(struct ctl_table *table, int write,
                                 do_proc_dointvec_minmax_conv, &param);
 }
 
+struct do_proc_douintvec_minmax_conv_param {
+        unsigned int *min;
+        unsigned int *max;
+};
+
+static int do_proc_douintvec_minmax_conv(unsigned long *lvalp,
+                                         unsigned int *valp,
+                                         int write, void *data)
+{
+        struct do_proc_douintvec_minmax_conv_param *param = data;
+
+        if (write) {
+                unsigned int val = *lvalp;
+
+                if ((param->min && *param->min > val) ||
+                    (param->max && *param->max < val))
+                        return -ERANGE;
+
+                if (*lvalp > UINT_MAX)
+                        return -EINVAL;
+                *valp = val;
+        } else {
+                unsigned int val = *valp;
+                *lvalp = (unsigned long) val;
+        }
+
+        return 0;
+}
+
+/**
+ * proc_douintvec_minmax - read a vector of unsigned ints with min/max values
+ * @table: the sysctl table
+ * @write: %TRUE if this is a write to the sysctl file
+ * @buffer: the user buffer
+ * @lenp: the size of the user buffer
+ * @ppos: file position
+ *
+ * Reads/writes up to table->maxlen/sizeof(unsigned int) unsigned integer
+ * values from/to the user buffer, treated as an ASCII string. Negative
+ * strings are not allowed.
+ *
+ * This routine will ensure the values are within the range specified by
+ * table->extra1 (min) and table->extra2 (max). There is a final sanity
+ * check for UINT_MAX to avoid having to support wrap around uses from
+ * userspace.
+ *
+ * Returns 0 on success.
+ */
+int proc_douintvec_minmax(struct ctl_table *table, int write,
+                          void __user *buffer, size_t *lenp, loff_t *ppos)
+{
+        struct do_proc_douintvec_minmax_conv_param param = {
+                .min = (unsigned int *) table->extra1,
+                .max = (unsigned int *) table->extra2,
+        };
+        return do_proc_douintvec(table, write, buffer, lenp, ppos,
+                                 do_proc_douintvec_minmax_conv, &param);
+}
+
 static void validate_coredump_safety(void)
 {
 #ifdef CONFIG_COREDUMP
@@ -2447,17 +2688,8 @@ static int __do_proc_doulongvec_minmax(void *data, struct ctl_table *table, int
         left = *lenp;
 
         if (write) {
-                if (*ppos) {
-                        switch (sysctl_writes_strict) {
-                        case SYSCTL_WRITES_STRICT:
-                                goto out;
-                        case SYSCTL_WRITES_WARN:
-                                warn_sysctl_write(table);
-                                break;
-                        default:
-                                break;
-                        }
-                }
+                if (proc_first_pos_non_zero_ignore(ppos, table))
+                        goto out;
 
                 if (left > PAGE_SIZE - 1)
                         left = PAGE_SIZE - 1;
@@ -2898,6 +3130,12 @@ int proc_dointvec_minmax(struct ctl_table *table, int write,
         return -ENOSYS;
 }
 
+int proc_douintvec_minmax(struct ctl_table *table, int write,
+                          void __user *buffer, size_t *lenp, loff_t *ppos)
+{
+        return -ENOSYS;
+}
+
 int proc_dointvec_jiffies(struct ctl_table *table, int write,
                     void __user *buffer, size_t *lenp, loff_t *ppos)
 {
@@ -2940,6 +3178,7 @@ EXPORT_SYMBOL(proc_dointvec);
 EXPORT_SYMBOL(proc_douintvec);
 EXPORT_SYMBOL(proc_dointvec_jiffies);
 EXPORT_SYMBOL(proc_dointvec_minmax);
+EXPORT_SYMBOL_GPL(proc_douintvec_minmax);
 EXPORT_SYMBOL(proc_dointvec_userhz_jiffies);
 EXPORT_SYMBOL(proc_dointvec_ms_jiffies);
 EXPORT_SYMBOL(proc_dostring);
diff --git a/kernel/sysctl_binary.c b/kernel/sysctl_binary.c
index ece4b177052b..02e1859f2ca8 100644
--- a/kernel/sysctl_binary.c
+++ b/kernel/sysctl_binary.c
@@ -1119,7 +1119,7 @@ static ssize_t bin_uuid(struct file *file,
         /* Only supports reads */
         if (oldval && oldlen) {
                 char buf[UUID_STRING_LEN + 1];
-                uuid_be uuid;
+                uuid_t uuid;
 
                 result = kernel_read(file, 0, buf, sizeof(buf) - 1);
                 if (result < 0)
@@ -1128,7 +1128,7 @@ static ssize_t bin_uuid(struct file *file,
                 buf[result] = '\0';
 
                 result = -EIO;
-                if (uuid_be_to_bin(buf, &uuid))
+                if (uuid_parse(buf, &uuid))
                         goto out;
 
                 if (oldlen > 16)
@@ -1346,7 +1346,7 @@ static void deprecated_sysctl_warning(const int *name, int nlen)
          * CTL_KERN/KERN_VERSION is used by older glibc and cannot
          * ever go away.
          */
-        if (name[0] == CTL_KERN && name[1] == KERN_VERSION)
+        if (nlen >= 2 && name[0] == CTL_KERN && name[1] == KERN_VERSION)
                 return;
 
         if (printk_ratelimit()) {
diff --git a/kernel/time/Kconfig b/kernel/time/Kconfig
index 4008d9f95dd7..ac09bc29eb08 100644
--- a/kernel/time/Kconfig
+++ b/kernel/time/Kconfig
@@ -126,56 +126,6 @@ config NO_HZ_FULL_ALL
          Note the boot CPU will still be kept outside the range to
          handle the timekeeping duty.
 
-config NO_HZ_FULL_SYSIDLE
-        bool "Detect full-system idle state for full dynticks system"
-        depends on NO_HZ_FULL
-        default n
-        help
-         At least one CPU must keep the scheduling-clock tick running for
-         timekeeping purposes whenever there is a non-idle CPU, where
-         "non-idle" also includes dynticks CPUs as long as they are
-         running non-idle tasks.  Because the underlying adaptive-tick
-         support cannot distinguish between all CPUs being idle and
-         all CPUs each running a single task in dynticks mode, the
-         underlying support simply ensures that there is always a CPU
-         handling the scheduling-clock tick, whether or not all CPUs
-         are idle.  This Kconfig option enables scalable detection of
-         the all-CPUs-idle state, thus allowing the scheduling-clock
-         tick to be disabled when all CPUs are idle.  Note that scalable
-         detection of the all-CPUs-idle state means that larger systems
-         will be slower to declare the all-CPUs-idle state.
-
-         Say Y if you would like to help debug all-CPUs-idle detection.
-
-         Say N if you are unsure.
-
-config NO_HZ_FULL_SYSIDLE_SMALL
-        int "Number of CPUs above which large-system approach is used"
-        depends on NO_HZ_FULL_SYSIDLE
-        range 1 NR_CPUS
-        default 8
-        help
-         The full-system idle detection mechanism takes a lazy approach
-         on large systems, as is required to attain decent scalability.
-         However, on smaller systems, scalability is not anywhere near as
-         large a concern as is energy efficiency.  The sysidle subsystem
-         therefore uses a fast but non-scalable algorithm for small
-         systems and a lazier but scalable algorithm for large systems.
-         This Kconfig parameter defines the number of CPUs in the largest
-         system that will be considered to be "small".
-
-         The default value will be fine in most cases.  Battery-powered
-         systems that (1) enable NO_HZ_FULL_SYSIDLE, (2) have larger
-         numbers of CPUs, and (3) are suffering from battery-lifetime
-         problems due to long sysidle latencies might wish to experiment
-         with larger values for this Kconfig parameter.  On the other
-         hand, they might be even better served by disabling NO_HZ_FULL
-         entirely, given that NO_HZ_FULL is intended for HPC and
-         real-time workloads that at present do not tend to be run on
-         battery-powered systems.
-
-         Take the default if you are unsure.
-
 config NO_HZ
         bool "Old Idle dynticks config"
         depends on !ARCH_USES_GETTIMEOFFSET && GENERIC_CLOCKEVENTS
diff --git a/kernel/time/alarmtimer.c b/kernel/time/alarmtimer.c
index 5cb5b0008d97..0b8ff7d257ea 100644
--- a/kernel/time/alarmtimer.c
+++ b/kernel/time/alarmtimer.c
@@ -27,6 +27,9 @@
 #include <linux/posix-timers.h>
 #include <linux/workqueue.h>
 #include <linux/freezer.h>
+#include <linux/compat.h>
+
+#include "posix-timers.h"
 
 #define CREATE_TRACE_POINTS
 #include <trace/events/alarmtimer.h>
@@ -45,11 +48,13 @@ static struct alarm_base {
         clockid_t               base_clockid;
 } alarm_bases[ALARM_NUMTYPE];
 
+#if defined(CONFIG_POSIX_TIMERS) || defined(CONFIG_RTC_CLASS)
 /* freezer information to handle clock_nanosleep triggered wakeups */
 static enum alarmtimer_type freezer_alarmtype;
 static ktime_t freezer_expires;
 static ktime_t freezer_delta;
 static DEFINE_SPINLOCK(freezer_delta_lock);
+#endif
 
 static struct wakeup_source *ws;
 
@@ -307,38 +312,6 @@ static int alarmtimer_resume(struct device *dev)
 }
 #endif
 
-static void alarmtimer_freezerset(ktime_t absexp, enum alarmtimer_type type)
-{
-        struct alarm_base *base;
-        unsigned long flags;
-        ktime_t delta;
-
-        switch(type) {
-        case ALARM_REALTIME:
-                base = &alarm_bases[ALARM_REALTIME];
-                type = ALARM_REALTIME_FREEZER;
-                break;
-        case ALARM_BOOTTIME:
-                base = &alarm_bases[ALARM_BOOTTIME];
-                type = ALARM_BOOTTIME_FREEZER;
-                break;
-        default:
-                WARN_ONCE(1, "Invalid alarm type: %d\n", type);
-                return;
-        }
-
-        delta = ktime_sub(absexp, base->gettime());
-
-        spin_lock_irqsave(&freezer_delta_lock, flags);
-        if (!freezer_delta || (delta < freezer_delta)) {
-                freezer_delta = delta;
-                freezer_expires = absexp;
-                freezer_alarmtype = type;
-        }
-        spin_unlock_irqrestore(&freezer_delta_lock, flags);
-}
-
-
 /**
  * alarm_init - Initialize an alarm structure
  * @alarm: ptr to alarm to be initialized
@@ -387,7 +360,7 @@ void alarm_start_relative(struct alarm *alarm, ktime_t start)
 {
         struct alarm_base *base = &alarm_bases[alarm->type];
 
-        start = ktime_add(start, base->gettime());
+        start = ktime_add_safe(start, base->gettime());
         alarm_start(alarm, start);
 }
 EXPORT_SYMBOL_GPL(alarm_start_relative);
@@ -475,7 +448,7 @@ u64 alarm_forward(struct alarm *alarm, ktime_t now, ktime_t interval)
                 overrun++;
         }
 
-        alarm->node.expires = ktime_add(alarm->node.expires, interval);
+        alarm->node.expires = ktime_add_safe(alarm->node.expires, interval);
         return overrun;
 }
 EXPORT_SYMBOL_GPL(alarm_forward);
@@ -488,6 +461,38 @@ u64 alarm_forward_now(struct alarm *alarm, ktime_t interval)
 }
 EXPORT_SYMBOL_GPL(alarm_forward_now);
 
+#ifdef CONFIG_POSIX_TIMERS
+
+static void alarmtimer_freezerset(ktime_t absexp, enum alarmtimer_type type)
+{
+        struct alarm_base *base;
+        unsigned long flags;
+        ktime_t delta;
+
+        switch(type) {
+        case ALARM_REALTIME:
+                base = &alarm_bases[ALARM_REALTIME];
+                type = ALARM_REALTIME_FREEZER;
+                break;
+        case ALARM_BOOTTIME:
+                base = &alarm_bases[ALARM_BOOTTIME];
+                type = ALARM_BOOTTIME_FREEZER;
+                break;
+        default:
+                WARN_ONCE(1, "Invalid alarm type: %d\n", type);
+                return;
+        }
+
+        delta = ktime_sub(absexp, base->gettime());
+
+        spin_lock_irqsave(&freezer_delta_lock, flags);
+        if (!freezer_delta || (delta < freezer_delta)) {
+                freezer_delta = delta;
+                freezer_expires = absexp;
+                freezer_alarmtype = type;
+        }
+        spin_unlock_irqrestore(&freezer_delta_lock, flags);
+}
 
 /**
  * clock2alarm - helper that converts from clockid to alarmtypes
@@ -511,22 +516,26 @@ static enum alarmtimer_type clock2alarm(clockid_t clockid)
 static enum alarmtimer_restart alarm_handle_timer(struct alarm *alarm,
                                                         ktime_t now)
 {
-        unsigned long flags;
         struct k_itimer *ptr = container_of(alarm, struct k_itimer,
-                                                it.alarm.alarmtimer);
+                                            it.alarm.alarmtimer);
         enum alarmtimer_restart result = ALARMTIMER_NORESTART;
+        unsigned long flags;
+        int si_private = 0;
 
         spin_lock_irqsave(&ptr->it_lock, flags);
-        if ((ptr->it_sigev_notify & ~SIGEV_THREAD_ID) != SIGEV_NONE) {
-                if (IS_ENABLED(CONFIG_POSIX_TIMERS) &&
-                    posix_timer_event(ptr, 0) != 0)
-                        ptr->it_overrun++;
-        }
 
-        /* Re-add periodic timers */
-        if (ptr->it.alarm.interval) {
-                ptr->it_overrun += alarm_forward(alarm, now,
-                                                ptr->it.alarm.interval);
+        ptr->it_active = 0;
+        if (ptr->it_interval)
+                si_private = ++ptr->it_requeue_pending;
+
+        if (posix_timer_event(ptr, si_private) && ptr->it_interval) {
+                /*
+                 * Handle ignored signals and rearm the timer. This will go
+                 * away once we handle ignored signals proper.
+                 */
+                ptr->it_overrun += alarm_forward_now(alarm, ptr->it_interval);
+                ++ptr->it_requeue_pending;
+                ptr->it_active = 1;
                 result = ALARMTIMER_RESTART;
         }
         spin_unlock_irqrestore(&ptr->it_lock, flags);
@@ -535,6 +544,72 @@ static enum alarmtimer_restart alarm_handle_timer(struct alarm *alarm,
 }
 
 /**
+ * alarm_timer_rearm - Posix timer callback for rearming timer
+ * @timr:       Pointer to the posixtimer data struct
+ */
+static void alarm_timer_rearm(struct k_itimer *timr)
+{
+        struct alarm *alarm = &timr->it.alarm.alarmtimer;
+
+        timr->it_overrun += alarm_forward_now(alarm, timr->it_interval);
+        alarm_start(alarm, alarm->node.expires);
+}
+
+/**
+ * alarm_timer_forward - Posix timer callback for forwarding timer
+ * @timr:       Pointer to the posixtimer data struct
+ * @now:        Current time to forward the timer against
+ */
+static int alarm_timer_forward(struct k_itimer *timr, ktime_t now)
+{
+        struct alarm *alarm = &timr->it.alarm.alarmtimer;
+
+        return (int) alarm_forward(alarm, timr->it_interval, now);
+}
+
+/**
+ * alarm_timer_remaining - Posix timer callback to retrieve remaining time
+ * @timr:       Pointer to the posixtimer data struct
+ * @now:        Current time to calculate against
+ */
+static ktime_t alarm_timer_remaining(struct k_itimer *timr, ktime_t now)
+{
+        struct alarm *alarm = &timr->it.alarm.alarmtimer;
+
+        return ktime_sub(now, alarm->node.expires);
+}
+
+/**
+ * alarm_timer_try_to_cancel - Posix timer callback to cancel a timer
+ * @timr:       Pointer to the posixtimer data struct
+ */
+static int alarm_timer_try_to_cancel(struct k_itimer *timr)
+{
+        return alarm_try_to_cancel(&timr->it.alarm.alarmtimer);
+}
+
+/**
+ * alarm_timer_arm - Posix timer callback to arm a timer
+ * @timr:       Pointer to the posixtimer data struct
+ * @expires:    The new expiry time
+ * @absolute:   Expiry value is absolute time
+ * @sigev_none: Posix timer does not deliver signals
+ */
+static void alarm_timer_arm(struct k_itimer *timr, ktime_t expires,
+                            bool absolute, bool sigev_none)
+{
+        struct alarm *alarm = &timr->it.alarm.alarmtimer;
+        struct alarm_base *base = &alarm_bases[alarm->type];
+
+        if (!absolute)
+                expires = ktime_add_safe(expires, base->gettime());
+        if (sigev_none)
+                alarm->node.expires = expires;
+        else
+                alarm_start(&timr->it.alarm.alarmtimer, expires);
+}
+
+/**
  * alarm_clock_getres - posix getres interface
  * @which_clock: clockid
  * @tp: timespec to fill
@@ -591,89 +666,6 @@ static int alarm_timer_create(struct k_itimer *new_timer)
 }
 
 /**
- * alarm_timer_get - posix timer_get interface
- * @new_timer: k_itimer pointer
- * @cur_setting: itimerspec data to fill
- *
- * Copies out the current itimerspec data
- */
-static void alarm_timer_get(struct k_itimer *timr,
-                            struct itimerspec64 *cur_setting)
-{
-        ktime_t relative_expiry_time =
-                alarm_expires_remaining(&(timr->it.alarm.alarmtimer));
-
-        if (ktime_to_ns(relative_expiry_time) > 0) {
-                cur_setting->it_value = ktime_to_timespec64(relative_expiry_time);
-        } else {
-                cur_setting->it_value.tv_sec = 0;
-                cur_setting->it_value.tv_nsec = 0;
-        }
-
-        cur_setting->it_interval = ktime_to_timespec64(timr->it.alarm.interval);
-}
-
-/**
- * alarm_timer_del - posix timer_del interface
- * @timr: k_itimer pointer to be deleted
- *
- * Cancels any programmed alarms for the given timer.
- */
-static int alarm_timer_del(struct k_itimer *timr)
-{
-        if (!rtcdev)
-                return -ENOTSUPP;
-
-        if (alarm_try_to_cancel(&timr->it.alarm.alarmtimer) < 0)
-                return TIMER_RETRY;
-
-        return 0;
-}
-
-/**
- * alarm_timer_set - posix timer_set interface
- * @timr: k_itimer pointer to be deleted
- * @flags: timer flags
- * @new_setting: itimerspec to be used
- * @old_setting: itimerspec being replaced
- *
- * Sets the timer to new_setting, and starts the timer.
- */
-static int alarm_timer_set(struct k_itimer *timr, int flags,
-                           struct itimerspec64 *new_setting,
-                           struct itimerspec64 *old_setting)
-{
-        ktime_t exp;
-
-        if (!rtcdev)
-                return -ENOTSUPP;
-
-        if (flags & ~TIMER_ABSTIME)
-                return -EINVAL;
-
-        if (old_setting)
-                alarm_timer_get(timr, old_setting);
-
-        /* If the timer was already set, cancel it */
-        if (alarm_try_to_cancel(&timr->it.alarm.alarmtimer) < 0)
-                return TIMER_RETRY;
-
-        /* start the timer */
-        timr->it.alarm.interval = timespec64_to_ktime(new_setting->it_interval);
-        exp = timespec64_to_ktime(new_setting->it_value);
-        /* Convert (if necessary) to absolute time */
-        if (flags != TIMER_ABSTIME) {
-                ktime_t now;
-
-                now = alarm_bases[timr->it.alarm.alarmtimer.type].gettime();
-                exp = ktime_add(now, exp);
-        }
-
-        alarm_start(&timr->it.alarm.alarmtimer, exp);
-        return 0;
-}
-
-/**
  * alarmtimer_nsleep_wakeup - Wakeup function for alarm_timer_nsleep
  * @alarm: ptr to alarm that fired
  *
@@ -697,8 +689,10 @@ static enum alarmtimer_restart alarmtimer_nsleep_wakeup(struct alarm *alarm,
  *
  * Sets the alarm timer and sleeps until it is fired or interrupted.
  */
-static int alarmtimer_do_nsleep(struct alarm *alarm, ktime_t absexp)
+static int alarmtimer_do_nsleep(struct alarm *alarm, ktime_t absexp,
+                                enum alarmtimer_type type)
 {
+        struct restart_block *restart;
         alarm->data = (void *)current;
         do {
                 set_current_state(TASK_INTERRUPTIBLE);
@@ -711,36 +705,25 @@ static int alarmtimer_do_nsleep(struct alarm *alarm, ktime_t absexp)
 
         __set_current_state(TASK_RUNNING);
 
-        return (alarm->data == NULL);
-}
-
-
-/**
- * update_rmtp - Update remaining timespec value
- * @exp: expiration time
- * @type: timer type
- * @rmtp: user pointer to remaining timepsec value
- *
- * Helper function that fills in rmtp value with time between
- * now and the exp value
- */
-static int update_rmtp(ktime_t exp, enum  alarmtimer_type type,
-                        struct timespec __user *rmtp)
-{
-        struct timespec rmt;
-        ktime_t rem;
-
-        rem = ktime_sub(exp, alarm_bases[type].gettime());
-
-        if (rem <= 0)
+        if (!alarm->data)
                 return 0;
-        rmt = ktime_to_timespec(rem);
 
-        if (copy_to_user(rmtp, &rmt, sizeof(*rmtp)))
-                return -EFAULT;
+        if (freezing(current))
+                alarmtimer_freezerset(absexp, type);
+        restart = &current->restart_block;
+        if (restart->nanosleep.type != TT_NONE) {
+                struct timespec64 rmt;
+                ktime_t rem;
+
+                rem = ktime_sub(absexp, alarm_bases[type].gettime());
 
-        return 1;
+                if (rem <= 0)
+                        return 0;
+                rmt = ktime_to_timespec64(rem);
 
+                return nanosleep_copyout(restart, &rmt);
+        }
+        return -ERESTART_RESTARTBLOCK;
 }
 
 /**
@@ -752,32 +735,12 @@ static int update_rmtp(ktime_t exp, enum  alarmtimer_type type,
 static long __sched alarm_timer_nsleep_restart(struct restart_block *restart)
 {
         enum  alarmtimer_type type = restart->nanosleep.clockid;
-        ktime_t exp;
-        struct timespec __user  *rmtp;
+        ktime_t exp = restart->nanosleep.expires;
         struct alarm alarm;
-        int ret = 0;
 
-        exp = restart->nanosleep.expires;
         alarm_init(&alarm, type, alarmtimer_nsleep_wakeup);
 
-        if (alarmtimer_do_nsleep(&alarm, exp))
-                goto out;
-
-        if (freezing(current))
-                alarmtimer_freezerset(exp, type);
-
-        rmtp = restart->nanosleep.rmtp;
-        if (rmtp) {
-                ret = update_rmtp(exp, type, rmtp);
-                if (ret <= 0)
-                        goto out;
-        }
-
-
-        /* The other values in restart are already filled in */
-        ret = -ERESTART_RESTARTBLOCK;
-out:
-        return ret;
+        return alarmtimer_do_nsleep(&alarm, exp, type);
 }
 
 /**
@@ -790,11 +753,10 @@ out:
  * Handles clock_nanosleep calls against _ALARM clockids
  */
 static int alarm_timer_nsleep(const clockid_t which_clock, int flags,
-                              struct timespec64 *tsreq,
-                              struct timespec __user *rmtp)
+                              const struct timespec64 *tsreq)
 {
         enum  alarmtimer_type type = clock2alarm(which_clock);
-        struct restart_block *restart;
+        struct restart_block *restart = &current->restart_block;
         struct alarm alarm;
         ktime_t exp;
         int ret = 0;
@@ -817,35 +779,36 @@ static int alarm_timer_nsleep(const clockid_t which_clock, int flags,
                 exp = ktime_add(now, exp);
         }
 
-        if (alarmtimer_do_nsleep(&alarm, exp))
-                goto out;
-
-        if (freezing(current))
-                alarmtimer_freezerset(exp, type);
+        ret = alarmtimer_do_nsleep(&alarm, exp, type);
+        if (ret != -ERESTART_RESTARTBLOCK)
+                return ret;
 
         /* abs timers don't set remaining time or restart */
-        if (flags == TIMER_ABSTIME) {
-                ret = -ERESTARTNOHAND;
-                goto out;
-        }
+        if (flags == TIMER_ABSTIME)
+                return -ERESTARTNOHAND;
 
-        if (rmtp) {
-                ret = update_rmtp(exp, type, rmtp);
-                if (ret <= 0)
-                        goto out;
-        }
-
-        restart = &current->restart_block;
         restart->fn = alarm_timer_nsleep_restart;
         restart->nanosleep.clockid = type;
         restart->nanosleep.expires = exp;
-        restart->nanosleep.rmtp = rmtp;
-        ret = -ERESTART_RESTARTBLOCK;
-
-out:
         return ret;
 }
 
+const struct k_clock alarm_clock = {
+        .clock_getres           = alarm_clock_getres,
+        .clock_get              = alarm_clock_get,
+        .timer_create           = alarm_timer_create,
+        .timer_set              = common_timer_set,
+        .timer_del              = common_timer_del,
+        .timer_get              = common_timer_get,
+        .timer_arm              = alarm_timer_arm,
+        .timer_rearm            = alarm_timer_rearm,
+        .timer_forward          = alarm_timer_forward,
+        .timer_remaining        = alarm_timer_remaining,
+        .timer_try_to_cancel    = alarm_timer_try_to_cancel,
+        .nsleep                 = alarm_timer_nsleep,
+};
+#endif /* CONFIG_POSIX_TIMERS */
+
 
 /* Suspend hook structures */
 static const struct dev_pm_ops alarmtimer_pm_ops = {
@@ -871,23 +834,9 @@ static int __init alarmtimer_init(void)
         struct platform_device *pdev;
         int error = 0;
         int i;
-        struct k_clock alarm_clock = {
-                .clock_getres   = alarm_clock_getres,
-                .clock_get      = alarm_clock_get,
-                .timer_create   = alarm_timer_create,
-                .timer_set      = alarm_timer_set,
-                .timer_del      = alarm_timer_del,
-                .timer_get      = alarm_timer_get,
-                .nsleep         = alarm_timer_nsleep,
-        };
 
         alarmtimer_rtc_timer_init();
 
-        if (IS_ENABLED(CONFIG_POSIX_TIMERS)) {
-                posix_timers_register_clock(CLOCK_REALTIME_ALARM, &alarm_clock);
-                posix_timers_register_clock(CLOCK_BOOTTIME_ALARM, &alarm_clock);
-        }
-
         /* Initialize alarm bases */
         alarm_bases[ALARM_REALTIME].base_clockid = CLOCK_REALTIME;
         alarm_bases[ALARM_REALTIME].gettime = &ktime_get_real;
diff --git a/kernel/time/clocksource.c b/kernel/time/clocksource.c
index 93621ae718d3..03918a19cf2d 100644
--- a/kernel/time/clocksource.c
+++ b/kernel/time/clocksource.c
@@ -233,6 +233,9 @@ static void clocksource_watchdog(unsigned long data)
                         continue;
                 }
 
+                if (cs == curr_clocksource && cs->tick_stable)
+                        cs->tick_stable(cs);
+
                 if (!(cs->flags & CLOCK_SOURCE_VALID_FOR_HRES) &&
                     (cs->flags & CLOCK_SOURCE_IS_CONTINUOUS) &&
                     (watchdog->flags & CLOCK_SOURCE_IS_CONTINUOUS)) {
diff --git a/kernel/time/hrtimer.c b/kernel/time/hrtimer.c
index ac053bb5296e..88f75f92ef36 100644
--- a/kernel/time/hrtimer.c
+++ b/kernel/time/hrtimer.c
@@ -51,6 +51,7 @@
 #include <linux/sched/debug.h>
 #include <linux/timer.h>
 #include <linux/freezer.h>
+#include <linux/compat.h>
 
 #include <linux/uaccess.h>
 
@@ -1439,8 +1440,29 @@ void hrtimer_init_sleeper(struct hrtimer_sleeper *sl, struct task_struct *task)
 }
 EXPORT_SYMBOL_GPL(hrtimer_init_sleeper);
 
+int nanosleep_copyout(struct restart_block *restart, struct timespec64 *ts)
+{
+        switch(restart->nanosleep.type) {
+#ifdef CONFIG_COMPAT
+        case TT_COMPAT:
+                if (compat_put_timespec64(ts, restart->nanosleep.compat_rmtp))
+                        return -EFAULT;
+                break;
+#endif
+        case TT_NATIVE:
+                if (put_timespec64(ts, restart->nanosleep.rmtp))
+                        return -EFAULT;
+                break;
+        default:
+                BUG();
+        }
+        return -ERESTART_RESTARTBLOCK;
+}
+
 static int __sched do_nanosleep(struct hrtimer_sleeper *t, enum hrtimer_mode mode)
 {
+        struct restart_block *restart;
+
         hrtimer_init_sleeper(t, current);
 
         do {
@@ -1457,53 +1479,38 @@ static int __sched do_nanosleep(struct hrtimer_sleeper *t, enum hrtimer_mode mod
 
         __set_current_state(TASK_RUNNING);
 
-        return t->task == NULL;
-}
-
-static int update_rmtp(struct hrtimer *timer, struct timespec __user *rmtp)
-{
-        struct timespec rmt;
-        ktime_t rem;
-
-        rem = hrtimer_expires_remaining(timer);
-        if (rem <= 0)
+        if (!t->task)
                 return 0;
-        rmt = ktime_to_timespec(rem);
 
-        if (copy_to_user(rmtp, &rmt, sizeof(*rmtp)))
-                return -EFAULT;
+        restart = &current->restart_block;
+        if (restart->nanosleep.type != TT_NONE) {
+                ktime_t rem = hrtimer_expires_remaining(&t->timer);
+                struct timespec64 rmt;
+
+                if (rem <= 0)
+                        return 0;
+                rmt = ktime_to_timespec64(rem);
 
-        return 1;
+                return nanosleep_copyout(restart, &rmt);
+        }
+        return -ERESTART_RESTARTBLOCK;
 }
 
-long __sched hrtimer_nanosleep_restart(struct restart_block *restart)
+static long __sched hrtimer_nanosleep_restart(struct restart_block *restart)
 {
         struct hrtimer_sleeper t;
-        struct timespec __user  *rmtp;
-        int ret = 0;
+        int ret;
 
         hrtimer_init_on_stack(&t.timer, restart->nanosleep.clockid,
                                 HRTIMER_MODE_ABS);
         hrtimer_set_expires_tv64(&t.timer, restart->nanosleep.expires);
 
-        if (do_nanosleep(&t, HRTIMER_MODE_ABS))
-                goto out;
-
-        rmtp = restart->nanosleep.rmtp;
-        if (rmtp) {
-                ret = update_rmtp(&t.timer, rmtp);
-                if (ret <= 0)
-                        goto out;
-        }
-
-        /* The other values in restart are already filled in */
-        ret = -ERESTART_RESTARTBLOCK;
-out:
+        ret = do_nanosleep(&t, HRTIMER_MODE_ABS);
         destroy_hrtimer_on_stack(&t.timer);
         return ret;
 }
 
-long hrtimer_nanosleep(struct timespec64 *rqtp, struct timespec __user *rmtp,
+long hrtimer_nanosleep(const struct timespec64 *rqtp,
                        const enum hrtimer_mode mode, const clockid_t clockid)
 {
         struct restart_block *restart;
@@ -1517,7 +1524,8 @@ long hrtimer_nanosleep(struct timespec64 *rqtp, struct timespec __user *rmtp,
 
         hrtimer_init_on_stack(&t.timer, clockid, mode);
         hrtimer_set_expires_range_ns(&t.timer, timespec64_to_ktime(*rqtp), slack);
-        if (do_nanosleep(&t, mode))
+        ret = do_nanosleep(&t, mode);
+        if (ret != -ERESTART_RESTARTBLOCK)
                 goto out;
 
         /* Absolute timers do not update the rmtp value and restart: */
@@ -1526,19 +1534,10 @@ long hrtimer_nanosleep(struct timespec64 *rqtp, struct timespec __user *rmtp,
                 goto out;
         }
 
-        if (rmtp) {
-                ret = update_rmtp(&t.timer, rmtp);
-                if (ret <= 0)
-                        goto out;
-        }
-
         restart = &current->restart_block;
         restart->fn = hrtimer_nanosleep_restart;
         restart->nanosleep.clockid = t.timer.base->clockid;
-        restart->nanosleep.rmtp = rmtp;
         restart->nanosleep.expires = hrtimer_get_expires_tv64(&t.timer);
-
-        ret = -ERESTART_RESTARTBLOCK;
 out:
         destroy_hrtimer_on_stack(&t.timer);
         return ret;
@@ -1547,18 +1546,37 @@ out:
 SYSCALL_DEFINE2(nanosleep, struct timespec __user *, rqtp,
                 struct timespec __user *, rmtp)
 {
-        struct timespec64 tu64;
-        struct timespec tu;
+        struct timespec64 tu;
+
+        if (get_timespec64(&tu, rqtp))
+                return -EFAULT;
+
+        if (!timespec64_valid(&tu))
+                return -EINVAL;
+
+        current->restart_block.nanosleep.type = rmtp ? TT_NATIVE : TT_NONE;
+        current->restart_block.nanosleep.rmtp = rmtp;
+        return hrtimer_nanosleep(&tu, HRTIMER_MODE_REL, CLOCK_MONOTONIC);
+}
+
+#ifdef CONFIG_COMPAT
+
+COMPAT_SYSCALL_DEFINE2(nanosleep, struct compat_timespec __user *, rqtp,
+                       struct compat_timespec __user *, rmtp)
+{
+        struct timespec64 tu;
 
-        if (copy_from_user(&tu, rqtp, sizeof(tu)))
+        if (compat_get_timespec64(&tu, rqtp))
                 return -EFAULT;
 
-        tu64 = timespec_to_timespec64(tu);
-        if (!timespec64_valid(&tu64))
+        if (!timespec64_valid(&tu))
                 return -EINVAL;
 
-        return hrtimer_nanosleep(&tu64, rmtp, HRTIMER_MODE_REL, CLOCK_MONOTONIC);
+        current->restart_block.nanosleep.type = rmtp ? TT_COMPAT : TT_NONE;
+        current->restart_block.nanosleep.compat_rmtp = rmtp;
+        return hrtimer_nanosleep(&tu, HRTIMER_MODE_REL, CLOCK_MONOTONIC);
 }
+#endif
 
 /*
  * Functions related to boot-time initialization:
diff --git a/kernel/time/itimer.c b/kernel/time/itimer.c
index 087d6a1279b8..2ef98a02376a 100644
--- a/kernel/time/itimer.c
+++ b/kernel/time/itimer.c
@@ -15,6 +15,7 @@
 #include <linux/posix-timers.h>
 #include <linux/hrtimer.h>
 #include <trace/events/timer.h>
+#include <linux/compat.h>
 
 #include <linux/uaccess.h>
 
@@ -116,6 +117,19 @@ SYSCALL_DEFINE2(getitimer, int, which, struct itimerval __user *, value)
         return error;
 }
 
+#ifdef CONFIG_COMPAT
+COMPAT_SYSCALL_DEFINE2(getitimer, int, which,
+                       struct compat_itimerval __user *, it)
+{
+        struct itimerval kit;
+        int error = do_getitimer(which, &kit);
+
+        if (!error && put_compat_itimerval(it, &kit))
+                error = -EFAULT;
+        return error;
+}
+#endif
+
 
 /*
  * The timer is automagically restarted, when interval != 0
@@ -138,8 +152,12 @@ static void set_cpu_itimer(struct task_struct *tsk, unsigned int clock_id,
         u64 oval, nval, ointerval, ninterval;
         struct cpu_itimer *it = &tsk->signal->it[clock_id];
 
-        nval = timeval_to_ns(&value->it_value);
-        ninterval = timeval_to_ns(&value->it_interval);
+        /*
+         * Use the to_ktime conversion because that clamps the maximum
+         * value to KTIME_MAX and avoid multiplication overflows.
+         */
+        nval = ktime_to_ns(timeval_to_ktime(value->it_value));
+        ninterval = ktime_to_ns(timeval_to_ktime(value->it_interval));
 
         spin_lock_irq(&tsk->sighand->siglock);
 
@@ -294,3 +312,27 @@ SYSCALL_DEFINE3(setitimer, int, which, struct itimerval __user *, value,
                 return -EFAULT;
         return 0;
 }
+
+#ifdef CONFIG_COMPAT
+COMPAT_SYSCALL_DEFINE3(setitimer, int, which,
+                       struct compat_itimerval __user *, in,
+                       struct compat_itimerval __user *, out)
+{
+        struct itimerval kin, kout;
+        int error;
+
+        if (in) {
+                if (get_compat_itimerval(&kin, in))
+                        return -EFAULT;
+        } else {
+                memset(&kin, 0, sizeof(kin));
+        }
+
+        error = do_setitimer(which, &kin, out ? &kout : NULL);
+        if (error || !out)
+                return error;
+        if (put_compat_itimerval(out, &kout))
+                return -EFAULT;
+        return 0;
+}
+#endif
diff --git a/kernel/time/posix-clock.c b/kernel/time/posix-clock.c
index 31d588d37a17..17cdc554c9fe 100644
--- a/kernel/time/posix-clock.c
+++ b/kernel/time/posix-clock.c
@@ -25,6 +25,8 @@
 #include <linux/syscalls.h>
 #include <linux/uaccess.h>
 
+#include "posix-timers.h"
+
 static void delete_clock(struct kref *kref);
 
 /*
@@ -82,38 +84,6 @@ static unsigned int posix_clock_poll(struct file *fp, poll_table *wait)
         return result;
 }
 
-static int posix_clock_fasync(int fd, struct file *fp, int on)
-{
-        struct posix_clock *clk = get_posix_clock(fp);
-        int err = 0;
-
-        if (!clk)
-                return -ENODEV;
-
-        if (clk->ops.fasync)
-                err = clk->ops.fasync(clk, fd, fp, on);
-
-        put_posix_clock(clk);
-
-        return err;
-}
-
-static int posix_clock_mmap(struct file *fp, struct vm_area_struct *vma)
-{
-        struct posix_clock *clk = get_posix_clock(fp);
-        int err = -ENODEV;
-
-        if (!clk)
-                return -ENODEV;
-
-        if (clk->ops.mmap)
-                err = clk->ops.mmap(clk, vma);
-
-        put_posix_clock(clk);
-
-        return err;
-}
-
 static long posix_clock_ioctl(struct file *fp,
                               unsigned int cmd, unsigned long arg)
 {
@@ -199,8 +169,6 @@ static const struct file_operations posix_clock_file_operations = {
         .unlocked_ioctl = posix_clock_ioctl,
         .open           = posix_clock_open,
         .release        = posix_clock_release,
-        .fasync         = posix_clock_fasync,
-        .mmap           = posix_clock_mmap,
 #ifdef CONFIG_COMPAT
         .compat_ioctl   = posix_clock_compat_ioctl,
 #endif
@@ -359,88 +327,9 @@ out:
         return err;
 }
 
-static int pc_timer_create(struct k_itimer *kit)
-{
-        clockid_t id = kit->it_clock;
-        struct posix_clock_desc cd;
-        int err;
-
-        err = get_clock_desc(id, &cd);
-        if (err)
-                return err;
-
-        if (cd.clk->ops.timer_create)
-                err = cd.clk->ops.timer_create(cd.clk, kit);
-        else
-                err = -EOPNOTSUPP;
-
-        put_clock_desc(&cd);
-
-        return err;
-}
-
-static int pc_timer_delete(struct k_itimer *kit)
-{
-        clockid_t id = kit->it_clock;
-        struct posix_clock_desc cd;
-        int err;
-
-        err = get_clock_desc(id, &cd);
-        if (err)
-                return err;
-
-        if (cd.clk->ops.timer_delete)
-                err = cd.clk->ops.timer_delete(cd.clk, kit);
-        else
-                err = -EOPNOTSUPP;
-
-        put_clock_desc(&cd);
-
-        return err;
-}
-
-static void pc_timer_gettime(struct k_itimer *kit, struct itimerspec64 *ts)
-{
-        clockid_t id = kit->it_clock;
-        struct posix_clock_desc cd;
-
-        if (get_clock_desc(id, &cd))
-                return;
-
-        if (cd.clk->ops.timer_gettime)
-                cd.clk->ops.timer_gettime(cd.clk, kit, ts);
-
-        put_clock_desc(&cd);
-}
-
-static int pc_timer_settime(struct k_itimer *kit, int flags,
-                            struct itimerspec64 *ts, struct itimerspec64 *old)
-{
-        clockid_t id = kit->it_clock;
-        struct posix_clock_desc cd;
-        int err;
-
-        err = get_clock_desc(id, &cd);
-        if (err)
-                return err;
-
-        if (cd.clk->ops.timer_settime)
-                err = cd.clk->ops.timer_settime(cd.clk, kit, flags, ts, old);
-        else
-                err = -EOPNOTSUPP;
-
-        put_clock_desc(&cd);
-
-        return err;
-}
-
-struct k_clock clock_posix_dynamic = {
+const struct k_clock clock_posix_dynamic = {
         .clock_getres   = pc_clock_getres,
         .clock_set      = pc_clock_settime,
         .clock_get      = pc_clock_gettime,
         .clock_adj      = pc_clock_adjtime,
-        .timer_create   = pc_timer_create,
-        .timer_set      = pc_timer_settime,
-        .timer_del      = pc_timer_delete,
-        .timer_get      = pc_timer_gettime,
 };
diff --git a/kernel/time/posix-cpu-timers.c b/kernel/time/posix-cpu-timers.c
index 1370f067fb51..a3bd5dbe0dc4 100644
--- a/kernel/time/posix-cpu-timers.c
+++ b/kernel/time/posix-cpu-timers.c
@@ -12,6 +12,11 @@
 #include <trace/events/timer.h>
 #include <linux/tick.h>
 #include <linux/workqueue.h>
+#include <linux/compat.h>
+
+#include "posix-timers.h"
+
+static void posix_cpu_timer_rearm(struct k_itimer *timer);
 
 /*
  * Called after updating RLIMIT_CPU to run cpu timer and update
@@ -322,6 +327,8 @@ static int posix_cpu_timer_create(struct k_itimer *new_timer)
         if (CPUCLOCK_WHICH(new_timer->it_clock) >= CPUCLOCK_MAX)
                 return -EINVAL;
 
+        new_timer->kclock = &clock_posix_cpu;
+
         INIT_LIST_HEAD(&new_timer->it.cpu.entry);
 
         rcu_read_lock();
@@ -524,7 +531,8 @@ static void cpu_timer_fire(struct k_itimer *timer)
                  * reload the timer.  But we need to keep it
                  * ticking in case the signal is deliverable next time.
                  */
-                posix_cpu_timer_schedule(timer);
+                posix_cpu_timer_rearm(timer);
+                ++timer->it_requeue_pending;
         }
 }
 
@@ -572,7 +580,11 @@ static int posix_cpu_timer_set(struct k_itimer *timer, int timer_flags,
 
         WARN_ON_ONCE(p == NULL);
 
-        new_expires = timespec64_to_ns(&new->it_value);
+        /*
+         * Use the to_ktime conversion because that clamps the maximum
+         * value to KTIME_MAX and avoid multiplication overflows.
+         */
+        new_expires = ktime_to_ns(timespec64_to_ktime(new->it_value));
 
         /*
          * Protect against sighand release/switch in exit/exec and p->cpu_timers
@@ -712,10 +724,8 @@ static void posix_cpu_timer_get(struct k_itimer *timer, struct itimerspec64 *itp
          */
         itp->it_interval = ns_to_timespec64(timer->it.cpu.incr);
 
-        if (timer->it.cpu.expires == 0) {       /* Timer not armed at all.  */
-                itp->it_value.tv_sec = itp->it_value.tv_nsec = 0;
+        if (!timer->it.cpu.expires)
                 return;
-        }
 
         /*
          * Sample the clock to take the difference with the expiry time.
@@ -739,7 +749,6 @@ static void posix_cpu_timer_get(struct k_itimer *timer, struct itimerspec64 *itp
                          * Call the timer disarmed, nothing else to do.
                          */
                         timer->it.cpu.expires = 0;
-                        itp->it_value = ns_to_timespec64(timer->it.cpu.expires);
                         return;
                 } else {
                         cpu_timer_sample_group(timer->it_clock, p, &now);
@@ -825,8 +834,10 @@ static void check_thread_timers(struct task_struct *tsk,
                          * At the hard limit, we just die.
                          * No need to calculate anything else now.
                          */
-                        pr_info("CPU Watchdog Timeout (hard): %s[%d]\n",
-                                tsk->comm, task_pid_nr(tsk));
+                        if (print_fatal_signals) {
+                                pr_info("CPU Watchdog Timeout (hard): %s[%d]\n",
+                                        tsk->comm, task_pid_nr(tsk));
+                        }
                         __group_send_sig_info(SIGKILL, SEND_SIG_PRIV, tsk);
                         return;
                 }
@@ -838,8 +849,10 @@ static void check_thread_timers(struct task_struct *tsk,
                                 soft += USEC_PER_SEC;
                                 sig->rlim[RLIMIT_RTTIME].rlim_cur = soft;
                         }
-                        pr_info("RT Watchdog Timeout (soft): %s[%d]\n",
-                                tsk->comm, task_pid_nr(tsk));
+                        if (print_fatal_signals) {
+                                pr_info("RT Watchdog Timeout (soft): %s[%d]\n",
+                                        tsk->comm, task_pid_nr(tsk));
+                        }
                         __group_send_sig_info(SIGXCPU, SEND_SIG_PRIV, tsk);
                 }
         }
@@ -936,8 +949,10 @@ static void check_process_timers(struct task_struct *tsk,
                          * At the hard limit, we just die.
                          * No need to calculate anything else now.
                          */
-                        pr_info("RT Watchdog Timeout (hard): %s[%d]\n",
-                                tsk->comm, task_pid_nr(tsk));
+                        if (print_fatal_signals) {
+                                pr_info("RT Watchdog Timeout (hard): %s[%d]\n",
+                                        tsk->comm, task_pid_nr(tsk));
+                        }
                         __group_send_sig_info(SIGKILL, SEND_SIG_PRIV, tsk);
                         return;
                 }
@@ -945,8 +960,10 @@ static void check_process_timers(struct task_struct *tsk,
                         /*
                          * At the soft limit, send a SIGXCPU every second.
                          */
-                        pr_info("CPU Watchdog Timeout (soft): %s[%d]\n",
-                                tsk->comm, task_pid_nr(tsk));
+                        if (print_fatal_signals) {
+                                pr_info("CPU Watchdog Timeout (soft): %s[%d]\n",
+                                        tsk->comm, task_pid_nr(tsk));
+                        }
                         __group_send_sig_info(SIGXCPU, SEND_SIG_PRIV, tsk);
                         if (soft < hard) {
                                 soft++;
@@ -968,10 +985,10 @@ static void check_process_timers(struct task_struct *tsk,
 }
 
 /*
- * This is called from the signal code (via do_schedule_next_timer)
+ * This is called from the signal code (via posixtimer_rearm)
  * when the last timer signal was delivered and we have to reload the timer.
  */
-void posix_cpu_timer_schedule(struct k_itimer *timer)
+static void posix_cpu_timer_rearm(struct k_itimer *timer)
 {
         struct sighand_struct *sighand;
         unsigned long flags;
@@ -987,12 +1004,12 @@ void posix_cpu_timer_schedule(struct k_itimer *timer)
                 cpu_clock_sample(timer->it_clock, p, &now);
                 bump_cpu_timer(timer, now);
                 if (unlikely(p->exit_state))
-                        goto out;
+                        return;
 
                 /* Protect timer list r/w in arm_timer() */
                 sighand = lock_task_sighand(p, &flags);
                 if (!sighand)
-                        goto out;
+                        return;
         } else {
                 /*
                  * Protect arm_timer() and timer sampling in case of call to
@@ -1005,11 +1022,10 @@ void posix_cpu_timer_schedule(struct k_itimer *timer)
                          * We can't even collect a sample any more.
                          */
                         timer->it.cpu.expires = 0;
-                        goto out;
+                        return;
                 } else if (unlikely(p->exit_state) && thread_group_empty(p)) {
-                        unlock_task_sighand(p, &flags);
-                        /* Optimizations: if the process is dying, no need to rearm */
-                        goto out;
+                        /* If the process is dying, no need to rearm */
+                        goto unlock;
                 }
                 cpu_timer_sample_group(timer->it_clock, p, &now);
                 bump_cpu_timer(timer, now);
@@ -1021,12 +1037,8 @@ void posix_cpu_timer_schedule(struct k_itimer *timer)
          */
         WARN_ON_ONCE(!irqs_disabled());
         arm_timer(timer);
+unlock:
         unlock_task_sighand(p, &flags);
-
-out:
-        timer->it_overrun_last = timer->it_overrun;
-        timer->it_overrun = -1;
-        ++timer->it_requeue_pending;
 }
 
 /**
@@ -1219,9 +1231,11 @@ void set_process_cpu_timer(struct task_struct *tsk, unsigned int clock_idx,
 }
 
 static int do_cpu_nanosleep(const clockid_t which_clock, int flags,
-                            struct timespec64 *rqtp, struct itimerspec64 *it)
+                            const struct timespec64 *rqtp)
 {
+        struct itimerspec64 it;
         struct k_itimer timer;
+        u64 expires;
         int error;
 
         /*
@@ -1235,12 +1249,13 @@ static int do_cpu_nanosleep(const clockid_t which_clock, int flags,
         timer.it_process = current;
         if (!error) {
                 static struct itimerspec64 zero_it;
+                struct restart_block *restart;
 
-                memset(it, 0, sizeof *it);
-                it->it_value = *rqtp;
+                memset(&it, 0, sizeof(it));
+                it.it_value = *rqtp;
 
                 spin_lock_irq(&timer.it_lock);
-                error = posix_cpu_timer_set(&timer, flags, it, NULL);
+                error = posix_cpu_timer_set(&timer, flags, &it, NULL);
                 if (error) {
                         spin_unlock_irq(&timer.it_lock);
                         return error;
@@ -1269,8 +1284,8 @@ static int do_cpu_nanosleep(const clockid_t which_clock, int flags,
                 /*
                  * We were interrupted by a signal.
                  */
-                *rqtp = ns_to_timespec64(timer.it.cpu.expires);
-                error = posix_cpu_timer_set(&timer, 0, &zero_it, it);
+                expires = timer.it.cpu.expires;
+                error = posix_cpu_timer_set(&timer, 0, &zero_it, &it);
                 if (!error) {
                         /*
                          * Timer is now unarmed, deletion can not fail.
@@ -1290,7 +1305,7 @@ static int do_cpu_nanosleep(const clockid_t which_clock, int flags,
                         spin_unlock_irq(&timer.it_lock);
                 }
 
-                if ((it->it_value.tv_sec | it->it_value.tv_nsec) == 0) {
+                if ((it.it_value.tv_sec | it.it_value.tv_nsec) == 0) {
                         /*
                          * It actually did fire already.
                          */
@@ -1298,6 +1313,13 @@ static int do_cpu_nanosleep(const clockid_t which_clock, int flags,
                 }
 
                 error = -ERESTART_RESTARTBLOCK;
+                /*
+                 * Report back to the user the time still remaining.
+                 */
+                restart = &current->restart_block;
+                restart->nanosleep.expires = expires;
+                if (restart->nanosleep.type != TT_NONE)
+                        error = nanosleep_copyout(restart, &it.it_value);
         }
 
         return error;
@@ -1306,11 +1328,9 @@ static int do_cpu_nanosleep(const clockid_t which_clock, int flags,
 static long posix_cpu_nsleep_restart(struct restart_block *restart_block);
 
 static int posix_cpu_nsleep(const clockid_t which_clock, int flags,
-                            struct timespec64 *rqtp, struct timespec __user *rmtp)
+                            const struct timespec64 *rqtp)
 {
         struct restart_block *restart_block = &current->restart_block;
-        struct itimerspec64 it;
-        struct timespec ts;
         int error;
 
         /*
@@ -1321,23 +1341,15 @@ static int posix_cpu_nsleep(const clockid_t which_clock, int flags,
              CPUCLOCK_PID(which_clock) == task_pid_vnr(current)))
                 return -EINVAL;
 
-        error = do_cpu_nanosleep(which_clock, flags, rqtp, &it);
+        error = do_cpu_nanosleep(which_clock, flags, rqtp);
 
         if (error == -ERESTART_RESTARTBLOCK) {
 
                 if (flags & TIMER_ABSTIME)
                         return -ERESTARTNOHAND;
-                /*
-                 * Report back to the user the time still remaining.
-                 */
-                ts = timespec64_to_timespec(it.it_value);
-                if (rmtp && copy_to_user(rmtp, &ts, sizeof(*rmtp)))
-                        return -EFAULT;
 
                 restart_block->fn = posix_cpu_nsleep_restart;
                 restart_block->nanosleep.clockid = which_clock;
-                restart_block->nanosleep.rmtp = rmtp;
-                restart_block->nanosleep.expires = timespec64_to_ns(rqtp);
         }
         return error;
 }
@@ -1345,28 +1357,11 @@ static int posix_cpu_nsleep(const clockid_t which_clock, int flags,
 static long posix_cpu_nsleep_restart(struct restart_block *restart_block)
 {
         clockid_t which_clock = restart_block->nanosleep.clockid;
-        struct itimerspec64 it;
         struct timespec64 t;
-        struct timespec tmp;
-        int error;
 
         t = ns_to_timespec64(restart_block->nanosleep.expires);
 
-        error = do_cpu_nanosleep(which_clock, TIMER_ABSTIME, &t, &it);
-
-        if (error == -ERESTART_RESTARTBLOCK) {
-                struct timespec __user *rmtp = restart_block->nanosleep.rmtp;
-                /*
-                 * Report back to the user the time still remaining.
-                 */
-                 tmp = timespec64_to_timespec(it.it_value);
-                if (rmtp && copy_to_user(rmtp, &tmp, sizeof(*rmtp)))
-                        return -EFAULT;
-
-                restart_block->nanosleep.expires = timespec64_to_ns(&t);
-        }
-        return error;
-
+        return do_cpu_nanosleep(which_clock, TIMER_ABSTIME, &t);
 }
 
 #define PROCESS_CLOCK   MAKE_PROCESS_CPUCLOCK(0, CPUCLOCK_SCHED)
@@ -1388,14 +1383,9 @@ static int process_cpu_timer_create(struct k_itimer *timer)
         return posix_cpu_timer_create(timer);
 }
 static int process_cpu_nsleep(const clockid_t which_clock, int flags,
-                              struct timespec64 *rqtp,
-                              struct timespec __user *rmtp)
-{
-        return posix_cpu_nsleep(PROCESS_CLOCK, flags, rqtp, rmtp);
-}
-static long process_cpu_nsleep_restart(struct restart_block *restart_block)
+                              const struct timespec64 *rqtp)
 {
-        return -EINVAL;
+        return posix_cpu_nsleep(PROCESS_CLOCK, flags, rqtp);
 }
 static int thread_cpu_clock_getres(const clockid_t which_clock,
                                    struct timespec64 *tp)
@@ -1413,36 +1403,27 @@ static int thread_cpu_timer_create(struct k_itimer *timer)
         return posix_cpu_timer_create(timer);
 }
 
-struct k_clock clock_posix_cpu = {
+const struct k_clock clock_posix_cpu = {
         .clock_getres   = posix_cpu_clock_getres,
         .clock_set      = posix_cpu_clock_set,
         .clock_get      = posix_cpu_clock_get,
         .timer_create   = posix_cpu_timer_create,
         .nsleep         = posix_cpu_nsleep,
-        .nsleep_restart = posix_cpu_nsleep_restart,
         .timer_set      = posix_cpu_timer_set,
         .timer_del      = posix_cpu_timer_del,
         .timer_get      = posix_cpu_timer_get,
+        .timer_rearm    = posix_cpu_timer_rearm,
 };
 
-static __init int init_posix_cpu_timers(void)
-{
-        struct k_clock process = {
-                .clock_getres   = process_cpu_clock_getres,
-                .clock_get      = process_cpu_clock_get,
-                .timer_create   = process_cpu_timer_create,
-                .nsleep         = process_cpu_nsleep,
-                .nsleep_restart = process_cpu_nsleep_restart,
-        };
-        struct k_clock thread = {
-                .clock_getres   = thread_cpu_clock_getres,
-                .clock_get      = thread_cpu_clock_get,
-                .timer_create   = thread_cpu_timer_create,
-        };
-
-        posix_timers_register_clock(CLOCK_PROCESS_CPUTIME_ID, &process);
-        posix_timers_register_clock(CLOCK_THREAD_CPUTIME_ID, &thread);
+const struct k_clock clock_process = {
+        .clock_getres   = process_cpu_clock_getres,
+        .clock_get      = process_cpu_clock_get,
+        .timer_create   = process_cpu_timer_create,
+        .nsleep         = process_cpu_nsleep,
+};
 
-        return 0;
-}
-__initcall(init_posix_cpu_timers);
+const struct k_clock clock_thread = {
+        .clock_getres   = thread_cpu_clock_getres,
+        .clock_get      = thread_cpu_clock_get,
+        .timer_create   = thread_cpu_timer_create,
+};
diff --git a/kernel/time/posix-stubs.c b/kernel/time/posix-stubs.c
index c0cd53eb018a..06f34feb635e 100644
--- a/kernel/time/posix-stubs.c
+++ b/kernel/time/posix-stubs.c
@@ -17,6 +17,7 @@
 #include <linux/ktime.h>
 #include <linux/timekeeping.h>
 #include <linux/posix-timers.h>
+#include <linux/compat.h>
 
 asmlinkage long sys_ni_posix_timers(void)
 {
@@ -27,6 +28,7 @@ asmlinkage long sys_ni_posix_timers(void)
 }
 
 #define SYS_NI(name)  SYSCALL_ALIAS(sys_##name, sys_ni_posix_timers)
+#define COMPAT_SYS_NI(name)  SYSCALL_ALIAS(compat_sys_##name, sys_ni_posix_timers)
 
 SYS_NI(timer_create);
 SYS_NI(timer_gettime);
@@ -49,40 +51,52 @@ SYS_NI(alarm);
 SYSCALL_DEFINE2(clock_settime, const clockid_t, which_clock,
                 const struct timespec __user *, tp)
 {
-        struct timespec64 new_tp64;
-        struct timespec new_tp;
+        struct timespec64 new_tp;
 
         if (which_clock != CLOCK_REALTIME)
                 return -EINVAL;
-        if (copy_from_user(&new_tp, tp, sizeof (*tp)))
+        if (get_timespec64(&new_tp, tp))
                 return -EFAULT;
 
-        new_tp64 = timespec_to_timespec64(new_tp);
-        return do_sys_settimeofday64(&new_tp64, NULL);
+        return do_sys_settimeofday64(&new_tp, NULL);
 }
 
-SYSCALL_DEFINE2(clock_gettime, const clockid_t, which_clock,
-                struct timespec __user *,tp)
+int do_clock_gettime(clockid_t which_clock, struct timespec64 *tp)
 {
-        struct timespec64 kernel_tp64;
-        struct timespec kernel_tp;
-
         switch (which_clock) {
-        case CLOCK_REALTIME: ktime_get_real_ts64(&kernel_tp64); break;
-        case CLOCK_MONOTONIC: ktime_get_ts64(&kernel_tp64); break;
-        case CLOCK_BOOTTIME: get_monotonic_boottime64(&kernel_tp64); break;
-        default: return -EINVAL;
+        case CLOCK_REALTIME:
+                ktime_get_real_ts64(tp);
+                break;
+        case CLOCK_MONOTONIC:
+                ktime_get_ts64(tp);
+                break;
+        case CLOCK_BOOTTIME:
+                get_monotonic_boottime64(tp);
+                break;
+        default:
+                return -EINVAL;
         }
 
-        kernel_tp = timespec64_to_timespec(kernel_tp64);
-        if (copy_to_user(tp, &kernel_tp, sizeof (kernel_tp)))
+        return 0;
+}
+SYSCALL_DEFINE2(clock_gettime, const clockid_t, which_clock,
+                struct timespec __user *, tp)
+{
+        int ret;
+        struct timespec64 kernel_tp;
+
+        ret = do_clock_gettime(which_clock, &kernel_tp);
+        if (ret)
+                return ret;
+
+        if (put_timespec64(&kernel_tp, tp))
                 return -EFAULT;
         return 0;
 }
 
 SYSCALL_DEFINE2(clock_getres, const clockid_t, which_clock, struct timespec __user *, tp)
 {
-        struct timespec rtn_tp = {
+        struct timespec64 rtn_tp = {
                 .tv_sec = 0,
                 .tv_nsec = hrtimer_resolution,
         };
@@ -91,7 +105,7 @@ SYSCALL_DEFINE2(clock_getres, const clockid_t, which_clock, struct timespec __us
         case CLOCK_REALTIME:
         case CLOCK_MONOTONIC:
         case CLOCK_BOOTTIME:
-                if (copy_to_user(tp, &rtn_tp, sizeof(rtn_tp)))
+                if (put_timespec64(&rtn_tp, tp))
                         return -EFAULT;
                 return 0;
         default:
@@ -110,22 +124,108 @@ SYSCALL_DEFINE4(clock_nanosleep, const clockid_t, which_clock, int, flags,
         case CLOCK_REALTIME:
         case CLOCK_MONOTONIC:
         case CLOCK_BOOTTIME:
-                if (copy_from_user(&t, rqtp, sizeof (struct timespec)))
-                        return -EFAULT;
-                t64 = timespec_to_timespec64(t);
-                if (!timespec64_valid(&t64))
-                        return -EINVAL;
-                return hrtimer_nanosleep(&t64, rmtp, flags & TIMER_ABSTIME ?
-                                         HRTIMER_MODE_ABS : HRTIMER_MODE_REL,
-                                         which_clock);
+                break;
         default:
                 return -EINVAL;
         }
+
+        if (copy_from_user(&t, rqtp, sizeof (struct timespec)))
+                return -EFAULT;
+        t64 = timespec_to_timespec64(t);
+        if (!timespec64_valid(&t64))
+                return -EINVAL;
+        if (flags & TIMER_ABSTIME)
+                rmtp = NULL;
+        current->restart_block.nanosleep.type = rmtp ? TT_NATIVE : TT_NONE;
+        current->restart_block.nanosleep.rmtp = rmtp;
+        return hrtimer_nanosleep(&t64, flags & TIMER_ABSTIME ?
+                                 HRTIMER_MODE_ABS : HRTIMER_MODE_REL,
+                                 which_clock);
 }
 
 #ifdef CONFIG_COMPAT
-long clock_nanosleep_restart(struct restart_block *restart_block)
+COMPAT_SYS_NI(timer_create);
+COMPAT_SYS_NI(clock_adjtime);
+COMPAT_SYS_NI(timer_settime);
+COMPAT_SYS_NI(timer_gettime);
+COMPAT_SYS_NI(getitimer);
+COMPAT_SYS_NI(setitimer);
+
+COMPAT_SYSCALL_DEFINE2(clock_settime, const clockid_t, which_clock,
+                       struct compat_timespec __user *, tp)
 {
-        return hrtimer_nanosleep_restart(restart_block);
+        struct timespec64 new_tp;
+
+        if (which_clock != CLOCK_REALTIME)
+                return -EINVAL;
+        if (compat_get_timespec64(&new_tp, tp))
+                return -EFAULT;
+
+        return do_sys_settimeofday64(&new_tp, NULL);
+}
+
+COMPAT_SYSCALL_DEFINE2(clock_gettime, clockid_t, which_clock,
+                       struct compat_timespec __user *, tp)
+{
+        int ret;
+        struct timespec64 kernel_tp;
+
+        ret = do_clock_gettime(which_clock, &kernel_tp);
+        if (ret)
+                return ret;
+
+        if (compat_put_timespec64(&kernel_tp, tp))
+                return -EFAULT;
+        return 0;
+}
+
+COMPAT_SYSCALL_DEFINE2(clock_getres, clockid_t, which_clock,
+                       struct compat_timespec __user *, tp)
+{
+        struct timespec64 rtn_tp = {
+                .tv_sec = 0,
+                .tv_nsec = hrtimer_resolution,
+        };
+
+        switch (which_clock) {
+        case CLOCK_REALTIME:
+        case CLOCK_MONOTONIC:
+        case CLOCK_BOOTTIME:
+                if (compat_put_timespec64(&rtn_tp, tp))
+                        return -EFAULT;
+                return 0;
+        default:
+                return -EINVAL;
+        }
+}
+
+COMPAT_SYSCALL_DEFINE4(clock_nanosleep, clockid_t, which_clock, int, flags,
+                       struct compat_timespec __user *, rqtp,
+                       struct compat_timespec __user *, rmtp)
+{
+        struct timespec64 t64;
+        struct timespec t;
+
+        switch (which_clock) {
+        case CLOCK_REALTIME:
+        case CLOCK_MONOTONIC:
+        case CLOCK_BOOTTIME:
+                break;
+        default:
+                return -EINVAL;
+        }
+
+        if (compat_get_timespec(&t, rqtp))
+                return -EFAULT;
+        t64 = timespec_to_timespec64(t);
+        if (!timespec64_valid(&t64))
+                return -EINVAL;
+        if (flags & TIMER_ABSTIME)
+                rmtp = NULL;
+        current->restart_block.nanosleep.type = rmtp ? TT_COMPAT : TT_NONE;
+        current->restart_block.nanosleep.compat_rmtp = rmtp;
+        return hrtimer_nanosleep(&t64, flags & TIMER_ABSTIME ?
+                                 HRTIMER_MODE_ABS : HRTIMER_MODE_REL,
+                                 which_clock);
 }
 #endif
diff --git a/kernel/time/posix-timers.c b/kernel/time/posix-timers.c
index 4d7b2ce09c27..13d6881f908b 100644
--- a/kernel/time/posix-timers.c
+++ b/kernel/time/posix-timers.c
@@ -49,8 +49,10 @@
 #include <linux/workqueue.h>
 #include <linux/export.h>
 #include <linux/hashtable.h>
+#include <linux/compat.h>
 
 #include "timekeeping.h"
+#include "posix-timers.h"
 
 /*
  * Management arrays for POSIX timers. Timers are now kept in static hash table
@@ -69,6 +71,10 @@ static struct kmem_cache *posix_timers_cache;
 static DEFINE_HASHTABLE(posix_timers_hashtable, 9);
 static DEFINE_SPINLOCK(hash_lock);
 
+static const struct k_clock * const posix_clocks[];
+static const struct k_clock *clockid_to_kclock(const clockid_t id);
+static const struct k_clock clock_realtime, clock_monotonic;
+
 /*
  * we assume that the new SIGEV_THREAD_ID shares no bits with the other
  * SIGEV values.  Here we put out an error if this assumption fails.
@@ -124,22 +130,6 @@ static DEFINE_SPINLOCK(hash_lock);
  *          have is CLOCK_REALTIME and its high res counter part, both of
  *          which we beg off on and pass to do_sys_settimeofday().
  */
-
-static struct k_clock posix_clocks[MAX_CLOCKS];
-
-/*
- * These ones are defined below.
- */
-static int common_nsleep(const clockid_t, int flags, struct timespec64 *t,
-                         struct timespec __user *rmtp);
-static int common_timer_create(struct k_itimer *new_timer);
-static void common_timer_get(struct k_itimer *, struct itimerspec64 *);
-static int common_timer_set(struct k_itimer *, int,
-                            struct itimerspec64 *, struct itimerspec64 *);
-static int common_timer_del(struct k_itimer *timer);
-
-static enum hrtimer_restart posix_timer_fn(struct hrtimer *data);
-
 static struct k_itimer *__lock_timer(timer_t timer_id, unsigned long *flags);
 
 #define lock_timer(tid, flags)                                             \
@@ -285,91 +275,23 @@ static int posix_get_hrtimer_res(clockid_t which_clock, struct timespec64 *tp)
  */
 static __init int init_posix_timers(void)
 {
-        struct k_clock clock_realtime = {
-                .clock_getres   = posix_get_hrtimer_res,
-                .clock_get      = posix_clock_realtime_get,
-                .clock_set      = posix_clock_realtime_set,
-                .clock_adj      = posix_clock_realtime_adj,
-                .nsleep         = common_nsleep,
-                .nsleep_restart = hrtimer_nanosleep_restart,
-                .timer_create   = common_timer_create,
-                .timer_set      = common_timer_set,
-                .timer_get      = common_timer_get,
-                .timer_del      = common_timer_del,
-        };
-        struct k_clock clock_monotonic = {
-                .clock_getres   = posix_get_hrtimer_res,
-                .clock_get      = posix_ktime_get_ts,
-                .nsleep         = common_nsleep,
-                .nsleep_restart = hrtimer_nanosleep_restart,
-                .timer_create   = common_timer_create,
-                .timer_set      = common_timer_set,
-                .timer_get      = common_timer_get,
-                .timer_del      = common_timer_del,
-        };
-        struct k_clock clock_monotonic_raw = {
-                .clock_getres   = posix_get_hrtimer_res,
-                .clock_get      = posix_get_monotonic_raw,
-        };
-        struct k_clock clock_realtime_coarse = {
-                .clock_getres   = posix_get_coarse_res,
-                .clock_get      = posix_get_realtime_coarse,
-        };
-        struct k_clock clock_monotonic_coarse = {
-                .clock_getres   = posix_get_coarse_res,
-                .clock_get      = posix_get_monotonic_coarse,
-        };
-        struct k_clock clock_tai = {
-                .clock_getres   = posix_get_hrtimer_res,
-                .clock_get      = posix_get_tai,
-                .nsleep         = common_nsleep,
-                .nsleep_restart = hrtimer_nanosleep_restart,
-                .timer_create   = common_timer_create,
-                .timer_set      = common_timer_set,
-                .timer_get      = common_timer_get,
-                .timer_del      = common_timer_del,
-        };
-        struct k_clock clock_boottime = {
-                .clock_getres   = posix_get_hrtimer_res,
-                .clock_get      = posix_get_boottime,
-                .nsleep         = common_nsleep,
-                .nsleep_restart = hrtimer_nanosleep_restart,
-                .timer_create   = common_timer_create,
-                .timer_set      = common_timer_set,
-                .timer_get      = common_timer_get,
-                .timer_del      = common_timer_del,
-        };
-
-        posix_timers_register_clock(CLOCK_REALTIME, &clock_realtime);
-        posix_timers_register_clock(CLOCK_MONOTONIC, &clock_monotonic);
-        posix_timers_register_clock(CLOCK_MONOTONIC_RAW, &clock_monotonic_raw);
-        posix_timers_register_clock(CLOCK_REALTIME_COARSE, &clock_realtime_coarse);
-        posix_timers_register_clock(CLOCK_MONOTONIC_COARSE, &clock_monotonic_coarse);
-        posix_timers_register_clock(CLOCK_BOOTTIME, &clock_boottime);
-        posix_timers_register_clock(CLOCK_TAI, &clock_tai);
-
         posix_timers_cache = kmem_cache_create("posix_timers_cache",
                                         sizeof (struct k_itimer), 0, SLAB_PANIC,
                                         NULL);
         return 0;
 }
-
 __initcall(init_posix_timers);
 
-static void schedule_next_timer(struct k_itimer *timr)
+static void common_hrtimer_rearm(struct k_itimer *timr)
 {
         struct hrtimer *timer = &timr->it.real.timer;
 
-        if (timr->it.real.interval == 0)
+        if (!timr->it_interval)
                 return;
 
         timr->it_overrun += (unsigned int) hrtimer_forward(timer,
                                                 timer->base->get_time(),
-                                                timr->it.real.interval);
-
-        timr->it_overrun_last = timr->it_overrun;
-        timr->it_overrun = -1;
-        ++timr->it_requeue_pending;
+                                                timr->it_interval);
         hrtimer_restart(timer);
 }
 
@@ -384,24 +306,27 @@ static void schedule_next_timer(struct k_itimer *timr)
  * To protect against the timer going away while the interrupt is queued,
  * we require that the it_requeue_pending flag be set.
  */
-void do_schedule_next_timer(struct siginfo *info)
+void posixtimer_rearm(struct siginfo *info)
 {
         struct k_itimer *timr;
         unsigned long flags;
 
         timr = lock_timer(info->si_tid, &flags);
+        if (!timr)
+                return;
+
+        if (timr->it_requeue_pending == info->si_sys_private) {
+                timr->kclock->timer_rearm(timr);
 
-        if (timr && timr->it_requeue_pending == info->si_sys_private) {
-                if (timr->it_clock < 0)
-                        posix_cpu_timer_schedule(timr);
-                else
-                        schedule_next_timer(timr);
+                timr->it_active = 1;
+                timr->it_overrun_last = timr->it_overrun;
+                timr->it_overrun = -1;
+                ++timr->it_requeue_pending;
 
                 info->si_overrun += timr->it_overrun_last;
         }
 
-        if (timr)
-                unlock_timer(timr, flags);
+        unlock_timer(timr, flags);
 }
 
 int posix_timer_event(struct k_itimer *timr, int si_private)
@@ -410,12 +335,12 @@ int posix_timer_event(struct k_itimer *timr, int si_private)
         int shared, ret = -1;
         /*
          * FIXME: if ->sigq is queued we can race with
-         * dequeue_signal()->do_schedule_next_timer().
+         * dequeue_signal()->posixtimer_rearm().
          *
          * If dequeue_signal() sees the "right" value of
-         * si_sys_private it calls do_schedule_next_timer().
+         * si_sys_private it calls posixtimer_rearm().
          * We re-queue ->sigq and drop ->it_lock().
-         * do_schedule_next_timer() locks the timer
+         * posixtimer_rearm() locks the timer
          * and re-schedules it while ->sigq is pending.
          * Not really bad, but not that we want.
          */
@@ -431,7 +356,6 @@ int posix_timer_event(struct k_itimer *timr, int si_private)
         /* If we failed to send the signal the timer stops. */
         return ret > 0;
 }
-EXPORT_SYMBOL_GPL(posix_timer_event);
 
 /*
  * This function gets called when a POSIX.1b interval timer expires.  It
@@ -450,7 +374,8 @@ static enum hrtimer_restart posix_timer_fn(struct hrtimer *timer)
         timr = container_of(timer, struct k_itimer, it.real.timer);
         spin_lock_irqsave(&timr->it_lock, flags);
 
-        if (timr->it.real.interval != 0)
+        timr->it_active = 0;
+        if (timr->it_interval != 0)
                 si_private = ++timr->it_requeue_pending;
 
         if (posix_timer_event(timr, si_private)) {
@@ -459,7 +384,7 @@ static enum hrtimer_restart posix_timer_fn(struct hrtimer *timer)
                  * we will not get a call back to restart it AND
                  * it should be restarted.
                  */
-                if (timr->it.real.interval != 0) {
+                if (timr->it_interval != 0) {
                         ktime_t now = hrtimer_cb_get_time(timer);
 
                         /*
@@ -488,15 +413,16 @@ static enum hrtimer_restart posix_timer_fn(struct hrtimer *timer)
                         {
                                 ktime_t kj = NSEC_PER_SEC / HZ;
 
-                                if (timr->it.real.interval < kj)
+                                if (timr->it_interval < kj)
                                         now = ktime_add(now, kj);
                         }
 #endif
                         timr->it_overrun += (unsigned int)
                                 hrtimer_forward(timer, now,
-                                                timr->it.real.interval);
+                                                timr->it_interval);
                         ret = HRTIMER_RESTART;
                         ++timr->it_requeue_pending;
+                        timr->it_active = 1;
                 }
         }
 
@@ -521,30 +447,6 @@ static struct pid *good_sigevent(sigevent_t * event)
         return task_pid(rtn);
 }
 
-void posix_timers_register_clock(const clockid_t clock_id,
-                                 struct k_clock *new_clock)
-{
-        if ((unsigned) clock_id >= MAX_CLOCKS) {
-                printk(KERN_WARNING "POSIX clock register failed for clock_id %d\n",
-                       clock_id);
-                return;
-        }
-
-        if (!new_clock->clock_get) {
-                printk(KERN_WARNING "POSIX clock id %d lacks clock_get()\n",
-                       clock_id);
-                return;
-        }
-        if (!new_clock->clock_getres) {
-                printk(KERN_WARNING "POSIX clock id %d lacks clock_getres()\n",
-                       clock_id);
-                return;
-        }
-
-        posix_clocks[clock_id] = *new_clock;
-}
-EXPORT_SYMBOL_GPL(posix_timers_register_clock);
-
 static struct k_itimer * alloc_posix_timer(void)
 {
         struct k_itimer *tmr;
@@ -581,17 +483,6 @@ static void release_posix_timer(struct k_itimer *tmr, int it_id_set)
         call_rcu(&tmr->it.rcu, k_itimer_rcu_free);
 }
 
-static struct k_clock *clockid_to_kclock(const clockid_t id)
-{
-        if (id < 0)
-                return (id & CLOCKFD_MASK) == CLOCKFD ?
-                        &clock_posix_dynamic : &clock_posix_cpu;
-
-        if (id >= MAX_CLOCKS || !posix_clocks[id].clock_getres)
-                return NULL;
-        return &posix_clocks[id];
-}
-
 static int common_timer_create(struct k_itimer *new_timer)
 {
         hrtimer_init(&new_timer->it.real.timer, new_timer->it_clock, 0);
@@ -599,15 +490,12 @@ static int common_timer_create(struct k_itimer *new_timer)
 }
 
 /* Create a POSIX.1b interval timer. */
-
-SYSCALL_DEFINE3(timer_create, const clockid_t, which_clock,
-                struct sigevent __user *, timer_event_spec,
-                timer_t __user *, created_timer_id)
+static int do_timer_create(clockid_t which_clock, struct sigevent *event,
+                           timer_t __user *created_timer_id)
 {
-        struct k_clock *kc = clockid_to_kclock(which_clock);
+        const struct k_clock *kc = clockid_to_kclock(which_clock);
         struct k_itimer *new_timer;
         int error, new_timer_id;
-        sigevent_t event;
         int it_id_set = IT_ID_NOT_SET;
 
         if (!kc)
@@ -629,31 +517,28 @@ SYSCALL_DEFINE3(timer_create, const clockid_t, which_clock,
         it_id_set = IT_ID_SET;
         new_timer->it_id = (timer_t) new_timer_id;
         new_timer->it_clock = which_clock;
+        new_timer->kclock = kc;
         new_timer->it_overrun = -1;
 
-        if (timer_event_spec) {
-                if (copy_from_user(&event, timer_event_spec, sizeof (event))) {
-                        error = -EFAULT;
-                        goto out;
-                }
+        if (event) {
                 rcu_read_lock();
-                new_timer->it_pid = get_pid(good_sigevent(&event));
+                new_timer->it_pid = get_pid(good_sigevent(event));
                 rcu_read_unlock();
                 if (!new_timer->it_pid) {
                         error = -EINVAL;
                         goto out;
                 }
+                new_timer->it_sigev_notify     = event->sigev_notify;
+                new_timer->sigq->info.si_signo = event->sigev_signo;
+                new_timer->sigq->info.si_value = event->sigev_value;
         } else {
-                memset(&event.sigev_value, 0, sizeof(event.sigev_value));
-                event.sigev_notify = SIGEV_SIGNAL;
-                event.sigev_signo = SIGALRM;
-                event.sigev_value.sival_int = new_timer->it_id;
+                new_timer->it_sigev_notify     = SIGEV_SIGNAL;
+                new_timer->sigq->info.si_signo = SIGALRM;
+                memset(&new_timer->sigq->info.si_value, 0, sizeof(sigval_t));
+                new_timer->sigq->info.si_value.sival_int = new_timer->it_id;
                 new_timer->it_pid = get_pid(task_tgid(current));
         }
 
-        new_timer->it_sigev_notify     = event.sigev_notify;
-        new_timer->sigq->info.si_signo = event.sigev_signo;
-        new_timer->sigq->info.si_value = event.sigev_value;
         new_timer->sigq->info.si_tid   = new_timer->it_id;
         new_timer->sigq->info.si_code  = SI_TIMER;
 
@@ -684,6 +569,36 @@ out:
         return error;
 }
 
+SYSCALL_DEFINE3(timer_create, const clockid_t, which_clock,
+                struct sigevent __user *, timer_event_spec,
+                timer_t __user *, created_timer_id)
+{
+        if (timer_event_spec) {
+                sigevent_t event;
+
+                if (copy_from_user(&event, timer_event_spec, sizeof (event)))
+                        return -EFAULT;
+                return do_timer_create(which_clock, &event, created_timer_id);
+        }
+        return do_timer_create(which_clock, NULL, created_timer_id);
+}
+
+#ifdef CONFIG_COMPAT
+COMPAT_SYSCALL_DEFINE3(timer_create, clockid_t, which_clock,
+                       struct compat_sigevent __user *, timer_event_spec,
+                       timer_t __user *, created_timer_id)
+{
+        if (timer_event_spec) {
+                sigevent_t event;
+
+                if (get_compat_sigevent(&event, timer_event_spec))
+                        return -EFAULT;
+                return do_timer_create(which_clock, &event, created_timer_id);
+        }
+        return do_timer_create(which_clock, NULL, created_timer_id);
+}
+#endif
+
 /*
  * Locking issues: We need to protect the result of the id look up until
  * we get the timer locked down so it is not deleted under us.  The
@@ -717,6 +632,20 @@ static struct k_itimer *__lock_timer(timer_t timer_id, unsigned long *flags)
         return NULL;
 }
 
+static ktime_t common_hrtimer_remaining(struct k_itimer *timr, ktime_t now)
+{
+        struct hrtimer *timer = &timr->it.real.timer;
+
+        return __hrtimer_expires_remaining_adjusted(timer, now);
+}
+
+static int common_hrtimer_forward(struct k_itimer *timr, ktime_t now)
+{
+        struct hrtimer *timer = &timr->it.real.timer;
+
+        return (int)hrtimer_forward(timer, now, timr->it_interval);
+}
+
 /*
  * Get the time remaining on a POSIX.1b interval timer.  This function
  * is ALWAYS called with spin_lock_irq on the timer, thus it must not
@@ -733,55 +662,61 @@ static struct k_itimer *__lock_timer(timer_t timer_id, unsigned long *flags)
  * it is the same as a requeue pending timer WRT to what we should
  * report.
  */
-static void
-common_timer_get(struct k_itimer *timr, struct itimerspec64 *cur_setting)
+void common_timer_get(struct k_itimer *timr, struct itimerspec64 *cur_setting)
 {
+        const struct k_clock *kc = timr->kclock;
         ktime_t now, remaining, iv;
-        struct hrtimer *timer = &timr->it.real.timer;
-
-        memset(cur_setting, 0, sizeof(*cur_setting));
+        struct timespec64 ts64;
+        bool sig_none;
 
-        iv = timr->it.real.interval;
+        sig_none = (timr->it_sigev_notify & ~SIGEV_THREAD_ID) == SIGEV_NONE;
+        iv = timr->it_interval;
 
         /* interval timer ? */
-        if (iv)
+        if (iv) {
                 cur_setting->it_interval = ktime_to_timespec64(iv);
-        else if (!hrtimer_active(timer) &&
-                 (timr->it_sigev_notify & ~SIGEV_THREAD_ID) != SIGEV_NONE)
-                return;
+        } else if (!timr->it_active) {
+                /*
+                 * SIGEV_NONE oneshot timers are never queued. Check them
+                 * below.
+                 */
+                if (!sig_none)
+                        return;
+        }
 
-        now = timer->base->get_time();
+        /*
+         * The timespec64 based conversion is suboptimal, but it's not
+         * worth to implement yet another callback.
+         */
+        kc->clock_get(timr->it_clock, &ts64);
+        now = timespec64_to_ktime(ts64);
 
         /*
-         * When a requeue is pending or this is a SIGEV_NONE
-         * timer move the expiry time forward by intervals, so
-         * expiry is > now.
+         * When a requeue is pending or this is a SIGEV_NONE timer move the
+         * expiry time forward by intervals, so expiry is > now.
          */
-        if (iv && (timr->it_requeue_pending & REQUEUE_PENDING ||
-                   (timr->it_sigev_notify & ~SIGEV_THREAD_ID) == SIGEV_NONE))
-                timr->it_overrun += (unsigned int) hrtimer_forward(timer, now, iv);
+        if (iv && (timr->it_requeue_pending & REQUEUE_PENDING || sig_none))
+                timr->it_overrun += kc->timer_forward(timr, now);
 
-        remaining = __hrtimer_expires_remaining_adjusted(timer, now);
+        remaining = kc->timer_remaining(timr, now);
         /* Return 0 only, when the timer is expired and not pending */
         if (remaining <= 0) {
                 /*
                  * A single shot SIGEV_NONE timer must return 0, when
                  * it is expired !
                  */
-                if ((timr->it_sigev_notify & ~SIGEV_THREAD_ID) != SIGEV_NONE)
+                if (!sig_none)
                         cur_setting->it_value.tv_nsec = 1;
-        } else
+        } else {
                 cur_setting->it_value = ktime_to_timespec64(remaining);
+        }
 }
 
 /* Get the time remaining on a POSIX.1b interval timer. */
-SYSCALL_DEFINE2(timer_gettime, timer_t, timer_id,
-                struct itimerspec __user *, setting)
+static int do_timer_gettime(timer_t timer_id,  struct itimerspec64 *setting)
 {
-        struct itimerspec64 cur_setting64;
-        struct itimerspec cur_setting;
         struct k_itimer *timr;
-        struct k_clock *kc;
+        const struct k_clock *kc;
         unsigned long flags;
         int ret = 0;
 
@@ -789,20 +724,45 @@ SYSCALL_DEFINE2(timer_gettime, timer_t, timer_id,
         if (!timr)
                 return -EINVAL;
 
-        kc = clockid_to_kclock(timr->it_clock);
+        memset(setting, 0, sizeof(*setting));
+        kc = timr->kclock;
         if (WARN_ON_ONCE(!kc || !kc->timer_get))
                 ret = -EINVAL;
         else
-                kc->timer_get(timr, &cur_setting64);
+                kc->timer_get(timr, setting);
 
         unlock_timer(timr, flags);
+        return ret;
+}
 
-        cur_setting = itimerspec64_to_itimerspec(&cur_setting64);
-        if (!ret && copy_to_user(setting, &cur_setting, sizeof (cur_setting)))
-                return -EFAULT;
+/* Get the time remaining on a POSIX.1b interval timer. */
+SYSCALL_DEFINE2(timer_gettime, timer_t, timer_id,
+                struct itimerspec __user *, setting)
+{
+        struct itimerspec64 cur_setting;
+
+        int ret = do_timer_gettime(timer_id, &cur_setting);
+        if (!ret) {
+                if (put_itimerspec64(&cur_setting, setting))
+                        ret = -EFAULT;
+        }
+        return ret;
+}
+
+#ifdef CONFIG_COMPAT
+COMPAT_SYSCALL_DEFINE2(timer_gettime, timer_t, timer_id,
+                       struct compat_itimerspec __user *, setting)
+{
+        struct itimerspec64 cur_setting;
 
+        int ret = do_timer_gettime(timer_id, &cur_setting);
+        if (!ret) {
+                if (put_compat_itimerspec64(&cur_setting, setting))
+                        ret = -EFAULT;
+        }
         return ret;
 }
+#endif
 
 /*
  * Get the number of overruns of a POSIX.1b interval timer.  This is to
@@ -810,7 +770,7 @@ SYSCALL_DEFINE2(timer_gettime, timer_t, timer_id,
  * accumulating overruns on the next timer.  The overrun is frozen when
  * the signal is delivered, either at the notify time (if the info block
  * is not queued) or at the actual delivery time (as we are informed by
- * the call back to do_schedule_next_timer().  So all we need to do is
+ * the call back to posixtimer_rearm().  So all we need to do is
  * to pick up the frozen overrun.
  */
 SYSCALL_DEFINE1(timer_getoverrun, timer_t, timer_id)
@@ -829,117 +789,175 @@ SYSCALL_DEFINE1(timer_getoverrun, timer_t, timer_id)
         return overrun;
 }
 
-/* Set a POSIX.1b interval timer. */
-/* timr->it_lock is taken. */
-static int
-common_timer_set(struct k_itimer *timr, int flags,
-                 struct itimerspec64 *new_setting, struct itimerspec64 *old_setting)
+static void common_hrtimer_arm(struct k_itimer *timr, ktime_t expires,
+                               bool absolute, bool sigev_none)
 {
         struct hrtimer *timer = &timr->it.real.timer;
         enum hrtimer_mode mode;
 
+        mode = absolute ? HRTIMER_MODE_ABS : HRTIMER_MODE_REL;
+        /*
+         * Posix magic: Relative CLOCK_REALTIME timers are not affected by
+         * clock modifications, so they become CLOCK_MONOTONIC based under the
+         * hood. See hrtimer_init(). Update timr->kclock, so the generic
+         * functions which use timr->kclock->clock_get() work.
+         *
+         * Note: it_clock stays unmodified, because the next timer_set() might
+         * use ABSTIME, so it needs to switch back.
+         */
+        if (timr->it_clock == CLOCK_REALTIME)
+                timr->kclock = absolute ? &clock_realtime : &clock_monotonic;
+
+        hrtimer_init(&timr->it.real.timer, timr->it_clock, mode);
+        timr->it.real.timer.function = posix_timer_fn;
+
+        if (!absolute)
+                expires = ktime_add_safe(expires, timer->base->get_time());
+        hrtimer_set_expires(timer, expires);
+
+        if (!sigev_none)
+                hrtimer_start_expires(timer, HRTIMER_MODE_ABS);
+}
+
+static int common_hrtimer_try_to_cancel(struct k_itimer *timr)
+{
+        return hrtimer_try_to_cancel(&timr->it.real.timer);
+}
+
+/* Set a POSIX.1b interval timer. */
+int common_timer_set(struct k_itimer *timr, int flags,
+                     struct itimerspec64 *new_setting,
+                     struct itimerspec64 *old_setting)
+{
+        const struct k_clock *kc = timr->kclock;
+        bool sigev_none;
+        ktime_t expires;
+
         if (old_setting)
                 common_timer_get(timr, old_setting);
 
-        /* disable the timer */
-        timr->it.real.interval = 0;
+        /* Prevent rearming by clearing the interval */
+        timr->it_interval = 0;
         /*
-         * careful here.  If smp we could be in the "fire" routine which will
-         * be spinning as we hold the lock.  But this is ONLY an SMP issue.
+         * Careful here. On SMP systems the timer expiry function could be
+         * active and spinning on timr->it_lock.
          */
-        if (hrtimer_try_to_cancel(timer) < 0)
+        if (kc->timer_try_to_cancel(timr) < 0)
                 return TIMER_RETRY;
 
-        timr->it_requeue_pending = (timr->it_requeue_pending + 2) & 
+        timr->it_active = 0;
+        timr->it_requeue_pending = (timr->it_requeue_pending + 2) &
                 ~REQUEUE_PENDING;
         timr->it_overrun_last = 0;
 
-        /* switch off the timer when it_value is zero */
+        /* Switch off the timer when it_value is zero */
         if (!new_setting->it_value.tv_sec && !new_setting->it_value.tv_nsec)
                 return 0;
 
-        mode = flags & TIMER_ABSTIME ? HRTIMER_MODE_ABS : HRTIMER_MODE_REL;
-        hrtimer_init(&timr->it.real.timer, timr->it_clock, mode);
-        timr->it.real.timer.function = posix_timer_fn;
-
-        hrtimer_set_expires(timer, timespec64_to_ktime(new_setting->it_value));
-
-        /* Convert interval */
-        timr->it.real.interval = timespec64_to_ktime(new_setting->it_interval);
-
-        /* SIGEV_NONE timers are not queued ! See common_timer_get */
-        if (((timr->it_sigev_notify & ~SIGEV_THREAD_ID) == SIGEV_NONE)) {
-                /* Setup correct expiry time for relative timers */
-                if (mode == HRTIMER_MODE_REL) {
-                        hrtimer_add_expires(timer, timer->base->get_time());
-                }
-                return 0;
-        }
+        timr->it_interval = timespec64_to_ktime(new_setting->it_interval);
+        expires = timespec64_to_ktime(new_setting->it_value);
+        sigev_none = (timr->it_sigev_notify & ~SIGEV_THREAD_ID) == SIGEV_NONE;
 
-        hrtimer_start_expires(timer, mode);
+        kc->timer_arm(timr, expires, flags & TIMER_ABSTIME, sigev_none);
+        timr->it_active = !sigev_none;
         return 0;
 }
 
-/* Set a POSIX.1b interval timer */
-SYSCALL_DEFINE4(timer_settime, timer_t, timer_id, int, flags,
-                const struct itimerspec __user *, new_setting,
-                struct itimerspec __user *, old_setting)
+static int do_timer_settime(timer_t timer_id, int flags,
+                            struct itimerspec64 *new_spec64,
+                            struct itimerspec64 *old_spec64)
 {
-        struct itimerspec64 new_spec64, old_spec64;
-        struct itimerspec64 *rtn = old_setting ? &old_spec64 : NULL;
-        struct itimerspec new_spec, old_spec;
+        const struct k_clock *kc;
         struct k_itimer *timr;
         unsigned long flag;
-        struct k_clock *kc;
         int error = 0;
 
-        if (!new_setting)
+        if (!timespec64_valid(&new_spec64->it_interval) ||
+            !timespec64_valid(&new_spec64->it_value))
                 return -EINVAL;
 
-        if (copy_from_user(&new_spec, new_setting, sizeof (new_spec)))
-                return -EFAULT;
-        new_spec64 = itimerspec_to_itimerspec64(&new_spec);
-
-        if (!timespec64_valid(&new_spec64.it_interval) ||
-            !timespec64_valid(&new_spec64.it_value))
-                return -EINVAL;
+        if (old_spec64)
+                memset(old_spec64, 0, sizeof(*old_spec64));
 retry:
         timr = lock_timer(timer_id, &flag);
         if (!timr)
                 return -EINVAL;
 
-        kc = clockid_to_kclock(timr->it_clock);
+        kc = timr->kclock;
         if (WARN_ON_ONCE(!kc || !kc->timer_set))
                 error = -EINVAL;
         else
-                error = kc->timer_set(timr, flags, &new_spec64, rtn);
+                error = kc->timer_set(timr, flags, new_spec64, old_spec64);
 
         unlock_timer(timr, flag);
         if (error == TIMER_RETRY) {
-                rtn = NULL;     // We already got the old time...
+                old_spec64 = NULL;      // We already got the old time...
                 goto retry;
         }
 
-        old_spec = itimerspec64_to_itimerspec(&old_spec64);
-        if (old_setting && !error &&
-            copy_to_user(old_setting, &old_spec, sizeof (old_spec)))
-                error = -EFAULT;
+        return error;
+}
+
+/* Set a POSIX.1b interval timer */
+SYSCALL_DEFINE4(timer_settime, timer_t, timer_id, int, flags,
+                const struct itimerspec __user *, new_setting,
+                struct itimerspec __user *, old_setting)
+{
+        struct itimerspec64 new_spec, old_spec;
+        struct itimerspec64 *rtn = old_setting ? &old_spec : NULL;
+        int error = 0;
+
+        if (!new_setting)
+                return -EINVAL;
 
+        if (get_itimerspec64(&new_spec, new_setting))
+                return -EFAULT;
+
+        error = do_timer_settime(timer_id, flags, &new_spec, rtn);
+        if (!error && old_setting) {
+                if (put_itimerspec64(&old_spec, old_setting))
+                        error = -EFAULT;
+        }
+        return error;
+}
+
+#ifdef CONFIG_COMPAT
+COMPAT_SYSCALL_DEFINE4(timer_settime, timer_t, timer_id, int, flags,
+                       struct compat_itimerspec __user *, new,
+                       struct compat_itimerspec __user *, old)
+{
+        struct itimerspec64 new_spec, old_spec;
+        struct itimerspec64 *rtn = old ? &old_spec : NULL;
+        int error = 0;
+
+        if (!new)
+                return -EINVAL;
+        if (get_compat_itimerspec64(&new_spec, new))
+                return -EFAULT;
+
+        error = do_timer_settime(timer_id, flags, &new_spec, rtn);
+        if (!error && old) {
+                if (put_compat_itimerspec64(&old_spec, old))
+                        error = -EFAULT;
+        }
         return error;
 }
+#endif
 
-static int common_timer_del(struct k_itimer *timer)
+int common_timer_del(struct k_itimer *timer)
 {
-        timer->it.real.interval = 0;
+        const struct k_clock *kc = timer->kclock;
 
-        if (hrtimer_try_to_cancel(&timer->it.real.timer) < 0)
+        timer->it_interval = 0;
+        if (kc->timer_try_to_cancel(timer) < 0)
                 return TIMER_RETRY;
+        timer->it_active = 0;
         return 0;
 }
 
 static inline int timer_delete_hook(struct k_itimer *timer)
 {
-        struct k_clock *kc = clockid_to_kclock(timer->it_clock);
+        const struct k_clock *kc = timer->kclock;
 
         if (WARN_ON_ONCE(!kc || !kc->timer_del))
                 return -EINVAL;
@@ -1018,35 +1036,31 @@ void exit_itimers(struct signal_struct *sig)
 SYSCALL_DEFINE2(clock_settime, const clockid_t, which_clock,
                 const struct timespec __user *, tp)
 {
-        struct k_clock *kc = clockid_to_kclock(which_clock);
-        struct timespec64 new_tp64;
-        struct timespec new_tp;
+        const struct k_clock *kc = clockid_to_kclock(which_clock);
+        struct timespec64 new_tp;
 
         if (!kc || !kc->clock_set)
                 return -EINVAL;
 
-        if (copy_from_user(&new_tp, tp, sizeof (*tp)))
+        if (get_timespec64(&new_tp, tp))
                 return -EFAULT;
-        new_tp64 = timespec_to_timespec64(new_tp);
 
-        return kc->clock_set(which_clock, &new_tp64);
+        return kc->clock_set(which_clock, &new_tp);
 }
 
 SYSCALL_DEFINE2(clock_gettime, const clockid_t, which_clock,
                 struct timespec __user *,tp)
 {
-        struct k_clock *kc = clockid_to_kclock(which_clock);
-        struct timespec64 kernel_tp64;
-        struct timespec kernel_tp;
+        const struct k_clock *kc = clockid_to_kclock(which_clock);
+        struct timespec64 kernel_tp;
         int error;
 
         if (!kc)
                 return -EINVAL;
 
-        error = kc->clock_get(which_clock, &kernel_tp64);
-        kernel_tp = timespec64_to_timespec(kernel_tp64);
+        error = kc->clock_get(which_clock, &kernel_tp);
 
-        if (!error && copy_to_user(tp, &kernel_tp, sizeof (kernel_tp)))
+        if (!error && put_timespec64(&kernel_tp, tp))
                 error = -EFAULT;
 
         return error;
@@ -1055,7 +1069,7 @@ SYSCALL_DEFINE2(clock_gettime, const clockid_t, which_clock,
 SYSCALL_DEFINE2(clock_adjtime, const clockid_t, which_clock,
                 struct timex __user *, utx)
 {
-        struct k_clock *kc = clockid_to_kclock(which_clock);
+        const struct k_clock *kc = clockid_to_kclock(which_clock);
         struct timex ktx;
         int err;
 
@@ -1078,30 +1092,106 @@ SYSCALL_DEFINE2(clock_adjtime, const clockid_t, which_clock,
 SYSCALL_DEFINE2(clock_getres, const clockid_t, which_clock,
                 struct timespec __user *, tp)
 {
-        struct k_clock *kc = clockid_to_kclock(which_clock);
-        struct timespec64 rtn_tp64;
-        struct timespec rtn_tp;
+        const struct k_clock *kc = clockid_to_kclock(which_clock);
+        struct timespec64 rtn_tp;
         int error;
 
         if (!kc)
                 return -EINVAL;
 
-        error = kc->clock_getres(which_clock, &rtn_tp64);
-        rtn_tp = timespec64_to_timespec(rtn_tp64);
+        error = kc->clock_getres(which_clock, &rtn_tp);
 
-        if (!error && tp && copy_to_user(tp, &rtn_tp, sizeof (rtn_tp)))
+        if (!error && tp && put_timespec64(&rtn_tp, tp))
                 error = -EFAULT;
 
         return error;
 }
 
+#ifdef CONFIG_COMPAT
+
+COMPAT_SYSCALL_DEFINE2(clock_settime, clockid_t, which_clock,
+                       struct compat_timespec __user *, tp)
+{
+        const struct k_clock *kc = clockid_to_kclock(which_clock);
+        struct timespec64 ts;
+
+        if (!kc || !kc->clock_set)
+                return -EINVAL;
+
+        if (compat_get_timespec64(&ts, tp))
+                return -EFAULT;
+
+        return kc->clock_set(which_clock, &ts);
+}
+
+COMPAT_SYSCALL_DEFINE2(clock_gettime, clockid_t, which_clock,
+                       struct compat_timespec __user *, tp)
+{
+        const struct k_clock *kc = clockid_to_kclock(which_clock);
+        struct timespec64 ts;
+        int err;
+
+        if (!kc)
+                return -EINVAL;
+
+        err = kc->clock_get(which_clock, &ts);
+
+        if (!err && compat_put_timespec64(&ts, tp))
+                err = -EFAULT;
+
+        return err;
+}
+
+COMPAT_SYSCALL_DEFINE2(clock_adjtime, clockid_t, which_clock,
+                       struct compat_timex __user *, utp)
+{
+        const struct k_clock *kc = clockid_to_kclock(which_clock);
+        struct timex ktx;
+        int err;
+
+        if (!kc)
+                return -EINVAL;
+        if (!kc->clock_adj)
+                return -EOPNOTSUPP;
+
+        err = compat_get_timex(&ktx, utp);
+        if (err)
+                return err;
+
+        err = kc->clock_adj(which_clock, &ktx);
+
+        if (err >= 0)
+                err = compat_put_timex(utp, &ktx);
+
+        return err;
+}
+
+COMPAT_SYSCALL_DEFINE2(clock_getres, clockid_t, which_clock,
+                       struct compat_timespec __user *, tp)
+{
+        const struct k_clock *kc = clockid_to_kclock(which_clock);
+        struct timespec64 ts;
+        int err;
+
+        if (!kc)
+                return -EINVAL;
+
+        err = kc->clock_getres(which_clock, &ts);
+        if (!err && tp && compat_put_timespec64(&ts, tp))
+                return -EFAULT;
+
+        return err;
+}
+
+#endif
+
 /*
  * nanosleep for monotonic and realtime clocks
  */
 static int common_nsleep(const clockid_t which_clock, int flags,
-                         struct timespec64 *tsave, struct timespec __user *rmtp)
+                         const struct timespec64 *rqtp)
 {
-        return hrtimer_nanosleep(tsave, rmtp, flags & TIMER_ABSTIME ?
+        return hrtimer_nanosleep(rqtp, flags & TIMER_ABSTIME ?
                                  HRTIMER_MODE_ABS : HRTIMER_MODE_REL,
                                  which_clock);
 }
@@ -1110,36 +1200,152 @@ SYSCALL_DEFINE4(clock_nanosleep, const clockid_t, which_clock, int, flags,
                 const struct timespec __user *, rqtp,
                 struct timespec __user *, rmtp)
 {
-        struct k_clock *kc = clockid_to_kclock(which_clock);
-        struct timespec64 t64;
-        struct timespec t;
+        const struct k_clock *kc = clockid_to_kclock(which_clock);
+        struct timespec64 t;
 
         if (!kc)
                 return -EINVAL;
         if (!kc->nsleep)
                 return -ENANOSLEEP_NOTSUP;
 
-        if (copy_from_user(&t, rqtp, sizeof (struct timespec)))
+        if (get_timespec64(&t, rqtp))
                 return -EFAULT;
 
-        t64 = timespec_to_timespec64(t);
-        if (!timespec64_valid(&t64))
+        if (!timespec64_valid(&t))
                 return -EINVAL;
+        if (flags & TIMER_ABSTIME)
+                rmtp = NULL;
+        current->restart_block.nanosleep.type = rmtp ? TT_NATIVE : TT_NONE;
+        current->restart_block.nanosleep.rmtp = rmtp;
 
-        return kc->nsleep(which_clock, flags, &t64, rmtp);
+        return kc->nsleep(which_clock, flags, &t);
 }
 
-/*
- * This will restart clock_nanosleep. This is required only by
- * compat_clock_nanosleep_restart for now.
- */
-long clock_nanosleep_restart(struct restart_block *restart_block)
+#ifdef CONFIG_COMPAT
+COMPAT_SYSCALL_DEFINE4(clock_nanosleep, clockid_t, which_clock, int, flags,
+                       struct compat_timespec __user *, rqtp,
+                       struct compat_timespec __user *, rmtp)
 {
-        clockid_t which_clock = restart_block->nanosleep.clockid;
-        struct k_clock *kc = clockid_to_kclock(which_clock);
+        const struct k_clock *kc = clockid_to_kclock(which_clock);
+        struct timespec64 t;
+
+        if (!kc)
+                return -EINVAL;
+        if (!kc->nsleep)
+                return -ENANOSLEEP_NOTSUP;
 
-        if (WARN_ON_ONCE(!kc || !kc->nsleep_restart))
+        if (compat_get_timespec64(&t, rqtp))
+                return -EFAULT;
+
+        if (!timespec64_valid(&t))
                 return -EINVAL;
+        if (flags & TIMER_ABSTIME)
+                rmtp = NULL;
+        current->restart_block.nanosleep.type = rmtp ? TT_COMPAT : TT_NONE;
+        current->restart_block.nanosleep.compat_rmtp = rmtp;
+
+        return kc->nsleep(which_clock, flags, &t);
+}
+#endif
 
-        return kc->nsleep_restart(restart_block);
+static const struct k_clock clock_realtime = {
+        .clock_getres           = posix_get_hrtimer_res,
+        .clock_get              = posix_clock_realtime_get,
+        .clock_set              = posix_clock_realtime_set,
+        .clock_adj              = posix_clock_realtime_adj,
+        .nsleep                 = common_nsleep,
+        .timer_create           = common_timer_create,
+        .timer_set              = common_timer_set,
+        .timer_get              = common_timer_get,
+        .timer_del              = common_timer_del,
+        .timer_rearm            = common_hrtimer_rearm,
+        .timer_forward          = common_hrtimer_forward,
+        .timer_remaining        = common_hrtimer_remaining,
+        .timer_try_to_cancel    = common_hrtimer_try_to_cancel,
+        .timer_arm              = common_hrtimer_arm,
+};
+
+static const struct k_clock clock_monotonic = {
+        .clock_getres           = posix_get_hrtimer_res,
+        .clock_get              = posix_ktime_get_ts,
+        .nsleep                 = common_nsleep,
+        .timer_create           = common_timer_create,
+        .timer_set              = common_timer_set,
+        .timer_get              = common_timer_get,
+        .timer_del              = common_timer_del,
+        .timer_rearm            = common_hrtimer_rearm,
+        .timer_forward          = common_hrtimer_forward,
+        .timer_remaining        = common_hrtimer_remaining,
+        .timer_try_to_cancel    = common_hrtimer_try_to_cancel,
+        .timer_arm              = common_hrtimer_arm,
+};
+
+static const struct k_clock clock_monotonic_raw = {
+        .clock_getres           = posix_get_hrtimer_res,
+        .clock_get              = posix_get_monotonic_raw,
+};
+
+static const struct k_clock clock_realtime_coarse = {
+        .clock_getres           = posix_get_coarse_res,
+        .clock_get              = posix_get_realtime_coarse,
+};
+
+static const struct k_clock clock_monotonic_coarse = {
+        .clock_getres           = posix_get_coarse_res,
+        .clock_get              = posix_get_monotonic_coarse,
+};
+
+static const struct k_clock clock_tai = {
+        .clock_getres           = posix_get_hrtimer_res,
+        .clock_get              = posix_get_tai,
+        .nsleep                 = common_nsleep,
+        .timer_create           = common_timer_create,
+        .timer_set              = common_timer_set,
+        .timer_get              = common_timer_get,
+        .timer_del              = common_timer_del,
+        .timer_rearm            = common_hrtimer_rearm,
+        .timer_forward          = common_hrtimer_forward,
+        .timer_remaining        = common_hrtimer_remaining,
+        .timer_try_to_cancel    = common_hrtimer_try_to_cancel,
+        .timer_arm              = common_hrtimer_arm,
+};
+
+static const struct k_clock clock_boottime = {
+        .clock_getres           = posix_get_hrtimer_res,
+        .clock_get              = posix_get_boottime,
+        .nsleep                 = common_nsleep,
+        .timer_create           = common_timer_create,
+        .timer_set              = common_timer_set,
+        .timer_get              = common_timer_get,
+        .timer_del              = common_timer_del,
+        .timer_rearm            = common_hrtimer_rearm,
+        .timer_forward          = common_hrtimer_forward,
+        .timer_remaining        = common_hrtimer_remaining,
+        .timer_try_to_cancel    = common_hrtimer_try_to_cancel,
+        .timer_arm              = common_hrtimer_arm,
+};
+
+static const struct k_clock * const posix_clocks[] = {
+        [CLOCK_REALTIME]                = &clock_realtime,
+        [CLOCK_MONOTONIC]               = &clock_monotonic,
+        [CLOCK_PROCESS_CPUTIME_ID]      = &clock_process,
+        [CLOCK_THREAD_CPUTIME_ID]       = &clock_thread,
+        [CLOCK_MONOTONIC_RAW]           = &clock_monotonic_raw,
+        [CLOCK_REALTIME_COARSE]         = &clock_realtime_coarse,
+        [CLOCK_MONOTONIC_COARSE]        = &clock_monotonic_coarse,
+        [CLOCK_BOOTTIME]                = &clock_boottime,
+        [CLOCK_REALTIME_ALARM]          = &alarm_clock,
+        [CLOCK_BOOTTIME_ALARM]          = &alarm_clock,
+        [CLOCK_TAI]                     = &clock_tai,
+};
+
+static const struct k_clock *clockid_to_kclock(const clockid_t id)
+{
+        if (id < 0)
+                return (id & CLOCKFD_MASK) == CLOCKFD ?
+                        &clock_posix_dynamic : &clock_posix_cpu;
+
+        if (id >= ARRAY_SIZE(posix_clocks) || !posix_clocks[id])
+                return NULL;
+        return posix_clocks[id];
 }
diff --git a/kernel/time/posix-timers.h b/kernel/time/posix-timers.h
new file mode 100644
index 000000000000..fb303c3be4d3
--- /dev/null
+++ b/kernel/time/posix-timers.h
@@ -0,0 +1,40 @@
+#define TIMER_RETRY 1
+
+struct k_clock {
+        int     (*clock_getres)(const clockid_t which_clock,
+                                struct timespec64 *tp);
+        int     (*clock_set)(const clockid_t which_clock,
+                             const struct timespec64 *tp);
+        int     (*clock_get)(const clockid_t which_clock,
+                             struct timespec64 *tp);
+        int     (*clock_adj)(const clockid_t which_clock, struct timex *tx);
+        int     (*timer_create)(struct k_itimer *timer);
+        int     (*nsleep)(const clockid_t which_clock, int flags,
+                          const struct timespec64 *);
+        int     (*timer_set)(struct k_itimer *timr, int flags,
+                             struct itimerspec64 *new_setting,
+                             struct itimerspec64 *old_setting);
+        int     (*timer_del)(struct k_itimer *timr);
+        void    (*timer_get)(struct k_itimer *timr,
+                             struct itimerspec64 *cur_setting);
+        void    (*timer_rearm)(struct k_itimer *timr);
+        int     (*timer_forward)(struct k_itimer *timr, ktime_t now);
+        ktime_t (*timer_remaining)(struct k_itimer *timr, ktime_t now);
+        int     (*timer_try_to_cancel)(struct k_itimer *timr);
+        void    (*timer_arm)(struct k_itimer *timr, ktime_t expires,
+                             bool absolute, bool sigev_none);
+};
+
+extern const struct k_clock clock_posix_cpu;
+extern const struct k_clock clock_posix_dynamic;
+extern const struct k_clock clock_process;
+extern const struct k_clock clock_thread;
+extern const struct k_clock alarm_clock;
+
+int posix_timer_event(struct k_itimer *timr, int si_private);
+
+void common_timer_get(struct k_itimer *timr, struct itimerspec64 *cur_setting);
+int common_timer_set(struct k_itimer *timr, int flags,
+                     struct itimerspec64 *new_setting,
+                     struct itimerspec64 *old_setting);
+int common_timer_del(struct k_itimer *timer);
diff --git a/kernel/time/tick-broadcast.c b/kernel/time/tick-broadcast.c
index 987e496bb51a..b398c2ea69b2 100644
--- a/kernel/time/tick-broadcast.c
+++ b/kernel/time/tick-broadcast.c
@@ -37,9 +37,11 @@ static int tick_broadcast_forced;
 static __cacheline_aligned_in_smp DEFINE_RAW_SPINLOCK(tick_broadcast_lock);
 
 #ifdef CONFIG_TICK_ONESHOT
+static void tick_broadcast_setup_oneshot(struct clock_event_device *bc);
 static void tick_broadcast_clear_oneshot(int cpu);
 static void tick_resume_broadcast_oneshot(struct clock_event_device *bc);
 #else
+static inline void tick_broadcast_setup_oneshot(struct clock_event_device *bc) { BUG(); }
 static inline void tick_broadcast_clear_oneshot(int cpu) { }
 static inline void tick_resume_broadcast_oneshot(struct clock_event_device *bc) { }
 #endif
@@ -867,7 +869,7 @@ static void tick_broadcast_init_next_event(struct cpumask *mask,
 /**
  * tick_broadcast_setup_oneshot - setup the broadcast device
  */
-void tick_broadcast_setup_oneshot(struct clock_event_device *bc)
+static void tick_broadcast_setup_oneshot(struct clock_event_device *bc)
 {
         int cpu = smp_processor_id();
 
diff --git a/kernel/time/tick-internal.h b/kernel/time/tick-internal.h
index f738251000fe..be0ac01f2e12 100644
--- a/kernel/time/tick-internal.h
+++ b/kernel/time/tick-internal.h
@@ -126,7 +126,6 @@ static inline int tick_check_oneshot_change(int allow_nohz) { return 0; }
 
 /* Functions related to oneshot broadcasting */
 #if defined(CONFIG_GENERIC_CLOCKEVENTS_BROADCAST) && defined(CONFIG_TICK_ONESHOT)
-extern void tick_broadcast_setup_oneshot(struct clock_event_device *bc);
 extern void tick_broadcast_switch_to_oneshot(void);
 extern void tick_shutdown_broadcast_oneshot(unsigned int cpu);
 extern int tick_broadcast_oneshot_active(void);
@@ -134,7 +133,6 @@ extern void tick_check_oneshot_broadcast_this_cpu(void);
 bool tick_broadcast_oneshot_available(void);
 extern struct cpumask *tick_get_broadcast_oneshot_mask(void);
 #else /* !(BROADCAST && ONESHOT): */
-static inline void tick_broadcast_setup_oneshot(struct clock_event_device *bc) { BUG(); }
 static inline void tick_broadcast_switch_to_oneshot(void) { }
 static inline void tick_shutdown_broadcast_oneshot(unsigned int cpu) { }
 static inline int tick_broadcast_oneshot_active(void) { return 0; }
diff --git a/kernel/time/tick-sched.c b/kernel/time/tick-sched.c
index 64c97fc130c4..c7a899c5ce64 100644
--- a/kernel/time/tick-sched.c
+++ b/kernel/time/tick-sched.c
@@ -150,6 +150,12 @@ static void tick_sched_handle(struct tick_sched *ts, struct pt_regs *regs)
                 touch_softlockup_watchdog_sched();
                 if (is_idle_task(current))
                         ts->idle_jiffies++;
+                /*
+                 * In case the current tick fired too early past its expected
+                 * expiration, make sure we don't bypass the next clock reprogramming
+                 * to the same deadline.
+                 */
+                ts->next_tick = 0;
         }
 #endif
         update_process_times(user_mode(regs));
@@ -554,7 +560,7 @@ static void tick_nohz_stop_idle(struct tick_sched *ts, ktime_t now)
         update_ts_time_stats(smp_processor_id(), ts, now, NULL);
         ts->idle_active = 0;
 
-        sched_clock_idle_wakeup_event(0);
+        sched_clock_idle_wakeup_event();
 }
 
 static ktime_t tick_nohz_start_idle(struct tick_sched *ts)
@@ -660,6 +666,12 @@ static void tick_nohz_restart(struct tick_sched *ts, ktime_t now)
                 hrtimer_start_expires(&ts->sched_timer, HRTIMER_MODE_ABS_PINNED);
         else
                 tick_program_event(hrtimer_get_expires(&ts->sched_timer), 1);
+
+        /*
+         * Reset to make sure next tick stop doesn't get fooled by past
+         * cached clock deadline.
+         */
+        ts->next_tick = 0;
 }
 
 static ktime_t tick_nohz_stop_sched_tick(struct tick_sched *ts,
@@ -701,8 +713,6 @@ static ktime_t tick_nohz_stop_sched_tick(struct tick_sched *ts,
          */
         delta = next_tick - basemono;
         if (delta <= (u64)TICK_NSEC) {
-                tick = 0;
-
                 /*
                  * Tell the timer code that the base is not idle, i.e. undo
                  * the effect of get_next_timer_interrupt():
@@ -712,23 +722,8 @@ static ktime_t tick_nohz_stop_sched_tick(struct tick_sched *ts,
                  * We've not stopped the tick yet, and there's a timer in the
                  * next period, so no point in stopping it either, bail.
                  */
-                if (!ts->tick_stopped)
-                        goto out;
-
-                /*
-                 * If, OTOH, we did stop it, but there's a pending (expired)
-                 * timer reprogram the timer hardware to fire now.
-                 *
-                 * We will not restart the tick proper, just prod the timer
-                 * hardware into firing an interrupt to process the pending
-                 * timers. Just like tick_irq_exit() will not restart the tick
-                 * for 'normal' interrupts.
-                 *
-                 * Only once we exit the idle loop will we re-enable the tick,
-                 * see tick_nohz_idle_exit().
-                 */
-                if (delta == 0) {
-                        tick_nohz_restart(ts, now);
+                if (!ts->tick_stopped) {
+                        tick = 0;
                         goto out;
                 }
         }
@@ -771,8 +766,16 @@ static ktime_t tick_nohz_stop_sched_tick(struct tick_sched *ts,
         tick = expires;
 
         /* Skip reprogram of event if its not changed */
-        if (ts->tick_stopped && (expires == dev->next_event))
-                goto out;
+        if (ts->tick_stopped && (expires == ts->next_tick)) {
+                /* Sanity check: make sure clockevent is actually programmed */
+                if (tick == KTIME_MAX || ts->next_tick == hrtimer_get_expires(&ts->sched_timer))
+                        goto out;
+
+                WARN_ON_ONCE(1);
+                printk_once("basemono: %llu ts->next_tick: %llu dev->next_event: %llu timer->active: %d timer->expires: %llu\n",
+                            basemono, ts->next_tick, dev->next_event,
+                            hrtimer_active(&ts->sched_timer), hrtimer_get_expires(&ts->sched_timer));
+        }
 
         /*
          * nohz_stop_sched_tick can be called several times before
@@ -782,8 +785,7 @@ static ktime_t tick_nohz_stop_sched_tick(struct tick_sched *ts,
          * the scheduler tick in nohz_restart_sched_tick.
          */
         if (!ts->tick_stopped) {
-                nohz_balance_enter_idle(cpu);
-                calc_load_enter_idle();
+                calc_load_nohz_start();
                 cpu_load_update_nohz_start();
 
                 ts->last_tick = hrtimer_get_expires(&ts->sched_timer);
@@ -791,6 +793,8 @@ static ktime_t tick_nohz_stop_sched_tick(struct tick_sched *ts,
                 trace_tick_stop(1, TICK_DEP_MASK_NONE);
         }
 
+        ts->next_tick = tick;
+
         /*
          * If the expiration time == KTIME_MAX, then we simply stop
          * the tick timer.
@@ -801,12 +805,17 @@ static ktime_t tick_nohz_stop_sched_tick(struct tick_sched *ts,
                 goto out;
         }
 
+        hrtimer_set_expires(&ts->sched_timer, tick);
+
         if (ts->nohz_mode == NOHZ_MODE_HIGHRES)
-                hrtimer_start(&ts->sched_timer, tick, HRTIMER_MODE_ABS_PINNED);
+                hrtimer_start_expires(&ts->sched_timer, HRTIMER_MODE_ABS_PINNED);
         else
                 tick_program_event(tick, 1);
 out:
-        /* Update the estimated sleep length */
+        /*
+         * Update the estimated sleep length until the next timer
+         * (not only the tick).
+         */
         ts->sleep_length = ktime_sub(dev->next_event, now);
         return tick;
 }
@@ -823,7 +832,7 @@ static void tick_nohz_restart_sched_tick(struct tick_sched *ts, ktime_t now)
          */
         timer_clear_idle();
 
-        calc_load_exit_idle();
+        calc_load_nohz_stop();
         touch_softlockup_watchdog_sched();
         /*
          * Cancel the scheduled timer and restore the tick
@@ -864,6 +873,11 @@ static bool can_stop_idle_tick(int cpu, struct tick_sched *ts)
         if (unlikely(!cpu_online(cpu))) {
                 if (cpu == tick_do_timer_cpu)
                         tick_do_timer_cpu = TICK_DO_TIMER_NONE;
+                /*
+                 * Make sure the CPU doesn't get fooled by obsolete tick
+                 * deadline if it comes back online later.
+                 */
+                ts->next_tick = 0;
                 return false;
         }
 
@@ -923,8 +937,10 @@ static void __tick_nohz_idle_enter(struct tick_sched *ts)
                         ts->idle_expires = expires;
                 }
 
-                if (!was_stopped && ts->tick_stopped)
+                if (!was_stopped && ts->tick_stopped) {
                         ts->idle_jiffies = ts->last_jiffies;
+                        nohz_balance_enter_idle(cpu);
+                }
         }
 }
 
@@ -1172,6 +1188,8 @@ static enum hrtimer_restart tick_sched_timer(struct hrtimer *timer)
          */
         if (regs)
                 tick_sched_handle(ts, regs);
+        else
+                ts->next_tick = 0;
 
         /* No need to reprogram if we are in idle or full dynticks mode */
         if (unlikely(ts->tick_stopped))
diff --git a/kernel/time/tick-sched.h b/kernel/time/tick-sched.h
index bf38226e5c17..075444e3d48e 100644
--- a/kernel/time/tick-sched.h
+++ b/kernel/time/tick-sched.h
@@ -27,6 +27,7 @@ enum tick_nohz_mode {
  *                      timer is modified for nohz sleeps. This is necessary
  *                      to resume the tick timer operation in the timeline
  *                      when the CPU returns from nohz sleep.
+ * @next_tick:          Next tick to be fired when in dynticks mode.
  * @tick_stopped:       Indicator that the idle tick has been stopped
  * @idle_jiffies:       jiffies at the entry to idle for idle time accounting
  * @idle_calls:         Total number of idle calls
@@ -44,6 +45,7 @@ struct tick_sched {
         unsigned long                   check_clocks;
         enum tick_nohz_mode             nohz_mode;
         ktime_t                         last_tick;
+        ktime_t                         next_tick;
         int                             inidle;
         int                             tick_stopped;
         unsigned long                   idle_jiffies;
diff --git a/kernel/time/time.c b/kernel/time/time.c
index 49c73c6ed648..44a8c1402133 100644
--- a/kernel/time/time.c
+++ b/kernel/time/time.c
@@ -39,6 +39,7 @@
 #include <linux/ptrace.h>
 
 #include <linux/uaccess.h>
+#include <linux/compat.h>
 #include <asm/unistd.h>
 
 #include <generated/timeconst.h>
@@ -99,6 +100,47 @@ SYSCALL_DEFINE1(stime, time_t __user *, tptr)
 
 #endif /* __ARCH_WANT_SYS_TIME */
 
+#ifdef CONFIG_COMPAT
+#ifdef __ARCH_WANT_COMPAT_SYS_TIME
+
+/* compat_time_t is a 32 bit "long" and needs to get converted. */
+COMPAT_SYSCALL_DEFINE1(time, compat_time_t __user *, tloc)
+{
+        struct timeval tv;
+        compat_time_t i;
+
+        do_gettimeofday(&tv);
+        i = tv.tv_sec;
+
+        if (tloc) {
+                if (put_user(i,tloc))
+                        return -EFAULT;
+        }
+        force_successful_syscall_return();
+        return i;
+}
+
+COMPAT_SYSCALL_DEFINE1(stime, compat_time_t __user *, tptr)
+{
+        struct timespec tv;
+        int err;
+
+        if (get_user(tv.tv_sec, tptr))
+                return -EFAULT;
+
+        tv.tv_nsec = 0;
+
+        err = security_settime(&tv, NULL);
+        if (err)
+                return err;
+
+        do_settimeofday(&tv);
+        return 0;
+}
+
+#endif /* __ARCH_WANT_COMPAT_SYS_TIME */
+#endif
+
 SYSCALL_DEFINE2(gettimeofday, struct timeval __user *, tv,
                 struct timezone __user *, tz)
 {
@@ -215,6 +257,47 @@ SYSCALL_DEFINE2(settimeofday, struct timeval __user *, tv,
         return do_sys_settimeofday64(tv ? &new_ts : NULL, tz ? &new_tz : NULL);
 }
 
+#ifdef CONFIG_COMPAT
+COMPAT_SYSCALL_DEFINE2(gettimeofday, struct compat_timeval __user *, tv,
+                       struct timezone __user *, tz)
+{
+        if (tv) {
+                struct timeval ktv;
+
+                do_gettimeofday(&ktv);
+                if (compat_put_timeval(&ktv, tv))
+                        return -EFAULT;
+        }
+        if (tz) {
+                if (copy_to_user(tz, &sys_tz, sizeof(sys_tz)))
+                        return -EFAULT;
+        }
+
+        return 0;
+}
+
+COMPAT_SYSCALL_DEFINE2(settimeofday, struct compat_timeval __user *, tv,
+                       struct timezone __user *, tz)
+{
+        struct timespec64 new_ts;
+        struct timeval user_tv;
+        struct timezone new_tz;
+
+        if (tv) {
+                if (compat_get_timeval(&user_tv, tv))
+                        return -EFAULT;
+                new_ts.tv_sec = user_tv.tv_sec;
+                new_ts.tv_nsec = user_tv.tv_usec * NSEC_PER_USEC;
+        }
+        if (tz) {
+                if (copy_from_user(&new_tz, tz, sizeof(*tz)))
+                        return -EFAULT;
+        }
+
+        return do_sys_settimeofday64(tv ? &new_ts : NULL, tz ? &new_tz : NULL);
+}
+#endif
+
 SYSCALL_DEFINE1(adjtimex, struct timex __user *, txc_p)
 {
         struct timex txc;               /* Local copy of parameter */
@@ -224,12 +307,33 @@ SYSCALL_DEFINE1(adjtimex, struct timex __user *, txc_p)
          * structure. But bear in mind that the structures
          * may change
          */
-        if(copy_from_user(&txc, txc_p, sizeof(struct timex)))
+        if (copy_from_user(&txc, txc_p, sizeof(struct timex)))
                 return -EFAULT;
         ret = do_adjtimex(&txc);
         return copy_to_user(txc_p, &txc, sizeof(struct timex)) ? -EFAULT : ret;
 }
 
+#ifdef CONFIG_COMPAT
+
+COMPAT_SYSCALL_DEFINE1(adjtimex, struct compat_timex __user *, utp)
+{
+        struct timex txc;
+        int err, ret;
+
+        err = compat_get_timex(&txc, utp);
+        if (err)
+                return err;
+
+        ret = do_adjtimex(&txc);
+
+        err = compat_put_timex(utp, &txc);
+        if (err)
+                return err;
+
+        return ret;
+}
+#endif
+
 /*
  * Convert jiffies to milliseconds and back.
  *
@@ -786,3 +890,61 @@ struct timespec64 timespec64_add_safe(const struct timespec64 lhs,
 
         return res;
 }
+
+int get_timespec64(struct timespec64 *ts,
+                   const struct timespec __user *uts)
+{
+        struct timespec kts;
+        int ret;
+
+        ret = copy_from_user(&kts, uts, sizeof(kts));
+        if (ret)
+                return -EFAULT;
+
+        ts->tv_sec = kts.tv_sec;
+        ts->tv_nsec = kts.tv_nsec;
+
+        return 0;
+}
+EXPORT_SYMBOL_GPL(get_timespec64);
+
+int put_timespec64(const struct timespec64 *ts,
+                   struct timespec __user *uts)
+{
+        struct timespec kts = {
+                .tv_sec = ts->tv_sec,
+                .tv_nsec = ts->tv_nsec
+        };
+        return copy_to_user(uts, &kts, sizeof(kts)) ? -EFAULT : 0;
+}
+EXPORT_SYMBOL_GPL(put_timespec64);
+
+int get_itimerspec64(struct itimerspec64 *it,
+                        const struct itimerspec __user *uit)
+{
+        int ret;
+
+        ret = get_timespec64(&it->it_interval, &uit->it_interval);
+        if (ret)
+                return ret;
+
+        ret = get_timespec64(&it->it_value, &uit->it_value);
+
+        return ret;
+}
+EXPORT_SYMBOL_GPL(get_itimerspec64);
+
+int put_itimerspec64(const struct itimerspec64 *it,
+                        struct itimerspec __user *uit)
+{
+        int ret;
+
+        ret = put_timespec64(&it->it_interval, &uit->it_interval);
+        if (ret)
+                return ret;
+
+        ret = put_timespec64(&it->it_value, &uit->it_value);
+
+        return ret;
+}
+EXPORT_SYMBOL_GPL(put_itimerspec64);
diff --git a/kernel/time/timekeeping.c b/kernel/time/timekeeping.c
index 9652bc57fd09..cedafa008de5 100644
--- a/kernel/time/timekeeping.c
+++ b/kernel/time/timekeeping.c
@@ -72,6 +72,10 @@ static inline void tk_normalize_xtime(struct timekeeper *tk)
                 tk->tkr_mono.xtime_nsec -= (u64)NSEC_PER_SEC << tk->tkr_mono.shift;
                 tk->xtime_sec++;
         }
+        while (tk->tkr_raw.xtime_nsec >= ((u64)NSEC_PER_SEC << tk->tkr_raw.shift)) {
+                tk->tkr_raw.xtime_nsec -= (u64)NSEC_PER_SEC << tk->tkr_raw.shift;
+                tk->raw_sec++;
+        }
 }
 
 static inline struct timespec64 tk_xtime(struct timekeeper *tk)
@@ -118,6 +122,26 @@ static inline void tk_update_sleep_time(struct timekeeper *tk, ktime_t delta)
         tk->offs_boot = ktime_add(tk->offs_boot, delta);
 }
 
+/*
+ * tk_clock_read - atomic clocksource read() helper
+ *
+ * This helper is necessary to use in the read paths because, while the
+ * seqlock ensures we don't return a bad value while structures are updated,
+ * it doesn't protect from potential crashes. There is the possibility that
+ * the tkr's clocksource may change between the read reference, and the
+ * clock reference passed to the read function.  This can cause crashes if
+ * the wrong clocksource is passed to the wrong read function.
+ * This isn't necessary to use when holding the timekeeper_lock or doing
+ * a read of the fast-timekeeper tkrs (which is protected by its own locking
+ * and update logic).
+ */
+static inline u64 tk_clock_read(struct tk_read_base *tkr)
+{
+        struct clocksource *clock = READ_ONCE(tkr->clock);
+
+        return clock->read(clock);
+}
+
 #ifdef CONFIG_DEBUG_TIMEKEEPING
 #define WARNING_FREQ (HZ*300) /* 5 minute rate-limiting */
 
@@ -175,7 +199,7 @@ static inline u64 timekeeping_get_delta(struct tk_read_base *tkr)
          */
         do {
                 seq = read_seqcount_begin(&tk_core.seq);
-                now = tkr->read(tkr->clock);
+                now = tk_clock_read(tkr);
                 last = tkr->cycle_last;
                 mask = tkr->mask;
                 max = tkr->clock->max_cycles;
@@ -209,7 +233,7 @@ static inline u64 timekeeping_get_delta(struct tk_read_base *tkr)
         u64 cycle_now, delta;
 
         /* read clocksource */
-        cycle_now = tkr->read(tkr->clock);
+        cycle_now = tk_clock_read(tkr);
 
         /* calculate the delta since the last update_wall_time */
         delta = clocksource_delta(cycle_now, tkr->cycle_last, tkr->mask);
@@ -238,12 +262,10 @@ static void tk_setup_internals(struct timekeeper *tk, struct clocksource *clock)
         ++tk->cs_was_changed_seq;
         old_clock = tk->tkr_mono.clock;
         tk->tkr_mono.clock = clock;
-        tk->tkr_mono.read = clock->read;
         tk->tkr_mono.mask = clock->mask;
-        tk->tkr_mono.cycle_last = tk->tkr_mono.read(clock);
+        tk->tkr_mono.cycle_last = tk_clock_read(&tk->tkr_mono);
 
         tk->tkr_raw.clock = clock;
-        tk->tkr_raw.read = clock->read;
         tk->tkr_raw.mask = clock->mask;
         tk->tkr_raw.cycle_last = tk->tkr_mono.cycle_last;
 
@@ -262,17 +284,19 @@ static void tk_setup_internals(struct timekeeper *tk, struct clocksource *clock)
         /* Go back from cycles -> shifted ns */
         tk->xtime_interval = interval * clock->mult;
         tk->xtime_remainder = ntpinterval - tk->xtime_interval;
-        tk->raw_interval = (interval * clock->mult) >> clock->shift;
+        tk->raw_interval = interval * clock->mult;
 
          /* if changing clocks, convert xtime_nsec shift units */
         if (old_clock) {
                 int shift_change = clock->shift - old_clock->shift;
-                if (shift_change < 0)
+                if (shift_change < 0) {
                         tk->tkr_mono.xtime_nsec >>= -shift_change;
-                else
+                        tk->tkr_raw.xtime_nsec >>= -shift_change;
+                } else {
                         tk->tkr_mono.xtime_nsec <<= shift_change;
+                        tk->tkr_raw.xtime_nsec <<= shift_change;
+                }
         }
-        tk->tkr_raw.xtime_nsec = 0;
 
         tk->tkr_mono.shift = clock->shift;
         tk->tkr_raw.shift = clock->shift;
@@ -404,7 +428,7 @@ static __always_inline u64 __ktime_get_fast_ns(struct tk_fast *tkf)
 
                 now += timekeeping_delta_to_ns(tkr,
                                 clocksource_delta(
-                                        tkr->read(tkr->clock),
+                                        tk_clock_read(tkr),
                                         tkr->cycle_last,
                                         tkr->mask));
         } while (read_seqcount_retry(&tkf->seq, seq));
@@ -461,6 +485,10 @@ static u64 dummy_clock_read(struct clocksource *cs)
         return cycles_at_suspend;
 }
 
+static struct clocksource dummy_clock = {
+        .read = dummy_clock_read,
+};
+
 /**
  * halt_fast_timekeeper - Prevent fast timekeeper from accessing clocksource.
  * @tk: Timekeeper to snapshot.
@@ -477,17 +505,18 @@ static void halt_fast_timekeeper(struct timekeeper *tk)
         struct tk_read_base *tkr = &tk->tkr_mono;
 
         memcpy(&tkr_dummy, tkr, sizeof(tkr_dummy));
-        cycles_at_suspend = tkr->read(tkr->clock);
-        tkr_dummy.read = dummy_clock_read;
+        cycles_at_suspend = tk_clock_read(tkr);
+        tkr_dummy.clock = &dummy_clock;
         update_fast_timekeeper(&tkr_dummy, &tk_fast_mono);
 
         tkr = &tk->tkr_raw;
         memcpy(&tkr_dummy, tkr, sizeof(tkr_dummy));
-        tkr_dummy.read = dummy_clock_read;
+        tkr_dummy.clock = &dummy_clock;
         update_fast_timekeeper(&tkr_dummy, &tk_fast_raw);
 }
 
 #ifdef CONFIG_GENERIC_TIME_VSYSCALL_OLD
+#warning Please contact your maintainers, as GENERIC_TIME_VSYSCALL_OLD compatibity will disappear soon.
 
 static inline void update_vsyscall(struct timekeeper *tk)
 {
@@ -597,9 +626,6 @@ static inline void tk_update_ktime_data(struct timekeeper *tk)
         nsec = (u32) tk->wall_to_monotonic.tv_nsec;
         tk->tkr_mono.base = ns_to_ktime(seconds * NSEC_PER_SEC + nsec);
 
-        /* Update the monotonic raw base */
-        tk->tkr_raw.base = timespec64_to_ktime(tk->raw_time);
-
         /*
          * The sum of the nanoseconds portions of xtime and
          * wall_to_monotonic can be greater/equal one second. Take
@@ -609,6 +635,11 @@ static inline void tk_update_ktime_data(struct timekeeper *tk)
         if (nsec >= NSEC_PER_SEC)
                 seconds++;
         tk->ktime_sec = seconds;
+
+        /* Update the monotonic raw base */
+        seconds = tk->raw_sec;
+        nsec = (u32)(tk->tkr_raw.xtime_nsec >> tk->tkr_raw.shift);
+        tk->tkr_raw.base = ns_to_ktime(seconds * NSEC_PER_SEC + nsec);
 }
 
 /* must hold timekeeper_lock */
@@ -649,11 +680,9 @@ static void timekeeping_update(struct timekeeper *tk, unsigned int action)
  */
 static void timekeeping_forward_now(struct timekeeper *tk)
 {
-        struct clocksource *clock = tk->tkr_mono.clock;
         u64 cycle_now, delta;
-        u64 nsec;
 
-        cycle_now = tk->tkr_mono.read(clock);
+        cycle_now = tk_clock_read(&tk->tkr_mono);
         delta = clocksource_delta(cycle_now, tk->tkr_mono.cycle_last, tk->tkr_mono.mask);
         tk->tkr_mono.cycle_last = cycle_now;
         tk->tkr_raw.cycle_last  = cycle_now;
@@ -663,10 +692,13 @@ static void timekeeping_forward_now(struct timekeeper *tk)
         /* If arch requires, add in get_arch_timeoffset() */
         tk->tkr_mono.xtime_nsec += (u64)arch_gettimeoffset() << tk->tkr_mono.shift;
 
-        tk_normalize_xtime(tk);
 
-        nsec = clocksource_cyc2ns(delta, tk->tkr_raw.mult, tk->tkr_raw.shift);
-        timespec64_add_ns(&tk->raw_time, nsec);
+        tk->tkr_raw.xtime_nsec += delta * tk->tkr_raw.mult;
+
+        /* If arch requires, add in get_arch_timeoffset() */
+        tk->tkr_raw.xtime_nsec += (u64)arch_gettimeoffset() << tk->tkr_raw.shift;
+
+        tk_normalize_xtime(tk);
 }
 
 /**
@@ -929,8 +961,7 @@ void ktime_get_snapshot(struct system_time_snapshot *systime_snapshot)
 
         do {
                 seq = read_seqcount_begin(&tk_core.seq);
-
-                now = tk->tkr_mono.read(tk->tkr_mono.clock);
+                now = tk_clock_read(&tk->tkr_mono);
                 systime_snapshot->cs_was_changed_seq = tk->cs_was_changed_seq;
                 systime_snapshot->clock_was_set_seq = tk->clock_was_set_seq;
                 base_real = ktime_add(tk->tkr_mono.base,
@@ -1108,7 +1139,7 @@ int get_device_system_crosststamp(int (*get_time_fn)
                  * Check whether the system counter value provided by the
                  * device driver is on the current timekeeping interval.
                  */
-                now = tk->tkr_mono.read(tk->tkr_mono.clock);
+                now = tk_clock_read(&tk->tkr_mono);
                 interval_start = tk->tkr_mono.cycle_last;
                 if (!cycle_between(interval_start, cycles, now)) {
                         clock_was_set_seq = tk->clock_was_set_seq;
@@ -1353,19 +1384,18 @@ int timekeeping_notify(struct clocksource *clock)
 void getrawmonotonic64(struct timespec64 *ts)
 {
         struct timekeeper *tk = &tk_core.timekeeper;
-        struct timespec64 ts64;
         unsigned long seq;
         u64 nsecs;
 
         do {
                 seq = read_seqcount_begin(&tk_core.seq);
+                ts->tv_sec = tk->raw_sec;
                 nsecs = timekeeping_get_ns(&tk->tkr_raw);
-                ts64 = tk->raw_time;
 
         } while (read_seqcount_retry(&tk_core.seq, seq));
 
-        timespec64_add_ns(&ts64, nsecs);
-        *ts = ts64;
+        ts->tv_nsec = 0;
+        timespec64_add_ns(ts, nsecs);
 }
 EXPORT_SYMBOL(getrawmonotonic64);
 
@@ -1489,8 +1519,7 @@ void __init timekeeping_init(void)
         tk_setup_internals(tk, clock);
 
         tk_set_xtime(tk, &now);
-        tk->raw_time.tv_sec = 0;
-        tk->raw_time.tv_nsec = 0;
+        tk->raw_sec = 0;
         if (boot.tv_sec == 0 && boot.tv_nsec == 0)
                 boot = tk_xtime(tk);
 
@@ -1629,7 +1658,7 @@ void timekeeping_resume(void)
          * The less preferred source will only be tried if there is no better
          * usable source. The rtc part is handled separately in rtc core code.
          */
-        cycle_now = tk->tkr_mono.read(clock);
+        cycle_now = tk_clock_read(&tk->tkr_mono);
         if ((clock->flags & CLOCK_SOURCE_SUSPEND_NONSTOP) &&
                 cycle_now > tk->tkr_mono.cycle_last) {
                 u64 nsec, cyc_delta;
@@ -1976,7 +2005,7 @@ static u64 logarithmic_accumulation(struct timekeeper *tk, u64 offset,
                                     u32 shift, unsigned int *clock_set)
 {
         u64 interval = tk->cycle_interval << shift;
-        u64 raw_nsecs;
+        u64 snsec_per_sec;
 
         /* If the offset is smaller than a shifted interval, do nothing */
         if (offset < interval)
@@ -1991,14 +2020,12 @@ static u64 logarithmic_accumulation(struct timekeeper *tk, u64 offset,
         *clock_set |= accumulate_nsecs_to_secs(tk);
 
         /* Accumulate raw time */
-        raw_nsecs = (u64)tk->raw_interval << shift;
-        raw_nsecs += tk->raw_time.tv_nsec;
-        if (raw_nsecs >= NSEC_PER_SEC) {
-                u64 raw_secs = raw_nsecs;
-                raw_nsecs = do_div(raw_secs, NSEC_PER_SEC);
-                tk->raw_time.tv_sec += raw_secs;
+        tk->tkr_raw.xtime_nsec += tk->raw_interval << shift;
+        snsec_per_sec = (u64)NSEC_PER_SEC << tk->tkr_raw.shift;
+        while (tk->tkr_raw.xtime_nsec >= snsec_per_sec) {
+                tk->tkr_raw.xtime_nsec -= snsec_per_sec;
+                tk->raw_sec++;
         }
-        tk->raw_time.tv_nsec = raw_nsecs;
 
         /* Accumulate error between NTP and clock interval */
         tk->ntp_error += tk->ntp_tick << shift;
@@ -2030,7 +2057,7 @@ void update_wall_time(void)
 #ifdef CONFIG_ARCH_USES_GETTIMEOFFSET
         offset = real_tk->cycle_interval;
 #else
-        offset = clocksource_delta(tk->tkr_mono.read(tk->tkr_mono.clock),
+        offset = clocksource_delta(tk_clock_read(&tk->tkr_mono),
                                    tk->tkr_mono.cycle_last, tk->tkr_mono.mask);
 #endif
 
diff --git a/kernel/time/timer.c b/kernel/time/timer.c
index 152a706ef8b8..71ce3f4eead3 100644
--- a/kernel/time/timer.c
+++ b/kernel/time/timer.c
@@ -195,7 +195,7 @@ EXPORT_SYMBOL(jiffies_64);
 #endif
 
 struct timer_base {
-        spinlock_t              lock;
+        raw_spinlock_t          lock;
         struct timer_list       *running_timer;
         unsigned long           clk;
         unsigned long           next_expiry;
@@ -913,10 +913,10 @@ static struct timer_base *lock_timer_base(struct timer_list *timer,
 
                 if (!(tf & TIMER_MIGRATING)) {
                         base = get_timer_base(tf);
-                        spin_lock_irqsave(&base->lock, *flags);
+                        raw_spin_lock_irqsave(&base->lock, *flags);
                         if (timer->flags == tf)
                                 return base;
-                        spin_unlock_irqrestore(&base->lock, *flags);
+                        raw_spin_unlock_irqrestore(&base->lock, *flags);
                 }
                 cpu_relax();
         }
@@ -986,9 +986,9 @@ __mod_timer(struct timer_list *timer, unsigned long expires, bool pending_only)
                         /* See the comment in lock_timer_base() */
                         timer->flags |= TIMER_MIGRATING;
 
-                        spin_unlock(&base->lock);
+                        raw_spin_unlock(&base->lock);
                         base = new_base;
-                        spin_lock(&base->lock);
+                        raw_spin_lock(&base->lock);
                         WRITE_ONCE(timer->flags,
                                    (timer->flags & ~TIMER_BASEMASK) | base->cpu);
                 }
@@ -1013,7 +1013,7 @@ __mod_timer(struct timer_list *timer, unsigned long expires, bool pending_only)
         }
 
 out_unlock:
-        spin_unlock_irqrestore(&base->lock, flags);
+        raw_spin_unlock_irqrestore(&base->lock, flags);
 
         return ret;
 }
@@ -1106,16 +1106,16 @@ void add_timer_on(struct timer_list *timer, int cpu)
         if (base != new_base) {
                 timer->flags |= TIMER_MIGRATING;
 
-                spin_unlock(&base->lock);
+                raw_spin_unlock(&base->lock);
                 base = new_base;
-                spin_lock(&base->lock);
+                raw_spin_lock(&base->lock);
                 WRITE_ONCE(timer->flags,
                            (timer->flags & ~TIMER_BASEMASK) | cpu);
         }
 
         debug_activate(timer, timer->expires);
         internal_add_timer(base, timer);
-        spin_unlock_irqrestore(&base->lock, flags);
+        raw_spin_unlock_irqrestore(&base->lock, flags);
 }
 EXPORT_SYMBOL_GPL(add_timer_on);
 
@@ -1141,7 +1141,7 @@ int del_timer(struct timer_list *timer)
         if (timer_pending(timer)) {
                 base = lock_timer_base(timer, &flags);
                 ret = detach_if_pending(timer, base, true);
-                spin_unlock_irqrestore(&base->lock, flags);
+                raw_spin_unlock_irqrestore(&base->lock, flags);
         }
 
         return ret;
@@ -1150,7 +1150,7 @@ EXPORT_SYMBOL(del_timer);
 
 /**
  * try_to_del_timer_sync - Try to deactivate a timer
- * @timer: timer do del
+ * @timer: timer to delete
  *
  * This function tries to deactivate a timer. Upon successful (ret >= 0)
  * exit the timer is not queued and the handler is not running on any CPU.
@@ -1168,7 +1168,7 @@ int try_to_del_timer_sync(struct timer_list *timer)
         if (base->running_timer != timer)
                 ret = detach_if_pending(timer, base, true);
 
-        spin_unlock_irqrestore(&base->lock, flags);
+        raw_spin_unlock_irqrestore(&base->lock, flags);
 
         return ret;
 }
@@ -1299,13 +1299,13 @@ static void expire_timers(struct timer_base *base, struct hlist_head *head)
                 data = timer->data;
 
                 if (timer->flags & TIMER_IRQSAFE) {
-                        spin_unlock(&base->lock);
+                        raw_spin_unlock(&base->lock);
                         call_timer_fn(timer, fn, data);
-                        spin_lock(&base->lock);
+                        raw_spin_lock(&base->lock);
                 } else {
-                        spin_unlock_irq(&base->lock);
+                        raw_spin_unlock_irq(&base->lock);
                         call_timer_fn(timer, fn, data);
-                        spin_lock_irq(&base->lock);
+                        raw_spin_lock_irq(&base->lock);
                 }
         }
 }
@@ -1474,7 +1474,7 @@ u64 get_next_timer_interrupt(unsigned long basej, u64 basem)
         if (cpu_is_offline(smp_processor_id()))
                 return expires;
 
-        spin_lock(&base->lock);
+        raw_spin_lock(&base->lock);
         nextevt = __next_timer_interrupt(base);
         is_max_delta = (nextevt == base->clk + NEXT_TIMER_MAX_DELTA);
         base->next_expiry = nextevt;
@@ -1502,7 +1502,7 @@ u64 get_next_timer_interrupt(unsigned long basej, u64 basem)
                 if ((expires - basem) > TICK_NSEC)
                         base->is_idle = true;
         }
-        spin_unlock(&base->lock);
+        raw_spin_unlock(&base->lock);
 
         return cmp_next_hrtimer_event(basem, expires);
 }
@@ -1590,7 +1590,7 @@ static inline void __run_timers(struct timer_base *base)
         if (!time_after_eq(jiffies, base->clk))
                 return;
 
-        spin_lock_irq(&base->lock);
+        raw_spin_lock_irq(&base->lock);
 
         while (time_after_eq(jiffies, base->clk)) {
 
@@ -1601,7 +1601,7 @@ static inline void __run_timers(struct timer_base *base)
                         expire_timers(base, heads + levels);
         }
         base->running_timer = NULL;
-        spin_unlock_irq(&base->lock);
+        raw_spin_unlock_irq(&base->lock);
 }
 
 /*
@@ -1786,16 +1786,16 @@ int timers_dead_cpu(unsigned int cpu)
                  * The caller is globally serialized and nobody else
                  * takes two locks at once, deadlock is not possible.
                  */
-                spin_lock_irq(&new_base->lock);
-                spin_lock_nested(&old_base->lock, SINGLE_DEPTH_NESTING);
+                raw_spin_lock_irq(&new_base->lock);
+                raw_spin_lock_nested(&old_base->lock, SINGLE_DEPTH_NESTING);
 
                 BUG_ON(old_base->running_timer);
 
                 for (i = 0; i < WHEEL_SIZE; i++)
                         migrate_timer_list(new_base, old_base->vectors + i);
 
-                spin_unlock(&old_base->lock);
-                spin_unlock_irq(&new_base->lock);
+                raw_spin_unlock(&old_base->lock);
+                raw_spin_unlock_irq(&new_base->lock);
                 put_cpu_ptr(&timer_bases);
         }
         return 0;
@@ -1811,7 +1811,7 @@ static void __init init_timer_cpu(int cpu)
         for (i = 0; i < NR_BASES; i++) {
                 base = per_cpu_ptr(&timer_bases[i], cpu);
                 base->cpu = cpu;
-                spin_lock_init(&base->lock);
+                raw_spin_lock_init(&base->lock);
                 base->clk = jiffies;
         }
 }
diff --git a/kernel/trace/Kconfig b/kernel/trace/Kconfig
index 7e06f04e98fe..434c840e2d82 100644
--- a/kernel/trace/Kconfig
+++ b/kernel/trace/Kconfig
@@ -667,30 +667,30 @@ config RING_BUFFER_STARTUP_TEST
 
          If unsure, say N
 
-config TRACE_ENUM_MAP_FILE
-       bool "Show enum mappings for trace events"
+config TRACE_EVAL_MAP_FILE
+       bool "Show eval mappings for trace events"
        depends on TRACING
        help
-        The "print fmt" of the trace events will show the enum names instead
-        of their values. This can cause problems for user space tools that
-        use this string to parse the raw data as user space does not know
+        The "print fmt" of the trace events will show the enum/sizeof names
+        instead of their values. This can cause problems for user space tools
+        that use this string to parse the raw data as user space does not know
         how to convert the string to its value.
 
         To fix this, there's a special macro in the kernel that can be used
-        to convert the enum into its value. If this macro is used, then the
-        print fmt strings will have the enums converted to their values.
+        to convert an enum/sizeof into its value. If this macro is used, then
+        the print fmt strings will be converted to their values.
 
         If something does not get converted properly, this option can be
-        used to show what enums the kernel tried to convert.
+        used to show what enums/sizeof the kernel tried to convert.
 
-        This option is for debugging the enum conversions. A file is created
-        in the tracing directory called "enum_map" that will show the enum
+        This option is for debugging the conversions. A file is created
+        in the tracing directory called "eval_map" that will show the
         names matched with their values and what trace event system they
         belong too.
 
         Normally, the mapping of the strings to values will be freed after
         boot up or module load. With this option, they will not be freed, as
-        they are needed for the "enum_map" file. Enabling this option will
+        they are needed for the "eval_map" file. Enabling this option will
         increase the memory footprint of the running kernel.
 
         If unsure, say N
diff --git a/kernel/trace/blktrace.c b/kernel/trace/blktrace.c
index 193c5f5e3f79..bc364f86100a 100644
--- a/kernel/trace/blktrace.c
+++ b/kernel/trace/blktrace.c
@@ -867,7 +867,7 @@ static void blk_add_trace_split(void *ignore,
 
                 __blk_add_trace(bt, bio->bi_iter.bi_sector,
                                 bio->bi_iter.bi_size, bio_op(bio), bio->bi_opf,
-                                BLK_TA_SPLIT, bio->bi_error, sizeof(rpdu),
+                                BLK_TA_SPLIT, bio->bi_status, sizeof(rpdu),
                                 &rpdu);
         }
 }
@@ -900,7 +900,7 @@ static void blk_add_trace_bio_remap(void *ignore,
         r.sector_from = cpu_to_be64(from);
 
         __blk_add_trace(bt, bio->bi_iter.bi_sector, bio->bi_iter.bi_size,
-                        bio_op(bio), bio->bi_opf, BLK_TA_REMAP, bio->bi_error,
+                        bio_op(bio), bio->bi_opf, BLK_TA_REMAP, bio->bi_status,
                         sizeof(r), &r);
 }
 
diff --git a/kernel/trace/bpf_trace.c b/kernel/trace/bpf_trace.c
index 460a031c77e5..37385193a608 100644
--- a/kernel/trace/bpf_trace.c
+++ b/kernel/trace/bpf_trace.c
@@ -122,8 +122,8 @@ static const struct bpf_func_proto *bpf_get_probe_write_proto(void)
 }
 
 /*
- * limited trace_printk()
- * only %d %u %x %ld %lu %lx %lld %llu %llx %p %s conversion specifiers allowed
+ * Only limited trace_printk() conversion specifiers allowed:
+ * %d %i %u %x %ld %li %lu %lx %lld %lli %llu %llx %p %s
  */
 BPF_CALL_5(bpf_trace_printk, char *, fmt, u32, fmt_size, u64, arg1,
            u64, arg2, u64, arg3)
@@ -198,7 +198,8 @@ BPF_CALL_5(bpf_trace_printk, char *, fmt, u32, fmt_size, u64, arg1,
                         i++;
                 }
 
-                if (fmt[i] != 'd' && fmt[i] != 'u' && fmt[i] != 'x')
+                if (fmt[i] != 'i' && fmt[i] != 'd' &&
+                    fmt[i] != 'u' && fmt[i] != 'x')
                         return -EINVAL;
                 fmt_cnt++;
         }
@@ -234,7 +235,8 @@ BPF_CALL_2(bpf_perf_event_read, struct bpf_map *, map, u64, flags)
         unsigned int cpu = smp_processor_id();
         u64 index = flags & BPF_F_INDEX_MASK;
         struct bpf_event_entry *ee;
-        struct perf_event *event;
+        u64 value = 0;
+        int err;
 
         if (unlikely(flags & ~(BPF_F_INDEX_MASK)))
                 return -EINVAL;
@@ -247,21 +249,14 @@ BPF_CALL_2(bpf_perf_event_read, struct bpf_map *, map, u64, flags)
         if (!ee)
                 return -ENOENT;
 
-        event = ee->event;
-        if (unlikely(event->attr.type != PERF_TYPE_HARDWARE &&
-                     event->attr.type != PERF_TYPE_RAW))
-                return -EINVAL;
-
-        /* make sure event is local and doesn't have pmu::count */
-        if (unlikely(event->oncpu != cpu || event->pmu->count))
-                return -EINVAL;
-
+        err = perf_event_read_local(ee->event, &value);
         /*
-         * we don't know if the function is run successfully by the
-         * return value. It can be judged in other places, such as
-         * eBPF programs.
+         * this api is ugly since we miss [-22..-2] range of valid
+         * counter values, but that's uapi
          */
-        return perf_event_read_local(event);
+        if (err)
+                return err;
+        return value;
 }
 
 static const struct bpf_func_proto bpf_perf_event_read_proto = {
@@ -272,14 +267,16 @@ static const struct bpf_func_proto bpf_perf_event_read_proto = {
         .arg2_type      = ARG_ANYTHING,
 };
 
+static DEFINE_PER_CPU(struct perf_sample_data, bpf_sd);
+
 static __always_inline u64
 __bpf_perf_event_output(struct pt_regs *regs, struct bpf_map *map,
                         u64 flags, struct perf_raw_record *raw)
 {
         struct bpf_array *array = container_of(map, struct bpf_array, map);
+        struct perf_sample_data *sd = this_cpu_ptr(&bpf_sd);
         unsigned int cpu = smp_processor_id();
         u64 index = flags & BPF_F_INDEX_MASK;
-        struct perf_sample_data sample_data;
         struct bpf_event_entry *ee;
         struct perf_event *event;
 
@@ -300,9 +297,9 @@ __bpf_perf_event_output(struct pt_regs *regs, struct bpf_map *map,
         if (unlikely(event->oncpu != cpu))
                 return -EOPNOTSUPP;
 
-        perf_sample_data_init(&sample_data, 0, 0);
-        sample_data.raw = raw;
-        perf_event_output(event, &sample_data, regs);
+        perf_sample_data_init(sd, 0, 0);
+        sd->raw = raw;
+        perf_event_output(event, sd, regs);
         return 0;
 }
 
@@ -483,7 +480,7 @@ static const struct bpf_func_proto *kprobe_prog_func_proto(enum bpf_func_id func
 
 /* bpf+kprobe programs can access fields of 'struct pt_regs' */
 static bool kprobe_prog_is_valid_access(int off, int size, enum bpf_access_type type,
-                                        enum bpf_reg_type *reg_type)
+                                        struct bpf_insn_access_aux *info)
 {
         if (off < 0 || off >= sizeof(struct pt_regs))
                 return false;
@@ -566,7 +563,7 @@ static const struct bpf_func_proto *tp_prog_func_proto(enum bpf_func_id func_id)
 }
 
 static bool tp_prog_is_valid_access(int off, int size, enum bpf_access_type type,
-                                    enum bpf_reg_type *reg_type)
+                                    struct bpf_insn_access_aux *info)
 {
         if (off < sizeof(void *) || off >= PERF_MAX_TRACE_SIZE)
                 return false;
@@ -585,40 +582,47 @@ const struct bpf_verifier_ops tracepoint_prog_ops = {
 };
 
 static bool pe_prog_is_valid_access(int off, int size, enum bpf_access_type type,
-                                    enum bpf_reg_type *reg_type)
+                                    struct bpf_insn_access_aux *info)
 {
+        const int size_sp = FIELD_SIZEOF(struct bpf_perf_event_data,
+                                         sample_period);
+
         if (off < 0 || off >= sizeof(struct bpf_perf_event_data))
                 return false;
         if (type != BPF_READ)
                 return false;
         if (off % size != 0)
                 return false;
-        if (off == offsetof(struct bpf_perf_event_data, sample_period)) {
-                if (size != sizeof(u64))
+
+        switch (off) {
+        case bpf_ctx_range(struct bpf_perf_event_data, sample_period):
+                bpf_ctx_record_field_size(info, size_sp);
+                if (!bpf_ctx_narrow_access_ok(off, size, size_sp))
                         return false;
-        } else {
+                break;
+        default:
                 if (size != sizeof(long))
                         return false;
         }
+
         return true;
 }
 
 static u32 pe_prog_convert_ctx_access(enum bpf_access_type type,
                                       const struct bpf_insn *si,
                                       struct bpf_insn *insn_buf,
-                                      struct bpf_prog *prog)
+                                      struct bpf_prog *prog, u32 *target_size)
 {
         struct bpf_insn *insn = insn_buf;
 
         switch (si->off) {
         case offsetof(struct bpf_perf_event_data, sample_period):
-                BUILD_BUG_ON(FIELD_SIZEOF(struct perf_sample_data, period) != sizeof(u64));
-
                 *insn++ = BPF_LDX_MEM(BPF_FIELD_SIZEOF(struct bpf_perf_event_data_kern,
                                                        data), si->dst_reg, si->src_reg,
                                       offsetof(struct bpf_perf_event_data_kern, data));
                 *insn++ = BPF_LDX_MEM(BPF_DW, si->dst_reg, si->dst_reg,
-                                      offsetof(struct perf_sample_data, period));
+                                      bpf_target_off(struct perf_sample_data, period, 8,
+                                                     target_size));
                 break;
         default:
                 *insn++ = BPF_LDX_MEM(BPF_FIELD_SIZEOF(struct bpf_perf_event_data_kern,
diff --git a/kernel/trace/ftrace.c b/kernel/trace/ftrace.c
index 74fdfe9ed3db..02004ae91860 100644
--- a/kernel/trace/ftrace.c
+++ b/kernel/trace/ftrace.c
@@ -113,7 +113,7 @@ static int ftrace_disabled __read_mostly;
 
 static DEFINE_MUTEX(ftrace_lock);
 
-static struct ftrace_ops *ftrace_ops_list __read_mostly = &ftrace_list_end;
+static struct ftrace_ops __rcu *ftrace_ops_list __read_mostly = &ftrace_list_end;
 ftrace_func_t ftrace_trace_function __read_mostly = ftrace_stub;
 static struct ftrace_ops global_ops;
 
@@ -169,8 +169,11 @@ int ftrace_nr_registered_ops(void)
 
         mutex_lock(&ftrace_lock);
 
-        for (ops = ftrace_ops_list;
-             ops != &ftrace_list_end; ops = ops->next)
+        for (ops = rcu_dereference_protected(ftrace_ops_list,
+                                             lockdep_is_held(&ftrace_lock));
+             ops != &ftrace_list_end;
+             ops = rcu_dereference_protected(ops->next,
+                                             lockdep_is_held(&ftrace_lock)))
                 cnt++;
 
         mutex_unlock(&ftrace_lock);
@@ -275,10 +278,11 @@ static void update_ftrace_function(void)
          * If there's only one ftrace_ops registered, the ftrace_ops_list
          * will point to the ops we want.
          */
-        set_function_trace_op = ftrace_ops_list;
+        set_function_trace_op = rcu_dereference_protected(ftrace_ops_list,
+                                                lockdep_is_held(&ftrace_lock));
 
         /* If there's no ftrace_ops registered, just call the stub function */
-        if (ftrace_ops_list == &ftrace_list_end) {
+        if (set_function_trace_op == &ftrace_list_end) {
                 func = ftrace_stub;
 
         /*
@@ -286,7 +290,8 @@ static void update_ftrace_function(void)
          * recursion safe and not dynamic and the arch supports passing ops,
          * then have the mcount trampoline call the function directly.
          */
-        } else if (ftrace_ops_list->next == &ftrace_list_end) {
+        } else if (rcu_dereference_protected(ftrace_ops_list->next,
+                        lockdep_is_held(&ftrace_lock)) == &ftrace_list_end) {
                 func = ftrace_ops_get_list_func(ftrace_ops_list);
 
         } else {
@@ -348,9 +353,11 @@ int using_ftrace_ops_list_func(void)
         return ftrace_trace_function == ftrace_ops_list_func;
 }
 
-static void add_ftrace_ops(struct ftrace_ops **list, struct ftrace_ops *ops)
+static void add_ftrace_ops(struct ftrace_ops __rcu **list,
+                           struct ftrace_ops *ops)
 {
-        ops->next = *list;
+        rcu_assign_pointer(ops->next, *list);
+
         /*
          * We are entering ops into the list but another
          * CPU might be walking that list. We need to make sure
@@ -360,7 +367,8 @@ static void add_ftrace_ops(struct ftrace_ops **list, struct ftrace_ops *ops)
         rcu_assign_pointer(*list, ops);
 }
 
-static int remove_ftrace_ops(struct ftrace_ops **list, struct ftrace_ops *ops)
+static int remove_ftrace_ops(struct ftrace_ops __rcu **list,
+                             struct ftrace_ops *ops)
 {
         struct ftrace_ops **p;
 
@@ -368,7 +376,10 @@ static int remove_ftrace_ops(struct ftrace_ops **list, struct ftrace_ops *ops)
          * If we are removing the last function, then simply point
          * to the ftrace_stub.
          */
-        if (*list == ops && ops->next == &ftrace_list_end) {
+        if (rcu_dereference_protected(*list,
+                        lockdep_is_held(&ftrace_lock)) == ops &&
+            rcu_dereference_protected(ops->next,
+                        lockdep_is_held(&ftrace_lock)) == &ftrace_list_end) {
                 *list = &ftrace_list_end;
                 return 0;
         }
@@ -1293,6 +1304,28 @@ static void ftrace_hash_clear(struct ftrace_hash *hash)
         FTRACE_WARN_ON(hash->count);
 }
 
+static void free_ftrace_mod(struct ftrace_mod_load *ftrace_mod)
+{
+        list_del(&ftrace_mod->list);
+        kfree(ftrace_mod->module);
+        kfree(ftrace_mod->func);
+        kfree(ftrace_mod);
+}
+
+static void clear_ftrace_mod_list(struct list_head *head)
+{
+        struct ftrace_mod_load *p, *n;
+
+        /* stack tracer isn't supported yet */
+        if (!head)
+                return;
+
+        mutex_lock(&ftrace_lock);
+        list_for_each_entry_safe(p, n, head, list)
+                free_ftrace_mod(p);
+        mutex_unlock(&ftrace_lock);
+}
+
 static void free_ftrace_hash(struct ftrace_hash *hash)
 {
         if (!hash || hash == EMPTY_HASH)
@@ -1346,6 +1379,35 @@ static struct ftrace_hash *alloc_ftrace_hash(int size_bits)
         return hash;
 }
 
+
+static int ftrace_add_mod(struct trace_array *tr,
+                          const char *func, const char *module,
+                          int enable)
+{
+        struct ftrace_mod_load *ftrace_mod;
+        struct list_head *mod_head = enable ? &tr->mod_trace : &tr->mod_notrace;
+
+        ftrace_mod = kzalloc(sizeof(*ftrace_mod), GFP_KERNEL);
+        if (!ftrace_mod)
+                return -ENOMEM;
+
+        ftrace_mod->func = kstrdup(func, GFP_KERNEL);
+        ftrace_mod->module = kstrdup(module, GFP_KERNEL);
+        ftrace_mod->enable = enable;
+
+        if (!ftrace_mod->func || !ftrace_mod->module)
+                goto out_free;
+
+        list_add(&ftrace_mod->list, mod_head);
+
+        return 0;
+
+ out_free:
+        free_ftrace_mod(ftrace_mod);
+
+        return -ENOMEM;
+}
+
 static struct ftrace_hash *
 alloc_and_copy_ftrace_hash(int size_bits, struct ftrace_hash *hash)
 {
@@ -1359,6 +1421,9 @@ alloc_and_copy_ftrace_hash(int size_bits, struct ftrace_hash *hash)
         if (!new_hash)
                 return NULL;
 
+        if (hash)
+                new_hash->flags = hash->flags;
+
         /* Empty hash? */
         if (ftrace_hash_empty(hash))
                 return new_hash;
@@ -1403,7 +1468,7 @@ __ftrace_hash_move(struct ftrace_hash *src)
         /*
          * If the new source is empty, just return the empty_hash.
          */
-        if (!src->count)
+        if (ftrace_hash_empty(src))
                 return EMPTY_HASH;
 
         /*
@@ -1420,6 +1485,8 @@ __ftrace_hash_move(struct ftrace_hash *src)
         if (!new_hash)
                 return NULL;
 
+        new_hash->flags = src->flags;
+
         size = 1 << src->size_bits;
         for (i = 0; i < size; i++) {
                 hhd = &src->buckets[i];
@@ -1513,8 +1580,8 @@ ftrace_ops_test(struct ftrace_ops *ops, unsigned long ip, void *regs)
                 return 0;
 #endif
 
-        hash.filter_hash = rcu_dereference_raw_notrace(ops->func_hash->filter_hash);
-        hash.notrace_hash = rcu_dereference_raw_notrace(ops->func_hash->notrace_hash);
+        rcu_assign_pointer(hash.filter_hash, ops->func_hash->filter_hash);
+        rcu_assign_pointer(hash.notrace_hash, ops->func_hash->notrace_hash);
 
         if (hash_contains_ip(ip, &hash))
                 ret = 1;
@@ -1650,7 +1717,7 @@ static bool __ftrace_hash_rec_update(struct ftrace_ops *ops,
         struct dyn_ftrace *rec;
         bool update = false;
         int count = 0;
-        int all = 0;
+        int all = false;
 
         /* Only update if the ops has been registered */
         if (!(ops->flags & FTRACE_OPS_FL_ENABLED))
@@ -1671,7 +1738,7 @@ static bool __ftrace_hash_rec_update(struct ftrace_ops *ops,
                 hash = ops->func_hash->filter_hash;
                 other_hash = ops->func_hash->notrace_hash;
                 if (ftrace_hash_empty(hash))
-                        all = 1;
+                        all = true;
         } else {
                 inc = !inc;
                 hash = ops->func_hash->notrace_hash;
@@ -2784,7 +2851,8 @@ static int ftrace_shutdown(struct ftrace_ops *ops, int command)
          * If there's no more ops registered with ftrace, run a
          * sanity check to make sure all rec flags are cleared.
          */
-        if (ftrace_ops_list == &ftrace_list_end) {
+        if (rcu_dereference_protected(ftrace_ops_list,
+                        lockdep_is_held(&ftrace_lock)) == &ftrace_list_end) {
                 struct ftrace_page *pg;
                 struct dyn_ftrace *rec;
 
@@ -3061,6 +3129,7 @@ ftrace_allocate_pages(unsigned long num_to_init)
 struct ftrace_iterator {
         loff_t                          pos;
         loff_t                          func_pos;
+        loff_t                          mod_pos;
         struct ftrace_page              *pg;
         struct dyn_ftrace               *func;
         struct ftrace_func_probe        *probe;
@@ -3068,6 +3137,8 @@ struct ftrace_iterator {
         struct trace_parser             parser;
         struct ftrace_hash              *hash;
         struct ftrace_ops               *ops;
+        struct trace_array              *tr;
+        struct list_head                *mod_list;
         int                             pidx;
         int                             idx;
         unsigned                        flags;
@@ -3152,13 +3223,13 @@ static void *t_probe_start(struct seq_file *m, loff_t *pos)
         if (!(iter->flags & FTRACE_ITER_DO_PROBES))
                 return NULL;
 
-        if (iter->func_pos > *pos)
+        if (iter->mod_pos > *pos)
                 return NULL;
 
         iter->probe = NULL;
         iter->probe_entry = NULL;
         iter->pidx = 0;
-        for (l = 0; l <= (*pos - iter->func_pos); ) {
+        for (l = 0; l <= (*pos - iter->mod_pos); ) {
                 p = t_probe_next(m, &l);
                 if (!p)
                         break;
@@ -3197,6 +3268,82 @@ t_probe_show(struct seq_file *m, struct ftrace_iterator *iter)
 }
 
 static void *
+t_mod_next(struct seq_file *m, loff_t *pos)
+{
+        struct ftrace_iterator *iter = m->private;
+        struct trace_array *tr = iter->tr;
+
+        (*pos)++;
+        iter->pos = *pos;
+
+        iter->mod_list = iter->mod_list->next;
+
+        if (iter->mod_list == &tr->mod_trace ||
+            iter->mod_list == &tr->mod_notrace) {
+                iter->flags &= ~FTRACE_ITER_MOD;
+                return NULL;
+        }
+
+        iter->mod_pos = *pos;
+
+        return iter;
+}
+
+static void *t_mod_start(struct seq_file *m, loff_t *pos)
+{
+        struct ftrace_iterator *iter = m->private;
+        void *p = NULL;
+        loff_t l;
+
+        if (iter->func_pos > *pos)
+                return NULL;
+
+        iter->mod_pos = iter->func_pos;
+
+        /* probes are only available if tr is set */
+        if (!iter->tr)
+                return NULL;
+
+        for (l = 0; l <= (*pos - iter->func_pos); ) {
+                p = t_mod_next(m, &l);
+                if (!p)
+                        break;
+        }
+        if (!p) {
+                iter->flags &= ~FTRACE_ITER_MOD;
+                return t_probe_start(m, pos);
+        }
+
+        /* Only set this if we have an item */
+        iter->flags |= FTRACE_ITER_MOD;
+
+        return iter;
+}
+
+static int
+t_mod_show(struct seq_file *m, struct ftrace_iterator *iter)
+{
+        struct ftrace_mod_load *ftrace_mod;
+        struct trace_array *tr = iter->tr;
+
+        if (WARN_ON_ONCE(!iter->mod_list) ||
+                         iter->mod_list == &tr->mod_trace ||
+                         iter->mod_list == &tr->mod_notrace)
+                return -EIO;
+
+        ftrace_mod = list_entry(iter->mod_list, struct ftrace_mod_load, list);
+
+        if (ftrace_mod->func)
+                seq_printf(m, "%s", ftrace_mod->func);
+        else
+                seq_putc(m, '*');
+
+        seq_printf(m, ":mod:%s\n", ftrace_mod->module);
+
+        return 0;
+}
+
+static void *
 t_func_next(struct seq_file *m, loff_t *pos)
 {
         struct ftrace_iterator *iter = m->private;
@@ -3237,7 +3384,7 @@ static void *
 t_next(struct seq_file *m, void *v, loff_t *pos)
 {
         struct ftrace_iterator *iter = m->private;
-        loff_t l = *pos; /* t_hash_start() must use original pos */
+        loff_t l = *pos; /* t_probe_start() must use original pos */
         void *ret;
 
         if (unlikely(ftrace_disabled))
@@ -3246,16 +3393,19 @@ t_next(struct seq_file *m, void *v, loff_t *pos)
         if (iter->flags & FTRACE_ITER_PROBE)
                 return t_probe_next(m, pos);
 
+        if (iter->flags & FTRACE_ITER_MOD)
+                return t_mod_next(m, pos);
+
         if (iter->flags & FTRACE_ITER_PRINTALL) {
                 /* next must increment pos, and t_probe_start does not */
                 (*pos)++;
-                return t_probe_start(m, &l);
+                return t_mod_start(m, &l);
         }
 
         ret = t_func_next(m, pos);
 
         if (!ret)
-                return t_probe_start(m, &l);
+                return t_mod_start(m, &l);
 
         return ret;
 }
@@ -3264,7 +3414,7 @@ static void reset_iter_read(struct ftrace_iterator *iter)
 {
         iter->pos = 0;
         iter->func_pos = 0;
-        iter->flags &= ~(FTRACE_ITER_PRINTALL | FTRACE_ITER_PROBE);
+        iter->flags &= ~(FTRACE_ITER_PRINTALL | FTRACE_ITER_PROBE | FTRACE_ITER_MOD);
 }
 
 static void *t_start(struct seq_file *m, loff_t *pos)
@@ -3293,15 +3443,15 @@ static void *t_start(struct seq_file *m, loff_t *pos)
             ftrace_hash_empty(iter->hash)) {
                 iter->func_pos = 1; /* Account for the message */
                 if (*pos > 0)
-                        return t_probe_start(m, pos);
+                        return t_mod_start(m, pos);
                 iter->flags |= FTRACE_ITER_PRINTALL;
                 /* reset in case of seek/pread */
                 iter->flags &= ~FTRACE_ITER_PROBE;
                 return iter;
         }
 
-        if (iter->flags & FTRACE_ITER_PROBE)
-                return t_probe_start(m, pos);
+        if (iter->flags & FTRACE_ITER_MOD)
+                return t_mod_start(m, pos);
 
         /*
          * Unfortunately, we need to restart at ftrace_pages_start
@@ -3317,7 +3467,7 @@ static void *t_start(struct seq_file *m, loff_t *pos)
         }
 
         if (!p)
-                return t_probe_start(m, pos);
+                return t_mod_start(m, pos);
 
         return iter;
 }
@@ -3351,6 +3501,9 @@ static int t_show(struct seq_file *m, void *v)
         if (iter->flags & FTRACE_ITER_PROBE)
                 return t_probe_show(m, iter);
 
+        if (iter->flags & FTRACE_ITER_MOD)
+                return t_mod_show(m, iter);
+
         if (iter->flags & FTRACE_ITER_PRINTALL) {
                 if (iter->flags & FTRACE_ITER_NOTRACE)
                         seq_puts(m, "#### no functions disabled ####\n");
@@ -3457,6 +3610,8 @@ ftrace_regex_open(struct ftrace_ops *ops, int flag,
 {
         struct ftrace_iterator *iter;
         struct ftrace_hash *hash;
+        struct list_head *mod_head;
+        struct trace_array *tr = ops->private;
         int ret = 0;
 
         ftrace_ops_init(ops);
@@ -3475,21 +3630,29 @@ ftrace_regex_open(struct ftrace_ops *ops, int flag,
 
         iter->ops = ops;
         iter->flags = flag;
+        iter->tr = tr;
 
         mutex_lock(&ops->func_hash->regex_lock);
 
-        if (flag & FTRACE_ITER_NOTRACE)
+        if (flag & FTRACE_ITER_NOTRACE) {
                 hash = ops->func_hash->notrace_hash;
-        else
+                mod_head = tr ? &tr->mod_notrace : NULL;
+        } else {
                 hash = ops->func_hash->filter_hash;
+                mod_head = tr ? &tr->mod_trace : NULL;
+        }
+
+        iter->mod_list = mod_head;
 
         if (file->f_mode & FMODE_WRITE) {
                 const int size_bits = FTRACE_HASH_DEFAULT_BITS;
 
-                if (file->f_flags & O_TRUNC)
+                if (file->f_flags & O_TRUNC) {
                         iter->hash = alloc_ftrace_hash(size_bits);
-                else
+                        clear_ftrace_mod_list(mod_head);
+                } else {
                         iter->hash = alloc_and_copy_ftrace_hash(size_bits, hash);
+                }
 
                 if (!iter->hash) {
                         trace_parser_put(&iter->parser);
@@ -3665,7 +3828,7 @@ match_records(struct ftrace_hash *hash, char *func, int len, char *mod)
         int exclude_mod = 0;
         int found = 0;
         int ret;
-        int clear_filter;
+        int clear_filter = 0;
 
         if (func) {
                 func_g.type = filter_parse_regex(func, len, &func_g.search,
@@ -3761,6 +3924,165 @@ static int ftrace_hash_move_and_update_ops(struct ftrace_ops *ops,
         return ret;
 }
 
+static bool module_exists(const char *module)
+{
+        /* All modules have the symbol __this_module */
+        const char this_mod[] = "__this_module";
+        const int modname_size = MAX_PARAM_PREFIX_LEN + sizeof(this_mod) + 1;
+        char modname[modname_size + 1];
+        unsigned long val;
+        int n;
+
+        n = snprintf(modname, modname_size + 1, "%s:%s", module, this_mod);
+
+        if (n > modname_size)
+                return false;
+
+        val = module_kallsyms_lookup_name(modname);
+        return val != 0;
+}
+
+static int cache_mod(struct trace_array *tr,
+                     const char *func, char *module, int enable)
+{
+        struct ftrace_mod_load *ftrace_mod, *n;
+        struct list_head *head = enable ? &tr->mod_trace : &tr->mod_notrace;
+        int ret;
+
+        mutex_lock(&ftrace_lock);
+
+        /* We do not cache inverse filters */
+        if (func[0] == '!') {
+                func++;
+                ret = -EINVAL;
+
+                /* Look to remove this hash */
+                list_for_each_entry_safe(ftrace_mod, n, head, list) {
+                        if (strcmp(ftrace_mod->module, module) != 0)
+                                continue;
+
+                        /* no func matches all */
+                        if (strcmp(func, "*") == 0 ||
+                            (ftrace_mod->func &&
+                             strcmp(ftrace_mod->func, func) == 0)) {
+                                ret = 0;
+                                free_ftrace_mod(ftrace_mod);
+                                continue;
+                        }
+                }
+                goto out;
+        }
+
+        ret = -EINVAL;
+        /* We only care about modules that have not been loaded yet */
+        if (module_exists(module))
+                goto out;
+
+        /* Save this string off, and execute it when the module is loaded */
+        ret = ftrace_add_mod(tr, func, module, enable);
+ out:
+        mutex_unlock(&ftrace_lock);
+
+        return ret;
+}
+
+static int
+ftrace_set_regex(struct ftrace_ops *ops, unsigned char *buf, int len,
+                 int reset, int enable);
+
+#ifdef CONFIG_MODULES
+static void process_mod_list(struct list_head *head, struct ftrace_ops *ops,
+                             char *mod, bool enable)
+{
+        struct ftrace_mod_load *ftrace_mod, *n;
+        struct ftrace_hash **orig_hash, *new_hash;
+        LIST_HEAD(process_mods);
+        char *func;
+        int ret;
+
+        mutex_lock(&ops->func_hash->regex_lock);
+
+        if (enable)
+                orig_hash = &ops->func_hash->filter_hash;
+        else
+                orig_hash = &ops->func_hash->notrace_hash;
+
+        new_hash = alloc_and_copy_ftrace_hash(FTRACE_HASH_DEFAULT_BITS,
+                                              *orig_hash);
+        if (!new_hash)
+                goto out; /* warn? */
+
+        mutex_lock(&ftrace_lock);
+
+        list_for_each_entry_safe(ftrace_mod, n, head, list) {
+
+                if (strcmp(ftrace_mod->module, mod) != 0)
+                        continue;
+
+                if (ftrace_mod->func)
+                        func = kstrdup(ftrace_mod->func, GFP_KERNEL);
+                else
+                        func = kstrdup("*", GFP_KERNEL);
+
+                if (!func) /* warn? */
+                        continue;
+
+                list_del(&ftrace_mod->list);
+                list_add(&ftrace_mod->list, &process_mods);
+
+                /* Use the newly allocated func, as it may be "*" */
+                kfree(ftrace_mod->func);
+                ftrace_mod->func = func;
+        }
+
+        mutex_unlock(&ftrace_lock);
+
+        list_for_each_entry_safe(ftrace_mod, n, &process_mods, list) {
+
+                func = ftrace_mod->func;
+
+                /* Grabs ftrace_lock, which is why we have this extra step */
+                match_records(new_hash, func, strlen(func), mod);
+                free_ftrace_mod(ftrace_mod);
+        }
+
+        if (enable && list_empty(head))
+                new_hash->flags &= ~FTRACE_HASH_FL_MOD;
+
+        mutex_lock(&ftrace_lock);
+
+        ret = ftrace_hash_move_and_update_ops(ops, orig_hash,
+                                              new_hash, enable);
+        mutex_unlock(&ftrace_lock);
+
+ out:
+        mutex_unlock(&ops->func_hash->regex_lock);
+
+        free_ftrace_hash(new_hash);
+}
+
+static void process_cached_mods(const char *mod_name)
+{
+        struct trace_array *tr;
+        char *mod;
+
+        mod = kstrdup(mod_name, GFP_KERNEL);
+        if (!mod)
+                return;
+
+        mutex_lock(&trace_types_lock);
+        list_for_each_entry(tr, &ftrace_trace_arrays, list) {
+                if (!list_empty(&tr->mod_trace))
+                        process_mod_list(&tr->mod_trace, tr->ops, mod, true);
+                if (!list_empty(&tr->mod_notrace))
+                        process_mod_list(&tr->mod_notrace, tr->ops, mod, false);
+        }
+        mutex_unlock(&trace_types_lock);
+
+        kfree(mod);
+}
+#endif
+
 /*
  * We register the module command as a template to show others how
  * to register the a command as well.
@@ -3768,10 +4090,16 @@ static int ftrace_hash_move_and_update_ops(struct ftrace_ops *ops,
 
 static int
 ftrace_mod_callback(struct trace_array *tr, struct ftrace_hash *hash,
-                    char *func, char *cmd, char *module, int enable)
+                    char *func_orig, char *cmd, char *module, int enable)
 {
+        char *func;
         int ret;
 
+        /* match_records() modifies func, and we need the original */
+        func = kstrdup(func_orig, GFP_KERNEL);
+        if (!func)
+                return -ENOMEM;
+
         /*
          * cmd == 'mod' because we only registered this func
          * for the 'mod' ftrace_func_command.
@@ -3780,8 +4108,10 @@ ftrace_mod_callback(struct trace_array *tr, struct ftrace_hash *hash,
          * parameter.
          */
         ret = match_records(hash, func, strlen(func), module);
+        kfree(func);
+
         if (!ret)
-                return -EINVAL;
+                return cache_mod(tr, func_orig, module, enable);
         if (ret < 0)
                 return ret;
         return 0;
@@ -4337,9 +4667,6 @@ static int ftrace_process_regex(struct ftrace_iterator *iter,
 
         command = strsep(&next, ":");
 
-        if (WARN_ON_ONCE(!tr))
-                return -EINVAL;
-
         mutex_lock(&ftrace_cmd_mutex);
         list_for_each_entry(p, &ftrace_commands, list) {
                 if (strcmp(p->name, command) == 0) {
@@ -4728,9 +5055,11 @@ int ftrace_regex_release(struct inode *inode, struct file *file)
         if (file->f_mode & FMODE_WRITE) {
                 filter_hash = !!(iter->flags & FTRACE_ITER_FILTER);
 
-                if (filter_hash)
+                if (filter_hash) {
                         orig_hash = &iter->ops->func_hash->filter_hash;
-                else
+                        if (iter->tr && !list_empty(&iter->tr->mod_trace))
+                                iter->hash->flags |= FTRACE_HASH_FL_MOD;
+                } else
                         orig_hash = &iter->ops->func_hash->notrace_hash;
 
                 mutex_lock(&ftrace_lock);
@@ -5063,7 +5392,7 @@ ftrace_graph_release(struct inode *inode, struct file *file)
         }
 
  out:
-        kfree(fgd->new_hash);
+        free_ftrace_hash(fgd->new_hash);
         kfree(fgd);
 
         return ret;
@@ -5388,6 +5717,7 @@ void ftrace_release_mod(struct module *mod)
                         if (pg == ftrace_pages)
                                 ftrace_pages = next_to_ftrace_page(last_pg);
 
+                        ftrace_update_tot_cnt -= pg->index;
                         *last_pg = pg->next;
                         order = get_count_order(pg->size / ENTRIES_PER_PAGE);
                         free_pages((unsigned long)pg->records, order);
@@ -5466,6 +5796,8 @@ void ftrace_module_enable(struct module *mod)
 
  out_unlock:
         mutex_unlock(&ftrace_lock);
+
+        process_cached_mods(mod->name);
 }
 
 void ftrace_module_init(struct module *mod)
@@ -5504,6 +5836,7 @@ void __init ftrace_free_init_mem(void)
                 if (!rec)
                         continue;
                 pg->index--;
+                ftrace_update_tot_cnt--;
                 if (!pg->index) {
                         *last_pg = pg->next;
                         order = get_count_order(pg->size / ENTRIES_PER_PAGE);
@@ -5570,6 +5903,8 @@ static void ftrace_update_trampoline(struct ftrace_ops *ops)
 void ftrace_init_trace_array(struct trace_array *tr)
 {
         INIT_LIST_HEAD(&tr->func_probes);
+        INIT_LIST_HEAD(&tr->mod_trace);
+        INIT_LIST_HEAD(&tr->mod_notrace);
 }
 #else
 
@@ -6130,7 +6465,8 @@ ftrace_enable_sysctl(struct ctl_table *table, int write,
         if (ftrace_enabled) {
 
                 /* we are starting ftrace again */
-                if (ftrace_ops_list != &ftrace_list_end)
+                if (rcu_dereference_protected(ftrace_ops_list,
+                        lockdep_is_held(&ftrace_lock)) != &ftrace_list_end)
                         update_ftrace_function();
 
                 ftrace_startup_sysctl();
diff --git a/kernel/trace/ring_buffer.c b/kernel/trace/ring_buffer.c
index 4ae268e687fe..529cc50d7243 100644
--- a/kernel/trace/ring_buffer.c
+++ b/kernel/trace/ring_buffer.c
@@ -1136,12 +1136,12 @@ static int __rb_allocate_pages(long nr_pages, struct list_head *pages, int cpu)
         for (i = 0; i < nr_pages; i++) {
                 struct page *page;
                 /*
-                 * __GFP_NORETRY flag makes sure that the allocation fails
-                 * gracefully without invoking oom-killer and the system is
-                 * not destabilized.
+                 * __GFP_RETRY_MAYFAIL flag makes sure that the allocation fails
+                 * gracefully without invoking oom-killer and the system is not
+                 * destabilized.
                  */
                 bpage = kzalloc_node(ALIGN(sizeof(*bpage), cache_line_size()),
-                                    GFP_KERNEL | __GFP_NORETRY,
+                                    GFP_KERNEL | __GFP_RETRY_MAYFAIL,
                                     cpu_to_node(cpu));
                 if (!bpage)
                         goto free_pages;
@@ -1149,7 +1149,7 @@ static int __rb_allocate_pages(long nr_pages, struct list_head *pages, int cpu)
                 list_add(&bpage->list, pages);
 
                 page = alloc_pages_node(cpu_to_node(cpu),
-                                        GFP_KERNEL | __GFP_NORETRY, 0);
+                                        GFP_KERNEL | __GFP_RETRY_MAYFAIL, 0);
                 if (!page)
                         goto free_pages;
                 bpage->page = page_address(page);
diff --git a/kernel/trace/trace.c b/kernel/trace/trace.c
index 1122f151466f..42b9355033d4 100644
--- a/kernel/trace/trace.c
+++ b/kernel/trace/trace.c
@@ -87,7 +87,7 @@ dummy_set_flag(struct trace_array *tr, u32 old_flags, u32 bit, int set)
  * tracing is active, only save the comm when a trace event
  * occurred.
  */
-static DEFINE_PER_CPU(bool, trace_cmdline_save);
+static DEFINE_PER_CPU(bool, trace_taskinfo_save);
 
 /*
  * Kill all tracing for good (never come back).
@@ -120,41 +120,41 @@ enum ftrace_dump_mode ftrace_dump_on_oops;
 /* When set, tracing will stop when a WARN*() is hit */
 int __disable_trace_on_warning;
 
-#ifdef CONFIG_TRACE_ENUM_MAP_FILE
-/* Map of enums to their values, for "enum_map" file */
-struct trace_enum_map_head {
+#ifdef CONFIG_TRACE_EVAL_MAP_FILE
+/* Map of enums to their values, for "eval_map" file */
+struct trace_eval_map_head {
         struct module                   *mod;
         unsigned long                   length;
 };
 
-union trace_enum_map_item;
+union trace_eval_map_item;
 
-struct trace_enum_map_tail {
+struct trace_eval_map_tail {
         /*
          * "end" is first and points to NULL as it must be different
-         * than "mod" or "enum_string"
+         * than "mod" or "eval_string"
          */
-        union trace_enum_map_item       *next;
+        union trace_eval_map_item       *next;
         const char                      *end;   /* points to NULL */
 };
 
-static DEFINE_MUTEX(trace_enum_mutex);
+static DEFINE_MUTEX(trace_eval_mutex);
 
 /*
- * The trace_enum_maps are saved in an array with two extra elements,
+ * The trace_eval_maps are saved in an array with two extra elements,
  * one at the beginning, and one at the end. The beginning item contains
  * the count of the saved maps (head.length), and the module they
  * belong to if not built in (head.mod). The ending item contains a
- * pointer to the next array of saved enum_map items.
+ * pointer to the next array of saved eval_map items.
  */
-union trace_enum_map_item {
-        struct trace_enum_map           map;
-        struct trace_enum_map_head      head;
-        struct trace_enum_map_tail      tail;
+union trace_eval_map_item {
+        struct trace_eval_map           map;
+        struct trace_eval_map_head      head;
+        struct trace_eval_map_tail      tail;
 };
 
-static union trace_enum_map_item *trace_enum_maps;
-#endif /* CONFIG_TRACE_ENUM_MAP_FILE */
+static union trace_eval_map_item *trace_eval_maps;
+#endif /* CONFIG_TRACE_EVAL_MAP_FILE */
 
 static int tracing_set_tracer(struct trace_array *tr, const char *buf);
 
@@ -790,7 +790,7 @@ EXPORT_SYMBOL_GPL(tracing_on);
 static __always_inline void
 __buffer_unlock_commit(struct ring_buffer *buffer, struct ring_buffer_event *event)
 {
-        __this_cpu_write(trace_cmdline_save, true);
+        __this_cpu_write(trace_taskinfo_save, true);
 
         /* If this is the temp buffer, we need to commit fully */
         if (this_cpu_read(trace_buffered_event) == event) {
@@ -1141,9 +1141,9 @@ unsigned long nsecs_to_usecs(unsigned long nsecs)
 
 /*
  * TRACE_FLAGS is defined as a tuple matching bit masks with strings.
- * It uses C(a, b) where 'a' is the enum name and 'b' is the string that
+ * It uses C(a, b) where 'a' is the eval (enum) name and 'b' is the string that
  * matches it. By defining "C(a, b) b", TRACE_FLAGS becomes a list
- * of strings in the order that the enums were defined.
+ * of strings in the order that the evals (enum) were defined.
  */
 #undef C
 #define C(a, b) b
@@ -1709,6 +1709,8 @@ void tracing_reset_all_online_cpus(void)
         }
 }
 
+static int *tgid_map;
+
 #define SAVED_CMDLINES_DEFAULT 128
 #define NO_CMDLINE_MAP UINT_MAX
 static arch_spinlock_t trace_cmdline_lock = __ARCH_SPIN_LOCK_UNLOCKED;
@@ -1722,7 +1724,7 @@ struct saved_cmdlines_buffer {
 static struct saved_cmdlines_buffer *savedcmd;
 
 /* temporary disable recording */
-static atomic_t trace_record_cmdline_disabled __read_mostly;
+static atomic_t trace_record_taskinfo_disabled __read_mostly;
 
 static inline char *get_saved_cmdlines(int idx)
 {
@@ -1910,13 +1912,15 @@ static void tracing_stop_tr(struct trace_array *tr)
         raw_spin_unlock_irqrestore(&tr->start_lock, flags);
 }
 
-void trace_stop_cmdline_recording(void);
-
 static int trace_save_cmdline(struct task_struct *tsk)
 {
         unsigned pid, idx;
 
-        if (!tsk->pid || unlikely(tsk->pid > PID_MAX_DEFAULT))
+        /* treat recording of idle task as a success */
+        if (!tsk->pid)
+                return 1;
+
+        if (unlikely(tsk->pid > PID_MAX_DEFAULT))
                 return 0;
 
         /*
@@ -1992,16 +1996,107 @@ void trace_find_cmdline(int pid, char comm[])
         preempt_enable();
 }
 
-void tracing_record_cmdline(struct task_struct *tsk)
+int trace_find_tgid(int pid)
+{
+        if (unlikely(!tgid_map || !pid || pid > PID_MAX_DEFAULT))
+                return 0;
+
+        return tgid_map[pid];
+}
+
+static int trace_save_tgid(struct task_struct *tsk)
+{
+        /* treat recording of idle task as a success */
+        if (!tsk->pid)
+                return 1;
+
+        if (unlikely(!tgid_map || tsk->pid > PID_MAX_DEFAULT))
+                return 0;
+
+        tgid_map[tsk->pid] = tsk->tgid;
+        return 1;
+}
+
+static bool tracing_record_taskinfo_skip(int flags)
+{
+        if (unlikely(!(flags & (TRACE_RECORD_CMDLINE | TRACE_RECORD_TGID))))
+                return true;
+        if (atomic_read(&trace_record_taskinfo_disabled) || !tracing_is_on())
+                return true;
+        if (!__this_cpu_read(trace_taskinfo_save))
+                return true;
+        return false;
+}
+
+/**
+ * tracing_record_taskinfo - record the task info of a task
+ *
+ * @task  - task to record
+ * @flags - TRACE_RECORD_CMDLINE for recording comm
+ *        - TRACE_RECORD_TGID for recording tgid
+ */
+void tracing_record_taskinfo(struct task_struct *task, int flags)
 {
-        if (atomic_read(&trace_record_cmdline_disabled) || !tracing_is_on())
+        bool done;
+
+        if (tracing_record_taskinfo_skip(flags))
                 return;
 
-        if (!__this_cpu_read(trace_cmdline_save))
+        /*
+         * Record as much task information as possible. If some fail, continue
+         * to try to record the others.
+         */
+        done = !(flags & TRACE_RECORD_CMDLINE) || trace_save_cmdline(task);
+        done &= !(flags & TRACE_RECORD_TGID) || trace_save_tgid(task);
+
+        /* If recording any information failed, retry again soon. */
+        if (!done)
                 return;
 
-        if (trace_save_cmdline(tsk))
-                __this_cpu_write(trace_cmdline_save, false);
+        __this_cpu_write(trace_taskinfo_save, false);
+}
+
+/**
+ * tracing_record_taskinfo_sched_switch - record task info for sched_switch
+ *
+ * @prev - previous task during sched_switch
+ * @next - next task during sched_switch
+ * @flags - TRACE_RECORD_CMDLINE for recording comm
+ *          TRACE_RECORD_TGID for recording tgid
+ */
+void tracing_record_taskinfo_sched_switch(struct task_struct *prev,
+                                          struct task_struct *next, int flags)
+{
+        bool done;
+
+        if (tracing_record_taskinfo_skip(flags))
+                return;
+
+        /*
+         * Record as much task information as possible. If some fail, continue
+         * to try to record the others.
+         */
+        done  = !(flags & TRACE_RECORD_CMDLINE) || trace_save_cmdline(prev);
+        done &= !(flags & TRACE_RECORD_CMDLINE) || trace_save_cmdline(next);
+        done &= !(flags & TRACE_RECORD_TGID) || trace_save_tgid(prev);
+        done &= !(flags & TRACE_RECORD_TGID) || trace_save_tgid(next);
+
+        /* If recording any information failed, retry again soon. */
+        if (!done)
+                return;
+
+        __this_cpu_write(trace_taskinfo_save, false);
+}
+
+/* Helpers to record a specific task information */
+void tracing_record_cmdline(struct task_struct *task)
+{
+        tracing_record_taskinfo(task, TRACE_RECORD_CMDLINE);
+}
+
+void tracing_record_tgid(struct task_struct *task)
+{
+        tracing_record_taskinfo(task, TRACE_RECORD_TGID);
 }
 
 /*
@@ -3146,7 +3241,7 @@ static void *s_start(struct seq_file *m, loff_t *pos)
 #endif
 
         if (!iter->snapshot)
-                atomic_inc(&trace_record_cmdline_disabled);
+                atomic_inc(&trace_record_taskinfo_disabled);
 
         if (*pos != iter->pos) {
                 iter->ent = NULL;
@@ -3191,7 +3286,7 @@ static void s_stop(struct seq_file *m, void *p)
 #endif
 
         if (!iter->snapshot)
-                atomic_dec(&trace_record_cmdline_disabled);
+                atomic_dec(&trace_record_taskinfo_disabled);
 
         trace_access_unlock(iter->cpu_file);
         trace_event_read_unlock();
@@ -3248,23 +3343,38 @@ static void print_event_info(struct trace_buffer *buf, struct seq_file *m)
         seq_puts(m, "#\n");
 }
 
-static void print_func_help_header(struct trace_buffer *buf, struct seq_file *m)
+static void print_func_help_header(struct trace_buffer *buf, struct seq_file *m,
+                                   unsigned int flags)
 {
+        bool tgid = flags & TRACE_ITER_RECORD_TGID;
+
         print_event_info(buf, m);
-        seq_puts(m, "#           TASK-PID   CPU#      TIMESTAMP  FUNCTION\n"
-                    "#              | |       |          |         |\n");
+
+        seq_printf(m, "#           TASK-PID   CPU#   %s  TIMESTAMP  FUNCTION\n", tgid ? "TGID     " : "");
+        seq_printf(m, "#              | |       |    %s     |         |\n",      tgid ? "  |      " : "");
 }
 
-static void print_func_help_header_irq(struct trace_buffer *buf, struct seq_file *m)
+static void print_func_help_header_irq(struct trace_buffer *buf, struct seq_file *m,
+                                       unsigned int flags)
 {
-        print_event_info(buf, m);
-        seq_puts(m, "#                              _-----=> irqs-off\n"
-                    "#                             / _----=> need-resched\n"
-                    "#                            | / _---=> hardirq/softirq\n"
-                    "#                            || / _--=> preempt-depth\n"
-                    "#                            ||| /     delay\n"
-                    "#           TASK-PID   CPU#  ||||    TIMESTAMP  FUNCTION\n"
-                    "#              | |       |   ||||       |         |\n");
+        bool tgid = flags & TRACE_ITER_RECORD_TGID;
+        const char tgid_space[] = "          ";
+        const char space[] = "  ";
+
+        seq_printf(m, "#                          %s  _-----=> irqs-off\n",
+                   tgid ? tgid_space : space);
+        seq_printf(m, "#                          %s / _----=> need-resched\n",
+                   tgid ? tgid_space : space);
+        seq_printf(m, "#                          %s| / _---=> hardirq/softirq\n",
+                   tgid ? tgid_space : space);
+        seq_printf(m, "#                          %s|| / _--=> preempt-depth\n",
+                   tgid ? tgid_space : space);
+        seq_printf(m, "#                          %s||| /     delay\n",
+                   tgid ? tgid_space : space);
+        seq_printf(m, "#           TASK-PID   CPU#%s||||    TIMESTAMP  FUNCTION\n",
+                   tgid ? "   TGID   " : space);
+        seq_printf(m, "#              | |       | %s||||       |         |\n",
+                   tgid ? "     |    " : space);
 }
 
 void
@@ -3580,9 +3690,11 @@ void trace_default_header(struct seq_file *m)
         } else {
                 if (!(trace_flags & TRACE_ITER_VERBOSE)) {
                         if (trace_flags & TRACE_ITER_IRQ_INFO)
-                                print_func_help_header_irq(iter->trace_buffer, m);
+                                print_func_help_header_irq(iter->trace_buffer,
+                                                           m, trace_flags);
                         else
-                                print_func_help_header(iter->trace_buffer, m);
+                                print_func_help_header(iter->trace_buffer, m,
+                                                       trace_flags);
                 }
         }
 }
@@ -4238,6 +4350,18 @@ int set_tracer_flag(struct trace_array *tr, unsigned int mask, int enabled)
         if (mask == TRACE_ITER_RECORD_CMD)
                 trace_event_enable_cmd_record(enabled);
 
+        if (mask == TRACE_ITER_RECORD_TGID) {
+                if (!tgid_map)
+                        tgid_map = kzalloc((PID_MAX_DEFAULT + 1) * sizeof(*tgid_map),
+                                           GFP_KERNEL);
+                if (!tgid_map) {
+                        tr->trace_flags &= ~TRACE_ITER_RECORD_TGID;
+                        return -ENOMEM;
+                }
+
+                trace_event_enable_tgid_record(enabled);
+        }
+
         if (mask == TRACE_ITER_EVENT_FORK)
                 trace_event_follow_fork(tr, enabled);
 
@@ -4473,7 +4597,8 @@ static const char readme_msg[] =
 #endif
 #if defined(CONFIG_KPROBE_EVENTS) || defined(CONFIG_UPROBE_EVENTS)
         "\t  accepts: event-definitions (one definition per line)\n"
-        "\t   Format: p|r[:[<group>/]<event>] <place> [<args>]\n"
+        "\t   Format: p[:[<group>/]<event>] <place> [<args>]\n"
+        "\t           r[maxactive][:[<group>/]<event>] <place> [<args>]\n"
         "\t           -:[<group>/]<event>\n"
 #ifdef CONFIG_KPROBE_EVENTS
         "\t    place: [<module>:]<symbol>[+<offset>]|<memaddr>\n"
@@ -4597,6 +4722,76 @@ static const struct file_operations tracing_readme_fops = {
         .llseek         = generic_file_llseek,
 };
 
+static void *saved_tgids_next(struct seq_file *m, void *v, loff_t *pos)
+{
+        int *ptr = v;
+
+        if (*pos || m->count)
+                ptr++;
+
+        (*pos)++;
+
+        for (; ptr <= &tgid_map[PID_MAX_DEFAULT]; ptr++) {
+                if (trace_find_tgid(*ptr))
+                        return ptr;
+        }
+
+        return NULL;
+}
+
+static void *saved_tgids_start(struct seq_file *m, loff_t *pos)
+{
+        void *v;
+        loff_t l = 0;
+
+        if (!tgid_map)
+                return NULL;
+
+        v = &tgid_map[0];
+        while (l <= *pos) {
+                v = saved_tgids_next(m, v, &l);
+                if (!v)
+                        return NULL;
+        }
+
+        return v;
+}
+
+static void saved_tgids_stop(struct seq_file *m, void *v)
+{
+}
+
+static int saved_tgids_show(struct seq_file *m, void *v)
+{
+        int pid = (int *)v - tgid_map;
+
+        seq_printf(m, "%d %d\n", pid, trace_find_tgid(pid));
+        return 0;
+}
+
+static const struct seq_operations tracing_saved_tgids_seq_ops = {
+        .start          = saved_tgids_start,
+        .stop           = saved_tgids_stop,
+        .next           = saved_tgids_next,
+        .show           = saved_tgids_show,
+};
+
+static int tracing_saved_tgids_open(struct inode *inode, struct file *filp)
+{
+        if (tracing_disabled)
+                return -ENODEV;
+
+        return seq_open(filp, &tracing_saved_tgids_seq_ops);
+}
+
+
+static const struct file_operations tracing_saved_tgids_fops = {
+        .open           = tracing_saved_tgids_open,
+        .read           = seq_read,
+        .llseek         = seq_lseek,
+        .release        = seq_release,
+};
+
 static void *saved_cmdlines_next(struct seq_file *m, void *v, loff_t *pos)
 {
         unsigned int *ptr = v;
@@ -4746,11 +4941,11 @@ static const struct file_operations tracing_saved_cmdlines_size_fops = {
         .write          = tracing_saved_cmdlines_size_write,
 };
 
-#ifdef CONFIG_TRACE_ENUM_MAP_FILE
-static union trace_enum_map_item *
-update_enum_map(union trace_enum_map_item *ptr)
+#ifdef CONFIG_TRACE_EVAL_MAP_FILE
+static union trace_eval_map_item *
+update_eval_map(union trace_eval_map_item *ptr)
 {
-        if (!ptr->map.enum_string) {
+        if (!ptr->map.eval_string) {
                 if (ptr->tail.next) {
                         ptr = ptr->tail.next;
                         /* Set ptr to the next real item (skip head) */
@@ -4761,15 +4956,15 @@ update_enum_map(union trace_enum_map_item *ptr)
         return ptr;
 }
 
-static void *enum_map_next(struct seq_file *m, void *v, loff_t *pos)
+static void *eval_map_next(struct seq_file *m, void *v, loff_t *pos)
 {
-        union trace_enum_map_item *ptr = v;
+        union trace_eval_map_item *ptr = v;
 
         /*
          * Paranoid! If ptr points to end, we don't want to increment past it.
          * This really should never happen.
          */
-        ptr = update_enum_map(ptr);
+        ptr = update_eval_map(ptr);
         if (WARN_ON_ONCE(!ptr))
                 return NULL;
 
@@ -4777,104 +4972,104 @@ static void *enum_map_next(struct seq_file *m, void *v, loff_t *pos)
 
         (*pos)++;
 
-        ptr = update_enum_map(ptr);
+        ptr = update_eval_map(ptr);
 
         return ptr;
 }
 
-static void *enum_map_start(struct seq_file *m, loff_t *pos)
+static void *eval_map_start(struct seq_file *m, loff_t *pos)
 {
-        union trace_enum_map_item *v;
+        union trace_eval_map_item *v;
         loff_t l = 0;
 
-        mutex_lock(&trace_enum_mutex);
+        mutex_lock(&trace_eval_mutex);
 
-        v = trace_enum_maps;
+        v = trace_eval_maps;
         if (v)
                 v++;
 
         while (v && l < *pos) {
-                v = enum_map_next(m, v, &l);
+                v = eval_map_next(m, v, &l);
         }
 
         return v;
 }
 
-static void enum_map_stop(struct seq_file *m, void *v)
+static void eval_map_stop(struct seq_file *m, void *v)
 {
-        mutex_unlock(&trace_enum_mutex);
+        mutex_unlock(&trace_eval_mutex);
 }
 
-static int enum_map_show(struct seq_file *m, void *v)
+static int eval_map_show(struct seq_file *m, void *v)
 {
-        union trace_enum_map_item *ptr = v;
+        union trace_eval_map_item *ptr = v;
 
         seq_printf(m, "%s %ld (%s)\n",
-                   ptr->map.enum_string, ptr->map.enum_value,
+                   ptr->map.eval_string, ptr->map.eval_value,
                    ptr->map.system);
 
         return 0;
 }
 
-static const struct seq_operations tracing_enum_map_seq_ops = {
-        .start          = enum_map_start,
-        .next           = enum_map_next,
-        .stop           = enum_map_stop,
-        .show           = enum_map_show,
+static const struct seq_operations tracing_eval_map_seq_ops = {
+        .start          = eval_map_start,
+        .next           = eval_map_next,
+        .stop           = eval_map_stop,
+        .show           = eval_map_show,
 };
 
-static int tracing_enum_map_open(struct inode *inode, struct file *filp)
+static int tracing_eval_map_open(struct inode *inode, struct file *filp)
 {
         if (tracing_disabled)
                 return -ENODEV;
 
-        return seq_open(filp, &tracing_enum_map_seq_ops);
+        return seq_open(filp, &tracing_eval_map_seq_ops);
 }
 
-static const struct file_operations tracing_enum_map_fops = {
-        .open           = tracing_enum_map_open,
+static const struct file_operations tracing_eval_map_fops = {
+        .open           = tracing_eval_map_open,
         .read           = seq_read,
         .llseek         = seq_lseek,
         .release        = seq_release,
 };
 
-static inline union trace_enum_map_item *
-trace_enum_jmp_to_tail(union trace_enum_map_item *ptr)
+static inline union trace_eval_map_item *
+trace_eval_jmp_to_tail(union trace_eval_map_item *ptr)
 {
         /* Return tail of array given the head */
         return ptr + ptr->head.length + 1;
 }
 
 static void
-trace_insert_enum_map_file(struct module *mod, struct trace_enum_map **start,
+trace_insert_eval_map_file(struct module *mod, struct trace_eval_map **start,
                            int len)
 {
-        struct trace_enum_map **stop;
-        struct trace_enum_map **map;
-        union trace_enum_map_item *map_array;
-        union trace_enum_map_item *ptr;
+        struct trace_eval_map **stop;
+        struct trace_eval_map **map;
+        union trace_eval_map_item *map_array;
+        union trace_eval_map_item *ptr;
 
         stop = start + len;
 
         /*
-         * The trace_enum_maps contains the map plus a head and tail item,
+         * The trace_eval_maps contains the map plus a head and tail item,
          * where the head holds the module and length of array, and the
          * tail holds a pointer to the next list.
          */
         map_array = kmalloc(sizeof(*map_array) * (len + 2), GFP_KERNEL);
         if (!map_array) {
-                pr_warn("Unable to allocate trace enum mapping\n");
+                pr_warn("Unable to allocate trace eval mapping\n");
                 return;
         }
 
-        mutex_lock(&trace_enum_mutex);
+        mutex_lock(&trace_eval_mutex);
 
-        if (!trace_enum_maps)
-                trace_enum_maps = map_array;
+        if (!trace_eval_maps)
+                trace_eval_maps = map_array;
         else {
-                ptr = trace_enum_maps;
+                ptr = trace_eval_maps;
                 for (;;) {
-                        ptr = trace_enum_jmp_to_tail(ptr);
+                        ptr = trace_eval_jmp_to_tail(ptr);
                         if (!ptr->tail.next)
                                 break;
                         ptr = ptr->tail.next;
@@ -4892,34 +5087,34 @@ trace_insert_enum_map_file(struct module *mod, struct trace_enum_map **start,
         }
         memset(map_array, 0, sizeof(*map_array));
 
-        mutex_unlock(&trace_enum_mutex);
+        mutex_unlock(&trace_eval_mutex);
 }
 
-static void trace_create_enum_file(struct dentry *d_tracer)
+static void trace_create_eval_file(struct dentry *d_tracer)
 {
-        trace_create_file("enum_map", 0444, d_tracer,
-                          NULL, &tracing_enum_map_fops);
+        trace_create_file("eval_map", 0444, d_tracer,
+                          NULL, &tracing_eval_map_fops);
 }
 
-#else /* CONFIG_TRACE_ENUM_MAP_FILE */
-static inline void trace_create_enum_file(struct dentry *d_tracer) { }
-static inline void trace_insert_enum_map_file(struct module *mod,
-                              struct trace_enum_map **start, int len) { }
-#endif /* !CONFIG_TRACE_ENUM_MAP_FILE */
+#else /* CONFIG_TRACE_EVAL_MAP_FILE */
+static inline void trace_create_eval_file(struct dentry *d_tracer) { }
+static inline void trace_insert_eval_map_file(struct module *mod,
+                              struct trace_eval_map **start, int len) { }
+#endif /* !CONFIG_TRACE_EVAL_MAP_FILE */
 
-static void trace_insert_enum_map(struct module *mod,
-                                  struct trace_enum_map **start, int len)
+static void trace_insert_eval_map(struct module *mod,
+                                  struct trace_eval_map **start, int len)
 {
-        struct trace_enum_map **map;
+        struct trace_eval_map **map;
 
         if (len <= 0)
                 return;
 
         map = start;
 
-        trace_event_enum_update(map, len);
+        trace_event_eval_update(map, len);
 
-        trace_insert_enum_map_file(mod, start, len);
+        trace_insert_eval_map_file(mod, start, len);
 }
 
 static ssize_t
@@ -6739,33 +6934,18 @@ static const struct file_operations tracing_stats_fops = {
 
 #ifdef CONFIG_DYNAMIC_FTRACE
 
-int __weak ftrace_arch_read_dyn_info(char *buf, int size)
-{
-        return 0;
-}
-
 static ssize_t
 tracing_read_dyn_info(struct file *filp, char __user *ubuf,
                   size_t cnt, loff_t *ppos)
 {
-        static char ftrace_dyn_info_buffer[1024];
-        static DEFINE_MUTEX(dyn_info_mutex);
         unsigned long *p = filp->private_data;
-        char *buf = ftrace_dyn_info_buffer;
-        int size = ARRAY_SIZE(ftrace_dyn_info_buffer);
+        char buf[64]; /* Not too big for a shallow stack */
         int r;
 
-        mutex_lock(&dyn_info_mutex);
-        r = sprintf(buf, "%ld ", *p);
-
-        r += ftrace_arch_read_dyn_info(buf+r, (size-1)-r);
+        r = scnprintf(buf, 63, "%ld", *p);
         buf[r++] = '\n';
 
-        r = simple_read_from_buffer(ubuf, cnt, ppos, buf, r);
-
-        mutex_unlock(&dyn_info_mutex);
-
-        return r;
+        return simple_read_from_buffer(ubuf, cnt, ppos, buf, r);
 }
 
 static const struct file_operations tracing_dyn_info_fops = {
@@ -6881,6 +7061,9 @@ ftrace_trace_snapshot_callback(struct trace_array *tr, struct ftrace_hash *hash,
         char *number;
         int ret;
 
+        if (!tr)
+                return -ENODEV;
+
         /* hash funcs only work with set_ftrace_filter */
         if (!enable)
                 return -EINVAL;
@@ -7591,6 +7774,7 @@ static int instance_rmdir(const char *name)
         }
         kfree(tr->topts);
 
+        free_cpumask_var(tr->tracing_cpumask);
         kfree(tr->name);
         kfree(tr);
 
@@ -7734,21 +7918,21 @@ struct dentry *tracing_init_dentry(void)
         return NULL;
 }
 
-extern struct trace_enum_map *__start_ftrace_enum_maps[];
-extern struct trace_enum_map *__stop_ftrace_enum_maps[];
+extern struct trace_eval_map *__start_ftrace_eval_maps[];
+extern struct trace_eval_map *__stop_ftrace_eval_maps[];
 
-static void __init trace_enum_init(void)
+static void __init trace_eval_init(void)
 {
         int len;
 
-        len = __stop_ftrace_enum_maps - __start_ftrace_enum_maps;
-        trace_insert_enum_map(NULL, __start_ftrace_enum_maps, len);
+        len = __stop_ftrace_eval_maps - __start_ftrace_eval_maps;
+        trace_insert_eval_map(NULL, __start_ftrace_eval_maps, len);
 }
 
 #ifdef CONFIG_MODULES
-static void trace_module_add_enums(struct module *mod)
+static void trace_module_add_evals(struct module *mod)
 {
-        if (!mod->num_trace_enums)
+        if (!mod->num_trace_evals)
                 return;
 
         /*
@@ -7758,40 +7942,40 @@ static void trace_module_add_enums(struct module *mod)
         if (trace_module_has_bad_taint(mod))
                 return;
 
-        trace_insert_enum_map(mod, mod->trace_enums, mod->num_trace_enums);
+        trace_insert_eval_map(mod, mod->trace_evals, mod->num_trace_evals);
 }
 
-#ifdef CONFIG_TRACE_ENUM_MAP_FILE
-static void trace_module_remove_enums(struct module *mod)
+#ifdef CONFIG_TRACE_EVAL_MAP_FILE
+static void trace_module_remove_evals(struct module *mod)
 {
-        union trace_enum_map_item *map;
-        union trace_enum_map_item **last = &trace_enum_maps;
+        union trace_eval_map_item *map;
+        union trace_eval_map_item **last = &trace_eval_maps;
 
-        if (!mod->num_trace_enums)
+        if (!mod->num_trace_evals)
                 return;
 
-        mutex_lock(&trace_enum_mutex);
+        mutex_lock(&trace_eval_mutex);
 
-        map = trace_enum_maps;
+        map = trace_eval_maps;
 
         while (map) {
                 if (map->head.mod == mod)
                         break;
-                map = trace_enum_jmp_to_tail(map);
+                map = trace_eval_jmp_to_tail(map);
                 last = &map->tail.next;
                 map = map->tail.next;
         }
         if (!map)
                 goto out;
 
-        *last = trace_enum_jmp_to_tail(map)->tail.next;
+        *last = trace_eval_jmp_to_tail(map)->tail.next;
         kfree(map);
  out:
-        mutex_unlock(&trace_enum_mutex);
+        mutex_unlock(&trace_eval_mutex);
 }
 #else
-static inline void trace_module_remove_enums(struct module *mod) { }
-#endif /* CONFIG_TRACE_ENUM_MAP_FILE */
+static inline void trace_module_remove_evals(struct module *mod) { }
+#endif /* CONFIG_TRACE_EVAL_MAP_FILE */
 
 static int trace_module_notify(struct notifier_block *self,
                                unsigned long val, void *data)
@@ -7800,10 +7984,10 @@ static int trace_module_notify(struct notifier_block *self,
 
         switch (val) {
         case MODULE_STATE_COMING:
-                trace_module_add_enums(mod);
+                trace_module_add_evals(mod);
                 break;
         case MODULE_STATE_GOING:
-                trace_module_remove_enums(mod);
+                trace_module_remove_evals(mod);
                 break;
         }
 
@@ -7841,9 +8025,12 @@ static __init int tracer_init_tracefs(void)
         trace_create_file("saved_cmdlines_size", 0644, d_tracer,
                           NULL, &tracing_saved_cmdlines_size_fops);
 
-        trace_enum_init();
+        trace_create_file("saved_tgids", 0444, d_tracer,
+                        NULL, &tracing_saved_tgids_fops);
+
+        trace_eval_init();
 
-        trace_create_enum_file(d_tracer);
+        trace_create_eval_file(d_tracer);
 
 #ifdef CONFIG_MODULES
         register_module_notifier(&trace_module_nb);
diff --git a/kernel/trace/trace.h b/kernel/trace/trace.h
index 39fd77330aab..490ba229931d 100644
--- a/kernel/trace/trace.h
+++ b/kernel/trace/trace.h
@@ -263,7 +263,10 @@ struct trace_array {
         struct ftrace_ops       *ops;
         struct trace_pid_list   __rcu *function_pids;
 #ifdef CONFIG_DYNAMIC_FTRACE
+        /* All of these are protected by the ftrace_lock */
         struct list_head        func_probes;
+        struct list_head        mod_trace;
+        struct list_head        mod_notrace;
 #endif
         /* function tracing enabled */
         int                     function_enabled;
@@ -637,6 +640,9 @@ void set_graph_array(struct trace_array *tr);
 
 void tracing_start_cmdline_record(void);
 void tracing_stop_cmdline_record(void);
+void tracing_start_tgid_record(void);
+void tracing_stop_tgid_record(void);
+
 int register_tracer(struct tracer *type);
 int is_tracing_stopped(void);
 
@@ -697,6 +703,7 @@ static inline void __trace_stack(struct trace_array *tr, unsigned long flags,
 extern u64 ftrace_now(int cpu);
 
 extern void trace_find_cmdline(int pid, char comm[]);
+extern int trace_find_tgid(int pid);
 extern void trace_event_follow_fork(struct trace_array *tr, bool enable);
 
 #ifdef CONFIG_DYNAMIC_FTRACE
@@ -761,10 +768,24 @@ enum print_line_t print_trace_line(struct trace_iterator *iter);
 
 extern char trace_find_mark(unsigned long long duration);
 
+struct ftrace_hash;
+
+struct ftrace_mod_load {
+        struct list_head        list;
+        char                    *func;
+        char                    *module;
+        int                      enable;
+};
+
+enum {
+        FTRACE_HASH_FL_MOD      = (1 << 0),
+};
+
 struct ftrace_hash {
         unsigned long           size_bits;
         struct hlist_head       *buckets;
         unsigned long           count;
+        unsigned long           flags;
         struct rcu_head         rcu;
 };
 
@@ -773,7 +794,7 @@ ftrace_lookup_ip(struct ftrace_hash *hash, unsigned long ip);
 
 static __always_inline bool ftrace_hash_empty(struct ftrace_hash *hash)
 {
-        return !hash || !hash->count;
+        return !hash || !(hash->count || (hash->flags & FTRACE_HASH_FL_MOD));
 }
 
 /* Standard output formatting function used for function return traces */
@@ -1107,6 +1128,7 @@ extern int trace_get_user(struct trace_parser *parser, const char __user *ubuf,
                 C(CONTEXT_INFO,         "context-info"),   /* Print pid/cpu/time */ \
                 C(LATENCY_FMT,          "latency-format"),      \
                 C(RECORD_CMD,           "record-cmd"),          \
+                C(RECORD_TGID,          "record-tgid"),         \
                 C(OVERWRITE,            "overwrite"),           \
                 C(STOP_ON_FREE,         "disable_on_free"),     \
                 C(IRQ_INFO,             "irq-info"),            \
@@ -1188,9 +1210,9 @@ struct ftrace_event_field {
 struct event_filter {
         int                     n_preds;        /* Number assigned */
         int                     a_preds;        /* allocated */
-        struct filter_pred      *preds;
-        struct filter_pred      *root;
-        char                    *filter_string;
+        struct filter_pred __rcu        *preds;
+        struct filter_pred __rcu        *root;
+        char                            *filter_string;
 };
 
 struct event_subsystem {
@@ -1423,6 +1445,8 @@ struct ftrace_event_field *
 trace_find_event_field(struct trace_event_call *call, char *name);
 
 extern void trace_event_enable_cmd_record(bool enable);
+extern void trace_event_enable_tgid_record(bool enable);
+
 extern int event_trace_add_tracer(struct dentry *parent, struct trace_array *tr);
 extern int event_trace_del_tracer(struct trace_array *tr);
 
@@ -1773,10 +1797,10 @@ static inline const char *get_syscall_name(int syscall)
 
 #ifdef CONFIG_EVENT_TRACING
 void trace_event_init(void);
-void trace_event_enum_update(struct trace_enum_map **map, int len);
+void trace_event_eval_update(struct trace_eval_map **map, int len);
 #else
 static inline void __init trace_event_init(void) { }
-static inline void trace_event_enum_update(struct trace_enum_map **map, int len) { }
+static inline void trace_event_eval_update(struct trace_eval_map **map, int len) { }
 #endif
 
 extern struct trace_iterator *tracepoint_print_iter;
diff --git a/kernel/trace/trace_events.c b/kernel/trace/trace_events.c
index e7973e10398c..36132f9280e6 100644
--- a/kernel/trace/trace_events.c
+++ b/kernel/trace/trace_events.c
@@ -343,6 +343,28 @@ void trace_event_enable_cmd_record(bool enable)
         mutex_unlock(&event_mutex);
 }
 
+void trace_event_enable_tgid_record(bool enable)
+{
+        struct trace_event_file *file;
+        struct trace_array *tr;
+
+        mutex_lock(&event_mutex);
+        do_for_each_event_file(tr, file) {
+                if (!(file->flags & EVENT_FILE_FL_ENABLED))
+                        continue;
+
+                if (enable) {
+                        tracing_start_tgid_record();
+                        set_bit(EVENT_FILE_FL_RECORDED_TGID_BIT, &file->flags);
+                } else {
+                        tracing_stop_tgid_record();
+                        clear_bit(EVENT_FILE_FL_RECORDED_TGID_BIT,
+                                  &file->flags);
+                }
+        } while_for_each_event_file();
+        mutex_unlock(&event_mutex);
+}
+
 static int __ftrace_event_enable_disable(struct trace_event_file *file,
                                          int enable, int soft_disable)
 {
@@ -381,6 +403,12 @@ static int __ftrace_event_enable_disable(struct trace_event_file *file,
                                 tracing_stop_cmdline_record();
                                 clear_bit(EVENT_FILE_FL_RECORDED_CMD_BIT, &file->flags);
                         }
+
+                        if (file->flags & EVENT_FILE_FL_RECORDED_TGID) {
+                                tracing_stop_tgid_record();
+                                clear_bit(EVENT_FILE_FL_RECORDED_CMD_BIT, &file->flags);
+                        }
+
                         call->class->reg(call, TRACE_REG_UNREGISTER, file);
                 }
                 /* If in SOFT_MODE, just set the SOFT_DISABLE_BIT, else clear it */
@@ -407,18 +435,30 @@ static int __ftrace_event_enable_disable(struct trace_event_file *file,
                 }
 
                 if (!(file->flags & EVENT_FILE_FL_ENABLED)) {
+                        bool cmd = false, tgid = false;
 
                         /* Keep the event disabled, when going to SOFT_MODE. */
                         if (soft_disable)
                                 set_bit(EVENT_FILE_FL_SOFT_DISABLED_BIT, &file->flags);
 
                         if (tr->trace_flags & TRACE_ITER_RECORD_CMD) {
+                                cmd = true;
                                 tracing_start_cmdline_record();
                                 set_bit(EVENT_FILE_FL_RECORDED_CMD_BIT, &file->flags);
                         }
+
+                        if (tr->trace_flags & TRACE_ITER_RECORD_TGID) {
+                                tgid = true;
+                                tracing_start_tgid_record();
+                                set_bit(EVENT_FILE_FL_RECORDED_TGID_BIT, &file->flags);
+                        }
+
                         ret = call->class->reg(call, TRACE_REG_REGISTER, file);
                         if (ret) {
-                                tracing_stop_cmdline_record();
+                                if (cmd)
+                                        tracing_stop_cmdline_record();
+                                if (tgid)
+                                        tracing_stop_tgid_record();
                                 pr_info("event trace: Could not enable event "
                                         "%s\n", trace_event_name(call));
                                 break;
@@ -2067,18 +2107,18 @@ __register_event(struct trace_event_call *call, struct module *mod)
         return 0;
 }
 
-static char *enum_replace(char *ptr, struct trace_enum_map *map, int len)
+static char *eval_replace(char *ptr, struct trace_eval_map *map, int len)
 {
         int rlen;
         int elen;
 
-        /* Find the length of the enum value as a string */
-        elen = snprintf(ptr, 0, "%ld", map->enum_value);
+        /* Find the length of the eval value as a string */
+        elen = snprintf(ptr, 0, "%ld", map->eval_value);
         /* Make sure there's enough room to replace the string with the value */
         if (len < elen)
                 return NULL;
 
-        snprintf(ptr, elen + 1, "%ld", map->enum_value);
+        snprintf(ptr, elen + 1, "%ld", map->eval_value);
 
         /* Get the rest of the string of ptr */
         rlen = strlen(ptr + len);
@@ -2090,11 +2130,11 @@ static char *enum_replace(char *ptr, struct trace_enum_map *map, int len)
 }
 
 static void update_event_printk(struct trace_event_call *call,
-                                struct trace_enum_map *map)
+                                struct trace_eval_map *map)
 {
         char *ptr;
         int quote = 0;
-        int len = strlen(map->enum_string);
+        int len = strlen(map->eval_string);
 
         for (ptr = call->print_fmt; *ptr; ptr++) {
                 if (*ptr == '\\') {
@@ -2125,16 +2165,16 @@ static void update_event_printk(struct trace_event_call *call,
                         continue;
                 }
                 if (isalpha(*ptr) || *ptr == '_') {
-                        if (strncmp(map->enum_string, ptr, len) == 0 &&
+                        if (strncmp(map->eval_string, ptr, len) == 0 &&
                             !isalnum(ptr[len]) && ptr[len] != '_') {
-                                ptr = enum_replace(ptr, map, len);
-                                /* Hmm, enum string smaller than value */
+                                ptr = eval_replace(ptr, map, len);
+                                /* enum/sizeof string smaller than value */
                                 if (WARN_ON_ONCE(!ptr))
                                         return;
                                 /*
-                                 * No need to decrement here, as enum_replace()
+                                 * No need to decrement here, as eval_replace()
                                  * returns the pointer to the character passed
-                                 * the enum, and two enums can not be placed
+                                 * the eval, and two evals can not be placed
                                  * back to back without something in between.
                                  * We can skip that something in between.
                                  */
@@ -2165,7 +2205,7 @@ static void update_event_printk(struct trace_event_call *call,
         }
 }
 
-void trace_event_enum_update(struct trace_enum_map **map, int len)
+void trace_event_eval_update(struct trace_eval_map **map, int len)
 {
         struct trace_event_call *call, *p;
         const char *last_system = NULL;
diff --git a/kernel/trace/trace_functions.c b/kernel/trace/trace_functions.c
index a3bddbfd0874..a0910c0cdf2e 100644
--- a/kernel/trace/trace_functions.c
+++ b/kernel/trace/trace_functions.c
@@ -654,6 +654,9 @@ ftrace_trace_onoff_callback(struct trace_array *tr, struct ftrace_hash *hash,
 {
         struct ftrace_probe_ops *ops;
 
+        if (!tr)
+                return -ENODEV;
+
         /* we register both traceon and traceoff to this callback */
         if (strcmp(cmd, "traceon") == 0)
                 ops = param ? &traceon_count_probe_ops : &traceon_probe_ops;
@@ -670,6 +673,9 @@ ftrace_stacktrace_callback(struct trace_array *tr, struct ftrace_hash *hash,
 {
         struct ftrace_probe_ops *ops;
 
+        if (!tr)
+                return -ENODEV;
+
         ops = param ? &stacktrace_count_probe_ops : &stacktrace_probe_ops;
 
         return ftrace_trace_probe_callback(tr, ops, hash, glob, cmd,
@@ -682,6 +688,9 @@ ftrace_dump_callback(struct trace_array *tr, struct ftrace_hash *hash,
 {
         struct ftrace_probe_ops *ops;
 
+        if (!tr)
+                return -ENODEV;
+
         ops = &dump_probe_ops;
 
         /* Only dump once. */
@@ -695,6 +704,9 @@ ftrace_cpudump_callback(struct trace_array *tr, struct ftrace_hash *hash,
 {
         struct ftrace_probe_ops *ops;
 
+        if (!tr)
+                return -ENODEV;
+
         ops = &cpudump_probe_ops;
 
         /* Only dump once. */
diff --git a/kernel/trace/trace_kprobe.c b/kernel/trace/trace_kprobe.c
index c129fca6ec99..c9b5aa10fbf9 100644
--- a/kernel/trace/trace_kprobe.c
+++ b/kernel/trace/trace_kprobe.c
@@ -598,6 +598,14 @@ static struct notifier_block trace_kprobe_module_nb = {
         .priority = 1   /* Invoked after kprobe module callback */
 };
 
+/* Convert certain expected symbols into '_' when generating event names */
+static inline void sanitize_event_name(char *name)
+{
+        while (*name++ != '\0')
+                if (*name == ':' || *name == '.')
+                        *name = '_';
+}
+
 static int create_trace_kprobe(int argc, char **argv)
 {
         /*
@@ -707,24 +715,20 @@ static int create_trace_kprobe(int argc, char **argv)
                 pr_info("Probe point is not specified.\n");
                 return -EINVAL;
         }
-        if (isdigit(argv[1][0])) {
-                /* an address specified */
-                ret = kstrtoul(&argv[1][0], 0, (unsigned long *)&addr);
-                if (ret) {
-                        pr_info("Failed to parse address.\n");
-                        return ret;
-                }
-        } else {
+
+        /* try to parse an address. if that fails, try to read the
+         * input as a symbol. */
+        if (kstrtoul(argv[1], 0, (unsigned long *)&addr)) {
                 /* a symbol specified */
                 symbol = argv[1];
                 /* TODO: support .init module functions */
                 ret = traceprobe_split_symbol_offset(symbol, &offset);
                 if (ret) {
-                        pr_info("Failed to parse symbol.\n");
+                        pr_info("Failed to parse either an address or a symbol.\n");
                         return ret;
                 }
                 if (offset && is_return &&
-                    !function_offset_within_entry(NULL, symbol, offset)) {
+                    !kprobe_on_func_entry(NULL, symbol, offset)) {
                         pr_info("Given offset is not valid for return probe.\n");
                         return -EINVAL;
                 }
@@ -740,6 +744,7 @@ static int create_trace_kprobe(int argc, char **argv)
                 else
                         snprintf(buf, MAX_EVENT_NAME_LEN, "%c_0x%p",
                                  is_return ? 'r' : 'p', addr);
+                sanitize_event_name(buf);
                 event = buf;
         }
         tk = alloc_trace_kprobe(group, event, addr, symbol, offset, maxactive,
diff --git a/kernel/trace/trace_output.c b/kernel/trace/trace_output.c
index 08f9bab8089e..bac629af2285 100644
--- a/kernel/trace/trace_output.c
+++ b/kernel/trace/trace_output.c
@@ -340,31 +340,41 @@ static inline const char *kretprobed(const char *name)
 static void
 seq_print_sym_short(struct trace_seq *s, const char *fmt, unsigned long address)
 {
-#ifdef CONFIG_KALLSYMS
         char str[KSYM_SYMBOL_LEN];
+#ifdef CONFIG_KALLSYMS
         const char *name;
 
         kallsyms_lookup(address, NULL, NULL, NULL, str);
 
         name = kretprobed(str);
 
-        trace_seq_printf(s, fmt, name);
+        if (name && strlen(name)) {
+                trace_seq_printf(s, fmt, name);
+                return;
+        }
 #endif
+        snprintf(str, KSYM_SYMBOL_LEN, "0x%08lx", address);
+        trace_seq_printf(s, fmt, str);
 }
 
 static void
 seq_print_sym_offset(struct trace_seq *s, const char *fmt,
                      unsigned long address)
 {
-#ifdef CONFIG_KALLSYMS
         char str[KSYM_SYMBOL_LEN];
+#ifdef CONFIG_KALLSYMS
         const char *name;
 
         sprint_symbol(str, address);
         name = kretprobed(str);
 
-        trace_seq_printf(s, fmt, name);
+        if (name && strlen(name)) {
+                trace_seq_printf(s, fmt, name);
+                return;
+        }
 #endif
+        snprintf(str, KSYM_SYMBOL_LEN, "0x%08lx", address);
+        trace_seq_printf(s, fmt, str);
 }
 
 #ifndef CONFIG_64BIT
@@ -587,6 +597,15 @@ int trace_print_context(struct trace_iterator *iter)
         trace_seq_printf(s, "%16s-%-5d [%03d] ",
                                comm, entry->pid, iter->cpu);
 
+        if (tr->trace_flags & TRACE_ITER_RECORD_TGID) {
+                unsigned int tgid = trace_find_tgid(entry->pid);
+
+                if (!tgid)
+                        trace_seq_printf(s, "(-----) ");
+                else
+                        trace_seq_printf(s, "(%5d) ", tgid);
+        }
+
         if (tr->trace_flags & TRACE_ITER_IRQ_INFO)
                 trace_print_lat_fmt(s, entry);
 
diff --git a/kernel/trace/trace_sched_switch.c b/kernel/trace/trace_sched_switch.c
index 4c896a0101bd..b341c02730be 100644
--- a/kernel/trace/trace_sched_switch.c
+++ b/kernel/trace/trace_sched_switch.c
@@ -12,27 +12,38 @@
 
 #include "trace.h"
 
-static int                      sched_ref;
+#define RECORD_CMDLINE  1
+#define RECORD_TGID     2
+
+static int              sched_cmdline_ref;
+static int              sched_tgid_ref;
 static DEFINE_MUTEX(sched_register_mutex);
 
 static void
 probe_sched_switch(void *ignore, bool preempt,
                    struct task_struct *prev, struct task_struct *next)
 {
-        if (unlikely(!sched_ref))
-                return;
+        int flags;
+
+        flags = (RECORD_TGID * !!sched_tgid_ref) +
+                (RECORD_CMDLINE * !!sched_cmdline_ref);
 
-        tracing_record_cmdline(prev);
-        tracing_record_cmdline(next);
+        if (!flags)
+                return;
+        tracing_record_taskinfo_sched_switch(prev, next, flags);
 }
 
 static void
 probe_sched_wakeup(void *ignore, struct task_struct *wakee)
 {
-        if (unlikely(!sched_ref))
-                return;
+        int flags;
+
+        flags = (RECORD_TGID * !!sched_tgid_ref) +
+                (RECORD_CMDLINE * !!sched_cmdline_ref);
 
-        tracing_record_cmdline(current);
+        if (!flags)
+                return;
+        tracing_record_taskinfo(current, flags);
 }
 
 static int tracing_sched_register(void)
@@ -75,28 +86,61 @@ static void tracing_sched_unregister(void)
         unregister_trace_sched_wakeup(probe_sched_wakeup, NULL);
 }
 
-static void tracing_start_sched_switch(void)
+static void tracing_start_sched_switch(int ops)
 {
+        bool sched_register = (!sched_cmdline_ref && !sched_tgid_ref);
         mutex_lock(&sched_register_mutex);
-        if (!(sched_ref++))
+
+        switch (ops) {
+        case RECORD_CMDLINE:
+                sched_cmdline_ref++;
+                break;
+
+        case RECORD_TGID:
+                sched_tgid_ref++;
+                break;
+        }
+
+        if (sched_register && (sched_cmdline_ref || sched_tgid_ref))
                 tracing_sched_register();
         mutex_unlock(&sched_register_mutex);
 }
 
-static void tracing_stop_sched_switch(void)
+static void tracing_stop_sched_switch(int ops)
 {
         mutex_lock(&sched_register_mutex);
-        if (!(--sched_ref))
+
+        switch (ops) {
+        case RECORD_CMDLINE:
+                sched_cmdline_ref--;
+                break;
+
+        case RECORD_TGID:
+                sched_tgid_ref--;
+                break;
+        }
+
+        if (!sched_cmdline_ref && !sched_tgid_ref)
                 tracing_sched_unregister();
         mutex_unlock(&sched_register_mutex);
 }
 
 void tracing_start_cmdline_record(void)
 {
-        tracing_start_sched_switch();
+        tracing_start_sched_switch(RECORD_CMDLINE);
 }
 
 void tracing_stop_cmdline_record(void)
 {
-        tracing_stop_sched_switch();
+        tracing_stop_sched_switch(RECORD_CMDLINE);
+}
+
+void tracing_start_tgid_record(void)
+{
+        tracing_start_sched_switch(RECORD_TGID);
+}
+
+void tracing_stop_tgid_record(void)
+{
+        tracing_stop_sched_switch(RECORD_TGID);
 }
diff --git a/kernel/trace/trace_stack.c b/kernel/trace/trace_stack.c
index 76aa04d4c925..a4df67cbc711 100644
--- a/kernel/trace/trace_stack.c
+++ b/kernel/trace/trace_stack.c
@@ -406,10 +406,14 @@ static const struct file_operations stack_trace_fops = {
         .release        = seq_release,
 };
 
+#ifdef CONFIG_DYNAMIC_FTRACE
+
 static int
 stack_trace_filter_open(struct inode *inode, struct file *file)
 {
-        return ftrace_regex_open(&trace_ops, FTRACE_ITER_FILTER,
+        struct ftrace_ops *ops = inode->i_private;
+
+        return ftrace_regex_open(ops, FTRACE_ITER_FILTER,
                                  inode, file);
 }
 
@@ -421,6 +425,8 @@ static const struct file_operations stack_trace_filter_fops = {
         .release = ftrace_regex_release,
 };
 
+#endif /* CONFIG_DYNAMIC_FTRACE */
+
 int
 stack_trace_sysctl(struct ctl_table *table, int write,
                    void __user *buffer, size_t *lenp,
@@ -475,8 +481,10 @@ static __init int stack_trace_init(void)
         trace_create_file("stack_trace", 0444, d_tracer,
                         NULL, &stack_trace_fops);
 
+#ifdef CONFIG_DYNAMIC_FTRACE
         trace_create_file("stack_trace_filter", 0444, d_tracer,
-                        NULL, &stack_trace_filter_fops);
+                          &trace_ops, &stack_trace_filter_fops);
+#endif
 
         if (stack_trace_filter_buf[0])
                 ftrace_set_early_filter(&trace_ops, stack_trace_filter_buf, 1);
diff --git a/kernel/watchdog.c b/kernel/watchdog.c
index 03e0b69bb5bf..06d3389bca0d 100644
--- a/kernel/watchdog.c
+++ b/kernel/watchdog.c
@@ -9,7 +9,7 @@
  * to those contributors as well.
  */
 
-#define pr_fmt(fmt) "NMI watchdog: " fmt
+#define pr_fmt(fmt) "watchdog: " fmt
 
 #include <linux/mm.h>
 #include <linux/cpu.h>
@@ -29,15 +29,58 @@
 #include <linux/kvm_para.h>
 #include <linux/kthread.h>
 
+/* Watchdog configuration */
 static DEFINE_MUTEX(watchdog_proc_mutex);
 
-#if defined(CONFIG_HAVE_NMI_WATCHDOG) || defined(CONFIG_HARDLOCKUP_DETECTOR)
-unsigned long __read_mostly watchdog_enabled = SOFT_WATCHDOG_ENABLED|NMI_WATCHDOG_ENABLED;
+int __read_mostly nmi_watchdog_enabled;
+
+#if defined(CONFIG_HARDLOCKUP_DETECTOR) || defined(CONFIG_HAVE_NMI_WATCHDOG)
+unsigned long __read_mostly watchdog_enabled = SOFT_WATCHDOG_ENABLED |
+                                                NMI_WATCHDOG_ENABLED;
 #else
 unsigned long __read_mostly watchdog_enabled = SOFT_WATCHDOG_ENABLED;
 #endif
-int __read_mostly nmi_watchdog_enabled;
+
+#ifdef CONFIG_HARDLOCKUP_DETECTOR
+/* boot commands */
+/*
+ * Should we panic when a soft-lockup or hard-lockup occurs:
+ */
+unsigned int __read_mostly hardlockup_panic =
+                        CONFIG_BOOTPARAM_HARDLOCKUP_PANIC_VALUE;
+/*
+ * We may not want to enable hard lockup detection by default in all cases,
+ * for example when running the kernel as a guest on a hypervisor. In these
+ * cases this function can be called to disable hard lockup detection. This
+ * function should only be executed once by the boot processor before the
+ * kernel command line parameters are parsed, because otherwise it is not
+ * possible to override this in hardlockup_panic_setup().
+ */
+void hardlockup_detector_disable(void)
+{
+        watchdog_enabled &= ~NMI_WATCHDOG_ENABLED;
+}
+
+static int __init hardlockup_panic_setup(char *str)
+{
+        if (!strncmp(str, "panic", 5))
+                hardlockup_panic = 1;
+        else if (!strncmp(str, "nopanic", 7))
+                hardlockup_panic = 0;
+        else if (!strncmp(str, "0", 1))
+                watchdog_enabled &= ~NMI_WATCHDOG_ENABLED;
+        else if (!strncmp(str, "1", 1))
+                watchdog_enabled |= NMI_WATCHDOG_ENABLED;
+        return 1;
+}
+__setup("nmi_watchdog=", hardlockup_panic_setup);
+
+#endif
+
+#ifdef CONFIG_SOFTLOCKUP_DETECTOR
 int __read_mostly soft_watchdog_enabled;
+#endif
+
 int __read_mostly watchdog_user_enabled;
 int __read_mostly watchdog_thresh = 10;
 
@@ -45,15 +88,9 @@ int __read_mostly watchdog_thresh = 10;
 int __read_mostly sysctl_softlockup_all_cpu_backtrace;
 int __read_mostly sysctl_hardlockup_all_cpu_backtrace;
 #endif
-static struct cpumask watchdog_cpumask __read_mostly;
+struct cpumask watchdog_cpumask __read_mostly;
 unsigned long *watchdog_cpumask_bits = cpumask_bits(&watchdog_cpumask);
 
-/* Helper for online, unparked cpus. */
-#define for_each_watchdog_cpu(cpu) \
-        for_each_cpu_and((cpu), cpu_online_mask, &watchdog_cpumask)
-
-atomic_t watchdog_park_in_progress = ATOMIC_INIT(0);
-
 /*
  * The 'watchdog_running' variable is set to 1 when the watchdog threads
  * are registered/started and is set to 0 when the watchdog threads are
@@ -72,7 +109,47 @@ static int __read_mostly watchdog_running;
  * of 'watchdog_running' cannot change while the watchdog is deactivated
  * temporarily (see related code in 'proc' handlers).
  */
-static int __read_mostly watchdog_suspended;
+int __read_mostly watchdog_suspended;
+
+/*
+ * These functions can be overridden if an architecture implements its
+ * own hardlockup detector.
+ *
+ * watchdog_nmi_enable/disable can be implemented to start and stop when
+ * softlockup watchdog threads start and stop. The arch must select the
+ * SOFTLOCKUP_DETECTOR Kconfig.
+ */
+int __weak watchdog_nmi_enable(unsigned int cpu)
+{
+        return 0;
+}
+void __weak watchdog_nmi_disable(unsigned int cpu)
+{
+}
+
+/*
+ * watchdog_nmi_reconfigure can be implemented to be notified after any
+ * watchdog configuration change. The arch hardlockup watchdog should
+ * respond to the following variables:
+ * - nmi_watchdog_enabled
+ * - watchdog_thresh
+ * - watchdog_cpumask
+ * - sysctl_hardlockup_all_cpu_backtrace
+ * - hardlockup_panic
+ * - watchdog_suspended
+ */
+void __weak watchdog_nmi_reconfigure(void)
+{
+}
+
+
+#ifdef CONFIG_SOFTLOCKUP_DETECTOR
+
+/* Helper for online, unparked cpus. */
+#define for_each_watchdog_cpu(cpu) \
+        for_each_cpu_and((cpu), cpu_online_mask, &watchdog_cpumask)
+
+atomic_t watchdog_park_in_progress = ATOMIC_INIT(0);
 
 static u64 __read_mostly sample_period;
 
@@ -120,6 +197,7 @@ static int __init softlockup_all_cpu_backtrace_setup(char *str)
         return 1;
 }
 __setup("softlockup_all_cpu_backtrace=", softlockup_all_cpu_backtrace_setup);
+#ifdef CONFIG_HARDLOCKUP_DETECTOR
 static int __init hardlockup_all_cpu_backtrace_setup(char *str)
 {
         sysctl_hardlockup_all_cpu_backtrace =
@@ -128,6 +206,7 @@ static int __init hardlockup_all_cpu_backtrace_setup(char *str)
 }
 __setup("hardlockup_all_cpu_backtrace=", hardlockup_all_cpu_backtrace_setup);
 #endif
+#endif
 
 /*
  * Hard-lockup warnings should be triggered after just a few seconds. Soft-
@@ -213,18 +292,6 @@ void touch_softlockup_watchdog_sync(void)
         __this_cpu_write(watchdog_touch_ts, 0);
 }
 
-/* watchdog detector functions */
-bool is_hardlockup(void)
-{
-        unsigned long hrint = __this_cpu_read(hrtimer_interrupts);
-
-        if (__this_cpu_read(hrtimer_interrupts_saved) == hrint)
-                return true;
-
-        __this_cpu_write(hrtimer_interrupts_saved, hrint);
-        return false;
-}
-
 static int is_softlockup(unsigned long touch_ts)
 {
         unsigned long now = get_timestamp();
@@ -237,21 +304,21 @@ static int is_softlockup(unsigned long touch_ts)
         return 0;
 }
 
-static void watchdog_interrupt_count(void)
+/* watchdog detector functions */
+bool is_hardlockup(void)
 {
-        __this_cpu_inc(hrtimer_interrupts);
-}
+        unsigned long hrint = __this_cpu_read(hrtimer_interrupts);
 
-/*
- * These two functions are mostly architecture specific
- * defining them as weak here.
- */
-int __weak watchdog_nmi_enable(unsigned int cpu)
-{
-        return 0;
+        if (__this_cpu_read(hrtimer_interrupts_saved) == hrint)
+                return true;
+
+        __this_cpu_write(hrtimer_interrupts_saved, hrint);
+        return false;
 }
-void __weak watchdog_nmi_disable(unsigned int cpu)
+
+static void watchdog_interrupt_count(void)
 {
+        __this_cpu_inc(hrtimer_interrupts);
 }
 
 static int watchdog_enable_all_cpus(void);
@@ -502,57 +569,6 @@ static void watchdog_unpark_threads(void)
                 kthread_unpark(per_cpu(softlockup_watchdog, cpu));
 }
 
-/*
- * Suspend the hard and soft lockup detector by parking the watchdog threads.
- */
-int lockup_detector_suspend(void)
-{
-        int ret = 0;
-
-        get_online_cpus();
-        mutex_lock(&watchdog_proc_mutex);
-        /*
-         * Multiple suspend requests can be active in parallel (counted by
-         * the 'watchdog_suspended' variable). If the watchdog threads are
-         * running, the first caller takes care that they will be parked.
-         * The state of 'watchdog_running' cannot change while a suspend
-         * request is active (see related code in 'proc' handlers).
-         */
-        if (watchdog_running && !watchdog_suspended)
-                ret = watchdog_park_threads();
-
-        if (ret == 0)
-                watchdog_suspended++;
-        else {
-                watchdog_disable_all_cpus();
-                pr_err("Failed to suspend lockup detectors, disabled\n");
-                watchdog_enabled = 0;
-        }
-
-        mutex_unlock(&watchdog_proc_mutex);
-
-        return ret;
-}
-
-/*
- * Resume the hard and soft lockup detector by unparking the watchdog threads.
- */
-void lockup_detector_resume(void)
-{
-        mutex_lock(&watchdog_proc_mutex);
-
-        watchdog_suspended--;
-        /*
-         * The watchdog threads are unparked if they were previously running
-         * and if there is no more active suspend request.
-         */
-        if (watchdog_running && !watchdog_suspended)
-                watchdog_unpark_threads();
-
-        mutex_unlock(&watchdog_proc_mutex);
-        put_online_cpus();
-}
-
 static int update_watchdog_all_cpus(void)
 {
         int ret;
@@ -605,6 +621,100 @@ static void watchdog_disable_all_cpus(void)
 }
 
 #ifdef CONFIG_SYSCTL
+static int watchdog_update_cpus(void)
+{
+        return smpboot_update_cpumask_percpu_thread(
+                    &watchdog_threads, &watchdog_cpumask);
+}
+#endif
+
+#else /* SOFTLOCKUP */
+static int watchdog_park_threads(void)
+{
+        return 0;
+}
+
+static void watchdog_unpark_threads(void)
+{
+}
+
+static int watchdog_enable_all_cpus(void)
+{
+        return 0;
+}
+
+static void watchdog_disable_all_cpus(void)
+{
+}
+
+#ifdef CONFIG_SYSCTL
+static int watchdog_update_cpus(void)
+{
+        return 0;
+}
+#endif
+
+static void set_sample_period(void)
+{
+}
+#endif /* SOFTLOCKUP */
+
+/*
+ * Suspend the hard and soft lockup detector by parking the watchdog threads.
+ */
+int lockup_detector_suspend(void)
+{
+        int ret = 0;
+
+        get_online_cpus();
+        mutex_lock(&watchdog_proc_mutex);
+        /*
+         * Multiple suspend requests can be active in parallel (counted by
+         * the 'watchdog_suspended' variable). If the watchdog threads are
+         * running, the first caller takes care that they will be parked.
+         * The state of 'watchdog_running' cannot change while a suspend
+         * request is active (see related code in 'proc' handlers).
+         */
+        if (watchdog_running && !watchdog_suspended)
+                ret = watchdog_park_threads();
+
+        if (ret == 0)
+                watchdog_suspended++;
+        else {
+                watchdog_disable_all_cpus();
+                pr_err("Failed to suspend lockup detectors, disabled\n");
+                watchdog_enabled = 0;
+        }
+
+        watchdog_nmi_reconfigure();
+
+        mutex_unlock(&watchdog_proc_mutex);
+
+        return ret;
+}
+
+/*
+ * Resume the hard and soft lockup detector by unparking the watchdog threads.
+ */
+void lockup_detector_resume(void)
+{
+        mutex_lock(&watchdog_proc_mutex);
+
+        watchdog_suspended--;
+        /*
+         * The watchdog threads are unparked if they were previously running
+         * and if there is no more active suspend request.
+         */
+        if (watchdog_running && !watchdog_suspended)
+                watchdog_unpark_threads();
+
+        watchdog_nmi_reconfigure();
+
+        mutex_unlock(&watchdog_proc_mutex);
+        put_online_cpus();
+}
+
+#ifdef CONFIG_SYSCTL
 
 /*
  * Update the run state of the lockup detectors.
@@ -625,6 +735,8 @@ static int proc_watchdog_update(void)
         else
                 watchdog_disable_all_cpus();
 
+        watchdog_nmi_reconfigure();
+
         return err;
 
 }
@@ -810,10 +922,11 @@ int proc_watchdog_cpumask(struct ctl_table *table, int write,
                          * a temporary cpumask, so we are likely not in a
                          * position to do much else to make things better.
                          */
-                        if (smpboot_update_cpumask_percpu_thread(
-                                    &watchdog_threads, &watchdog_cpumask) != 0)
+                        if (watchdog_update_cpus() != 0)
                                 pr_err("cpumask update failed\n");
                 }
+
+                watchdog_nmi_reconfigure();
         }
 out:
         mutex_unlock(&watchdog_proc_mutex);
diff --git a/kernel/watchdog_hld.c b/kernel/watchdog_hld.c
index 54a427d1f344..295a0d84934c 100644
--- a/kernel/watchdog_hld.c
+++ b/kernel/watchdog_hld.c
@@ -22,41 +22,9 @@ static DEFINE_PER_CPU(bool, hard_watchdog_warn);
 static DEFINE_PER_CPU(bool, watchdog_nmi_touch);
 static DEFINE_PER_CPU(struct perf_event *, watchdog_ev);
 
-/* boot commands */
-/*
- * Should we panic when a soft-lockup or hard-lockup occurs:
- */
-unsigned int __read_mostly hardlockup_panic =
-                        CONFIG_BOOTPARAM_HARDLOCKUP_PANIC_VALUE;
 static unsigned long hardlockup_allcpu_dumped;
-/*
- * We may not want to enable hard lockup detection by default in all cases,
- * for example when running the kernel as a guest on a hypervisor. In these
- * cases this function can be called to disable hard lockup detection. This
- * function should only be executed once by the boot processor before the
- * kernel command line parameters are parsed, because otherwise it is not
- * possible to override this in hardlockup_panic_setup().
- */
-void hardlockup_detector_disable(void)
-{
-        watchdog_enabled &= ~NMI_WATCHDOG_ENABLED;
-}
-
-static int __init hardlockup_panic_setup(char *str)
-{
-        if (!strncmp(str, "panic", 5))
-                hardlockup_panic = 1;
-        else if (!strncmp(str, "nopanic", 7))
-                hardlockup_panic = 0;
-        else if (!strncmp(str, "0", 1))
-                watchdog_enabled &= ~NMI_WATCHDOG_ENABLED;
-        else if (!strncmp(str, "1", 1))
-                watchdog_enabled |= NMI_WATCHDOG_ENABLED;
-        return 1;
-}
-__setup("nmi_watchdog=", hardlockup_panic_setup);
 
-void touch_nmi_watchdog(void)
+void arch_touch_nmi_watchdog(void)
 {
         /*
          * Using __raw here because some code paths have
@@ -66,9 +34,8 @@ void touch_nmi_watchdog(void)
          * going off.
          */
         raw_cpu_write(watchdog_nmi_touch, true);
-        touch_softlockup_watchdog();
 }
-EXPORT_SYMBOL(touch_nmi_watchdog);
+EXPORT_SYMBOL(arch_touch_nmi_watchdog);
 
 static struct perf_event_attr wd_hw_attr = {
         .type           = PERF_TYPE_HARDWARE,
diff --git a/kernel/workqueue.c b/kernel/workqueue.c
index c74bf39ef764..a86688fabc55 100644
--- a/kernel/workqueue.c
+++ b/kernel/workqueue.c
@@ -2864,11 +2864,11 @@ bool flush_work(struct work_struct *work)
 EXPORT_SYMBOL_GPL(flush_work);
 
 struct cwt_wait {
-        wait_queue_t            wait;
+        wait_queue_entry_t              wait;
         struct work_struct      *work;
 };
 
-static int cwt_wakefn(wait_queue_t *wait, unsigned mode, int sync, void *key)
+static int cwt_wakefn(wait_queue_entry_t *wait, unsigned mode, int sync, void *key)
 {
         struct cwt_wait *cwait = container_of(wait, struct cwt_wait, wait);