Merge tag 'at24-4.17-rc5-fixes-for-wolfram' of git://git.kernel.org/pub/scm/linux/kernel/git/brgl/linux into i2c/for-current

Single bug-fix for a regression introduced during the 4.17 merge window.

10 files changed, 155 insertions, 78 deletions

diff --git a/kernel/bpf/arraymap.c b/kernel/bpf/arraymap.c
index 14750e7c5ee4..027107f4be53 100644
--- a/kernel/bpf/arraymap.c
+++ b/kernel/bpf/arraymap.c
@@ -476,7 +476,7 @@ static u32 prog_fd_array_sys_lookup_elem(void *ptr)
 }
 
 /* decrement refcnt of all bpf_progs that are stored in this map */
-void bpf_fd_array_map_clear(struct bpf_map *map)
+static void bpf_fd_array_map_clear(struct bpf_map *map)
 {
         struct bpf_array *array = container_of(map, struct bpf_array, map);
         int i;
@@ -495,6 +495,7 @@ const struct bpf_map_ops prog_array_map_ops = {
         .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,
+        .map_release_uref = bpf_fd_array_map_clear,
 };
 
 static struct bpf_event_entry *bpf_event_entry_gen(struct file *perf_file,
diff --git a/kernel/bpf/sockmap.c b/kernel/bpf/sockmap.c
index a3b21385e947..098eca568c2b 100644
--- a/kernel/bpf/sockmap.c
+++ b/kernel/bpf/sockmap.c
@@ -43,6 +43,7 @@
 #include <net/tcp.h>
 #include <linux/ptr_ring.h>
 #include <net/inet_common.h>
+#include <linux/sched/signal.h>
 
 #define SOCK_CREATE_FLAG_MASK \
         (BPF_F_NUMA_NODE | BPF_F_RDONLY | BPF_F_WRONLY)
@@ -325,6 +326,9 @@ retry:
                         if (ret > 0) {
                                 if (apply)
                                         apply_bytes -= ret;
+
+                                sg->offset += ret;
+                                sg->length -= ret;
                                 size -= ret;
                                 offset += ret;
                                 if (uncharge)
@@ -332,8 +336,6 @@ retry:
                                 goto retry;
                         }
 
-                        sg->length = size;
-                        sg->offset = offset;
                         return ret;
                 }
 
@@ -391,7 +393,8 @@ static void return_mem_sg(struct sock *sk, int bytes, struct sk_msg_buff *md)
         } while (i != md->sg_end);
 }
 
-static void free_bytes_sg(struct sock *sk, int bytes, struct sk_msg_buff *md)
+static void free_bytes_sg(struct sock *sk, int bytes,
+                          struct sk_msg_buff *md, bool charge)
 {
         struct scatterlist *sg = md->sg_data;
         int i = md->sg_start, free;
@@ -401,11 +404,13 @@ static void free_bytes_sg(struct sock *sk, int bytes, struct sk_msg_buff *md)
                 if (bytes < free) {
                         sg[i].length -= bytes;
                         sg[i].offset += bytes;
-                        sk_mem_uncharge(sk, bytes);
+                        if (charge)
+                                sk_mem_uncharge(sk, bytes);
                         break;
                 }
 
-                sk_mem_uncharge(sk, sg[i].length);
+                if (charge)
+                        sk_mem_uncharge(sk, sg[i].length);
                 put_page(sg_page(&sg[i]));
                 bytes -= sg[i].length;
                 sg[i].length = 0;
@@ -416,6 +421,7 @@ static void free_bytes_sg(struct sock *sk, int bytes, struct sk_msg_buff *md)
                 if (i == MAX_SKB_FRAGS)
                         i = 0;
         }
+        md->sg_start = i;
 }
 
 static int free_sg(struct sock *sk, int start, struct sk_msg_buff *md)
@@ -523,8 +529,6 @@ static int bpf_tcp_ingress(struct sock *sk, int apply_bytes,
         i = md->sg_start;
 
         do {
-                r->sg_data[i] = md->sg_data[i];
-
                 size = (apply && apply_bytes < md->sg_data[i].length) ?
                         apply_bytes : md->sg_data[i].length;
 
@@ -535,6 +539,7 @@ static int bpf_tcp_ingress(struct sock *sk, int apply_bytes,
                 }
 
                 sk_mem_charge(sk, size);
+                r->sg_data[i] = md->sg_data[i];
                 r->sg_data[i].length = size;
                 md->sg_data[i].length -= size;
                 md->sg_data[i].offset += size;
@@ -575,10 +580,10 @@ static int bpf_tcp_sendmsg_do_redirect(struct sock *sk, int send,
                                        struct sk_msg_buff *md,
                                        int flags)
 {
+        bool ingress = !!(md->flags & BPF_F_INGRESS);
         struct smap_psock *psock;
         struct scatterlist *sg;
-        int i, err, free = 0;
-        bool ingress = !!(md->flags & BPF_F_INGRESS);
+        int err = 0;
 
         sg = md->sg_data;
 
@@ -606,16 +611,8 @@ static int bpf_tcp_sendmsg_do_redirect(struct sock *sk, int send,
 out_rcu:
         rcu_read_unlock();
 out:
-        i = md->sg_start;
-        while (sg[i].length) {
-                free += sg[i].length;
-                put_page(sg_page(&sg[i]));
-                sg[i].length = 0;
-                i++;
-                if (i == MAX_SKB_FRAGS)
-                        i = 0;
-        }
-        return free;
+        free_bytes_sg(NULL, send, md, false);
+        return err;
 }
 
 static inline void bpf_md_init(struct smap_psock *psock)
@@ -700,19 +697,26 @@ more_data:
                 err = bpf_tcp_sendmsg_do_redirect(redir, send, m, flags);
                 lock_sock(sk);
 
+                if (unlikely(err < 0)) {
+                        free_start_sg(sk, m);
+                        psock->sg_size = 0;
+                        if (!cork)
+                                *copied -= send;
+                } else {
+                        psock->sg_size -= send;
+                }
+
                 if (cork) {
                         free_start_sg(sk, m);
+                        psock->sg_size = 0;
                         kfree(m);
                         m = NULL;
+                        err = 0;
                 }
-                if (unlikely(err))
-                        *copied -= err;
-                else
-                        psock->sg_size -= send;
                 break;
         case __SK_DROP:
         default:
-                free_bytes_sg(sk, send, m);
+                free_bytes_sg(sk, send, m, true);
                 apply_bytes_dec(psock, send);
                 *copied -= send;
                 psock->sg_size -= send;
@@ -732,6 +736,26 @@ out_err:
         return err;
 }
 
+static int bpf_wait_data(struct sock *sk,
+                         struct smap_psock *psk, int flags,
+                         long timeo, int *err)
+{
+        int rc;
+
+        DEFINE_WAIT_FUNC(wait, woken_wake_function);
+
+        add_wait_queue(sk_sleep(sk), &wait);
+        sk_set_bit(SOCKWQ_ASYNC_WAITDATA, sk);
+        rc = sk_wait_event(sk, &timeo,
+                           !list_empty(&psk->ingress) ||
+                           !skb_queue_empty(&sk->sk_receive_queue),
+                           &wait);
+        sk_clear_bit(SOCKWQ_ASYNC_WAITDATA, sk);
+        remove_wait_queue(sk_sleep(sk), &wait);
+
+        return rc;
+}
+
 static int bpf_tcp_recvmsg(struct sock *sk, struct msghdr *msg, size_t len,
                            int nonblock, int flags, int *addr_len)
 {
@@ -755,6 +779,7 @@ static int bpf_tcp_recvmsg(struct sock *sk, struct msghdr *msg, size_t len,
                 return tcp_recvmsg(sk, msg, len, nonblock, flags, addr_len);
 
         lock_sock(sk);
+bytes_ready:
         while (copied != len) {
                 struct scatterlist *sg;
                 struct sk_msg_buff *md;
@@ -809,6 +834,28 @@ static int bpf_tcp_recvmsg(struct sock *sk, struct msghdr *msg, size_t len,
                 }
         }
 
+        if (!copied) {
+                long timeo;
+                int data;
+                int err = 0;
+
+                timeo = sock_rcvtimeo(sk, nonblock);
+                data = bpf_wait_data(sk, psock, flags, timeo, &err);
+
+                if (data) {
+                        if (!skb_queue_empty(&sk->sk_receive_queue)) {
+                                release_sock(sk);
+                                smap_release_sock(psock, sk);
+                                copied = tcp_recvmsg(sk, msg, len, nonblock, flags, addr_len);
+                                return copied;
+                        }
+                        goto bytes_ready;
+                }
+
+                if (err)
+                        copied = err;
+        }
+
         release_sock(sk);
         smap_release_sock(psock, sk);
         return copied;
@@ -1831,7 +1878,7 @@ static int sock_map_update_elem(struct bpf_map *map,
         return err;
 }
 
-static void sock_map_release(struct bpf_map *map, struct file *map_file)
+static void sock_map_release(struct bpf_map *map)
 {
         struct bpf_stab *stab = container_of(map, struct bpf_stab, map);
         struct bpf_prog *orig;
@@ -1855,7 +1902,7 @@ const struct bpf_map_ops sock_map_ops = {
         .map_get_next_key = sock_map_get_next_key,
         .map_update_elem = sock_map_update_elem,
         .map_delete_elem = sock_map_delete_elem,
-        .map_release = sock_map_release,
+        .map_release_uref = sock_map_release,
 };
 
 BPF_CALL_4(bpf_sock_map_update, struct bpf_sock_ops_kern *, bpf_sock,
diff --git a/kernel/bpf/syscall.c b/kernel/bpf/syscall.c
index 4ca46df19c9a..ebfe9f29dae8 100644
--- a/kernel/bpf/syscall.c
+++ b/kernel/bpf/syscall.c
@@ -257,8 +257,8 @@ static void bpf_map_free_deferred(struct work_struct *work)
 static void bpf_map_put_uref(struct bpf_map *map)
 {
         if (atomic_dec_and_test(&map->usercnt)) {
-                if (map->map_type == BPF_MAP_TYPE_PROG_ARRAY)
-                        bpf_fd_array_map_clear(map);
+                if (map->ops->map_release_uref)
+                        map->ops->map_release_uref(map);
         }
 }
 
diff --git a/kernel/events/uprobes.c b/kernel/events/uprobes.c
index ce6848e46e94..1725b902983f 100644
--- a/kernel/events/uprobes.c
+++ b/kernel/events/uprobes.c
@@ -491,7 +491,7 @@ static struct uprobe *alloc_uprobe(struct inode *inode, loff_t offset)
         if (!uprobe)
                 return NULL;
 
-        uprobe->inode = igrab(inode);
+        uprobe->inode = inode;
         uprobe->offset = offset;
         init_rwsem(&uprobe->register_rwsem);
         init_rwsem(&uprobe->consumer_rwsem);
@@ -502,7 +502,6 @@ static struct uprobe *alloc_uprobe(struct inode *inode, loff_t offset)
         if (cur_uprobe) {
                 kfree(uprobe);
                 uprobe = cur_uprobe;
-                iput(inode);
         }
 
         return uprobe;
@@ -701,7 +700,6 @@ static void delete_uprobe(struct uprobe *uprobe)
         rb_erase(&uprobe->rb_node, &uprobes_tree);
         spin_unlock(&uprobes_treelock);
         RB_CLEAR_NODE(&uprobe->rb_node); /* for uprobe_is_active() */
-        iput(uprobe->inode);
         put_uprobe(uprobe);
 }
 
@@ -873,7 +871,8 @@ static void __uprobe_unregister(struct uprobe *uprobe, struct uprobe_consumer *u
  * tuple).  Creation refcount stops uprobe_unregister from freeing the
  * @uprobe even before the register operation is complete. Creation
  * refcount is released when the last @uc for the @uprobe
- * unregisters.
+ * unregisters. Caller of uprobe_register() is required to keep @inode
+ * (and the containing mount) referenced.
  *
  * Return errno if it cannot successully install probes
  * else return 0 (success)
diff --git a/kernel/time/clocksource.c b/kernel/time/clocksource.c
index 0e974cface0b..84f37420fcf5 100644
--- a/kernel/time/clocksource.c
+++ b/kernel/time/clocksource.c
@@ -119,6 +119,16 @@ static DEFINE_SPINLOCK(watchdog_lock);
 static int watchdog_running;
 static atomic_t watchdog_reset_pending;
 
+static void inline clocksource_watchdog_lock(unsigned long *flags)
+{
+        spin_lock_irqsave(&watchdog_lock, *flags);
+}
+
+static void inline clocksource_watchdog_unlock(unsigned long *flags)
+{
+        spin_unlock_irqrestore(&watchdog_lock, *flags);
+}
+
 static int clocksource_watchdog_kthread(void *data);
 static void __clocksource_change_rating(struct clocksource *cs, int rating);
 
@@ -142,9 +152,19 @@ static void __clocksource_unstable(struct clocksource *cs)
         cs->flags &= ~(CLOCK_SOURCE_VALID_FOR_HRES | CLOCK_SOURCE_WATCHDOG);
         cs->flags |= CLOCK_SOURCE_UNSTABLE;
 
+        /*
+         * If the clocksource is registered clocksource_watchdog_kthread() will
+         * re-rate and re-select.
+         */
+        if (list_empty(&cs->list)) {
+                cs->rating = 0;
+                return;
+        }
+
         if (cs->mark_unstable)
                 cs->mark_unstable(cs);
 
+        /* kick clocksource_watchdog_kthread() */
         if (finished_booting)
                 schedule_work(&watchdog_work);
 }
@@ -153,10 +173,8 @@ static void __clocksource_unstable(struct clocksource *cs)
  * clocksource_mark_unstable - mark clocksource unstable via watchdog
  * @cs:         clocksource to be marked unstable
  *
- * This function is called instead of clocksource_change_rating from
- * cpu hotplug code to avoid a deadlock between the clocksource mutex
- * and the cpu hotplug mutex. It defers the update of the clocksource
- * to the watchdog thread.
+ * This function is called by the x86 TSC code to mark clocksources as unstable;
+ * it defers demotion and re-selection to a kthread.
  */
 void clocksource_mark_unstable(struct clocksource *cs)
 {
@@ -164,7 +182,7 @@ void clocksource_mark_unstable(struct clocksource *cs)
 
         spin_lock_irqsave(&watchdog_lock, flags);
         if (!(cs->flags & CLOCK_SOURCE_UNSTABLE)) {
-                if (list_empty(&cs->wd_list))
+                if (!list_empty(&cs->list) && list_empty(&cs->wd_list))
                         list_add(&cs->wd_list, &watchdog_list);
                 __clocksource_unstable(cs);
         }
@@ -319,9 +337,8 @@ static void clocksource_resume_watchdog(void)
 
 static void clocksource_enqueue_watchdog(struct clocksource *cs)
 {
-        unsigned long flags;
+        INIT_LIST_HEAD(&cs->wd_list);
 
-        spin_lock_irqsave(&watchdog_lock, flags);
         if (cs->flags & CLOCK_SOURCE_MUST_VERIFY) {
                 /* cs is a clocksource to be watched. */
                 list_add(&cs->wd_list, &watchdog_list);
@@ -331,7 +348,6 @@ static void clocksource_enqueue_watchdog(struct clocksource *cs)
                 if (cs->flags & CLOCK_SOURCE_IS_CONTINUOUS)
                         cs->flags |= CLOCK_SOURCE_VALID_FOR_HRES;
         }
-        spin_unlock_irqrestore(&watchdog_lock, flags);
 }
 
 static void clocksource_select_watchdog(bool fallback)
@@ -373,9 +389,6 @@ static void clocksource_select_watchdog(bool fallback)
 
 static void clocksource_dequeue_watchdog(struct clocksource *cs)
 {
-        unsigned long flags;
-
-        spin_lock_irqsave(&watchdog_lock, flags);
         if (cs != watchdog) {
                 if (cs->flags & CLOCK_SOURCE_MUST_VERIFY) {
                         /* cs is a watched clocksource. */
@@ -384,21 +397,19 @@ static void clocksource_dequeue_watchdog(struct clocksource *cs)
                         clocksource_stop_watchdog();
                 }
         }
-        spin_unlock_irqrestore(&watchdog_lock, flags);
 }
 
 static int __clocksource_watchdog_kthread(void)
 {
         struct clocksource *cs, *tmp;
         unsigned long flags;
-        LIST_HEAD(unstable);
         int select = 0;
 
         spin_lock_irqsave(&watchdog_lock, flags);
         list_for_each_entry_safe(cs, tmp, &watchdog_list, wd_list) {
                 if (cs->flags & CLOCK_SOURCE_UNSTABLE) {
                         list_del_init(&cs->wd_list);
-                        list_add(&cs->wd_list, &unstable);
+                        __clocksource_change_rating(cs, 0);
                         select = 1;
                 }
                 if (cs->flags & CLOCK_SOURCE_RESELECT) {
@@ -410,11 +421,6 @@ static int __clocksource_watchdog_kthread(void)
         clocksource_stop_watchdog();
         spin_unlock_irqrestore(&watchdog_lock, flags);
 
-        /* Needs to be done outside of watchdog lock */
-        list_for_each_entry_safe(cs, tmp, &unstable, wd_list) {
-                list_del_init(&cs->wd_list);
-                __clocksource_change_rating(cs, 0);
-        }
         return select;
 }
 
@@ -447,6 +453,9 @@ static inline int __clocksource_watchdog_kthread(void) { return 0; }
 static bool clocksource_is_watchdog(struct clocksource *cs) { return false; }
 void clocksource_mark_unstable(struct clocksource *cs) { }
 
+static void inline clocksource_watchdog_lock(unsigned long *flags) { }
+static void inline clocksource_watchdog_unlock(unsigned long *flags) { }
+
 #endif /* CONFIG_CLOCKSOURCE_WATCHDOG */
 
 /**
@@ -779,14 +788,19 @@ EXPORT_SYMBOL_GPL(__clocksource_update_freq_scale);
  */
 int __clocksource_register_scale(struct clocksource *cs, u32 scale, u32 freq)
 {
+        unsigned long flags;
 
         /* Initialize mult/shift and max_idle_ns */
         __clocksource_update_freq_scale(cs, scale, freq);
 
         /* Add clocksource to the clocksource list */
         mutex_lock(&clocksource_mutex);
+
+        clocksource_watchdog_lock(&flags);
         clocksource_enqueue(cs);
         clocksource_enqueue_watchdog(cs);
+        clocksource_watchdog_unlock(&flags);
+
         clocksource_select();
         clocksource_select_watchdog(false);
         mutex_unlock(&clocksource_mutex);
@@ -808,8 +822,13 @@ static void __clocksource_change_rating(struct clocksource *cs, int rating)
  */
 void clocksource_change_rating(struct clocksource *cs, int rating)
 {
+        unsigned long flags;
+
         mutex_lock(&clocksource_mutex);
+        clocksource_watchdog_lock(&flags);
         __clocksource_change_rating(cs, rating);
+        clocksource_watchdog_unlock(&flags);
+
         clocksource_select();
         clocksource_select_watchdog(false);
         mutex_unlock(&clocksource_mutex);
@@ -821,6 +840,8 @@ EXPORT_SYMBOL(clocksource_change_rating);
  */
 static int clocksource_unbind(struct clocksource *cs)
 {
+        unsigned long flags;
+
         if (clocksource_is_watchdog(cs)) {
                 /* Select and try to install a replacement watchdog. */
                 clocksource_select_watchdog(true);
@@ -834,8 +855,12 @@ static int clocksource_unbind(struct clocksource *cs)
                 if (curr_clocksource == cs)
                         return -EBUSY;
         }
+
+        clocksource_watchdog_lock(&flags);
         clocksource_dequeue_watchdog(cs);
         list_del_init(&cs->list);
+        clocksource_watchdog_unlock(&flags);
+
         return 0;
 }
 
diff --git a/kernel/trace/ftrace.c b/kernel/trace/ftrace.c
index 16bbf062018f..8d83bcf9ef69 100644
--- a/kernel/trace/ftrace.c
+++ b/kernel/trace/ftrace.c
@@ -5514,10 +5514,10 @@ static __init int ftrace_init_dyn_tracefs(struct dentry *d_tracer)
         ftrace_create_filter_files(&global_ops, d_tracer);
 
 #ifdef CONFIG_FUNCTION_GRAPH_TRACER
-        trace_create_file("set_graph_function", 0444, d_tracer,
+        trace_create_file("set_graph_function", 0644, d_tracer,
                                     NULL,
                                     &ftrace_graph_fops);
-        trace_create_file("set_graph_notrace", 0444, d_tracer,
+        trace_create_file("set_graph_notrace", 0644, d_tracer,
                                     NULL,
                                     &ftrace_graph_notrace_fops);
 #endif /* CONFIG_FUNCTION_GRAPH_TRACER */
diff --git a/kernel/trace/trace_events_hist.c b/kernel/trace/trace_events_hist.c
index 0d7b3ffbecc2..b9061ed59bbd 100644
--- a/kernel/trace/trace_events_hist.c
+++ b/kernel/trace/trace_events_hist.c
@@ -2466,6 +2466,7 @@ parse_field(struct hist_trigger_data *hist_data, struct trace_event_file *file,
                 else if (strcmp(modifier, "usecs") == 0)
                         *flags |= HIST_FIELD_FL_TIMESTAMP_USECS;
                 else {
+                        hist_err("Invalid field modifier: ", modifier);
                         field = ERR_PTR(-EINVAL);
                         goto out;
                 }
@@ -2481,6 +2482,7 @@ parse_field(struct hist_trigger_data *hist_data, struct trace_event_file *file,
         else {
                 field = trace_find_event_field(file->event_call, field_name);
                 if (!field || !field->size) {
+                        hist_err("Couldn't find field: ", field_name);
                         field = ERR_PTR(-EINVAL);
                         goto out;
                 }
@@ -4913,6 +4915,16 @@ static void hist_field_print(struct seq_file *m, struct hist_field *hist_field)
                 seq_printf(m, "%s", field_name);
         } else if (hist_field->flags & HIST_FIELD_FL_TIMESTAMP)
                 seq_puts(m, "common_timestamp");
+
+        if (hist_field->flags) {
+                if (!(hist_field->flags & HIST_FIELD_FL_VAR_REF) &&
+                    !(hist_field->flags & HIST_FIELD_FL_EXPR)) {
+                        const char *flags = get_hist_field_flags(hist_field);
+
+                        if (flags)
+                                seq_printf(m, ".%s", flags);
+                }
+        }
 }
 
 static int event_hist_trigger_print(struct seq_file *m,
diff --git a/kernel/trace/trace_stack.c b/kernel/trace/trace_stack.c
index 3c7bfc4bf5e9..4237eba4ef20 100644
--- a/kernel/trace/trace_stack.c
+++ b/kernel/trace/trace_stack.c
@@ -472,7 +472,7 @@ static __init int stack_trace_init(void)
                         NULL, &stack_trace_fops);
 
 #ifdef CONFIG_DYNAMIC_FTRACE
-        trace_create_file("stack_trace_filter", 0444, d_tracer,
+        trace_create_file("stack_trace_filter", 0644, d_tracer,
                           &trace_ops, &stack_trace_filter_fops);
 #endif
 
diff --git a/kernel/trace/trace_uprobe.c b/kernel/trace/trace_uprobe.c
index 34fd0e0ec51d..ac892878dbe6 100644
--- a/kernel/trace/trace_uprobe.c
+++ b/kernel/trace/trace_uprobe.c
@@ -55,6 +55,7 @@ struct trace_uprobe {
         struct list_head                list;
         struct trace_uprobe_filter      filter;
         struct uprobe_consumer          consumer;
+        struct path                     path;
         struct inode                    *inode;
         char                            *filename;
         unsigned long                   offset;
@@ -289,7 +290,7 @@ static void free_trace_uprobe(struct trace_uprobe *tu)
         for (i = 0; i < tu->tp.nr_args; i++)
                 traceprobe_free_probe_arg(&tu->tp.args[i]);
 
-        iput(tu->inode);
+        path_put(&tu->path);
         kfree(tu->tp.call.class->system);
         kfree(tu->tp.call.name);
         kfree(tu->filename);
@@ -363,7 +364,6 @@ end:
 static int create_trace_uprobe(int argc, char **argv)
 {
         struct trace_uprobe *tu;
-        struct inode *inode;
         char *arg, *event, *group, *filename;
         char buf[MAX_EVENT_NAME_LEN];
         struct path path;
@@ -371,7 +371,6 @@ static int create_trace_uprobe(int argc, char **argv)
         bool is_delete, is_return;
         int i, ret;
 
-        inode = NULL;
         ret = 0;
         is_delete = false;
         is_return = false;
@@ -437,21 +436,16 @@ static int create_trace_uprobe(int argc, char **argv)
         }
         /* Find the last occurrence, in case the path contains ':' too. */
         arg = strrchr(argv[1], ':');
-        if (!arg) {
-                ret = -EINVAL;
-                goto fail_address_parse;
-        }
+        if (!arg)
+                return -EINVAL;
 
         *arg++ = '\0';
         filename = argv[1];
         ret = kern_path(filename, LOOKUP_FOLLOW, &path);
         if (ret)
-                goto fail_address_parse;
-
-        inode = igrab(d_real_inode(path.dentry));
-        path_put(&path);
+                return ret;
 
-        if (!inode || !S_ISREG(inode->i_mode)) {
+        if (!d_is_reg(path.dentry)) {
                 ret = -EINVAL;
                 goto fail_address_parse;
         }
@@ -490,7 +484,7 @@ static int create_trace_uprobe(int argc, char **argv)
                 goto fail_address_parse;
         }
         tu->offset = offset;
-        tu->inode = inode;
+        tu->path = path;
         tu->filename = kstrdup(filename, GFP_KERNEL);
 
         if (!tu->filename) {
@@ -558,7 +552,7 @@ error:
         return ret;
 
 fail_address_parse:
-        iput(inode);
+        path_put(&path);
 
         pr_info("Failed to parse address or file.\n");
 
@@ -922,6 +916,7 @@ probe_event_enable(struct trace_uprobe *tu, struct trace_event_file *file,
                 goto err_flags;
 
         tu->consumer.filter = filter;
+        tu->inode = d_real_inode(tu->path.dentry);
         ret = uprobe_register(tu->inode, tu->offset, &tu->consumer);
         if (ret)
                 goto err_buffer;
@@ -967,6 +962,7 @@ probe_event_disable(struct trace_uprobe *tu, struct trace_event_file *file)
         WARN_ON(!uprobe_filter_is_empty(&tu->filter));
 
         uprobe_unregister(tu->inode, tu->offset, &tu->consumer);
+        tu->inode = NULL;
         tu->tp.flags &= file ? ~TP_FLAG_TRACE : ~TP_FLAG_PROFILE;
 
         uprobe_buffer_disable();
@@ -1337,7 +1333,6 @@ struct trace_event_call *
 create_local_trace_uprobe(char *name, unsigned long offs, bool is_return)
 {
         struct trace_uprobe *tu;
-        struct inode *inode;
         struct path path;
         int ret;
 
@@ -1345,11 +1340,8 @@ create_local_trace_uprobe(char *name, unsigned long offs, bool is_return)
         if (ret)
                 return ERR_PTR(ret);
 
-        inode = igrab(d_inode(path.dentry));
-        path_put(&path);
-
-        if (!inode || !S_ISREG(inode->i_mode)) {
-                iput(inode);
+        if (!d_is_reg(path.dentry)) {
+                path_put(&path);
                 return ERR_PTR(-EINVAL);
         }
 
@@ -1364,11 +1356,12 @@ create_local_trace_uprobe(char *name, unsigned long offs, bool is_return)
         if (IS_ERR(tu)) {
                 pr_info("Failed to allocate trace_uprobe.(%d)\n",
                         (int)PTR_ERR(tu));
+                path_put(&path);
                 return ERR_CAST(tu);
         }
 
         tu->offset = offs;
-        tu->inode = inode;
+        tu->path = path;
         tu->filename = kstrdup(name, GFP_KERNEL);
         init_trace_event_call(tu, &tu->tp.call);
 
diff --git a/kernel/tracepoint.c b/kernel/tracepoint.c
index 671b13457387..1e37da2e0c25 100644
--- a/kernel/tracepoint.c
+++ b/kernel/tracepoint.c
@@ -207,7 +207,7 @@ static int tracepoint_add_func(struct tracepoint *tp,
                         lockdep_is_held(&tracepoints_mutex));
         old = func_add(&tp_funcs, func, prio);
         if (IS_ERR(old)) {
-                WARN_ON_ONCE(1);
+                WARN_ON_ONCE(PTR_ERR(old) != -ENOMEM);
                 return PTR_ERR(old);
         }
 
@@ -239,7 +239,7 @@ static int tracepoint_remove_func(struct tracepoint *tp,
                         lockdep_is_held(&tracepoints_mutex));
         old = func_remove(&tp_funcs, func);
         if (IS_ERR(old)) {
-                WARN_ON_ONCE(1);
+                WARN_ON_ONCE(PTR_ERR(old) != -ENOMEM);
                 return PTR_ERR(old);
         }