LCOV - code coverage report
Current view: top level - kernel/trace - trace_kprobe.c (source / functions) Hit Total Coverage
Test: gcov_data_raspi2_real_modules_combined.info Lines: 29 569 5.1 %
Date: 2020-09-30 20:25:40 Functions: 4 48 8.3 %
Branches: 11 517 2.1 %

           Branch data     Line data    Source code
       1                 :            : // SPDX-License-Identifier: GPL-2.0
       2                 :            : /*
       3                 :            :  * Kprobes-based tracing events
       4                 :            :  *
       5                 :            :  * Created by Masami Hiramatsu <mhiramat@redhat.com>
       6                 :            :  *
       7                 :            :  */
       8                 :            : #define pr_fmt(fmt)     "trace_kprobe: " fmt
       9                 :            : 
      10                 :            : #include <linux/security.h>
      11                 :            : #include <linux/module.h>
      12                 :            : #include <linux/uaccess.h>
      13                 :            : #include <linux/rculist.h>
      14                 :            : #include <linux/error-injection.h>
      15                 :            : 
      16                 :            : #include <asm/setup.h>  /* for COMMAND_LINE_SIZE */
      17                 :            : 
      18                 :            : #include "trace_dynevent.h"
      19                 :            : #include "trace_kprobe_selftest.h"
      20                 :            : #include "trace_probe.h"
      21                 :            : #include "trace_probe_tmpl.h"
      22                 :            : 
      23                 :            : #define KPROBE_EVENT_SYSTEM "kprobes"
      24                 :            : #define KRETPROBE_MAXACTIVE_MAX 4096
      25                 :            : #define MAX_KPROBE_CMDLINE_SIZE 1024
      26                 :            : 
      27                 :            : /* Kprobe early definition from command line */
      28                 :            : static char kprobe_boot_events_buf[COMMAND_LINE_SIZE] __initdata;
      29                 :            : static bool kprobe_boot_events_enabled __initdata;
      30                 :            : 
      31                 :          0 : static int __init set_kprobe_boot_events(char *str)
      32                 :            : {
      33                 :          0 :         strlcpy(kprobe_boot_events_buf, str, COMMAND_LINE_SIZE);
      34                 :          0 :         return 0;
      35                 :            : }
      36                 :            : __setup("kprobe_event=", set_kprobe_boot_events);
      37                 :            : 
      38                 :            : static int trace_kprobe_create(int argc, const char **argv);
      39                 :            : static int trace_kprobe_show(struct seq_file *m, struct dyn_event *ev);
      40                 :            : static int trace_kprobe_release(struct dyn_event *ev);
      41                 :            : static bool trace_kprobe_is_busy(struct dyn_event *ev);
      42                 :            : static bool trace_kprobe_match(const char *system, const char *event,
      43                 :            :                         int argc, const char **argv, struct dyn_event *ev);
      44                 :            : 
      45                 :            : static struct dyn_event_operations trace_kprobe_ops = {
      46                 :            :         .create = trace_kprobe_create,
      47                 :            :         .show = trace_kprobe_show,
      48                 :            :         .is_busy = trace_kprobe_is_busy,
      49                 :            :         .free = trace_kprobe_release,
      50                 :            :         .match = trace_kprobe_match,
      51                 :            : };
      52                 :            : 
      53                 :            : /*
      54                 :            :  * Kprobe event core functions
      55                 :            :  */
      56                 :            : struct trace_kprobe {
      57                 :            :         struct dyn_event        devent;
      58                 :            :         struct kretprobe        rp;     /* Use rp.kp for kprobe use */
      59                 :            :         unsigned long __percpu *nhit;
      60                 :            :         const char              *symbol;        /* symbol name */
      61                 :            :         struct trace_probe      tp;
      62                 :            : };
      63                 :            : 
      64                 :            : static bool is_trace_kprobe(struct dyn_event *ev)
      65                 :            : {
      66                 :          0 :         return ev->ops == &trace_kprobe_ops;
      67                 :            : }
      68                 :            : 
      69                 :            : static struct trace_kprobe *to_trace_kprobe(struct dyn_event *ev)
      70                 :            : {
      71                 :            :         return container_of(ev, struct trace_kprobe, devent);
      72                 :            : }
      73                 :            : 
      74                 :            : /**
      75                 :            :  * for_each_trace_kprobe - iterate over the trace_kprobe list
      76                 :            :  * @pos:        the struct trace_kprobe * for each entry
      77                 :            :  * @dpos:       the struct dyn_event * to use as a loop cursor
      78                 :            :  */
      79                 :            : #define for_each_trace_kprobe(pos, dpos)        \
      80                 :            :         for_each_dyn_event(dpos)                \
      81                 :            :                 if (is_trace_kprobe(dpos) && (pos = to_trace_kprobe(dpos)))
      82                 :            : 
      83                 :            : #define SIZEOF_TRACE_KPROBE(n)                          \
      84                 :            :         (offsetof(struct trace_kprobe, tp.args) +       \
      85                 :            :         (sizeof(struct probe_arg) * (n)))
      86                 :            : 
      87                 :            : static nokprobe_inline bool trace_kprobe_is_return(struct trace_kprobe *tk)
      88                 :            : {
      89                 :          0 :         return tk->rp.handler != NULL;
      90                 :            : }
      91                 :            : 
      92                 :            : static nokprobe_inline const char *trace_kprobe_symbol(struct trace_kprobe *tk)
      93                 :            : {
      94   [ #  #  #  #  :          0 :         return tk->symbol ? tk->symbol : "unknown";
          #  #  #  #  #  
          #  #  #  #  #  
                   #  # ]
      95                 :            : }
      96                 :            : 
      97                 :            : static nokprobe_inline unsigned long trace_kprobe_offset(struct trace_kprobe *tk)
      98                 :            : {
      99                 :          0 :         return tk->rp.kp.offset;
     100                 :            : }
     101                 :            : 
     102                 :            : static nokprobe_inline bool trace_kprobe_has_gone(struct trace_kprobe *tk)
     103                 :            : {
     104                 :          0 :         return !!(kprobe_gone(&tk->rp.kp));
     105                 :            : }
     106                 :            : 
     107                 :            : static nokprobe_inline bool trace_kprobe_within_module(struct trace_kprobe *tk,
     108                 :            :                                                  struct module *mod)
     109                 :            : {
     110                 :          0 :         int len = strlen(mod->name);
     111                 :            :         const char *name = trace_kprobe_symbol(tk);
     112   [ #  #  #  # ]:          0 :         return strncmp(mod->name, name, len) == 0 && name[len] == ':';
     113                 :            : }
     114                 :            : 
     115                 :            : static nokprobe_inline bool trace_kprobe_module_exist(struct trace_kprobe *tk)
     116                 :            : {
     117                 :            :         char *p;
     118                 :            :         bool ret;
     119                 :            : 
     120   [ #  #  #  # ]:          0 :         if (!tk->symbol)
     121                 :            :                 return false;
     122                 :          0 :         p = strchr(tk->symbol, ':');
     123   [ #  #  #  # ]:          0 :         if (!p)
     124                 :            :                 return true;
     125                 :          0 :         *p = '\0';
     126                 :          0 :         mutex_lock(&module_mutex);
     127                 :          0 :         ret = !!find_module(tk->symbol);
     128                 :          0 :         mutex_unlock(&module_mutex);
     129                 :          0 :         *p = ':';
     130                 :            : 
     131                 :            :         return ret;
     132                 :            : }
     133                 :            : 
     134                 :          0 : static bool trace_kprobe_is_busy(struct dyn_event *ev)
     135                 :            : {
     136                 :            :         struct trace_kprobe *tk = to_trace_kprobe(ev);
     137                 :            : 
     138                 :          0 :         return trace_probe_is_enabled(&tk->tp);
     139                 :            : }
     140                 :            : 
     141                 :          0 : static bool trace_kprobe_match_command_head(struct trace_kprobe *tk,
     142                 :            :                                             int argc, const char **argv)
     143                 :            : {
     144                 :            :         char buf[MAX_ARGSTR_LEN + 1];
     145                 :            : 
     146         [ #  # ]:          0 :         if (!argc)
     147                 :            :                 return true;
     148                 :            : 
     149         [ #  # ]:          0 :         if (!tk->symbol)
     150                 :          0 :                 snprintf(buf, sizeof(buf), "0x%p", tk->rp.kp.addr);
     151         [ #  # ]:          0 :         else if (tk->rp.kp.offset)
     152                 :          0 :                 snprintf(buf, sizeof(buf), "%s+%u",
     153                 :            :                          trace_kprobe_symbol(tk), tk->rp.kp.offset);
     154                 :            :         else
     155                 :          0 :                 snprintf(buf, sizeof(buf), "%s", trace_kprobe_symbol(tk));
     156         [ #  # ]:          0 :         if (strcmp(buf, argv[0]))
     157                 :            :                 return false;
     158                 :          0 :         argc--; argv++;
     159                 :            : 
     160                 :          0 :         return trace_probe_match_command_args(&tk->tp, argc, argv);
     161                 :            : }
     162                 :            : 
     163                 :          0 : static bool trace_kprobe_match(const char *system, const char *event,
     164                 :            :                         int argc, const char **argv, struct dyn_event *ev)
     165                 :            : {
     166                 :            :         struct trace_kprobe *tk = to_trace_kprobe(ev);
     167                 :            : 
     168         [ #  # ]:          0 :         return strcmp(trace_probe_name(&tk->tp), event) == 0 &&
     169   [ #  #  #  #  :          0 :             (!system || strcmp(trace_probe_group_name(&tk->tp), system) == 0) &&
                   #  # ]
     170                 :          0 :             trace_kprobe_match_command_head(tk, argc, argv);
     171                 :            : }
     172                 :            : 
     173                 :            : static nokprobe_inline unsigned long trace_kprobe_nhit(struct trace_kprobe *tk)
     174                 :            : {
     175                 :            :         unsigned long nhit = 0;
     176                 :            :         int cpu;
     177                 :            : 
     178         [ #  # ]:          0 :         for_each_possible_cpu(cpu)
     179                 :          0 :                 nhit += *per_cpu_ptr(tk->nhit, cpu);
     180                 :            : 
     181                 :          0 :         return nhit;
     182                 :            : }
     183                 :            : 
     184                 :            : static nokprobe_inline bool trace_kprobe_is_registered(struct trace_kprobe *tk)
     185                 :            : {
     186   [ #  #  #  #  :          0 :         return !(list_empty(&tk->rp.kp.list) &&
          #  #  #  #  #  
          #  #  #  #  #  
                   #  # ]
     187                 :          0 :                  hlist_unhashed(&tk->rp.kp.hlist));
     188                 :            : }
     189                 :            : 
     190                 :            : /* Return 0 if it fails to find the symbol address */
     191                 :            : static nokprobe_inline
     192                 :            : unsigned long trace_kprobe_address(struct trace_kprobe *tk)
     193                 :            : {
     194                 :            :         unsigned long addr;
     195                 :            : 
     196         [ #  # ]:          0 :         if (tk->symbol) {
     197                 :          0 :                 addr = (unsigned long)
     198                 :            :                         kallsyms_lookup_name(trace_kprobe_symbol(tk));
     199                 :            :                 if (addr)
     200                 :            :                         addr += tk->rp.kp.offset;
     201                 :            :         } else {
     202                 :            :                 addr = (unsigned long)tk->rp.kp.addr;
     203                 :            :         }
     204                 :            :         return addr;
     205                 :            : }
     206                 :            : 
     207                 :            : static nokprobe_inline struct trace_kprobe *
     208                 :            : trace_kprobe_primary_from_call(struct trace_event_call *call)
     209                 :            : {
     210                 :            :         struct trace_probe *tp;
     211                 :            : 
     212                 :          0 :         tp = trace_probe_primary_from_call(call);
     213   [ #  #  #  #  :          0 :         if (WARN_ON_ONCE(!tp))
          #  #  #  #  #  
          #  #  #  #  #  
          #  #  #  #  #  
             #  #  #  #  
                      # ]
     214                 :            :                 return NULL;
     215                 :            : 
     216                 :          0 :         return container_of(tp, struct trace_kprobe, tp);
     217                 :            : }
     218                 :            : 
     219                 :          0 : bool trace_kprobe_on_func_entry(struct trace_event_call *call)
     220                 :            : {
     221                 :            :         struct trace_kprobe *tk = trace_kprobe_primary_from_call(call);
     222                 :            : 
     223   [ #  #  #  # ]:          0 :         return tk ? kprobe_on_func_entry(tk->rp.kp.addr,
     224                 :          0 :                         tk->rp.kp.addr ? NULL : tk->rp.kp.symbol_name,
     225   [ #  #  #  # ]:          0 :                         tk->rp.kp.addr ? 0 : tk->rp.kp.offset) : false;
     226                 :            : }
     227                 :            : 
     228                 :          0 : bool trace_kprobe_error_injectable(struct trace_event_call *call)
     229                 :            : {
     230                 :            :         struct trace_kprobe *tk = trace_kprobe_primary_from_call(call);
     231                 :            : 
     232         [ #  # ]:          0 :         return tk ? within_error_injection_list(trace_kprobe_address(tk)) :
     233                 :            :                false;
     234                 :            : }
     235                 :            : 
     236                 :            : static int register_kprobe_event(struct trace_kprobe *tk);
     237                 :            : static int unregister_kprobe_event(struct trace_kprobe *tk);
     238                 :            : 
     239                 :            : static int kprobe_dispatcher(struct kprobe *kp, struct pt_regs *regs);
     240                 :            : static int kretprobe_dispatcher(struct kretprobe_instance *ri,
     241                 :            :                                 struct pt_regs *regs);
     242                 :            : 
     243                 :          0 : static void free_trace_kprobe(struct trace_kprobe *tk)
     244                 :            : {
     245         [ #  # ]:          0 :         if (tk) {
     246                 :          0 :                 trace_probe_cleanup(&tk->tp);
     247                 :          0 :                 kfree(tk->symbol);
     248                 :          0 :                 free_percpu(tk->nhit);
     249                 :          0 :                 kfree(tk);
     250                 :            :         }
     251                 :          0 : }
     252                 :            : 
     253                 :            : /*
     254                 :            :  * Allocate new trace_probe and initialize it (including kprobes).
     255                 :            :  */
     256                 :          0 : static struct trace_kprobe *alloc_trace_kprobe(const char *group,
     257                 :            :                                              const char *event,
     258                 :            :                                              void *addr,
     259                 :            :                                              const char *symbol,
     260                 :            :                                              unsigned long offs,
     261                 :            :                                              int maxactive,
     262                 :            :                                              int nargs, bool is_return)
     263                 :            : {
     264                 :            :         struct trace_kprobe *tk;
     265                 :            :         int ret = -ENOMEM;
     266                 :            : 
     267                 :          0 :         tk = kzalloc(SIZEOF_TRACE_KPROBE(nargs), GFP_KERNEL);
     268         [ #  # ]:          0 :         if (!tk)
     269                 :            :                 return ERR_PTR(ret);
     270                 :            : 
     271                 :          0 :         tk->nhit = alloc_percpu(unsigned long);
     272         [ #  # ]:          0 :         if (!tk->nhit)
     273                 :            :                 goto error;
     274                 :            : 
     275         [ #  # ]:          0 :         if (symbol) {
     276                 :          0 :                 tk->symbol = kstrdup(symbol, GFP_KERNEL);
     277         [ #  # ]:          0 :                 if (!tk->symbol)
     278                 :            :                         goto error;
     279                 :          0 :                 tk->rp.kp.symbol_name = tk->symbol;
     280                 :          0 :                 tk->rp.kp.offset = offs;
     281                 :            :         } else
     282                 :          0 :                 tk->rp.kp.addr = addr;
     283                 :            : 
     284         [ #  # ]:          0 :         if (is_return)
     285                 :          0 :                 tk->rp.handler = kretprobe_dispatcher;
     286                 :            :         else
     287                 :          0 :                 tk->rp.kp.pre_handler = kprobe_dispatcher;
     288                 :            : 
     289                 :          0 :         tk->rp.maxactive = maxactive;
     290                 :            :         INIT_HLIST_NODE(&tk->rp.kp.hlist);
     291                 :          0 :         INIT_LIST_HEAD(&tk->rp.kp.list);
     292                 :            : 
     293                 :          0 :         ret = trace_probe_init(&tk->tp, event, group, false);
     294         [ #  # ]:          0 :         if (ret < 0)
     295                 :            :                 goto error;
     296                 :            : 
     297                 :          0 :         dyn_event_init(&tk->devent, &trace_kprobe_ops);
     298                 :          0 :         return tk;
     299                 :            : error:
     300                 :          0 :         free_trace_kprobe(tk);
     301                 :          0 :         return ERR_PTR(ret);
     302                 :            : }
     303                 :            : 
     304                 :          0 : static struct trace_kprobe *find_trace_kprobe(const char *event,
     305                 :            :                                               const char *group)
     306                 :            : {
     307                 :            :         struct dyn_event *pos;
     308                 :            :         struct trace_kprobe *tk;
     309                 :            : 
     310   [ #  #  #  #  :          0 :         for_each_trace_kprobe(tk, pos)
                   #  # ]
     311   [ #  #  #  # ]:          0 :                 if (strcmp(trace_probe_name(&tk->tp), event) == 0 &&
     312                 :          0 :                     strcmp(trace_probe_group_name(&tk->tp), group) == 0)
     313                 :          0 :                         return tk;
     314                 :            :         return NULL;
     315                 :            : }
     316                 :            : 
     317                 :          0 : static inline int __enable_trace_kprobe(struct trace_kprobe *tk)
     318                 :            : {
     319                 :            :         int ret = 0;
     320                 :            : 
     321   [ #  #  #  # ]:          0 :         if (trace_kprobe_is_registered(tk) && !trace_kprobe_has_gone(tk)) {
     322         [ #  # ]:          0 :                 if (trace_kprobe_is_return(tk))
     323                 :            :                         ret = enable_kretprobe(&tk->rp);
     324                 :            :                 else
     325                 :          0 :                         ret = enable_kprobe(&tk->rp.kp);
     326                 :            :         }
     327                 :            : 
     328                 :          0 :         return ret;
     329                 :            : }
     330                 :            : 
     331                 :          0 : static void __disable_trace_kprobe(struct trace_probe *tp)
     332                 :            : {
     333                 :            :         struct trace_probe *pos;
     334                 :            :         struct trace_kprobe *tk;
     335                 :            : 
     336         [ #  # ]:          0 :         list_for_each_entry(pos, trace_probe_probe_list(tp), list) {
     337                 :            :                 tk = container_of(pos, struct trace_kprobe, tp);
     338         [ #  # ]:          0 :                 if (!trace_kprobe_is_registered(tk))
     339                 :          0 :                         continue;
     340         [ #  # ]:          0 :                 if (trace_kprobe_is_return(tk))
     341                 :            :                         disable_kretprobe(&tk->rp);
     342                 :            :                 else
     343                 :          0 :                         disable_kprobe(&tk->rp.kp);
     344                 :            :         }
     345                 :          0 : }
     346                 :            : 
     347                 :            : /*
     348                 :            :  * Enable trace_probe
     349                 :            :  * if the file is NULL, enable "perf" handler, or enable "trace" handler.
     350                 :            :  */
     351                 :          0 : static int enable_trace_kprobe(struct trace_event_call *call,
     352                 :            :                                 struct trace_event_file *file)
     353                 :            : {
     354                 :            :         struct trace_probe *pos, *tp;
     355                 :            :         struct trace_kprobe *tk;
     356                 :            :         bool enabled;
     357                 :            :         int ret = 0;
     358                 :            : 
     359                 :            :         tp = trace_probe_primary_from_call(call);
     360   [ #  #  #  #  :          0 :         if (WARN_ON_ONCE(!tp))
                   #  # ]
     361                 :            :                 return -ENODEV;
     362                 :            :         enabled = trace_probe_is_enabled(tp);
     363                 :            : 
     364                 :            :         /* This also changes "enabled" state */
     365         [ #  # ]:          0 :         if (file) {
     366                 :          0 :                 ret = trace_probe_add_file(tp, file);
     367         [ #  # ]:          0 :                 if (ret)
     368                 :            :                         return ret;
     369                 :            :         } else
     370                 :            :                 trace_probe_set_flag(tp, TP_FLAG_PROFILE);
     371                 :            : 
     372         [ #  # ]:          0 :         if (enabled)
     373                 :            :                 return 0;
     374                 :            : 
     375         [ #  # ]:          0 :         list_for_each_entry(pos, trace_probe_probe_list(tp), list) {
     376                 :          0 :                 tk = container_of(pos, struct trace_kprobe, tp);
     377         [ #  # ]:          0 :                 if (trace_kprobe_has_gone(tk))
     378                 :          0 :                         continue;
     379                 :          0 :                 ret = __enable_trace_kprobe(tk);
     380         [ #  # ]:          0 :                 if (ret)
     381                 :            :                         break;
     382                 :            :                 enabled = true;
     383                 :            :         }
     384                 :            : 
     385         [ #  # ]:          0 :         if (ret) {
     386                 :            :                 /* Failed to enable one of them. Roll back all */
     387         [ #  # ]:          0 :                 if (enabled)
     388                 :          0 :                         __disable_trace_kprobe(tp);
     389         [ #  # ]:          0 :                 if (file)
     390                 :          0 :                         trace_probe_remove_file(tp, file);
     391                 :            :                 else
     392                 :            :                         trace_probe_clear_flag(tp, TP_FLAG_PROFILE);
     393                 :            :         }
     394                 :            : 
     395                 :          0 :         return ret;
     396                 :            : }
     397                 :            : 
     398                 :            : /*
     399                 :            :  * Disable trace_probe
     400                 :            :  * if the file is NULL, disable "perf" handler, or disable "trace" handler.
     401                 :            :  */
     402                 :          0 : static int disable_trace_kprobe(struct trace_event_call *call,
     403                 :            :                                 struct trace_event_file *file)
     404                 :            : {
     405                 :            :         struct trace_probe *tp;
     406                 :            : 
     407                 :            :         tp = trace_probe_primary_from_call(call);
     408   [ #  #  #  #  :          0 :         if (WARN_ON_ONCE(!tp))
                   #  # ]
     409                 :            :                 return -ENODEV;
     410                 :            : 
     411         [ #  # ]:          0 :         if (file) {
     412         [ #  # ]:          0 :                 if (!trace_probe_get_file_link(tp, file))
     413                 :            :                         return -ENOENT;
     414         [ #  # ]:          0 :                 if (!trace_probe_has_single_file(tp))
     415                 :            :                         goto out;
     416                 :            :                 trace_probe_clear_flag(tp, TP_FLAG_TRACE);
     417                 :            :         } else
     418                 :            :                 trace_probe_clear_flag(tp, TP_FLAG_PROFILE);
     419                 :            : 
     420         [ #  # ]:          0 :         if (!trace_probe_is_enabled(tp))
     421                 :          0 :                 __disable_trace_kprobe(tp);
     422                 :            : 
     423                 :            :  out:
     424         [ #  # ]:          0 :         if (file)
     425                 :            :                 /*
     426                 :            :                  * Synchronization is done in below function. For perf event,
     427                 :            :                  * file == NULL and perf_trace_event_unreg() calls
     428                 :            :                  * tracepoint_synchronize_unregister() to ensure synchronize
     429                 :            :                  * event. We don't need to care about it.
     430                 :            :                  */
     431                 :          0 :                 trace_probe_remove_file(tp, file);
     432                 :            : 
     433                 :            :         return 0;
     434                 :            : }
     435                 :            : 
     436                 :            : #if defined(CONFIG_KPROBES_ON_FTRACE) && \
     437                 :            :         !defined(CONFIG_KPROBE_EVENTS_ON_NOTRACE)
     438                 :            : static bool __within_notrace_func(unsigned long addr)
     439                 :            : {
     440                 :            :         unsigned long offset, size;
     441                 :            : 
     442                 :            :         if (!addr || !kallsyms_lookup_size_offset(addr, &size, &offset))
     443                 :            :                 return false;
     444                 :            : 
     445                 :            :         /* Get the entry address of the target function */
     446                 :            :         addr -= offset;
     447                 :            : 
     448                 :            :         /*
     449                 :            :          * Since ftrace_location_range() does inclusive range check, we need
     450                 :            :          * to subtract 1 byte from the end address.
     451                 :            :          */
     452                 :            :         return !ftrace_location_range(addr, addr + size - 1);
     453                 :            : }
     454                 :            : 
     455                 :            : static bool within_notrace_func(struct trace_kprobe *tk)
     456                 :            : {
     457                 :            :         unsigned long addr = trace_kprobe_address(tk);
     458                 :            :         char symname[KSYM_NAME_LEN], *p;
     459                 :            : 
     460                 :            :         if (!__within_notrace_func(addr))
     461                 :            :                 return false;
     462                 :            : 
     463                 :            :         /* Check if the address is on a suffixed-symbol */
     464                 :            :         if (!lookup_symbol_name(addr, symname)) {
     465                 :            :                 p = strchr(symname, '.');
     466                 :            :                 if (!p)
     467                 :            :                         return true;
     468                 :            :                 *p = '\0';
     469                 :            :                 addr = (unsigned long)kprobe_lookup_name(symname, 0);
     470                 :            :                 if (addr)
     471                 :            :                         return __within_notrace_func(addr);
     472                 :            :         }
     473                 :            : 
     474                 :            :         return true;
     475                 :            : }
     476                 :            : #else
     477                 :            : #define within_notrace_func(tk) (false)
     478                 :            : #endif
     479                 :            : 
     480                 :            : /* Internal register function - just handle k*probes and flags */
     481                 :          0 : static int __register_trace_kprobe(struct trace_kprobe *tk)
     482                 :            : {
     483                 :            :         int i, ret;
     484                 :            : 
     485                 :          0 :         ret = security_locked_down(LOCKDOWN_KPROBES);
     486         [ #  # ]:          0 :         if (ret)
     487                 :            :                 return ret;
     488                 :            : 
     489         [ #  # ]:          0 :         if (trace_kprobe_is_registered(tk))
     490                 :            :                 return -EINVAL;
     491                 :            : 
     492                 :            :         if (within_notrace_func(tk)) {
     493                 :            :                 pr_warn("Could not probe notrace function %s\n",
     494                 :            :                         trace_kprobe_symbol(tk));
     495                 :            :                 return -EINVAL;
     496                 :            :         }
     497                 :            : 
     498         [ #  # ]:          0 :         for (i = 0; i < tk->tp.nr_args; i++) {
     499                 :          0 :                 ret = traceprobe_update_arg(&tk->tp.args[i]);
     500         [ #  # ]:          0 :                 if (ret)
     501                 :          0 :                         return ret;
     502                 :            :         }
     503                 :            : 
     504                 :            :         /* Set/clear disabled flag according to tp->flag */
     505         [ #  # ]:          0 :         if (trace_probe_is_enabled(&tk->tp))
     506                 :          0 :                 tk->rp.kp.flags &= ~KPROBE_FLAG_DISABLED;
     507                 :            :         else
     508                 :          0 :                 tk->rp.kp.flags |= KPROBE_FLAG_DISABLED;
     509                 :            : 
     510         [ #  # ]:          0 :         if (trace_kprobe_is_return(tk))
     511                 :          0 :                 ret = register_kretprobe(&tk->rp);
     512                 :            :         else
     513                 :          0 :                 ret = register_kprobe(&tk->rp.kp);
     514                 :            : 
     515                 :          0 :         return ret;
     516                 :            : }
     517                 :            : 
     518                 :            : /* Internal unregister function - just handle k*probes and flags */
     519                 :          0 : static void __unregister_trace_kprobe(struct trace_kprobe *tk)
     520                 :            : {
     521         [ #  # ]:          0 :         if (trace_kprobe_is_registered(tk)) {
     522         [ #  # ]:          0 :                 if (trace_kprobe_is_return(tk))
     523                 :          0 :                         unregister_kretprobe(&tk->rp);
     524                 :            :                 else
     525                 :          0 :                         unregister_kprobe(&tk->rp.kp);
     526                 :            :                 /* Cleanup kprobe for reuse and mark it unregistered */
     527                 :            :                 INIT_HLIST_NODE(&tk->rp.kp.hlist);
     528                 :            :                 INIT_LIST_HEAD(&tk->rp.kp.list);
     529         [ #  # ]:          0 :                 if (tk->rp.kp.symbol_name)
     530                 :          0 :                         tk->rp.kp.addr = NULL;
     531                 :            :         }
     532                 :          0 : }
     533                 :            : 
     534                 :            : /* Unregister a trace_probe and probe_event */
     535                 :          0 : static int unregister_trace_kprobe(struct trace_kprobe *tk)
     536                 :            : {
     537                 :            :         /* If other probes are on the event, just unregister kprobe */
     538         [ #  # ]:          0 :         if (trace_probe_has_sibling(&tk->tp))
     539                 :            :                 goto unreg;
     540                 :            : 
     541                 :            :         /* Enabled event can not be unregistered */
     542         [ #  # ]:          0 :         if (trace_probe_is_enabled(&tk->tp))
     543                 :            :                 return -EBUSY;
     544                 :            : 
     545                 :            :         /* Will fail if probe is being used by ftrace or perf */
     546         [ #  # ]:          0 :         if (unregister_kprobe_event(tk))
     547                 :            :                 return -EBUSY;
     548                 :            : 
     549                 :            : unreg:
     550                 :          0 :         __unregister_trace_kprobe(tk);
     551                 :            :         dyn_event_remove(&tk->devent);
     552                 :          0 :         trace_probe_unlink(&tk->tp);
     553                 :            : 
     554                 :          0 :         return 0;
     555                 :            : }
     556                 :            : 
     557                 :          0 : static bool trace_kprobe_has_same_kprobe(struct trace_kprobe *orig,
     558                 :            :                                          struct trace_kprobe *comp)
     559                 :            : {
     560                 :          0 :         struct trace_probe_event *tpe = orig->tp.event;
     561                 :            :         struct trace_probe *pos;
     562                 :            :         int i;
     563                 :            : 
     564         [ #  # ]:          0 :         list_for_each_entry(pos, &tpe->probes, list) {
     565                 :            :                 orig = container_of(pos, struct trace_kprobe, tp);
     566         [ #  # ]:          0 :                 if (strcmp(trace_kprobe_symbol(orig),
     567         [ #  # ]:          0 :                            trace_kprobe_symbol(comp)) ||
     568                 :            :                     trace_kprobe_offset(orig) != trace_kprobe_offset(comp))
     569                 :          0 :                         continue;
     570                 :            : 
     571                 :            :                 /*
     572                 :            :                  * trace_probe_compare_arg_type() ensured that nr_args and
     573                 :            :                  * each argument name and type are same. Let's compare comm.
     574                 :            :                  */
     575         [ #  # ]:          0 :                 for (i = 0; i < orig->tp.nr_args; i++) {
     576         [ #  # ]:          0 :                         if (strcmp(orig->tp.args[i].comm,
     577                 :            :                                    comp->tp.args[i].comm))
     578                 :            :                                 break;
     579                 :            :                 }
     580                 :            : 
     581         [ #  # ]:          0 :                 if (i == orig->tp.nr_args)
     582                 :            :                         return true;
     583                 :            :         }
     584                 :            : 
     585                 :            :         return false;
     586                 :            : }
     587                 :            : 
     588                 :          0 : static int append_trace_kprobe(struct trace_kprobe *tk, struct trace_kprobe *to)
     589                 :            : {
     590                 :            :         int ret;
     591                 :            : 
     592                 :          0 :         ret = trace_probe_compare_arg_type(&tk->tp, &to->tp);
     593         [ #  # ]:          0 :         if (ret) {
     594                 :            :                 /* Note that argument starts index = 2 */
     595                 :          0 :                 trace_probe_log_set_index(ret + 1);
     596                 :          0 :                 trace_probe_log_err(0, DIFF_ARG_TYPE);
     597                 :          0 :                 return -EEXIST;
     598                 :            :         }
     599         [ #  # ]:          0 :         if (trace_kprobe_has_same_kprobe(to, tk)) {
     600                 :          0 :                 trace_probe_log_set_index(0);
     601                 :          0 :                 trace_probe_log_err(0, SAME_PROBE);
     602                 :          0 :                 return -EEXIST;
     603                 :            :         }
     604                 :            : 
     605                 :            :         /* Append to existing event */
     606                 :          0 :         ret = trace_probe_append(&tk->tp, &to->tp);
     607         [ #  # ]:          0 :         if (ret)
     608                 :            :                 return ret;
     609                 :            : 
     610                 :            :         /* Register k*probe */
     611                 :          0 :         ret = __register_trace_kprobe(tk);
     612   [ #  #  #  # ]:          0 :         if (ret == -ENOENT && !trace_kprobe_module_exist(tk)) {
     613                 :          0 :                 pr_warn("This probe might be able to register after target module is loaded. Continue.\n");
     614                 :            :                 ret = 0;
     615                 :            :         }
     616                 :            : 
     617         [ #  # ]:          0 :         if (ret)
     618                 :          0 :                 trace_probe_unlink(&tk->tp);
     619                 :            :         else
     620                 :          0 :                 dyn_event_add(&tk->devent);
     621                 :            : 
     622                 :          0 :         return ret;
     623                 :            : }
     624                 :            : 
     625                 :            : /* Register a trace_probe and probe_event */
     626                 :          0 : static int register_trace_kprobe(struct trace_kprobe *tk)
     627                 :            : {
     628                 :            :         struct trace_kprobe *old_tk;
     629                 :            :         int ret;
     630                 :            : 
     631                 :          0 :         mutex_lock(&event_mutex);
     632                 :            : 
     633                 :          0 :         old_tk = find_trace_kprobe(trace_probe_name(&tk->tp),
     634                 :            :                                    trace_probe_group_name(&tk->tp));
     635         [ #  # ]:          0 :         if (old_tk) {
     636         [ #  # ]:          0 :                 if (trace_kprobe_is_return(tk) != trace_kprobe_is_return(old_tk)) {
     637                 :          0 :                         trace_probe_log_set_index(0);
     638                 :          0 :                         trace_probe_log_err(0, DIFF_PROBE_TYPE);
     639                 :            :                         ret = -EEXIST;
     640                 :            :                 } else {
     641                 :          0 :                         ret = append_trace_kprobe(tk, old_tk);
     642                 :            :                 }
     643                 :            :                 goto end;
     644                 :            :         }
     645                 :            : 
     646                 :            :         /* Register new event */
     647                 :          0 :         ret = register_kprobe_event(tk);
     648         [ #  # ]:          0 :         if (ret) {
     649                 :          0 :                 pr_warn("Failed to register probe event(%d)\n", ret);
     650                 :          0 :                 goto end;
     651                 :            :         }
     652                 :            : 
     653                 :            :         /* Register k*probe */
     654                 :          0 :         ret = __register_trace_kprobe(tk);
     655   [ #  #  #  # ]:          0 :         if (ret == -ENOENT && !trace_kprobe_module_exist(tk)) {
     656                 :          0 :                 pr_warn("This probe might be able to register after target module is loaded. Continue.\n");
     657                 :            :                 ret = 0;
     658                 :            :         }
     659                 :            : 
     660         [ #  # ]:          0 :         if (ret < 0)
     661                 :            :                 unregister_kprobe_event(tk);
     662                 :            :         else
     663                 :          0 :                 dyn_event_add(&tk->devent);
     664                 :            : 
     665                 :            : end:
     666                 :          0 :         mutex_unlock(&event_mutex);
     667                 :          0 :         return ret;
     668                 :            : }
     669                 :            : 
     670                 :            : /* Module notifier call back, checking event on the module */
     671                 :      14904 : static int trace_kprobe_module_callback(struct notifier_block *nb,
     672                 :            :                                        unsigned long val, void *data)
     673                 :            : {
     674                 :            :         struct module *mod = data;
     675                 :            :         struct dyn_event *pos;
     676                 :            :         struct trace_kprobe *tk;
     677                 :            :         int ret;
     678                 :            : 
     679         [ +  + ]:      14904 :         if (val != MODULE_STATE_COMING)
     680                 :            :                 return NOTIFY_DONE;
     681                 :            : 
     682                 :            :         /* Update probes on coming module */
     683                 :       7452 :         mutex_lock(&event_mutex);
     684   [ #  #  #  #  :       7452 :         for_each_trace_kprobe(tk, pos) {
                   -  + ]
     685         [ #  # ]:          0 :                 if (trace_kprobe_within_module(tk, mod)) {
     686                 :            :                         /* Don't need to check busy - this should have gone. */
     687                 :          0 :                         __unregister_trace_kprobe(tk);
     688                 :          0 :                         ret = __register_trace_kprobe(tk);
     689         [ #  # ]:          0 :                         if (ret)
     690                 :          0 :                                 pr_warn("Failed to re-register probe %s on %s: %d\n",
     691                 :            :                                         trace_probe_name(&tk->tp),
     692                 :            :                                         mod->name, ret);
     693                 :            :                 }
     694                 :            :         }
     695                 :       7452 :         mutex_unlock(&event_mutex);
     696                 :            : 
     697                 :       7452 :         return NOTIFY_DONE;
     698                 :            : }
     699                 :            : 
     700                 :            : static struct notifier_block trace_kprobe_module_nb = {
     701                 :            :         .notifier_call = trace_kprobe_module_callback,
     702                 :            :         .priority = 1   /* Invoked after kprobe module callback */
     703                 :            : };
     704                 :            : 
     705                 :            : /* Convert certain expected symbols into '_' when generating event names */
     706                 :            : static inline void sanitize_event_name(char *name)
     707                 :            : {
     708         [ #  # ]:          0 :         while (*name++ != '\0')
     709         [ #  # ]:          0 :                 if (*name == ':' || *name == '.')
     710                 :          0 :                         *name = '_';
     711                 :            : }
     712                 :            : 
     713                 :          0 : static int trace_kprobe_create(int argc, const char *argv[])
     714                 :            : {
     715                 :            :         /*
     716                 :            :          * Argument syntax:
     717                 :            :          *  - Add kprobe:
     718                 :            :          *      p[:[GRP/]EVENT] [MOD:]KSYM[+OFFS]|KADDR [FETCHARGS]
     719                 :            :          *  - Add kretprobe:
     720                 :            :          *      r[MAXACTIVE][:[GRP/]EVENT] [MOD:]KSYM[+0] [FETCHARGS]
     721                 :            :          * Fetch args:
     722                 :            :          *  $retval     : fetch return value
     723                 :            :          *  $stack      : fetch stack address
     724                 :            :          *  $stackN     : fetch Nth of stack (N:0-)
     725                 :            :          *  $comm       : fetch current task comm
     726                 :            :          *  @ADDR       : fetch memory at ADDR (ADDR should be in kernel)
     727                 :            :          *  @SYM[+|-offs] : fetch memory at SYM +|- offs (SYM is a data symbol)
     728                 :            :          *  %REG        : fetch register REG
     729                 :            :          * Dereferencing memory fetch:
     730                 :            :          *  +|-offs(ARG) : fetch memory at ARG +|- offs address.
     731                 :            :          * Alias name of args:
     732                 :            :          *  NAME=FETCHARG : set NAME as alias of FETCHARG.
     733                 :            :          * Type of args:
     734                 :            :          *  FETCHARG:TYPE : use TYPE instead of unsigned long.
     735                 :            :          */
     736                 :            :         struct trace_kprobe *tk = NULL;
     737                 :            :         int i, len, ret = 0;
     738                 :            :         bool is_return = false;
     739                 :            :         char *symbol = NULL, *tmp = NULL;
     740                 :          0 :         const char *event = NULL, *group = KPROBE_EVENT_SYSTEM;
     741                 :          0 :         int maxactive = 0;
     742                 :          0 :         long offset = 0;
     743                 :          0 :         void *addr = NULL;
     744                 :            :         char buf[MAX_EVENT_NAME_LEN];
     745                 :            :         unsigned int flags = TPARG_FL_KERNEL;
     746                 :            : 
     747      [ #  #  # ]:          0 :         switch (argv[0][0]) {
     748                 :            :         case 'r':
     749                 :            :                 is_return = true;
     750                 :            :                 flags |= TPARG_FL_RETURN;
     751                 :          0 :                 break;
     752                 :            :         case 'p':
     753                 :            :                 break;
     754                 :            :         default:
     755                 :            :                 return -ECANCELED;
     756                 :            :         }
     757         [ #  # ]:          0 :         if (argc < 2)
     758                 :            :                 return -ECANCELED;
     759                 :            : 
     760                 :          0 :         trace_probe_log_init("trace_kprobe", argc, argv);
     761                 :            : 
     762                 :          0 :         event = strchr(&argv[0][1], ':');
     763         [ #  # ]:          0 :         if (event)
     764                 :          0 :                 event++;
     765                 :            : 
     766         [ #  # ]:          0 :         if (isdigit(argv[0][1])) {
     767         [ #  # ]:          0 :                 if (!is_return) {
     768                 :          0 :                         trace_probe_log_err(1, MAXACT_NO_KPROBE);
     769                 :          0 :                         goto parse_error;
     770                 :            :                 }
     771         [ #  # ]:          0 :                 if (event)
     772                 :          0 :                         len = event - &argv[0][1] - 1;
     773                 :            :                 else
     774                 :          0 :                         len = strlen(&argv[0][1]);
     775         [ #  # ]:          0 :                 if (len > MAX_EVENT_NAME_LEN - 1) {
     776                 :          0 :                         trace_probe_log_err(1, BAD_MAXACT);
     777                 :          0 :                         goto parse_error;
     778                 :            :                 }
     779                 :          0 :                 memcpy(buf, &argv[0][1], len);
     780                 :          0 :                 buf[len] = '\0';
     781                 :          0 :                 ret = kstrtouint(buf, 0, &maxactive);
     782   [ #  #  #  # ]:          0 :                 if (ret || !maxactive) {
     783                 :          0 :                         trace_probe_log_err(1, BAD_MAXACT);
     784                 :          0 :                         goto parse_error;
     785                 :            :                 }
     786                 :            :                 /* kretprobes instances are iterated over via a list. The
     787                 :            :                  * maximum should stay reasonable.
     788                 :            :                  */
     789         [ #  # ]:          0 :                 if (maxactive > KRETPROBE_MAXACTIVE_MAX) {
     790                 :          0 :                         trace_probe_log_err(1, MAXACT_TOO_BIG);
     791                 :          0 :                         goto parse_error;
     792                 :            :                 }
     793                 :            :         }
     794                 :            : 
     795                 :            :         /* try to parse an address. if that fails, try to read the
     796                 :            :          * input as a symbol. */
     797         [ #  # ]:          0 :         if (kstrtoul(argv[1], 0, (unsigned long *)&addr)) {
     798                 :          0 :                 trace_probe_log_set_index(1);
     799                 :            :                 /* Check whether uprobe event specified */
     800   [ #  #  #  # ]:          0 :                 if (strchr(argv[1], '/') && strchr(argv[1], ':')) {
     801                 :            :                         ret = -ECANCELED;
     802                 :            :                         goto error;
     803                 :            :                 }
     804                 :            :                 /* a symbol specified */
     805                 :          0 :                 symbol = kstrdup(argv[1], GFP_KERNEL);
     806         [ #  # ]:          0 :                 if (!symbol)
     807                 :            :                         return -ENOMEM;
     808                 :            :                 /* TODO: support .init module functions */
     809                 :          0 :                 ret = traceprobe_split_symbol_offset(symbol, &offset);
     810   [ #  #  #  # ]:          0 :                 if (ret || offset < 0 || offset > UINT_MAX) {
     811                 :          0 :                         trace_probe_log_err(0, BAD_PROBE_ADDR);
     812                 :          0 :                         goto parse_error;
     813                 :            :                 }
     814         [ #  # ]:          0 :                 if (kprobe_on_func_entry(NULL, symbol, offset))
     815                 :          0 :                         flags |= TPARG_FL_FENTRY;
     816   [ #  #  #  #  :          0 :                 if (offset && is_return && !(flags & TPARG_FL_FENTRY)) {
                   #  # ]
     817                 :          0 :                         trace_probe_log_err(0, BAD_RETPROBE);
     818                 :          0 :                         goto parse_error;
     819                 :            :                 }
     820                 :            :         }
     821                 :            : 
     822                 :          0 :         trace_probe_log_set_index(0);
     823         [ #  # ]:          0 :         if (event) {
     824                 :          0 :                 ret = traceprobe_parse_event_name(&event, &group, buf,
     825                 :          0 :                                                   event - argv[0]);
     826         [ #  # ]:          0 :                 if (ret)
     827                 :            :                         goto parse_error;
     828                 :            :         } else {
     829                 :            :                 /* Make a new event name */
     830         [ #  # ]:          0 :                 if (symbol)
     831         [ #  # ]:          0 :                         snprintf(buf, MAX_EVENT_NAME_LEN, "%c_%s_%ld",
     832                 :            :                                  is_return ? 'r' : 'p', symbol, offset);
     833                 :            :                 else
     834         [ #  # ]:          0 :                         snprintf(buf, MAX_EVENT_NAME_LEN, "%c_0x%p",
     835                 :            :                                  is_return ? 'r' : 'p', addr);
     836                 :            :                 sanitize_event_name(buf);
     837                 :          0 :                 event = buf;
     838                 :            :         }
     839                 :            : 
     840                 :            :         /* setup a probe */
     841                 :          0 :         tk = alloc_trace_kprobe(group, event, addr, symbol, offset, maxactive,
     842                 :            :                                argc - 2, is_return);
     843         [ #  # ]:          0 :         if (IS_ERR(tk)) {
     844                 :            :                 ret = PTR_ERR(tk);
     845                 :            :                 /* This must return -ENOMEM, else there is a bug */
     846   [ #  #  #  # ]:          0 :                 WARN_ON_ONCE(ret != -ENOMEM);
     847                 :            :                 goto out;       /* We know tk is not allocated */
     848                 :            :         }
     849                 :            :         argc -= 2; argv += 2;
     850                 :            : 
     851                 :            :         /* parse arguments */
     852         [ #  # ]:          0 :         for (i = 0; i < argc && i < MAX_TRACE_ARGS; i++) {
     853                 :          0 :                 tmp = kstrdup(argv[i], GFP_KERNEL);
     854         [ #  # ]:          0 :                 if (!tmp) {
     855                 :            :                         ret = -ENOMEM;
     856                 :            :                         goto error;
     857                 :            :                 }
     858                 :            : 
     859                 :          0 :                 trace_probe_log_set_index(i + 2);
     860                 :          0 :                 ret = traceprobe_parse_probe_arg(&tk->tp, i, tmp, flags);
     861                 :          0 :                 kfree(tmp);
     862         [ #  # ]:          0 :                 if (ret)
     863                 :            :                         goto error;     /* This can be -ENOMEM */
     864                 :            :         }
     865                 :            : 
     866                 :          0 :         ret = traceprobe_set_print_fmt(&tk->tp, is_return);
     867         [ #  # ]:          0 :         if (ret < 0)
     868                 :            :                 goto error;
     869                 :            : 
     870                 :          0 :         ret = register_trace_kprobe(tk);
     871         [ #  # ]:          0 :         if (ret) {
     872                 :          0 :                 trace_probe_log_set_index(1);
     873         [ #  # ]:          0 :                 if (ret == -EILSEQ)
     874                 :          0 :                         trace_probe_log_err(0, BAD_INSN_BNDRY);
     875         [ #  # ]:          0 :                 else if (ret == -ENOENT)
     876                 :          0 :                         trace_probe_log_err(0, BAD_PROBE_ADDR);
     877         [ #  # ]:          0 :                 else if (ret != -ENOMEM && ret != -EEXIST)
     878                 :          0 :                         trace_probe_log_err(0, FAIL_REG_PROBE);
     879                 :            :                 goto error;
     880                 :            :         }
     881                 :            : 
     882                 :            : out:
     883                 :          0 :         trace_probe_log_clear();
     884                 :          0 :         kfree(symbol);
     885                 :          0 :         return ret;
     886                 :            : 
     887                 :            : parse_error:
     888                 :            :         ret = -EINVAL;
     889                 :            : error:
     890                 :          0 :         free_trace_kprobe(tk);
     891                 :          0 :         goto out;
     892                 :            : }
     893                 :            : 
     894                 :          0 : static int create_or_delete_trace_kprobe(int argc, char **argv)
     895                 :            : {
     896                 :            :         int ret;
     897                 :            : 
     898         [ #  # ]:          0 :         if (argv[0][0] == '-')
     899                 :          0 :                 return dyn_event_release(argc, argv, &trace_kprobe_ops);
     900                 :            : 
     901                 :          0 :         ret = trace_kprobe_create(argc, (const char **)argv);
     902         [ #  # ]:          0 :         return ret == -ECANCELED ? -EINVAL : ret;
     903                 :            : }
     904                 :            : 
     905                 :          0 : static int trace_kprobe_release(struct dyn_event *ev)
     906                 :            : {
     907                 :            :         struct trace_kprobe *tk = to_trace_kprobe(ev);
     908                 :          0 :         int ret = unregister_trace_kprobe(tk);
     909                 :            : 
     910         [ #  # ]:          0 :         if (!ret)
     911                 :          0 :                 free_trace_kprobe(tk);
     912                 :          0 :         return ret;
     913                 :            : }
     914                 :            : 
     915                 :          0 : static int trace_kprobe_show(struct seq_file *m, struct dyn_event *ev)
     916                 :            : {
     917                 :            :         struct trace_kprobe *tk = to_trace_kprobe(ev);
     918                 :            :         int i;
     919                 :            : 
     920         [ #  # ]:          0 :         seq_putc(m, trace_kprobe_is_return(tk) ? 'r' : 'p');
     921   [ #  #  #  # ]:          0 :         if (trace_kprobe_is_return(tk) && tk->rp.maxactive)
     922                 :          0 :                 seq_printf(m, "%d", tk->rp.maxactive);
     923                 :          0 :         seq_printf(m, ":%s/%s", trace_probe_group_name(&tk->tp),
     924                 :            :                                 trace_probe_name(&tk->tp));
     925                 :            : 
     926         [ #  # ]:          0 :         if (!tk->symbol)
     927                 :          0 :                 seq_printf(m, " 0x%p", tk->rp.kp.addr);
     928         [ #  # ]:          0 :         else if (tk->rp.kp.offset)
     929                 :          0 :                 seq_printf(m, " %s+%u", trace_kprobe_symbol(tk),
     930                 :            :                            tk->rp.kp.offset);
     931                 :            :         else
     932                 :          0 :                 seq_printf(m, " %s", trace_kprobe_symbol(tk));
     933                 :            : 
     934         [ #  # ]:          0 :         for (i = 0; i < tk->tp.nr_args; i++)
     935                 :          0 :                 seq_printf(m, " %s=%s", tk->tp.args[i].name, tk->tp.args[i].comm);
     936                 :          0 :         seq_putc(m, '\n');
     937                 :            : 
     938                 :          0 :         return 0;
     939                 :            : }
     940                 :            : 
     941                 :          0 : static int probes_seq_show(struct seq_file *m, void *v)
     942                 :            : {
     943                 :            :         struct dyn_event *ev = v;
     944                 :            : 
     945         [ #  # ]:          0 :         if (!is_trace_kprobe(ev))
     946                 :            :                 return 0;
     947                 :            : 
     948                 :          0 :         return trace_kprobe_show(m, ev);
     949                 :            : }
     950                 :            : 
     951                 :            : static const struct seq_operations probes_seq_op = {
     952                 :            :         .start  = dyn_event_seq_start,
     953                 :            :         .next   = dyn_event_seq_next,
     954                 :            :         .stop   = dyn_event_seq_stop,
     955                 :            :         .show   = probes_seq_show
     956                 :            : };
     957                 :            : 
     958                 :          0 : static int probes_open(struct inode *inode, struct file *file)
     959                 :            : {
     960                 :            :         int ret;
     961                 :            : 
     962                 :          0 :         ret = security_locked_down(LOCKDOWN_TRACEFS);
     963         [ #  # ]:          0 :         if (ret)
     964                 :            :                 return ret;
     965                 :            : 
     966   [ #  #  #  # ]:          0 :         if ((file->f_mode & FMODE_WRITE) && (file->f_flags & O_TRUNC)) {
     967                 :          0 :                 ret = dyn_events_release_all(&trace_kprobe_ops);
     968         [ #  # ]:          0 :                 if (ret < 0)
     969                 :            :                         return ret;
     970                 :            :         }
     971                 :            : 
     972                 :          0 :         return seq_open(file, &probes_seq_op);
     973                 :            : }
     974                 :            : 
     975                 :          0 : static ssize_t probes_write(struct file *file, const char __user *buffer,
     976                 :            :                             size_t count, loff_t *ppos)
     977                 :            : {
     978                 :          0 :         return trace_parse_run_command(file, buffer, count, ppos,
     979                 :            :                                        create_or_delete_trace_kprobe);
     980                 :            : }
     981                 :            : 
     982                 :            : static const struct file_operations kprobe_events_ops = {
     983                 :            :         .owner          = THIS_MODULE,
     984                 :            :         .open           = probes_open,
     985                 :            :         .read           = seq_read,
     986                 :            :         .llseek         = seq_lseek,
     987                 :            :         .release        = seq_release,
     988                 :            :         .write          = probes_write,
     989                 :            : };
     990                 :            : 
     991                 :            : /* Probes profiling interfaces */
     992                 :          0 : static int probes_profile_seq_show(struct seq_file *m, void *v)
     993                 :            : {
     994                 :            :         struct dyn_event *ev = v;
     995                 :            :         struct trace_kprobe *tk;
     996                 :            : 
     997         [ #  # ]:          0 :         if (!is_trace_kprobe(ev))
     998                 :            :                 return 0;
     999                 :            : 
    1000                 :            :         tk = to_trace_kprobe(ev);
    1001                 :          0 :         seq_printf(m, "  %-44s %15lu %15lu\n",
    1002                 :            :                    trace_probe_name(&tk->tp),
    1003                 :            :                    trace_kprobe_nhit(tk),
    1004                 :            :                    tk->rp.kp.nmissed);
    1005                 :            : 
    1006                 :          0 :         return 0;
    1007                 :            : }
    1008                 :            : 
    1009                 :            : static const struct seq_operations profile_seq_op = {
    1010                 :            :         .start  = dyn_event_seq_start,
    1011                 :            :         .next   = dyn_event_seq_next,
    1012                 :            :         .stop   = dyn_event_seq_stop,
    1013                 :            :         .show   = probes_profile_seq_show
    1014                 :            : };
    1015                 :            : 
    1016                 :          0 : static int profile_open(struct inode *inode, struct file *file)
    1017                 :            : {
    1018                 :            :         int ret;
    1019                 :            : 
    1020                 :          0 :         ret = security_locked_down(LOCKDOWN_TRACEFS);
    1021         [ #  # ]:          0 :         if (ret)
    1022                 :            :                 return ret;
    1023                 :            : 
    1024                 :          0 :         return seq_open(file, &profile_seq_op);
    1025                 :            : }
    1026                 :            : 
    1027                 :            : static const struct file_operations kprobe_profile_ops = {
    1028                 :            :         .owner          = THIS_MODULE,
    1029                 :            :         .open           = profile_open,
    1030                 :            :         .read           = seq_read,
    1031                 :            :         .llseek         = seq_lseek,
    1032                 :            :         .release        = seq_release,
    1033                 :            : };
    1034                 :            : 
    1035                 :            : /* Kprobe specific fetch functions */
    1036                 :            : 
    1037                 :            : /* Return the length of string -- including null terminal byte */
    1038                 :            : static nokprobe_inline int
    1039                 :            : fetch_store_strlen(unsigned long addr)
    1040                 :            : {
    1041                 :            :         int ret, len = 0;
    1042                 :            :         u8 c;
    1043                 :            : 
    1044                 :            :         do {
    1045                 :          0 :                 ret = probe_kernel_read(&c, (u8 *)addr + len, 1);
    1046                 :          0 :                 len++;
    1047   [ #  #  #  # ]:          0 :         } while (c && ret == 0 && len < MAX_STRING_SIZE);
    1048                 :            : 
    1049         [ #  # ]:          0 :         return (ret < 0) ? ret : len;
    1050                 :            : }
    1051                 :            : 
    1052                 :            : /* Return the length of string -- including null terminal byte */
    1053                 :            : static nokprobe_inline int
    1054                 :            : fetch_store_strlen_user(unsigned long addr)
    1055                 :            : {
    1056                 :          0 :         const void __user *uaddr =  (__force const void __user *)addr;
    1057                 :            : 
    1058                 :          0 :         return strnlen_unsafe_user(uaddr, MAX_STRING_SIZE);
    1059                 :            : }
    1060                 :            : 
    1061                 :            : /*
    1062                 :            :  * Fetch a null-terminated string. Caller MUST set *(u32 *)buf with max
    1063                 :            :  * length and relative data location.
    1064                 :            :  */
    1065                 :            : static nokprobe_inline int
    1066                 :            : fetch_store_string(unsigned long addr, void *dest, void *base)
    1067                 :            : {
    1068                 :          0 :         int maxlen = get_loc_len(*(u32 *)dest);
    1069                 :            :         void *__dest;
    1070                 :            :         long ret;
    1071                 :            : 
    1072         [ #  # ]:          0 :         if (unlikely(!maxlen))
    1073                 :            :                 return -ENOMEM;
    1074                 :            : 
    1075                 :            :         __dest = get_loc_data(dest, base);
    1076                 :            : 
    1077                 :            :         /*
    1078                 :            :          * Try to get string again, since the string can be changed while
    1079                 :            :          * probing.
    1080                 :            :          */
    1081                 :          0 :         ret = strncpy_from_unsafe(__dest, (void *)addr, maxlen);
    1082         [ #  # ]:          0 :         if (ret >= 0)
    1083                 :          0 :                 *(u32 *)dest = make_data_loc(ret, __dest - base);
    1084                 :            : 
    1085                 :            :         return ret;
    1086                 :            : }
    1087                 :            : 
    1088                 :            : /*
    1089                 :            :  * Fetch a null-terminated string from user. Caller MUST set *(u32 *)buf
    1090                 :            :  * with max length and relative data location.
    1091                 :            :  */
    1092                 :            : static nokprobe_inline int
    1093                 :            : fetch_store_string_user(unsigned long addr, void *dest, void *base)
    1094                 :            : {
    1095                 :          0 :         const void __user *uaddr =  (__force const void __user *)addr;
    1096                 :          0 :         int maxlen = get_loc_len(*(u32 *)dest);
    1097                 :            :         void *__dest;
    1098                 :            :         long ret;
    1099                 :            : 
    1100         [ #  # ]:          0 :         if (unlikely(!maxlen))
    1101                 :            :                 return -ENOMEM;
    1102                 :            : 
    1103                 :            :         __dest = get_loc_data(dest, base);
    1104                 :            : 
    1105                 :          0 :         ret = strncpy_from_unsafe_user(__dest, uaddr, maxlen);
    1106         [ #  # ]:          0 :         if (ret >= 0)
    1107                 :          0 :                 *(u32 *)dest = make_data_loc(ret, __dest - base);
    1108                 :            : 
    1109                 :            :         return ret;
    1110                 :            : }
    1111                 :            : 
    1112                 :            : static nokprobe_inline int
    1113                 :            : probe_mem_read(void *dest, void *src, size_t size)
    1114                 :            : {
    1115                 :          0 :         return probe_kernel_read(dest, src, size);
    1116                 :            : }
    1117                 :            : 
    1118                 :            : static nokprobe_inline int
    1119                 :            : probe_mem_read_user(void *dest, void *src, size_t size)
    1120                 :            : {
    1121                 :            :         const void __user *uaddr =  (__force const void __user *)src;
    1122                 :            : 
    1123                 :          0 :         return probe_user_read(dest, uaddr, size);
    1124                 :            : }
    1125                 :            : 
    1126                 :            : /* Note that we don't verify it, since the code does not come from user space */
    1127                 :            : static int
    1128                 :          0 : process_fetch_insn(struct fetch_insn *code, struct pt_regs *regs, void *dest,
    1129                 :            :                    void *base)
    1130                 :            : {
    1131                 :            :         unsigned long val;
    1132                 :            : 
    1133                 :            : retry:
    1134                 :            :         /* 1st stage: get value from context */
    1135   [ #  #  #  #  :          0 :         switch (code->op) {
             #  #  #  #  
                      # ]
    1136                 :            :         case FETCH_OP_REG:
    1137                 :          0 :                 val = regs_get_register(regs, code->param);
    1138                 :          0 :                 break;
    1139                 :            :         case FETCH_OP_STACK:
    1140                 :          0 :                 val = regs_get_kernel_stack_nth(regs, code->param);
    1141                 :          0 :                 break;
    1142                 :            :         case FETCH_OP_STACKP:
    1143                 :            :                 val = kernel_stack_pointer(regs);
    1144                 :          0 :                 break;
    1145                 :            :         case FETCH_OP_RETVAL:
    1146                 :            :                 val = regs_return_value(regs);
    1147                 :          0 :                 break;
    1148                 :            :         case FETCH_OP_IMM:
    1149                 :          0 :                 val = code->immediate;
    1150                 :          0 :                 break;
    1151                 :            :         case FETCH_OP_COMM:
    1152                 :          0 :                 val = (unsigned long)current->comm;
    1153                 :          0 :                 break;
    1154                 :            :         case FETCH_OP_DATA:
    1155                 :          0 :                 val = (unsigned long)code->data;
    1156                 :          0 :                 break;
    1157                 :            : #ifdef CONFIG_HAVE_FUNCTION_ARG_ACCESS_API
    1158                 :            :         case FETCH_OP_ARG:
    1159                 :            :                 val = regs_get_kernel_argument(regs, code->param);
    1160                 :            :                 break;
    1161                 :            : #endif
    1162                 :            :         case FETCH_NOP_SYMBOL:  /* Ignore a place holder */
    1163                 :          0 :                 code++;
    1164                 :          0 :                 goto retry;
    1165                 :            :         default:
    1166                 :            :                 return -EILSEQ;
    1167                 :            :         }
    1168                 :          0 :         code++;
    1169                 :            : 
    1170                 :          0 :         return process_fetch_insn_bottom(code, val, dest, base);
    1171                 :            : }
    1172                 :            : NOKPROBE_SYMBOL(process_fetch_insn)
    1173                 :            : 
    1174                 :            : /* Kprobe handler */
    1175                 :            : static nokprobe_inline void
    1176                 :            : __kprobe_trace_func(struct trace_kprobe *tk, struct pt_regs *regs,
    1177                 :            :                     struct trace_event_file *trace_file)
    1178                 :            : {
    1179                 :            :         struct kprobe_trace_entry_head *entry;
    1180                 :            :         struct ring_buffer_event *event;
    1181                 :            :         struct ring_buffer *buffer;
    1182                 :            :         int size, dsize, pc;
    1183                 :            :         unsigned long irq_flags;
    1184                 :          0 :         struct trace_event_call *call = trace_probe_event_call(&tk->tp);
    1185                 :            : 
    1186         [ #  # ]:          0 :         WARN_ON(call != trace_file->event_call);
    1187                 :            : 
    1188         [ #  # ]:          0 :         if (trace_trigger_soft_disabled(trace_file))
    1189                 :          0 :                 return;
    1190                 :            : 
    1191                 :          0 :         local_save_flags(irq_flags);
    1192                 :            :         pc = preempt_count();
    1193                 :            : 
    1194                 :            :         dsize = __get_data_size(&tk->tp, regs);
    1195                 :          0 :         size = sizeof(*entry) + tk->tp.size + dsize;
    1196                 :            : 
    1197                 :          0 :         event = trace_event_buffer_lock_reserve(&buffer, trace_file,
    1198                 :            :                                                 call->event.type,
    1199                 :            :                                                 size, irq_flags, pc);
    1200         [ #  # ]:          0 :         if (!event)
    1201                 :            :                 return;
    1202                 :            : 
    1203                 :          0 :         entry = ring_buffer_event_data(event);
    1204                 :          0 :         entry->ip = (unsigned long)tk->rp.kp.addr;
    1205                 :          0 :         store_trace_args(&entry[1], &tk->tp, regs, sizeof(*entry), dsize);
    1206                 :            : 
    1207                 :          0 :         event_trigger_unlock_commit_regs(trace_file, buffer, event,
    1208                 :            :                                          entry, irq_flags, pc, regs);
    1209                 :            : }
    1210                 :            : 
    1211                 :            : static void
    1212                 :          0 : kprobe_trace_func(struct trace_kprobe *tk, struct pt_regs *regs)
    1213                 :            : {
    1214                 :            :         struct event_file_link *link;
    1215                 :            : 
    1216         [ #  # ]:          0 :         trace_probe_for_each_link_rcu(link, &tk->tp)
    1217                 :          0 :                 __kprobe_trace_func(tk, regs, link->file);
    1218                 :          0 : }
    1219                 :            : NOKPROBE_SYMBOL(kprobe_trace_func);
    1220                 :            : 
    1221                 :            : /* Kretprobe handler */
    1222                 :            : static nokprobe_inline void
    1223                 :            : __kretprobe_trace_func(struct trace_kprobe *tk, struct kretprobe_instance *ri,
    1224                 :            :                        struct pt_regs *regs,
    1225                 :            :                        struct trace_event_file *trace_file)
    1226                 :            : {
    1227                 :            :         struct kretprobe_trace_entry_head *entry;
    1228                 :            :         struct ring_buffer_event *event;
    1229                 :            :         struct ring_buffer *buffer;
    1230                 :            :         int size, pc, dsize;
    1231                 :            :         unsigned long irq_flags;
    1232                 :          0 :         struct trace_event_call *call = trace_probe_event_call(&tk->tp);
    1233                 :            : 
    1234         [ #  # ]:          0 :         WARN_ON(call != trace_file->event_call);
    1235                 :            : 
    1236         [ #  # ]:          0 :         if (trace_trigger_soft_disabled(trace_file))
    1237                 :          0 :                 return;
    1238                 :            : 
    1239                 :          0 :         local_save_flags(irq_flags);
    1240                 :            :         pc = preempt_count();
    1241                 :            : 
    1242                 :            :         dsize = __get_data_size(&tk->tp, regs);
    1243                 :          0 :         size = sizeof(*entry) + tk->tp.size + dsize;
    1244                 :            : 
    1245                 :          0 :         event = trace_event_buffer_lock_reserve(&buffer, trace_file,
    1246                 :            :                                                 call->event.type,
    1247                 :            :                                                 size, irq_flags, pc);
    1248         [ #  # ]:          0 :         if (!event)
    1249                 :            :                 return;
    1250                 :            : 
    1251                 :          0 :         entry = ring_buffer_event_data(event);
    1252                 :          0 :         entry->func = (unsigned long)tk->rp.kp.addr;
    1253                 :          0 :         entry->ret_ip = (unsigned long)ri->ret_addr;
    1254                 :          0 :         store_trace_args(&entry[1], &tk->tp, regs, sizeof(*entry), dsize);
    1255                 :            : 
    1256                 :          0 :         event_trigger_unlock_commit_regs(trace_file, buffer, event,
    1257                 :            :                                          entry, irq_flags, pc, regs);
    1258                 :            : }
    1259                 :            : 
    1260                 :            : static void
    1261                 :          0 : kretprobe_trace_func(struct trace_kprobe *tk, struct kretprobe_instance *ri,
    1262                 :            :                      struct pt_regs *regs)
    1263                 :            : {
    1264                 :            :         struct event_file_link *link;
    1265                 :            : 
    1266         [ #  # ]:          0 :         trace_probe_for_each_link_rcu(link, &tk->tp)
    1267                 :          0 :                 __kretprobe_trace_func(tk, ri, regs, link->file);
    1268                 :          0 : }
    1269                 :            : NOKPROBE_SYMBOL(kretprobe_trace_func);
    1270                 :            : 
    1271                 :            : /* Event entry printers */
    1272                 :            : static enum print_line_t
    1273                 :          0 : print_kprobe_event(struct trace_iterator *iter, int flags,
    1274                 :            :                    struct trace_event *event)
    1275                 :            : {
    1276                 :            :         struct kprobe_trace_entry_head *field;
    1277                 :          0 :         struct trace_seq *s = &iter->seq;
    1278                 :            :         struct trace_probe *tp;
    1279                 :            : 
    1280                 :          0 :         field = (struct kprobe_trace_entry_head *)iter->ent;
    1281                 :            :         tp = trace_probe_primary_from_call(
    1282                 :            :                 container_of(event, struct trace_event_call, event));
    1283   [ #  #  #  #  :          0 :         if (WARN_ON_ONCE(!tp))
                   #  # ]
    1284                 :            :                 goto out;
    1285                 :            : 
    1286                 :          0 :         trace_seq_printf(s, "%s: (", trace_probe_name(tp));
    1287                 :            : 
    1288         [ #  # ]:          0 :         if (!seq_print_ip_sym(s, field->ip, flags | TRACE_ITER_SYM_OFFSET))
    1289                 :            :                 goto out;
    1290                 :            : 
    1291                 :          0 :         trace_seq_putc(s, ')');
    1292                 :            : 
    1293         [ #  # ]:          0 :         if (print_probe_args(s, tp->args, tp->nr_args,
    1294                 :            :                              (u8 *)&field[1], field) < 0)
    1295                 :            :                 goto out;
    1296                 :            : 
    1297                 :          0 :         trace_seq_putc(s, '\n');
    1298                 :            :  out:
    1299                 :          0 :         return trace_handle_return(s);
    1300                 :            : }
    1301                 :            : 
    1302                 :            : static enum print_line_t
    1303                 :          0 : print_kretprobe_event(struct trace_iterator *iter, int flags,
    1304                 :            :                       struct trace_event *event)
    1305                 :            : {
    1306                 :            :         struct kretprobe_trace_entry_head *field;
    1307                 :          0 :         struct trace_seq *s = &iter->seq;
    1308                 :            :         struct trace_probe *tp;
    1309                 :            : 
    1310                 :          0 :         field = (struct kretprobe_trace_entry_head *)iter->ent;
    1311                 :            :         tp = trace_probe_primary_from_call(
    1312                 :            :                 container_of(event, struct trace_event_call, event));
    1313   [ #  #  #  #  :          0 :         if (WARN_ON_ONCE(!tp))
                   #  # ]
    1314                 :            :                 goto out;
    1315                 :            : 
    1316                 :          0 :         trace_seq_printf(s, "%s: (", trace_probe_name(tp));
    1317                 :            : 
    1318         [ #  # ]:          0 :         if (!seq_print_ip_sym(s, field->ret_ip, flags | TRACE_ITER_SYM_OFFSET))
    1319                 :            :                 goto out;
    1320                 :            : 
    1321                 :          0 :         trace_seq_puts(s, " <- ");
    1322                 :            : 
    1323         [ #  # ]:          0 :         if (!seq_print_ip_sym(s, field->func, flags & ~TRACE_ITER_SYM_OFFSET))
    1324                 :            :                 goto out;
    1325                 :            : 
    1326                 :          0 :         trace_seq_putc(s, ')');
    1327                 :            : 
    1328         [ #  # ]:          0 :         if (print_probe_args(s, tp->args, tp->nr_args,
    1329                 :            :                              (u8 *)&field[1], field) < 0)
    1330                 :            :                 goto out;
    1331                 :            : 
    1332                 :          0 :         trace_seq_putc(s, '\n');
    1333                 :            : 
    1334                 :            :  out:
    1335                 :          0 :         return trace_handle_return(s);
    1336                 :            : }
    1337                 :            : 
    1338                 :            : 
    1339                 :          0 : static int kprobe_event_define_fields(struct trace_event_call *event_call)
    1340                 :            : {
    1341                 :            :         int ret;
    1342                 :            :         struct kprobe_trace_entry_head field;
    1343                 :            :         struct trace_probe *tp;
    1344                 :            : 
    1345                 :            :         tp = trace_probe_primary_from_call(event_call);
    1346   [ #  #  #  #  :          0 :         if (WARN_ON_ONCE(!tp))
                   #  # ]
    1347                 :            :                 return -ENOENT;
    1348                 :            : 
    1349         [ #  # ]:          0 :         DEFINE_FIELD(unsigned long, ip, FIELD_STRING_IP, 0);
    1350                 :            : 
    1351                 :          0 :         return traceprobe_define_arg_fields(event_call, sizeof(field), tp);
    1352                 :            : }
    1353                 :            : 
    1354                 :          0 : static int kretprobe_event_define_fields(struct trace_event_call *event_call)
    1355                 :            : {
    1356                 :            :         int ret;
    1357                 :            :         struct kretprobe_trace_entry_head field;
    1358                 :            :         struct trace_probe *tp;
    1359                 :            : 
    1360                 :            :         tp = trace_probe_primary_from_call(event_call);
    1361   [ #  #  #  #  :          0 :         if (WARN_ON_ONCE(!tp))
                   #  # ]
    1362                 :            :                 return -ENOENT;
    1363                 :            : 
    1364         [ #  # ]:          0 :         DEFINE_FIELD(unsigned long, func, FIELD_STRING_FUNC, 0);
    1365         [ #  # ]:          0 :         DEFINE_FIELD(unsigned long, ret_ip, FIELD_STRING_RETIP, 0);
    1366                 :            : 
    1367                 :          0 :         return traceprobe_define_arg_fields(event_call, sizeof(field), tp);
    1368                 :            : }
    1369                 :            : 
    1370                 :            : #ifdef CONFIG_PERF_EVENTS
    1371                 :            : 
    1372                 :            : /* Kprobe profile handler */
    1373                 :            : static int
    1374                 :          0 : kprobe_perf_func(struct trace_kprobe *tk, struct pt_regs *regs)
    1375                 :            : {
    1376                 :            :         struct trace_event_call *call = trace_probe_event_call(&tk->tp);
    1377                 :            :         struct kprobe_trace_entry_head *entry;
    1378                 :            :         struct hlist_head *head;
    1379                 :            :         int size, __size, dsize;
    1380                 :            :         int rctx;
    1381                 :            : 
    1382         [ #  # ]:          0 :         if (bpf_prog_array_valid(call)) {
    1383                 :          0 :                 unsigned long orig_ip = instruction_pointer(regs);
    1384                 :            :                 int ret;
    1385                 :            : 
    1386                 :          0 :                 ret = trace_call_bpf(call, regs);
    1387                 :            : 
    1388                 :            :                 /*
    1389                 :            :                  * We need to check and see if we modified the pc of the
    1390                 :            :                  * pt_regs, and if so return 1 so that we don't do the
    1391                 :            :                  * single stepping.
    1392                 :            :                  */
    1393         [ #  # ]:          0 :                 if (orig_ip != instruction_pointer(regs))
    1394                 :            :                         return 1;
    1395         [ #  # ]:          0 :                 if (!ret)
    1396                 :            :                         return 0;
    1397                 :            :         }
    1398                 :            : 
    1399                 :          0 :         head = this_cpu_ptr(call->perf_events);
    1400         [ #  # ]:          0 :         if (hlist_empty(head))
    1401                 :            :                 return 0;
    1402                 :            : 
    1403                 :            :         dsize = __get_data_size(&tk->tp, regs);
    1404                 :          0 :         __size = sizeof(*entry) + tk->tp.size + dsize;
    1405                 :          0 :         size = ALIGN(__size + sizeof(u32), sizeof(u64));
    1406                 :          0 :         size -= sizeof(u32);
    1407                 :            : 
    1408                 :          0 :         entry = perf_trace_buf_alloc(size, NULL, &rctx);
    1409         [ #  # ]:          0 :         if (!entry)
    1410                 :            :                 return 0;
    1411                 :            : 
    1412                 :          0 :         entry->ip = (unsigned long)tk->rp.kp.addr;
    1413                 :          0 :         memset(&entry[1], 0, dsize);
    1414                 :            :         store_trace_args(&entry[1], &tk->tp, regs, sizeof(*entry), dsize);
    1415                 :          0 :         perf_trace_buf_submit(entry, size, rctx, call->event.type, 1, regs,
    1416                 :            :                               head, NULL);
    1417                 :          0 :         return 0;
    1418                 :            : }
    1419                 :            : NOKPROBE_SYMBOL(kprobe_perf_func);
    1420                 :            : 
    1421                 :            : /* Kretprobe profile handler */
    1422                 :            : static void
    1423                 :          0 : kretprobe_perf_func(struct trace_kprobe *tk, struct kretprobe_instance *ri,
    1424                 :            :                     struct pt_regs *regs)
    1425                 :            : {
    1426                 :            :         struct trace_event_call *call = trace_probe_event_call(&tk->tp);
    1427                 :            :         struct kretprobe_trace_entry_head *entry;
    1428                 :            :         struct hlist_head *head;
    1429                 :            :         int size, __size, dsize;
    1430                 :            :         int rctx;
    1431                 :            : 
    1432   [ #  #  #  # ]:          0 :         if (bpf_prog_array_valid(call) && !trace_call_bpf(call, regs))
    1433                 :          0 :                 return;
    1434                 :            : 
    1435                 :          0 :         head = this_cpu_ptr(call->perf_events);
    1436         [ #  # ]:          0 :         if (hlist_empty(head))
    1437                 :            :                 return;
    1438                 :            : 
    1439                 :            :         dsize = __get_data_size(&tk->tp, regs);
    1440                 :          0 :         __size = sizeof(*entry) + tk->tp.size + dsize;
    1441                 :          0 :         size = ALIGN(__size + sizeof(u32), sizeof(u64));
    1442                 :          0 :         size -= sizeof(u32);
    1443                 :            : 
    1444                 :          0 :         entry = perf_trace_buf_alloc(size, NULL, &rctx);
    1445         [ #  # ]:          0 :         if (!entry)
    1446                 :            :                 return;
    1447                 :            : 
    1448                 :          0 :         entry->func = (unsigned long)tk->rp.kp.addr;
    1449                 :          0 :         entry->ret_ip = (unsigned long)ri->ret_addr;
    1450                 :          0 :         store_trace_args(&entry[1], &tk->tp, regs, sizeof(*entry), dsize);
    1451                 :          0 :         perf_trace_buf_submit(entry, size, rctx, call->event.type, 1, regs,
    1452                 :            :                               head, NULL);
    1453                 :            : }
    1454                 :            : NOKPROBE_SYMBOL(kretprobe_perf_func);
    1455                 :            : 
    1456                 :          0 : int bpf_get_kprobe_info(const struct perf_event *event, u32 *fd_type,
    1457                 :            :                         const char **symbol, u64 *probe_offset,
    1458                 :            :                         u64 *probe_addr, bool perf_type_tracepoint)
    1459                 :            : {
    1460                 :          0 :         const char *pevent = trace_event_name(event->tp_event);
    1461                 :          0 :         const char *group = event->tp_event->class->system;
    1462                 :            :         struct trace_kprobe *tk;
    1463                 :            : 
    1464         [ #  # ]:          0 :         if (perf_type_tracepoint)
    1465                 :          0 :                 tk = find_trace_kprobe(pevent, group);
    1466                 :            :         else
    1467                 :            :                 tk = trace_kprobe_primary_from_call(event->tp_event);
    1468         [ #  # ]:          0 :         if (!tk)
    1469                 :            :                 return -EINVAL;
    1470                 :            : 
    1471         [ #  # ]:          0 :         *fd_type = trace_kprobe_is_return(tk) ? BPF_FD_TYPE_KRETPROBE
    1472                 :            :                                               : BPF_FD_TYPE_KPROBE;
    1473         [ #  # ]:          0 :         if (tk->symbol) {
    1474                 :          0 :                 *symbol = tk->symbol;
    1475                 :          0 :                 *probe_offset = tk->rp.kp.offset;
    1476                 :          0 :                 *probe_addr = 0;
    1477                 :            :         } else {
    1478                 :          0 :                 *symbol = NULL;
    1479                 :          0 :                 *probe_offset = 0;
    1480                 :          0 :                 *probe_addr = (unsigned long)tk->rp.kp.addr;
    1481                 :            :         }
    1482                 :            :         return 0;
    1483                 :            : }
    1484                 :            : #endif  /* CONFIG_PERF_EVENTS */
    1485                 :            : 
    1486                 :            : /*
    1487                 :            :  * called by perf_trace_init() or __ftrace_set_clr_event() under event_mutex.
    1488                 :            :  *
    1489                 :            :  * kprobe_trace_self_tests_init() does enable_trace_probe/disable_trace_probe
    1490                 :            :  * lockless, but we can't race with this __init function.
    1491                 :            :  */
    1492                 :          0 : static int kprobe_register(struct trace_event_call *event,
    1493                 :            :                            enum trace_reg type, void *data)
    1494                 :            : {
    1495                 :            :         struct trace_event_file *file = data;
    1496                 :            : 
    1497   [ #  #  #  #  :          0 :         switch (type) {
                      # ]
    1498                 :            :         case TRACE_REG_REGISTER:
    1499                 :          0 :                 return enable_trace_kprobe(event, file);
    1500                 :            :         case TRACE_REG_UNREGISTER:
    1501                 :          0 :                 return disable_trace_kprobe(event, file);
    1502                 :            : 
    1503                 :            : #ifdef CONFIG_PERF_EVENTS
    1504                 :            :         case TRACE_REG_PERF_REGISTER:
    1505                 :          0 :                 return enable_trace_kprobe(event, NULL);
    1506                 :            :         case TRACE_REG_PERF_UNREGISTER:
    1507                 :          0 :                 return disable_trace_kprobe(event, NULL);
    1508                 :            :         case TRACE_REG_PERF_OPEN:
    1509                 :            :         case TRACE_REG_PERF_CLOSE:
    1510                 :            :         case TRACE_REG_PERF_ADD:
    1511                 :            :         case TRACE_REG_PERF_DEL:
    1512                 :            :                 return 0;
    1513                 :            : #endif
    1514                 :            :         }
    1515                 :            :         return 0;
    1516                 :            : }
    1517                 :            : 
    1518                 :          0 : static int kprobe_dispatcher(struct kprobe *kp, struct pt_regs *regs)
    1519                 :            : {
    1520                 :          0 :         struct trace_kprobe *tk = container_of(kp, struct trace_kprobe, rp.kp);
    1521                 :            :         int ret = 0;
    1522                 :            : 
    1523                 :          0 :         raw_cpu_inc(*tk->nhit);
    1524                 :            : 
    1525         [ #  # ]:          0 :         if (trace_probe_test_flag(&tk->tp, TP_FLAG_TRACE))
    1526                 :          0 :                 kprobe_trace_func(tk, regs);
    1527                 :            : #ifdef CONFIG_PERF_EVENTS
    1528         [ #  # ]:          0 :         if (trace_probe_test_flag(&tk->tp, TP_FLAG_PROFILE))
    1529                 :          0 :                 ret = kprobe_perf_func(tk, regs);
    1530                 :            : #endif
    1531                 :          0 :         return ret;
    1532                 :            : }
    1533                 :            : NOKPROBE_SYMBOL(kprobe_dispatcher);
    1534                 :            : 
    1535                 :            : static int
    1536                 :          0 : kretprobe_dispatcher(struct kretprobe_instance *ri, struct pt_regs *regs)
    1537                 :            : {
    1538                 :          0 :         struct trace_kprobe *tk = container_of(ri->rp, struct trace_kprobe, rp);
    1539                 :            : 
    1540                 :          0 :         raw_cpu_inc(*tk->nhit);
    1541                 :            : 
    1542         [ #  # ]:          0 :         if (trace_probe_test_flag(&tk->tp, TP_FLAG_TRACE))
    1543                 :          0 :                 kretprobe_trace_func(tk, ri, regs);
    1544                 :            : #ifdef CONFIG_PERF_EVENTS
    1545         [ #  # ]:          0 :         if (trace_probe_test_flag(&tk->tp, TP_FLAG_PROFILE))
    1546                 :          0 :                 kretprobe_perf_func(tk, ri, regs);
    1547                 :            : #endif
    1548                 :          0 :         return 0;       /* We don't tweek kernel, so just return 0 */
    1549                 :            : }
    1550                 :            : NOKPROBE_SYMBOL(kretprobe_dispatcher);
    1551                 :            : 
    1552                 :            : static struct trace_event_functions kretprobe_funcs = {
    1553                 :            :         .trace          = print_kretprobe_event
    1554                 :            : };
    1555                 :            : 
    1556                 :            : static struct trace_event_functions kprobe_funcs = {
    1557                 :            :         .trace          = print_kprobe_event
    1558                 :            : };
    1559                 :            : 
    1560                 :            : static inline void init_trace_event_call(struct trace_kprobe *tk)
    1561                 :            : {
    1562                 :            :         struct trace_event_call *call = trace_probe_event_call(&tk->tp);
    1563                 :            : 
    1564   [ #  #  #  # ]:          0 :         if (trace_kprobe_is_return(tk)) {
    1565                 :          0 :                 call->event.funcs = &kretprobe_funcs;
    1566                 :          0 :                 call->class->define_fields = kretprobe_event_define_fields;
    1567                 :            :         } else {
    1568                 :          0 :                 call->event.funcs = &kprobe_funcs;
    1569                 :          0 :                 call->class->define_fields = kprobe_event_define_fields;
    1570                 :            :         }
    1571                 :            : 
    1572                 :          0 :         call->flags = TRACE_EVENT_FL_KPROBE;
    1573                 :          0 :         call->class->reg = kprobe_register;
    1574                 :            : }
    1575                 :            : 
    1576                 :          0 : static int register_kprobe_event(struct trace_kprobe *tk)
    1577                 :            : {
    1578                 :            :         init_trace_event_call(tk);
    1579                 :            : 
    1580                 :          0 :         return trace_probe_register_event_call(&tk->tp);
    1581                 :            : }
    1582                 :            : 
    1583                 :            : static int unregister_kprobe_event(struct trace_kprobe *tk)
    1584                 :            : {
    1585                 :            :         return trace_probe_unregister_event_call(&tk->tp);
    1586                 :            : }
    1587                 :            : 
    1588                 :            : #ifdef CONFIG_PERF_EVENTS
    1589                 :            : /* create a trace_kprobe, but don't add it to global lists */
    1590                 :            : struct trace_event_call *
    1591                 :          0 : create_local_trace_kprobe(char *func, void *addr, unsigned long offs,
    1592                 :            :                           bool is_return)
    1593                 :            : {
    1594                 :            :         struct trace_kprobe *tk;
    1595                 :            :         int ret;
    1596                 :            :         char *event;
    1597                 :            : 
    1598                 :            :         /*
    1599                 :            :          * local trace_kprobes are not added to dyn_event, so they are never
    1600                 :            :          * searched in find_trace_kprobe(). Therefore, there is no concern of
    1601                 :            :          * duplicated name here.
    1602                 :            :          */
    1603         [ #  # ]:          0 :         event = func ? func : "DUMMY_EVENT";
    1604                 :            : 
    1605                 :          0 :         tk = alloc_trace_kprobe(KPROBE_EVENT_SYSTEM, event, (void *)addr, func,
    1606                 :            :                                 offs, 0 /* maxactive */, 0 /* nargs */,
    1607                 :            :                                 is_return);
    1608                 :            : 
    1609         [ #  # ]:          0 :         if (IS_ERR(tk)) {
    1610                 :          0 :                 pr_info("Failed to allocate trace_probe.(%d)\n",
    1611                 :            :                         (int)PTR_ERR(tk));
    1612                 :          0 :                 return ERR_CAST(tk);
    1613                 :            :         }
    1614                 :            : 
    1615                 :            :         init_trace_event_call(tk);
    1616                 :            : 
    1617         [ #  # ]:          0 :         if (traceprobe_set_print_fmt(&tk->tp, trace_kprobe_is_return(tk)) < 0) {
    1618                 :            :                 ret = -ENOMEM;
    1619                 :            :                 goto error;
    1620                 :            :         }
    1621                 :            : 
    1622                 :          0 :         ret = __register_trace_kprobe(tk);
    1623         [ #  # ]:          0 :         if (ret < 0)
    1624                 :            :                 goto error;
    1625                 :            : 
    1626                 :          0 :         return trace_probe_event_call(&tk->tp);
    1627                 :            : error:
    1628                 :          0 :         free_trace_kprobe(tk);
    1629                 :          0 :         return ERR_PTR(ret);
    1630                 :            : }
    1631                 :            : 
    1632                 :          0 : void destroy_local_trace_kprobe(struct trace_event_call *event_call)
    1633                 :            : {
    1634                 :            :         struct trace_kprobe *tk;
    1635                 :            : 
    1636                 :            :         tk = trace_kprobe_primary_from_call(event_call);
    1637         [ #  # ]:          0 :         if (unlikely(!tk))
    1638                 :            :                 return;
    1639                 :            : 
    1640         [ #  # ]:          0 :         if (trace_probe_is_enabled(&tk->tp)) {
    1641                 :          0 :                 WARN_ON(1);
    1642                 :          0 :                 return;
    1643                 :            :         }
    1644                 :            : 
    1645                 :          0 :         __unregister_trace_kprobe(tk);
    1646                 :            : 
    1647                 :          0 :         free_trace_kprobe(tk);
    1648                 :            : }
    1649                 :            : #endif /* CONFIG_PERF_EVENTS */
    1650                 :            : 
    1651                 :        207 : static __init void enable_boot_kprobe_events(void)
    1652                 :            : {
    1653                 :        207 :         struct trace_array *tr = top_trace_array();
    1654                 :            :         struct trace_event_file *file;
    1655                 :            :         struct trace_kprobe *tk;
    1656                 :            :         struct dyn_event *pos;
    1657                 :            : 
    1658                 :        207 :         mutex_lock(&event_mutex);
    1659   [ #  #  #  #  :        207 :         for_each_trace_kprobe(tk, pos) {
                   -  + ]
    1660         [ #  # ]:          0 :                 list_for_each_entry(file, &tr->events, list)
    1661         [ #  # ]:          0 :                         if (file->event_call == trace_probe_event_call(&tk->tp))
    1662                 :          0 :                                 trace_event_enable_disable(file, 1, 0);
    1663                 :            :         }
    1664                 :        207 :         mutex_unlock(&event_mutex);
    1665                 :        207 : }
    1666                 :            : 
    1667                 :        207 : static __init void setup_boot_kprobe_events(void)
    1668                 :            : {
    1669                 :            :         char *p, *cmd = kprobe_boot_events_buf;
    1670                 :            :         int ret;
    1671                 :            : 
    1672                 :        207 :         strreplace(kprobe_boot_events_buf, ',', ' ');
    1673                 :            : 
    1674   [ +  -  -  + ]:        414 :         while (cmd && *cmd != '\0') {
    1675                 :          0 :                 p = strchr(cmd, ';');
    1676         [ #  # ]:          0 :                 if (p)
    1677                 :          0 :                         *p++ = '\0';
    1678                 :            : 
    1679                 :          0 :                 ret = trace_run_command(cmd, create_or_delete_trace_kprobe);
    1680         [ #  # ]:          0 :                 if (ret)
    1681                 :          0 :                         pr_warn("Failed to add event(%d): %s\n", ret, cmd);
    1682                 :            :                 else
    1683                 :          0 :                         kprobe_boot_events_enabled = true;
    1684                 :            : 
    1685                 :            :                 cmd = p;
    1686                 :            :         }
    1687                 :            : 
    1688                 :        207 :         enable_boot_kprobe_events();
    1689                 :        207 : }
    1690                 :            : 
    1691                 :            : /* Make a tracefs interface for controlling probe points */
    1692                 :        207 : static __init int init_kprobe_trace(void)
    1693                 :            : {
    1694                 :            :         struct dentry *d_tracer;
    1695                 :            :         struct dentry *entry;
    1696                 :            :         int ret;
    1697                 :            : 
    1698                 :        207 :         ret = dyn_event_register(&trace_kprobe_ops);
    1699         [ +  - ]:        207 :         if (ret)
    1700                 :            :                 return ret;
    1701                 :            : 
    1702         [ +  - ]:        207 :         if (register_module_notifier(&trace_kprobe_module_nb))
    1703                 :            :                 return -EINVAL;
    1704                 :            : 
    1705                 :        207 :         d_tracer = tracing_init_dentry();
    1706         [ +  - ]:        207 :         if (IS_ERR(d_tracer))
    1707                 :            :                 return 0;
    1708                 :            : 
    1709                 :        207 :         entry = tracefs_create_file("kprobe_events", 0644, d_tracer,
    1710                 :            :                                     NULL, &kprobe_events_ops);
    1711                 :            : 
    1712                 :            :         /* Event list interface */
    1713         [ -  + ]:        207 :         if (!entry)
    1714                 :          0 :                 pr_warn("Could not create tracefs 'kprobe_events' entry\n");
    1715                 :            : 
    1716                 :            :         /* Profile interface */
    1717                 :        207 :         entry = tracefs_create_file("kprobe_profile", 0444, d_tracer,
    1718                 :            :                                     NULL, &kprobe_profile_ops);
    1719                 :            : 
    1720         [ -  + ]:        207 :         if (!entry)
    1721                 :          0 :                 pr_warn("Could not create tracefs 'kprobe_profile' entry\n");
    1722                 :            : 
    1723                 :        207 :         setup_boot_kprobe_events();
    1724                 :            : 
    1725                 :        207 :         return 0;
    1726                 :            : }
    1727                 :            : fs_initcall(init_kprobe_trace);
    1728                 :            : 
    1729                 :            : 
    1730                 :            : #ifdef CONFIG_FTRACE_STARTUP_TEST
    1731                 :            : static __init struct trace_event_file *
    1732                 :            : find_trace_probe_file(struct trace_kprobe *tk, struct trace_array *tr)
    1733                 :            : {
    1734                 :            :         struct trace_event_file *file;
    1735                 :            : 
    1736                 :            :         list_for_each_entry(file, &tr->events, list)
    1737                 :            :                 if (file->event_call == trace_probe_event_call(&tk->tp))
    1738                 :            :                         return file;
    1739                 :            : 
    1740                 :            :         return NULL;
    1741                 :            : }
    1742                 :            : 
    1743                 :            : /*
    1744                 :            :  * Nobody but us can call enable_trace_kprobe/disable_trace_kprobe at this
    1745                 :            :  * stage, we can do this lockless.
    1746                 :            :  */
    1747                 :            : static __init int kprobe_trace_self_tests_init(void)
    1748                 :            : {
    1749                 :            :         int ret, warn = 0;
    1750                 :            :         int (*target)(int, int, int, int, int, int);
    1751                 :            :         struct trace_kprobe *tk;
    1752                 :            :         struct trace_event_file *file;
    1753                 :            : 
    1754                 :            :         if (tracing_is_disabled())
    1755                 :            :                 return -ENODEV;
    1756                 :            : 
    1757                 :            :         if (kprobe_boot_events_enabled) {
    1758                 :            :                 pr_info("Skipping kprobe tests due to kprobe_event on cmdline\n");
    1759                 :            :                 return 0;
    1760                 :            :         }
    1761                 :            : 
    1762                 :            :         target = kprobe_trace_selftest_target;
    1763                 :            : 
    1764                 :            :         pr_info("Testing kprobe tracing: ");
    1765                 :            : 
    1766                 :            :         ret = trace_run_command("p:testprobe kprobe_trace_selftest_target $stack $stack0 +0($stack)",
    1767                 :            :                                 create_or_delete_trace_kprobe);
    1768                 :            :         if (WARN_ON_ONCE(ret)) {
    1769                 :            :                 pr_warn("error on probing function entry.\n");
    1770                 :            :                 warn++;
    1771                 :            :         } else {
    1772                 :            :                 /* Enable trace point */
    1773                 :            :                 tk = find_trace_kprobe("testprobe", KPROBE_EVENT_SYSTEM);
    1774                 :            :                 if (WARN_ON_ONCE(tk == NULL)) {
    1775                 :            :                         pr_warn("error on getting new probe.\n");
    1776                 :            :                         warn++;
    1777                 :            :                 } else {
    1778                 :            :                         file = find_trace_probe_file(tk, top_trace_array());
    1779                 :            :                         if (WARN_ON_ONCE(file == NULL)) {
    1780                 :            :                                 pr_warn("error on getting probe file.\n");
    1781                 :            :                                 warn++;
    1782                 :            :                         } else
    1783                 :            :                                 enable_trace_kprobe(
    1784                 :            :                                         trace_probe_event_call(&tk->tp), file);
    1785                 :            :                 }
    1786                 :            :         }
    1787                 :            : 
    1788                 :            :         ret = trace_run_command("r:testprobe2 kprobe_trace_selftest_target $retval",
    1789                 :            :                                 create_or_delete_trace_kprobe);
    1790                 :            :         if (WARN_ON_ONCE(ret)) {
    1791                 :            :                 pr_warn("error on probing function return.\n");
    1792                 :            :                 warn++;
    1793                 :            :         } else {
    1794                 :            :                 /* Enable trace point */
    1795                 :            :                 tk = find_trace_kprobe("testprobe2", KPROBE_EVENT_SYSTEM);
    1796                 :            :                 if (WARN_ON_ONCE(tk == NULL)) {
    1797                 :            :                         pr_warn("error on getting 2nd new probe.\n");
    1798                 :            :                         warn++;
    1799                 :            :                 } else {
    1800                 :            :                         file = find_trace_probe_file(tk, top_trace_array());
    1801                 :            :                         if (WARN_ON_ONCE(file == NULL)) {
    1802                 :            :                                 pr_warn("error on getting probe file.\n");
    1803                 :            :                                 warn++;
    1804                 :            :                         } else
    1805                 :            :                                 enable_trace_kprobe(
    1806                 :            :                                         trace_probe_event_call(&tk->tp), file);
    1807                 :            :                 }
    1808                 :            :         }
    1809                 :            : 
    1810                 :            :         if (warn)
    1811                 :            :                 goto end;
    1812                 :            : 
    1813                 :            :         ret = target(1, 2, 3, 4, 5, 6);
    1814                 :            : 
    1815                 :            :         /*
    1816                 :            :          * Not expecting an error here, the check is only to prevent the
    1817                 :            :          * optimizer from removing the call to target() as otherwise there
    1818                 :            :          * are no side-effects and the call is never performed.
    1819                 :            :          */
    1820                 :            :         if (ret != 21)
    1821                 :            :                 warn++;
    1822                 :            : 
    1823                 :            :         /* Disable trace points before removing it */
    1824                 :            :         tk = find_trace_kprobe("testprobe", KPROBE_EVENT_SYSTEM);
    1825                 :            :         if (WARN_ON_ONCE(tk == NULL)) {
    1826                 :            :                 pr_warn("error on getting test probe.\n");
    1827                 :            :                 warn++;
    1828                 :            :         } else {
    1829                 :            :                 if (trace_kprobe_nhit(tk) != 1) {
    1830                 :            :                         pr_warn("incorrect number of testprobe hits\n");
    1831                 :            :                         warn++;
    1832                 :            :                 }
    1833                 :            : 
    1834                 :            :                 file = find_trace_probe_file(tk, top_trace_array());
    1835                 :            :                 if (WARN_ON_ONCE(file == NULL)) {
    1836                 :            :                         pr_warn("error on getting probe file.\n");
    1837                 :            :                         warn++;
    1838                 :            :                 } else
    1839                 :            :                         disable_trace_kprobe(
    1840                 :            :                                 trace_probe_event_call(&tk->tp), file);
    1841                 :            :         }
    1842                 :            : 
    1843                 :            :         tk = find_trace_kprobe("testprobe2", KPROBE_EVENT_SYSTEM);
    1844                 :            :         if (WARN_ON_ONCE(tk == NULL)) {
    1845                 :            :                 pr_warn("error on getting 2nd test probe.\n");
    1846                 :            :                 warn++;
    1847                 :            :         } else {
    1848                 :            :                 if (trace_kprobe_nhit(tk) != 1) {
    1849                 :            :                         pr_warn("incorrect number of testprobe2 hits\n");
    1850                 :            :                         warn++;
    1851                 :            :                 }
    1852                 :            : 
    1853                 :            :                 file = find_trace_probe_file(tk, top_trace_array());
    1854                 :            :                 if (WARN_ON_ONCE(file == NULL)) {
    1855                 :            :                         pr_warn("error on getting probe file.\n");
    1856                 :            :                         warn++;
    1857                 :            :                 } else
    1858                 :            :                         disable_trace_kprobe(
    1859                 :            :                                 trace_probe_event_call(&tk->tp), file);
    1860                 :            :         }
    1861                 :            : 
    1862                 :            :         ret = trace_run_command("-:testprobe", create_or_delete_trace_kprobe);
    1863                 :            :         if (WARN_ON_ONCE(ret)) {
    1864                 :            :                 pr_warn("error on deleting a probe.\n");
    1865                 :            :                 warn++;
    1866                 :            :         }
    1867                 :            : 
    1868                 :            :         ret = trace_run_command("-:testprobe2", create_or_delete_trace_kprobe);
    1869                 :            :         if (WARN_ON_ONCE(ret)) {
    1870                 :            :                 pr_warn("error on deleting a probe.\n");
    1871                 :            :                 warn++;
    1872                 :            :         }
    1873                 :            : 
    1874                 :            : end:
    1875                 :            :         ret = dyn_events_release_all(&trace_kprobe_ops);
    1876                 :            :         if (WARN_ON_ONCE(ret)) {
    1877                 :            :                 pr_warn("error on cleaning up probes.\n");
    1878                 :            :                 warn++;
    1879                 :            :         }
    1880                 :            :         /*
    1881                 :            :          * Wait for the optimizer work to finish. Otherwise it might fiddle
    1882                 :            :          * with probes in already freed __init text.
    1883                 :            :          */
    1884                 :            :         wait_for_kprobe_optimizer();
    1885                 :            :         if (warn)
    1886                 :            :                 pr_cont("NG: Some tests are failed. Please check them.\n");
    1887                 :            :         else
    1888                 :            :                 pr_cont("OK\n");
    1889                 :            :         return 0;
    1890                 :            : }
    1891                 :            : 
    1892                 :            : late_initcall(kprobe_trace_self_tests_init);
    1893                 :            : 
    1894                 :            : #endif

Generated by: LCOV version 1.14