LCOV - code coverage report
Current view: top level - kernel/trace - trace_events.c (source / functions) Hit Total Coverage
Test: Real Lines: 275 1084 25.4 %
Date: 2020-10-17 15:46:16 Functions: 1 117 0.9 %
Legend: Neither, QEMU, Real, Both Branches: 0 0 -

           Branch data     Line data    Source code
       1                 :            : // SPDX-License-Identifier: GPL-2.0
       2                 :            : /*
       3                 :            :  * event tracer
       4                 :            :  *
       5                 :            :  * Copyright (C) 2008 Red Hat Inc, Steven Rostedt <srostedt@redhat.com>
       6                 :            :  *
       7                 :            :  *  - Added format output of fields of the trace point.
       8                 :            :  *    This was based off of work by Tom Zanussi <tzanussi@gmail.com>.
       9                 :            :  *
      10                 :            :  */
      11                 :            : 
      12                 :            : #define pr_fmt(fmt) fmt
      13                 :            : 
      14                 :            : #include <linux/workqueue.h>
      15                 :            : #include <linux/security.h>
      16                 :            : #include <linux/spinlock.h>
      17                 :            : #include <linux/kthread.h>
      18                 :            : #include <linux/tracefs.h>
      19                 :            : #include <linux/uaccess.h>
      20                 :            : #include <linux/module.h>
      21                 :            : #include <linux/ctype.h>
      22                 :            : #include <linux/sort.h>
      23                 :            : #include <linux/slab.h>
      24                 :            : #include <linux/delay.h>
      25                 :            : 
      26                 :            : #include <trace/events/sched.h>
      27                 :            : 
      28                 :            : #include <asm/setup.h>
      29                 :            : 
      30                 :            : #include "trace_output.h"
      31                 :            : 
      32                 :            : #undef TRACE_SYSTEM
      33                 :            : #define TRACE_SYSTEM "TRACE_SYSTEM"
      34                 :            : 
      35                 :            : DEFINE_MUTEX(event_mutex);
      36                 :            : 
      37                 :            : LIST_HEAD(ftrace_events);
      38                 :            : static LIST_HEAD(ftrace_generic_fields);
      39                 :            : static LIST_HEAD(ftrace_common_fields);
      40                 :            : 
      41                 :            : #define GFP_TRACE (GFP_KERNEL | __GFP_ZERO)
      42                 :            : 
      43                 :            : static struct kmem_cache *field_cachep;
      44                 :            : static struct kmem_cache *file_cachep;
      45                 :            : 
      46                 :            : static inline int system_refcount(struct event_subsystem *system)
      47                 :            : {
      48                 :          0 :         return system->ref_count;
      49                 :            : }
      50                 :            : 
      51                 :            : static int system_refcount_inc(struct event_subsystem *system)
      52                 :            : {
      53                 :          0 :         return system->ref_count++;
      54                 :            : }
      55                 :            : 
      56                 :            : static int system_refcount_dec(struct event_subsystem *system)
      57                 :            : {
      58                 :          0 :         return --system->ref_count;
      59                 :            : }
      60                 :            : 
      61                 :            : /* Double loops, do not use break, only goto's work */
      62                 :            : #define do_for_each_event_file(tr, file)                        \
      63                 :            :         list_for_each_entry(tr, &ftrace_trace_arrays, list) {       \
      64                 :            :                 list_for_each_entry(file, &tr->events, list)
      65                 :            : 
      66                 :            : #define do_for_each_event_file_safe(tr, file)                   \
      67                 :            :         list_for_each_entry(tr, &ftrace_trace_arrays, list) {       \
      68                 :            :                 struct trace_event_file *___n;                          \
      69                 :            :                 list_for_each_entry_safe(file, ___n, &tr->events, list)
      70                 :            : 
      71                 :            : #define while_for_each_event_file()             \
      72                 :            :         }
      73                 :            : 
      74                 :            : static struct ftrace_event_field *
      75                 :          0 : __find_event_field(struct list_head *head, char *name)
      76                 :            : {
      77                 :            :         struct ftrace_event_field *field;
      78                 :            : 
      79                 :          0 :         list_for_each_entry(field, head, link) {
      80                 :          0 :                 if (!strcmp(field->name, name))
      81                 :          0 :                         return field;
      82                 :            :         }
      83                 :            : 
      84                 :            :         return NULL;
      85                 :            : }
      86                 :            : 
      87                 :            : struct ftrace_event_field *
      88                 :          0 : trace_find_event_field(struct trace_event_call *call, char *name)
      89                 :            : {
      90                 :            :         struct ftrace_event_field *field;
      91                 :            :         struct list_head *head;
      92                 :            : 
      93                 :            :         head = trace_get_fields(call);
      94                 :          0 :         field = __find_event_field(head, name);
      95                 :          0 :         if (field)
      96                 :            :                 return field;
      97                 :            : 
      98                 :          0 :         field = __find_event_field(&ftrace_generic_fields, name);
      99                 :          0 :         if (field)
     100                 :            :                 return field;
     101                 :            : 
     102                 :          0 :         return __find_event_field(&ftrace_common_fields, name);
     103                 :            : }
     104                 :            : 
     105                 :          3 : static int __trace_define_field(struct list_head *head, const char *type,
     106                 :            :                                 const char *name, int offset, int size,
     107                 :            :                                 int is_signed, int filter_type)
     108                 :            : {
     109                 :            :         struct ftrace_event_field *field;
     110                 :            : 
     111                 :          3 :         field = kmem_cache_alloc(field_cachep, GFP_TRACE);
     112                 :          3 :         if (!field)
     113                 :            :                 return -ENOMEM;
     114                 :            : 
     115                 :          3 :         field->name = name;
     116                 :          3 :         field->type = type;
     117                 :            : 
     118                 :          3 :         if (filter_type == FILTER_OTHER)
     119                 :          3 :                 field->filter_type = filter_assign_type(type);
     120                 :            :         else
     121                 :          3 :                 field->filter_type = filter_type;
     122                 :            : 
     123                 :          3 :         field->offset = offset;
     124                 :          3 :         field->size = size;
     125                 :          3 :         field->is_signed = is_signed;
     126                 :            : 
     127                 :          3 :         list_add(&field->link, head);
     128                 :            : 
     129                 :          3 :         return 0;
     130                 :            : }
     131                 :            : 
     132                 :          3 : int trace_define_field(struct trace_event_call *call, const char *type,
     133                 :            :                        const char *name, int offset, int size, int is_signed,
     134                 :            :                        int filter_type)
     135                 :            : {
     136                 :            :         struct list_head *head;
     137                 :            : 
     138                 :          3 :         if (WARN_ON(!call->class))
     139                 :            :                 return 0;
     140                 :            : 
     141                 :            :         head = trace_get_fields(call);
     142                 :          3 :         return __trace_define_field(head, type, name, offset, size,
     143                 :            :                                     is_signed, filter_type);
     144                 :            : }
     145                 :            : EXPORT_SYMBOL_GPL(trace_define_field);
     146                 :            : 
     147                 :            : #define __generic_field(type, item, filter_type)                        \
     148                 :            :         ret = __trace_define_field(&ftrace_generic_fields, #type,   \
     149                 :            :                                    #item, 0, 0, is_signed_type(type),   \
     150                 :            :                                    filter_type);                        \
     151                 :            :         if (ret)                                                        \
     152                 :            :                 return ret;
     153                 :            : 
     154                 :            : #define __common_field(type, item)                                      \
     155                 :            :         ret = __trace_define_field(&ftrace_common_fields, #type,    \
     156                 :            :                                    "common_" #item,                   \
     157                 :            :                                    offsetof(typeof(ent), item),         \
     158                 :            :                                    sizeof(ent.item),                    \
     159                 :            :                                    is_signed_type(type), FILTER_OTHER); \
     160                 :            :         if (ret)                                                        \
     161                 :            :                 return ret;
     162                 :            : 
     163                 :          3 : static int trace_define_generic_fields(void)
     164                 :            : {
     165                 :            :         int ret;
     166                 :            : 
     167                 :          3 :         __generic_field(int, CPU, FILTER_CPU);
     168                 :          3 :         __generic_field(int, cpu, FILTER_CPU);
     169                 :          3 :         __generic_field(char *, COMM, FILTER_COMM);
     170                 :          3 :         __generic_field(char *, comm, FILTER_COMM);
     171                 :            : 
     172                 :            :         return ret;
     173                 :            : }
     174                 :            : 
     175                 :          3 : static int trace_define_common_fields(void)
     176                 :            : {
     177                 :            :         int ret;
     178                 :            :         struct trace_entry ent;
     179                 :            : 
     180                 :          3 :         __common_field(unsigned short, type);
     181                 :          3 :         __common_field(unsigned char, flags);
     182                 :          3 :         __common_field(unsigned char, preempt_count);
     183                 :          3 :         __common_field(int, pid);
     184                 :            : 
     185                 :            :         return ret;
     186                 :            : }
     187                 :            : 
     188                 :          0 : static void trace_destroy_fields(struct trace_event_call *call)
     189                 :            : {
     190                 :            :         struct ftrace_event_field *field, *next;
     191                 :            :         struct list_head *head;
     192                 :            : 
     193                 :            :         head = trace_get_fields(call);
     194                 :          0 :         list_for_each_entry_safe(field, next, head, link) {
     195                 :            :                 list_del(&field->link);
     196                 :          0 :                 kmem_cache_free(field_cachep, field);
     197                 :            :         }
     198                 :          0 : }
     199                 :            : 
     200                 :            : /*
     201                 :            :  * run-time version of trace_event_get_offsets_<call>() that returns the last
     202                 :            :  * accessible offset of trace fields excluding __dynamic_array bytes
     203                 :            :  */
     204                 :          0 : int trace_event_get_offsets(struct trace_event_call *call)
     205                 :            : {
     206                 :            :         struct ftrace_event_field *tail;
     207                 :            :         struct list_head *head;
     208                 :            : 
     209                 :            :         head = trace_get_fields(call);
     210                 :            :         /*
     211                 :            :          * head->next points to the last field with the largest offset,
     212                 :            :          * since it was added last by trace_define_field()
     213                 :            :          */
     214                 :          0 :         tail = list_first_entry(head, struct ftrace_event_field, link);
     215                 :          0 :         return tail->offset + tail->size;
     216                 :            : }
     217                 :            : 
     218                 :          3 : int trace_event_raw_init(struct trace_event_call *call)
     219                 :            : {
     220                 :            :         int id;
     221                 :            : 
     222                 :          3 :         id = register_trace_event(&call->event);
     223                 :          3 :         if (!id)
     224                 :            :                 return -ENODEV;
     225                 :            : 
     226                 :          3 :         return 0;
     227                 :            : }
     228                 :            : EXPORT_SYMBOL_GPL(trace_event_raw_init);
     229                 :            : 
     230                 :          0 : bool trace_event_ignore_this_pid(struct trace_event_file *trace_file)
     231                 :            : {
     232                 :          0 :         struct trace_array *tr = trace_file->tr;
     233                 :            :         struct trace_array_cpu *data;
     234                 :            :         struct trace_pid_list *pid_list;
     235                 :            : 
     236                 :          0 :         pid_list = rcu_dereference_raw(tr->filtered_pids);
     237                 :          0 :         if (!pid_list)
     238                 :            :                 return false;
     239                 :            : 
     240                 :          0 :         data = this_cpu_ptr(tr->trace_buffer.data);
     241                 :            : 
     242                 :          0 :         return data->ignore_pid;
     243                 :            : }
     244                 :            : EXPORT_SYMBOL_GPL(trace_event_ignore_this_pid);
     245                 :            : 
     246                 :          0 : void *trace_event_buffer_reserve(struct trace_event_buffer *fbuffer,
     247                 :            :                                  struct trace_event_file *trace_file,
     248                 :            :                                  unsigned long len)
     249                 :            : {
     250                 :          0 :         struct trace_event_call *event_call = trace_file->event_call;
     251                 :            : 
     252                 :          0 :         if ((trace_file->flags & EVENT_FILE_FL_PID_FILTER) &&
     253                 :            :             trace_event_ignore_this_pid(trace_file))
     254                 :            :                 return NULL;
     255                 :            : 
     256                 :          0 :         local_save_flags(fbuffer->flags);
     257                 :          0 :         fbuffer->pc = preempt_count();
     258                 :            :         /*
     259                 :            :          * If CONFIG_PREEMPTION is enabled, then the tracepoint itself disables
     260                 :            :          * preemption (adding one to the preempt_count). Since we are
     261                 :            :          * interested in the preempt_count at the time the tracepoint was
     262                 :            :          * hit, we need to subtract one to offset the increment.
     263                 :            :          */
     264                 :            :         if (IS_ENABLED(CONFIG_PREEMPTION))
     265                 :            :                 fbuffer->pc--;
     266                 :          0 :         fbuffer->trace_file = trace_file;
     267                 :            : 
     268                 :          0 :         fbuffer->event =
     269                 :          0 :                 trace_event_buffer_lock_reserve(&fbuffer->buffer, trace_file,
     270                 :            :                                                 event_call->event.type, len,
     271                 :            :                                                 fbuffer->flags, fbuffer->pc);
     272                 :          0 :         if (!fbuffer->event)
     273                 :            :                 return NULL;
     274                 :            : 
     275                 :          0 :         fbuffer->entry = ring_buffer_event_data(fbuffer->event);
     276                 :          0 :         return fbuffer->entry;
     277                 :            : }
     278                 :            : EXPORT_SYMBOL_GPL(trace_event_buffer_reserve);
     279                 :            : 
     280                 :          0 : int trace_event_reg(struct trace_event_call *call,
     281                 :            :                     enum trace_reg type, void *data)
     282                 :            : {
     283                 :            :         struct trace_event_file *file = data;
     284                 :            : 
     285                 :          0 :         WARN_ON(!(call->flags & TRACE_EVENT_FL_TRACEPOINT));
     286                 :          0 :         switch (type) {
     287                 :            :         case TRACE_REG_REGISTER:
     288                 :          0 :                 return tracepoint_probe_register(call->tp,
     289                 :          0 :                                                  call->class->probe,
     290                 :            :                                                  file);
     291                 :            :         case TRACE_REG_UNREGISTER:
     292                 :          0 :                 tracepoint_probe_unregister(call->tp,
     293                 :          0 :                                             call->class->probe,
     294                 :            :                                             file);
     295                 :          0 :                 return 0;
     296                 :            : 
     297                 :            : #ifdef CONFIG_PERF_EVENTS
     298                 :            :         case TRACE_REG_PERF_REGISTER:
     299                 :          0 :                 return tracepoint_probe_register(call->tp,
     300                 :          0 :                                                  call->class->perf_probe,
     301                 :            :                                                  call);
     302                 :            :         case TRACE_REG_PERF_UNREGISTER:
     303                 :          0 :                 tracepoint_probe_unregister(call->tp,
     304                 :          0 :                                             call->class->perf_probe,
     305                 :            :                                             call);
     306                 :          0 :                 return 0;
     307                 :            :         case TRACE_REG_PERF_OPEN:
     308                 :            :         case TRACE_REG_PERF_CLOSE:
     309                 :            :         case TRACE_REG_PERF_ADD:
     310                 :            :         case TRACE_REG_PERF_DEL:
     311                 :            :                 return 0;
     312                 :            : #endif
     313                 :            :         }
     314                 :            :         return 0;
     315                 :            : }
     316                 :            : EXPORT_SYMBOL_GPL(trace_event_reg);
     317                 :            : 
     318                 :          0 : void trace_event_enable_cmd_record(bool enable)
     319                 :            : {
     320                 :            :         struct trace_event_file *file;
     321                 :            :         struct trace_array *tr;
     322                 :            : 
     323                 :            :         lockdep_assert_held(&event_mutex);
     324                 :            : 
     325                 :          0 :         do_for_each_event_file(tr, file) {
     326                 :            : 
     327                 :          0 :                 if (!(file->flags & EVENT_FILE_FL_ENABLED))
     328                 :          0 :                         continue;
     329                 :            : 
     330                 :          0 :                 if (enable) {
     331                 :          0 :                         tracing_start_cmdline_record();
     332                 :          0 :                         set_bit(EVENT_FILE_FL_RECORDED_CMD_BIT, &file->flags);
     333                 :            :                 } else {
     334                 :          0 :                         tracing_stop_cmdline_record();
     335                 :          0 :                         clear_bit(EVENT_FILE_FL_RECORDED_CMD_BIT, &file->flags);
     336                 :            :                 }
     337                 :            :         } while_for_each_event_file();
     338                 :          0 : }
     339                 :            : 
     340                 :          0 : void trace_event_enable_tgid_record(bool enable)
     341                 :            : {
     342                 :            :         struct trace_event_file *file;
     343                 :            :         struct trace_array *tr;
     344                 :            : 
     345                 :            :         lockdep_assert_held(&event_mutex);
     346                 :            : 
     347                 :          0 :         do_for_each_event_file(tr, file) {
     348                 :          0 :                 if (!(file->flags & EVENT_FILE_FL_ENABLED))
     349                 :          0 :                         continue;
     350                 :            : 
     351                 :          0 :                 if (enable) {
     352                 :          0 :                         tracing_start_tgid_record();
     353                 :          0 :                         set_bit(EVENT_FILE_FL_RECORDED_TGID_BIT, &file->flags);
     354                 :            :                 } else {
     355                 :          0 :                         tracing_stop_tgid_record();
     356                 :          0 :                         clear_bit(EVENT_FILE_FL_RECORDED_TGID_BIT,
     357                 :            :                                   &file->flags);
     358                 :            :                 }
     359                 :            :         } while_for_each_event_file();
     360                 :          0 : }
     361                 :            : 
     362                 :          0 : static int __ftrace_event_enable_disable(struct trace_event_file *file,
     363                 :            :                                          int enable, int soft_disable)
     364                 :            : {
     365                 :          0 :         struct trace_event_call *call = file->event_call;
     366                 :          0 :         struct trace_array *tr = file->tr;
     367                 :          0 :         unsigned long file_flags = file->flags;
     368                 :            :         int ret = 0;
     369                 :            :         int disable;
     370                 :            : 
     371                 :          0 :         switch (enable) {
     372                 :            :         case 0:
     373                 :            :                 /*
     374                 :            :                  * When soft_disable is set and enable is cleared, the sm_ref
     375                 :            :                  * reference counter is decremented. If it reaches 0, we want
     376                 :            :                  * to clear the SOFT_DISABLED flag but leave the event in the
     377                 :            :                  * state that it was. That is, if the event was enabled and
     378                 :            :                  * SOFT_DISABLED isn't set, then do nothing. But if SOFT_DISABLED
     379                 :            :                  * is set we do not want the event to be enabled before we
     380                 :            :                  * clear the bit.
     381                 :            :                  *
     382                 :            :                  * When soft_disable is not set but the SOFT_MODE flag is,
     383                 :            :                  * we do nothing. Do not disable the tracepoint, otherwise
     384                 :            :                  * "soft enable"s (clearing the SOFT_DISABLED bit) wont work.
     385                 :            :                  */
     386                 :          0 :                 if (soft_disable) {
     387                 :          0 :                         if (atomic_dec_return(&file->sm_ref) > 0)
     388                 :            :                                 break;
     389                 :          0 :                         disable = file->flags & EVENT_FILE_FL_SOFT_DISABLED;
     390                 :          0 :                         clear_bit(EVENT_FILE_FL_SOFT_MODE_BIT, &file->flags);
     391                 :            :                 } else
     392                 :          0 :                         disable = !(file->flags & EVENT_FILE_FL_SOFT_MODE);
     393                 :            : 
     394                 :          0 :                 if (disable && (file->flags & EVENT_FILE_FL_ENABLED)) {
     395                 :          0 :                         clear_bit(EVENT_FILE_FL_ENABLED_BIT, &file->flags);
     396                 :          0 :                         if (file->flags & EVENT_FILE_FL_RECORDED_CMD) {
     397                 :          0 :                                 tracing_stop_cmdline_record();
     398                 :          0 :                                 clear_bit(EVENT_FILE_FL_RECORDED_CMD_BIT, &file->flags);
     399                 :            :                         }
     400                 :            : 
     401                 :          0 :                         if (file->flags & EVENT_FILE_FL_RECORDED_TGID) {
     402                 :          0 :                                 tracing_stop_tgid_record();
     403                 :          0 :                                 clear_bit(EVENT_FILE_FL_RECORDED_TGID_BIT, &file->flags);
     404                 :            :                         }
     405                 :            : 
     406                 :          0 :                         call->class->reg(call, TRACE_REG_UNREGISTER, file);
     407                 :            :                 }
     408                 :            :                 /* If in SOFT_MODE, just set the SOFT_DISABLE_BIT, else clear it */
     409                 :          0 :                 if (file->flags & EVENT_FILE_FL_SOFT_MODE)
     410                 :          0 :                         set_bit(EVENT_FILE_FL_SOFT_DISABLED_BIT, &file->flags);
     411                 :            :                 else
     412                 :          0 :                         clear_bit(EVENT_FILE_FL_SOFT_DISABLED_BIT, &file->flags);
     413                 :            :                 break;
     414                 :            :         case 1:
     415                 :            :                 /*
     416                 :            :                  * When soft_disable is set and enable is set, we want to
     417                 :            :                  * register the tracepoint for the event, but leave the event
     418                 :            :                  * as is. That means, if the event was already enabled, we do
     419                 :            :                  * nothing (but set SOFT_MODE). If the event is disabled, we
     420                 :            :                  * set SOFT_DISABLED before enabling the event tracepoint, so
     421                 :            :                  * it still seems to be disabled.
     422                 :            :                  */
     423                 :          0 :                 if (!soft_disable)
     424                 :          0 :                         clear_bit(EVENT_FILE_FL_SOFT_DISABLED_BIT, &file->flags);
     425                 :            :                 else {
     426                 :          0 :                         if (atomic_inc_return(&file->sm_ref) > 1)
     427                 :            :                                 break;
     428                 :          0 :                         set_bit(EVENT_FILE_FL_SOFT_MODE_BIT, &file->flags);
     429                 :            :                 }
     430                 :            : 
     431                 :          0 :                 if (!(file->flags & EVENT_FILE_FL_ENABLED)) {
     432                 :            :                         bool cmd = false, tgid = false;
     433                 :            : 
     434                 :            :                         /* Keep the event disabled, when going to SOFT_MODE. */
     435                 :          0 :                         if (soft_disable)
     436                 :          0 :                                 set_bit(EVENT_FILE_FL_SOFT_DISABLED_BIT, &file->flags);
     437                 :            : 
     438                 :          0 :                         if (tr->trace_flags & TRACE_ITER_RECORD_CMD) {
     439                 :            :                                 cmd = true;
     440                 :          0 :                                 tracing_start_cmdline_record();
     441                 :          0 :                                 set_bit(EVENT_FILE_FL_RECORDED_CMD_BIT, &file->flags);
     442                 :            :                         }
     443                 :            : 
     444                 :          0 :                         if (tr->trace_flags & TRACE_ITER_RECORD_TGID) {
     445                 :            :                                 tgid = true;
     446                 :          0 :                                 tracing_start_tgid_record();
     447                 :          0 :                                 set_bit(EVENT_FILE_FL_RECORDED_TGID_BIT, &file->flags);
     448                 :            :                         }
     449                 :            : 
     450                 :          0 :                         ret = call->class->reg(call, TRACE_REG_REGISTER, file);
     451                 :          0 :                         if (ret) {
     452                 :          0 :                                 if (cmd)
     453                 :          0 :                                         tracing_stop_cmdline_record();
     454                 :          0 :                                 if (tgid)
     455                 :          0 :                                         tracing_stop_tgid_record();
     456                 :          0 :                                 pr_info("event trace: Could not enable event "
     457                 :            :                                         "%s\n", trace_event_name(call));
     458                 :          0 :                                 break;
     459                 :            :                         }
     460                 :          0 :                         set_bit(EVENT_FILE_FL_ENABLED_BIT, &file->flags);
     461                 :            : 
     462                 :            :                         /* WAS_ENABLED gets set but never cleared. */
     463                 :          0 :                         set_bit(EVENT_FILE_FL_WAS_ENABLED_BIT, &file->flags);
     464                 :            :                 }
     465                 :            :                 break;
     466                 :            :         }
     467                 :            : 
     468                 :            :         /* Enable or disable use of trace_buffered_event */
     469                 :          0 :         if ((file_flags & EVENT_FILE_FL_SOFT_DISABLED) !=
     470                 :          0 :             (file->flags & EVENT_FILE_FL_SOFT_DISABLED)) {
     471                 :          0 :                 if (file->flags & EVENT_FILE_FL_SOFT_DISABLED)
     472                 :          0 :                         trace_buffered_event_enable();
     473                 :            :                 else
     474                 :          0 :                         trace_buffered_event_disable();
     475                 :            :         }
     476                 :            : 
     477                 :          0 :         return ret;
     478                 :            : }
     479                 :            : 
     480                 :          0 : int trace_event_enable_disable(struct trace_event_file *file,
     481                 :            :                                int enable, int soft_disable)
     482                 :            : {
     483                 :          0 :         return __ftrace_event_enable_disable(file, enable, soft_disable);
     484                 :            : }
     485                 :            : 
     486                 :            : static int ftrace_event_enable_disable(struct trace_event_file *file,
     487                 :            :                                        int enable)
     488                 :            : {
     489                 :          0 :         return __ftrace_event_enable_disable(file, enable, 0);
     490                 :            : }
     491                 :            : 
     492                 :          0 : static void ftrace_clear_events(struct trace_array *tr)
     493                 :            : {
     494                 :            :         struct trace_event_file *file;
     495                 :            : 
     496                 :          0 :         mutex_lock(&event_mutex);
     497                 :          0 :         list_for_each_entry(file, &tr->events, list) {
     498                 :            :                 ftrace_event_enable_disable(file, 0);
     499                 :            :         }
     500                 :          0 :         mutex_unlock(&event_mutex);
     501                 :          0 : }
     502                 :            : 
     503                 :            : static void
     504                 :          0 : event_filter_pid_sched_process_exit(void *data, struct task_struct *task)
     505                 :            : {
     506                 :            :         struct trace_pid_list *pid_list;
     507                 :            :         struct trace_array *tr = data;
     508                 :            : 
     509                 :          0 :         pid_list = rcu_dereference_raw(tr->filtered_pids);
     510                 :          0 :         trace_filter_add_remove_task(pid_list, NULL, task);
     511                 :          0 : }
     512                 :            : 
     513                 :            : static void
     514                 :          0 : event_filter_pid_sched_process_fork(void *data,
     515                 :            :                                     struct task_struct *self,
     516                 :            :                                     struct task_struct *task)
     517                 :            : {
     518                 :            :         struct trace_pid_list *pid_list;
     519                 :            :         struct trace_array *tr = data;
     520                 :            : 
     521                 :          0 :         pid_list = rcu_dereference_sched(tr->filtered_pids);
     522                 :          0 :         trace_filter_add_remove_task(pid_list, self, task);
     523                 :          0 : }
     524                 :            : 
     525                 :          0 : void trace_event_follow_fork(struct trace_array *tr, bool enable)
     526                 :            : {
     527                 :          0 :         if (enable) {
     528                 :            :                 register_trace_prio_sched_process_fork(event_filter_pid_sched_process_fork,
     529                 :            :                                                        tr, INT_MIN);
     530                 :            :                 register_trace_prio_sched_process_free(event_filter_pid_sched_process_exit,
     531                 :            :                                                        tr, INT_MAX);
     532                 :            :         } else {
     533                 :            :                 unregister_trace_sched_process_fork(event_filter_pid_sched_process_fork,
     534                 :            :                                                     tr);
     535                 :            :                 unregister_trace_sched_process_free(event_filter_pid_sched_process_exit,
     536                 :            :                                                     tr);
     537                 :            :         }
     538                 :          0 : }
     539                 :            : 
     540                 :            : static void
     541                 :          0 : event_filter_pid_sched_switch_probe_pre(void *data, bool preempt,
     542                 :            :                     struct task_struct *prev, struct task_struct *next)
     543                 :            : {
     544                 :            :         struct trace_array *tr = data;
     545                 :            :         struct trace_pid_list *pid_list;
     546                 :            : 
     547                 :          0 :         pid_list = rcu_dereference_sched(tr->filtered_pids);
     548                 :            : 
     549                 :          0 :         this_cpu_write(tr->trace_buffer.data->ignore_pid,
     550                 :            :                        trace_ignore_this_task(pid_list, prev) &&
     551                 :            :                        trace_ignore_this_task(pid_list, next));
     552                 :          0 : }
     553                 :            : 
     554                 :            : static void
     555                 :          0 : event_filter_pid_sched_switch_probe_post(void *data, bool preempt,
     556                 :            :                     struct task_struct *prev, struct task_struct *next)
     557                 :            : {
     558                 :            :         struct trace_array *tr = data;
     559                 :            :         struct trace_pid_list *pid_list;
     560                 :            : 
     561                 :          0 :         pid_list = rcu_dereference_sched(tr->filtered_pids);
     562                 :            : 
     563                 :          0 :         this_cpu_write(tr->trace_buffer.data->ignore_pid,
     564                 :            :                        trace_ignore_this_task(pid_list, next));
     565                 :          0 : }
     566                 :            : 
     567                 :            : static void
     568                 :          0 : event_filter_pid_sched_wakeup_probe_pre(void *data, struct task_struct *task)
     569                 :            : {
     570                 :            :         struct trace_array *tr = data;
     571                 :            :         struct trace_pid_list *pid_list;
     572                 :            : 
     573                 :            :         /* Nothing to do if we are already tracing */
     574                 :          0 :         if (!this_cpu_read(tr->trace_buffer.data->ignore_pid))
     575                 :          0 :                 return;
     576                 :            : 
     577                 :          0 :         pid_list = rcu_dereference_sched(tr->filtered_pids);
     578                 :            : 
     579                 :          0 :         this_cpu_write(tr->trace_buffer.data->ignore_pid,
     580                 :            :                        trace_ignore_this_task(pid_list, task));
     581                 :            : }
     582                 :            : 
     583                 :            : static void
     584                 :          0 : event_filter_pid_sched_wakeup_probe_post(void *data, struct task_struct *task)
     585                 :            : {
     586                 :            :         struct trace_array *tr = data;
     587                 :            :         struct trace_pid_list *pid_list;
     588                 :            : 
     589                 :            :         /* Nothing to do if we are not tracing */
     590                 :          0 :         if (this_cpu_read(tr->trace_buffer.data->ignore_pid))
     591                 :          0 :                 return;
     592                 :            : 
     593                 :          0 :         pid_list = rcu_dereference_sched(tr->filtered_pids);
     594                 :            : 
     595                 :            :         /* Set tracing if current is enabled */
     596                 :          0 :         this_cpu_write(tr->trace_buffer.data->ignore_pid,
     597                 :            :                        trace_ignore_this_task(pid_list, current));
     598                 :            : }
     599                 :            : 
     600                 :          0 : static void __ftrace_clear_event_pids(struct trace_array *tr)
     601                 :            : {
     602                 :            :         struct trace_pid_list *pid_list;
     603                 :            :         struct trace_event_file *file;
     604                 :            :         int cpu;
     605                 :            : 
     606                 :          0 :         pid_list = rcu_dereference_protected(tr->filtered_pids,
     607                 :            :                                              lockdep_is_held(&event_mutex));
     608                 :          0 :         if (!pid_list)
     609                 :          0 :                 return;
     610                 :            : 
     611                 :            :         unregister_trace_sched_switch(event_filter_pid_sched_switch_probe_pre, tr);
     612                 :            :         unregister_trace_sched_switch(event_filter_pid_sched_switch_probe_post, tr);
     613                 :            : 
     614                 :            :         unregister_trace_sched_wakeup(event_filter_pid_sched_wakeup_probe_pre, tr);
     615                 :            :         unregister_trace_sched_wakeup(event_filter_pid_sched_wakeup_probe_post, tr);
     616                 :            : 
     617                 :            :         unregister_trace_sched_wakeup_new(event_filter_pid_sched_wakeup_probe_pre, tr);
     618                 :            :         unregister_trace_sched_wakeup_new(event_filter_pid_sched_wakeup_probe_post, tr);
     619                 :            : 
     620                 :            :         unregister_trace_sched_waking(event_filter_pid_sched_wakeup_probe_pre, tr);
     621                 :            :         unregister_trace_sched_waking(event_filter_pid_sched_wakeup_probe_post, tr);
     622                 :            : 
     623                 :          0 :         list_for_each_entry(file, &tr->events, list) {
     624                 :          0 :                 clear_bit(EVENT_FILE_FL_PID_FILTER_BIT, &file->flags);
     625                 :            :         }
     626                 :            : 
     627                 :          0 :         for_each_possible_cpu(cpu)
     628                 :          0 :                 per_cpu_ptr(tr->trace_buffer.data, cpu)->ignore_pid = false;
     629                 :            : 
     630                 :            :         rcu_assign_pointer(tr->filtered_pids, NULL);
     631                 :            : 
     632                 :            :         /* Wait till all users are no longer using pid filtering */
     633                 :            :         tracepoint_synchronize_unregister();
     634                 :            : 
     635                 :          0 :         trace_free_pid_list(pid_list);
     636                 :            : }
     637                 :            : 
     638                 :          0 : static void ftrace_clear_event_pids(struct trace_array *tr)
     639                 :            : {
     640                 :          0 :         mutex_lock(&event_mutex);
     641                 :          0 :         __ftrace_clear_event_pids(tr);
     642                 :          0 :         mutex_unlock(&event_mutex);
     643                 :          0 : }
     644                 :            : 
     645                 :          0 : static void __put_system(struct event_subsystem *system)
     646                 :            : {
     647                 :          0 :         struct event_filter *filter = system->filter;
     648                 :            : 
     649                 :          0 :         WARN_ON_ONCE(system_refcount(system) == 0);
     650                 :          0 :         if (system_refcount_dec(system))
     651                 :          0 :                 return;
     652                 :            : 
     653                 :            :         list_del(&system->list);
     654                 :            : 
     655                 :          0 :         if (filter) {
     656                 :          0 :                 kfree(filter->filter_string);
     657                 :          0 :                 kfree(filter);
     658                 :            :         }
     659                 :          0 :         kfree_const(system->name);
     660                 :          0 :         kfree(system);
     661                 :            : }
     662                 :            : 
     663                 :          0 : static void __get_system(struct event_subsystem *system)
     664                 :            : {
     665                 :          0 :         WARN_ON_ONCE(system_refcount(system) == 0);
     666                 :            :         system_refcount_inc(system);
     667                 :          0 : }
     668                 :            : 
     669                 :          0 : static void __get_system_dir(struct trace_subsystem_dir *dir)
     670                 :            : {
     671                 :          0 :         WARN_ON_ONCE(dir->ref_count == 0);
     672                 :          0 :         dir->ref_count++;
     673                 :          0 :         __get_system(dir->subsystem);
     674                 :          0 : }
     675                 :            : 
     676                 :          0 : static void __put_system_dir(struct trace_subsystem_dir *dir)
     677                 :            : {
     678                 :          0 :         WARN_ON_ONCE(dir->ref_count == 0);
     679                 :            :         /* If the subsystem is about to be freed, the dir must be too */
     680                 :          0 :         WARN_ON_ONCE(system_refcount(dir->subsystem) == 1 && dir->ref_count != 1);
     681                 :            : 
     682                 :          0 :         __put_system(dir->subsystem);
     683                 :          0 :         if (!--dir->ref_count)
     684                 :          0 :                 kfree(dir);
     685                 :          0 : }
     686                 :            : 
     687                 :          0 : static void put_system(struct trace_subsystem_dir *dir)
     688                 :            : {
     689                 :          0 :         mutex_lock(&event_mutex);
     690                 :          0 :         __put_system_dir(dir);
     691                 :          0 :         mutex_unlock(&event_mutex);
     692                 :          0 : }
     693                 :            : 
     694                 :          0 : static void remove_subsystem(struct trace_subsystem_dir *dir)
     695                 :            : {
     696                 :          0 :         if (!dir)
     697                 :          0 :                 return;
     698                 :            : 
     699                 :          0 :         if (!--dir->nr_events) {
     700                 :          0 :                 tracefs_remove_recursive(dir->entry);
     701                 :            :                 list_del(&dir->list);
     702                 :          0 :                 __put_system_dir(dir);
     703                 :            :         }
     704                 :            : }
     705                 :            : 
     706                 :          0 : static void remove_event_file_dir(struct trace_event_file *file)
     707                 :            : {
     708                 :          0 :         struct dentry *dir = file->dir;
     709                 :            :         struct dentry *child;
     710                 :            : 
     711                 :          0 :         if (dir) {
     712                 :            :                 spin_lock(&dir->d_lock); /* probably unneeded */
     713                 :          0 :                 list_for_each_entry(child, &dir->d_subdirs, d_child) {
     714                 :          0 :                         if (d_really_is_positive(child))        /* probably unneeded */
     715                 :          0 :                                 d_inode(child)->i_private = NULL;
     716                 :            :                 }
     717                 :            :                 spin_unlock(&dir->d_lock);
     718                 :            : 
     719                 :          0 :                 tracefs_remove_recursive(dir);
     720                 :            :         }
     721                 :            : 
     722                 :            :         list_del(&file->list);
     723                 :          0 :         remove_subsystem(file->system);
     724                 :          0 :         free_event_filter(file->filter);
     725                 :          0 :         kmem_cache_free(file_cachep, file);
     726                 :          0 : }
     727                 :            : 
     728                 :            : /*
     729                 :            :  * __ftrace_set_clr_event(NULL, NULL, NULL, set) will set/unset all events.
     730                 :            :  */
     731                 :            : static int
     732                 :          0 : __ftrace_set_clr_event_nolock(struct trace_array *tr, const char *match,
     733                 :            :                               const char *sub, const char *event, int set)
     734                 :            : {
     735                 :            :         struct trace_event_file *file;
     736                 :            :         struct trace_event_call *call;
     737                 :            :         const char *name;
     738                 :            :         int ret = -EINVAL;
     739                 :            :         int eret = 0;
     740                 :            : 
     741                 :          0 :         list_for_each_entry(file, &tr->events, list) {
     742                 :            : 
     743                 :          0 :                 call = file->event_call;
     744                 :            :                 name = trace_event_name(call);
     745                 :            : 
     746                 :          0 :                 if (!name || !call->class || !call->class->reg)
     747                 :          0 :                         continue;
     748                 :            : 
     749                 :          0 :                 if (call->flags & TRACE_EVENT_FL_IGNORE_ENABLE)
     750                 :          0 :                         continue;
     751                 :            : 
     752                 :          0 :                 if (match &&
     753                 :          0 :                     strcmp(match, name) != 0 &&
     754                 :          0 :                     strcmp(match, call->class->system) != 0)
     755                 :          0 :                         continue;
     756                 :            : 
     757                 :          0 :                 if (sub && strcmp(sub, call->class->system) != 0)
     758                 :          0 :                         continue;
     759                 :            : 
     760                 :          0 :                 if (event && strcmp(event, name) != 0)
     761                 :          0 :                         continue;
     762                 :            : 
     763                 :            :                 ret = ftrace_event_enable_disable(file, set);
     764                 :            : 
     765                 :            :                 /*
     766                 :            :                  * Save the first error and return that. Some events
     767                 :            :                  * may still have been enabled, but let the user
     768                 :            :                  * know that something went wrong.
     769                 :            :                  */
     770                 :          0 :                 if (ret && !eret)
     771                 :            :                         eret = ret;
     772                 :            : 
     773                 :            :                 ret = eret;
     774                 :            :         }
     775                 :            : 
     776                 :          0 :         return ret;
     777                 :            : }
     778                 :            : 
     779                 :          0 : static int __ftrace_set_clr_event(struct trace_array *tr, const char *match,
     780                 :            :                                   const char *sub, const char *event, int set)
     781                 :            : {
     782                 :            :         int ret;
     783                 :            : 
     784                 :          0 :         mutex_lock(&event_mutex);
     785                 :          0 :         ret = __ftrace_set_clr_event_nolock(tr, match, sub, event, set);
     786                 :          0 :         mutex_unlock(&event_mutex);
     787                 :            : 
     788                 :          0 :         return ret;
     789                 :            : }
     790                 :            : 
     791                 :          0 : int ftrace_set_clr_event(struct trace_array *tr, char *buf, int set)
     792                 :            : {
     793                 :            :         char *event = NULL, *sub = NULL, *match;
     794                 :            :         int ret;
     795                 :            : 
     796                 :            :         /*
     797                 :            :          * The buf format can be <subsystem>:<event-name>
     798                 :            :          *  *:<event-name> means any event by that name.
     799                 :            :          *  :<event-name> is the same.
     800                 :            :          *
     801                 :            :          *  <subsystem>:* means all events in that subsystem
     802                 :            :          *  <subsystem>: means the same.
     803                 :            :          *
     804                 :            :          *  <name> (no ':') means all events in a subsystem with
     805                 :            :          *  the name <name> or any event that matches <name>
     806                 :            :          */
     807                 :            : 
     808                 :          0 :         match = strsep(&buf, ":");
     809                 :          0 :         if (buf) {
     810                 :            :                 sub = match;
     811                 :            :                 event = buf;
     812                 :            :                 match = NULL;
     813                 :            : 
     814                 :          0 :                 if (!strlen(sub) || strcmp(sub, "*") == 0)
     815                 :            :                         sub = NULL;
     816                 :          0 :                 if (!strlen(event) || strcmp(event, "*") == 0)
     817                 :            :                         event = NULL;
     818                 :            :         }
     819                 :            : 
     820                 :          0 :         ret = __ftrace_set_clr_event(tr, match, sub, event, set);
     821                 :            : 
     822                 :            :         /* Put back the colon to allow this to be called again */
     823                 :          0 :         if (buf)
     824                 :          0 :                 *(buf - 1) = ':';
     825                 :            : 
     826                 :          0 :         return ret;
     827                 :            : }
     828                 :            : EXPORT_SYMBOL_GPL(ftrace_set_clr_event);
     829                 :            : 
     830                 :            : /**
     831                 :            :  * trace_set_clr_event - enable or disable an event
     832                 :            :  * @system: system name to match (NULL for any system)
     833                 :            :  * @event: event name to match (NULL for all events, within system)
     834                 :            :  * @set: 1 to enable, 0 to disable
     835                 :            :  *
     836                 :            :  * This is a way for other parts of the kernel to enable or disable
     837                 :            :  * event recording.
     838                 :            :  *
     839                 :            :  * Returns 0 on success, -EINVAL if the parameters do not match any
     840                 :            :  * registered events.
     841                 :            :  */
     842                 :          0 : int trace_set_clr_event(const char *system, const char *event, int set)
     843                 :            : {
     844                 :          0 :         struct trace_array *tr = top_trace_array();
     845                 :            : 
     846                 :          0 :         if (!tr)
     847                 :            :                 return -ENODEV;
     848                 :            : 
     849                 :          0 :         return __ftrace_set_clr_event(tr, NULL, system, event, set);
     850                 :            : }
     851                 :            : EXPORT_SYMBOL_GPL(trace_set_clr_event);
     852                 :            : 
     853                 :            : /* 128 should be much more than enough */
     854                 :            : #define EVENT_BUF_SIZE          127
     855                 :            : 
     856                 :            : static ssize_t
     857                 :          0 : ftrace_event_write(struct file *file, const char __user *ubuf,
     858                 :            :                    size_t cnt, loff_t *ppos)
     859                 :            : {
     860                 :            :         struct trace_parser parser;
     861                 :          0 :         struct seq_file *m = file->private_data;
     862                 :          0 :         struct trace_array *tr = m->private;
     863                 :            :         ssize_t read, ret;
     864                 :            : 
     865                 :          0 :         if (!cnt)
     866                 :            :                 return 0;
     867                 :            : 
     868                 :          0 :         ret = tracing_update_buffers();
     869                 :          0 :         if (ret < 0)
     870                 :            :                 return ret;
     871                 :            : 
     872                 :          0 :         if (trace_parser_get_init(&parser, EVENT_BUF_SIZE + 1))
     873                 :            :                 return -ENOMEM;
     874                 :            : 
     875                 :          0 :         read = trace_get_user(&parser, ubuf, cnt, ppos);
     876                 :            : 
     877                 :          0 :         if (read >= 0 && trace_parser_loaded((&parser))) {
     878                 :            :                 int set = 1;
     879                 :            : 
     880                 :          0 :                 if (*parser.buffer == '!')
     881                 :            :                         set = 0;
     882                 :            : 
     883                 :          0 :                 ret = ftrace_set_clr_event(tr, parser.buffer + !set, set);
     884                 :          0 :                 if (ret)
     885                 :            :                         goto out_put;
     886                 :            :         }
     887                 :            : 
     888                 :            :         ret = read;
     889                 :            : 
     890                 :            :  out_put:
     891                 :          0 :         trace_parser_put(&parser);
     892                 :            : 
     893                 :          0 :         return ret;
     894                 :            : }
     895                 :            : 
     896                 :            : static void *
     897                 :          0 : t_next(struct seq_file *m, void *v, loff_t *pos)
     898                 :            : {
     899                 :            :         struct trace_event_file *file = v;
     900                 :            :         struct trace_event_call *call;
     901                 :          0 :         struct trace_array *tr = m->private;
     902                 :            : 
     903                 :          0 :         (*pos)++;
     904                 :            : 
     905                 :          0 :         list_for_each_entry_continue(file, &tr->events, list) {
     906                 :          0 :                 call = file->event_call;
     907                 :            :                 /*
     908                 :            :                  * The ftrace subsystem is for showing formats only.
     909                 :            :                  * They can not be enabled or disabled via the event files.
     910                 :            :                  */
     911                 :          0 :                 if (call->class && call->class->reg &&
     912                 :          0 :                     !(call->flags & TRACE_EVENT_FL_IGNORE_ENABLE))
     913                 :          0 :                         return file;
     914                 :            :         }
     915                 :            : 
     916                 :            :         return NULL;
     917                 :            : }
     918                 :            : 
     919                 :          0 : static void *t_start(struct seq_file *m, loff_t *pos)
     920                 :            : {
     921                 :            :         struct trace_event_file *file;
     922                 :          0 :         struct trace_array *tr = m->private;
     923                 :            :         loff_t l;
     924                 :            : 
     925                 :          0 :         mutex_lock(&event_mutex);
     926                 :            : 
     927                 :          0 :         file = list_entry(&tr->events, struct trace_event_file, list);
     928                 :          0 :         for (l = 0; l <= *pos; ) {
     929                 :          0 :                 file = t_next(m, file, &l);
     930                 :          0 :                 if (!file)
     931                 :            :                         break;
     932                 :            :         }
     933                 :          0 :         return file;
     934                 :            : }
     935                 :            : 
     936                 :            : static void *
     937                 :          0 : s_next(struct seq_file *m, void *v, loff_t *pos)
     938                 :            : {
     939                 :            :         struct trace_event_file *file = v;
     940                 :          0 :         struct trace_array *tr = m->private;
     941                 :            : 
     942                 :          0 :         (*pos)++;
     943                 :            : 
     944                 :          0 :         list_for_each_entry_continue(file, &tr->events, list) {
     945                 :          0 :                 if (file->flags & EVENT_FILE_FL_ENABLED)
     946                 :          0 :                         return file;
     947                 :            :         }
     948                 :            : 
     949                 :            :         return NULL;
     950                 :            : }
     951                 :            : 
     952                 :          0 : static void *s_start(struct seq_file *m, loff_t *pos)
     953                 :            : {
     954                 :            :         struct trace_event_file *file;
     955                 :          0 :         struct trace_array *tr = m->private;
     956                 :            :         loff_t l;
     957                 :            : 
     958                 :          0 :         mutex_lock(&event_mutex);
     959                 :            : 
     960                 :          0 :         file = list_entry(&tr->events, struct trace_event_file, list);
     961                 :          0 :         for (l = 0; l <= *pos; ) {
     962                 :            :                 file = s_next(m, file, &l);
     963                 :          0 :                 if (!file)
     964                 :            :                         break;
     965                 :            :         }
     966                 :          0 :         return file;
     967                 :            : }
     968                 :            : 
     969                 :          0 : static int t_show(struct seq_file *m, void *v)
     970                 :            : {
     971                 :            :         struct trace_event_file *file = v;
     972                 :          0 :         struct trace_event_call *call = file->event_call;
     973                 :            : 
     974                 :          0 :         if (strcmp(call->class->system, TRACE_SYSTEM) != 0)
     975                 :          0 :                 seq_printf(m, "%s:", call->class->system);
     976                 :          0 :         seq_printf(m, "%s\n", trace_event_name(call));
     977                 :            : 
     978                 :          0 :         return 0;
     979                 :            : }
     980                 :            : 
     981                 :          0 : static void t_stop(struct seq_file *m, void *p)
     982                 :            : {
     983                 :          0 :         mutex_unlock(&event_mutex);
     984                 :          0 : }
     985                 :            : 
     986                 :            : static void *
     987                 :          0 : p_next(struct seq_file *m, void *v, loff_t *pos)
     988                 :            : {
     989                 :          0 :         struct trace_array *tr = m->private;
     990                 :          0 :         struct trace_pid_list *pid_list = rcu_dereference_sched(tr->filtered_pids);
     991                 :            : 
     992                 :          0 :         return trace_pid_next(pid_list, v, pos);
     993                 :            : }
     994                 :            : 
     995                 :          0 : static void *p_start(struct seq_file *m, loff_t *pos)
     996                 :            :         __acquires(RCU)
     997                 :            : {
     998                 :            :         struct trace_pid_list *pid_list;
     999                 :          0 :         struct trace_array *tr = m->private;
    1000                 :            : 
    1001                 :            :         /*
    1002                 :            :          * Grab the mutex, to keep calls to p_next() having the same
    1003                 :            :          * tr->filtered_pids as p_start() has.
    1004                 :            :          * If we just passed the tr->filtered_pids around, then RCU would
    1005                 :            :          * have been enough, but doing that makes things more complex.
    1006                 :            :          */
    1007                 :          0 :         mutex_lock(&event_mutex);
    1008                 :            :         rcu_read_lock_sched();
    1009                 :            : 
    1010                 :          0 :         pid_list = rcu_dereference_sched(tr->filtered_pids);
    1011                 :            : 
    1012                 :          0 :         if (!pid_list)
    1013                 :            :                 return NULL;
    1014                 :            : 
    1015                 :          0 :         return trace_pid_start(pid_list, pos);
    1016                 :            : }
    1017                 :            : 
    1018                 :          0 : static void p_stop(struct seq_file *m, void *p)
    1019                 :            :         __releases(RCU)
    1020                 :            : {
    1021                 :            :         rcu_read_unlock_sched();
    1022                 :          0 :         mutex_unlock(&event_mutex);
    1023                 :          0 : }
    1024                 :            : 
    1025                 :            : static ssize_t
    1026                 :          0 : event_enable_read(struct file *filp, char __user *ubuf, size_t cnt,
    1027                 :            :                   loff_t *ppos)
    1028                 :            : {
    1029                 :            :         struct trace_event_file *file;
    1030                 :            :         unsigned long flags;
    1031                 :          0 :         char buf[4] = "0";
    1032                 :            : 
    1033                 :          0 :         mutex_lock(&event_mutex);
    1034                 :            :         file = event_file_data(filp);
    1035                 :          0 :         if (likely(file))
    1036                 :          0 :                 flags = file->flags;
    1037                 :          0 :         mutex_unlock(&event_mutex);
    1038                 :            : 
    1039                 :          0 :         if (!file)
    1040                 :            :                 return -ENODEV;
    1041                 :            : 
    1042                 :          0 :         if (flags & EVENT_FILE_FL_ENABLED &&
    1043                 :            :             !(flags & EVENT_FILE_FL_SOFT_DISABLED))
    1044                 :          0 :                 strcpy(buf, "1");
    1045                 :            : 
    1046                 :          0 :         if (flags & EVENT_FILE_FL_SOFT_DISABLED ||
    1047                 :            :             flags & EVENT_FILE_FL_SOFT_MODE)
    1048                 :          0 :                 strcat(buf, "*");
    1049                 :            : 
    1050                 :          0 :         strcat(buf, "\n");
    1051                 :            : 
    1052                 :          0 :         return simple_read_from_buffer(ubuf, cnt, ppos, buf, strlen(buf));
    1053                 :            : }
    1054                 :            : 
    1055                 :            : static ssize_t
    1056                 :          0 : event_enable_write(struct file *filp, const char __user *ubuf, size_t cnt,
    1057                 :            :                    loff_t *ppos)
    1058                 :            : {
    1059                 :            :         struct trace_event_file *file;
    1060                 :            :         unsigned long val;
    1061                 :            :         int ret;
    1062                 :            : 
    1063                 :          0 :         ret = kstrtoul_from_user(ubuf, cnt, 10, &val);
    1064                 :          0 :         if (ret)
    1065                 :            :                 return ret;
    1066                 :            : 
    1067                 :          0 :         ret = tracing_update_buffers();
    1068                 :          0 :         if (ret < 0)
    1069                 :            :                 return ret;
    1070                 :            : 
    1071                 :          0 :         switch (val) {
    1072                 :            :         case 0:
    1073                 :            :         case 1:
    1074                 :            :                 ret = -ENODEV;
    1075                 :          0 :                 mutex_lock(&event_mutex);
    1076                 :            :                 file = event_file_data(filp);
    1077                 :          0 :                 if (likely(file))
    1078                 :          0 :                         ret = ftrace_event_enable_disable(file, val);
    1079                 :          0 :                 mutex_unlock(&event_mutex);
    1080                 :            :                 break;
    1081                 :            : 
    1082                 :            :         default:
    1083                 :            :                 return -EINVAL;
    1084                 :            :         }
    1085                 :            : 
    1086                 :          0 :         *ppos += cnt;
    1087                 :            : 
    1088                 :          0 :         return ret ? ret : cnt;
    1089                 :            : }
    1090                 :            : 
    1091                 :            : static ssize_t
    1092                 :          0 : system_enable_read(struct file *filp, char __user *ubuf, size_t cnt,
    1093                 :            :                    loff_t *ppos)
    1094                 :            : {
    1095                 :          0 :         const char set_to_char[4] = { '?', '0', '1', 'X' };
    1096                 :          0 :         struct trace_subsystem_dir *dir = filp->private_data;
    1097                 :          0 :         struct event_subsystem *system = dir->subsystem;
    1098                 :            :         struct trace_event_call *call;
    1099                 :            :         struct trace_event_file *file;
    1100                 :          0 :         struct trace_array *tr = dir->tr;
    1101                 :            :         char buf[2];
    1102                 :            :         int set = 0;
    1103                 :            :         int ret;
    1104                 :            : 
    1105                 :          0 :         mutex_lock(&event_mutex);
    1106                 :          0 :         list_for_each_entry(file, &tr->events, list) {
    1107                 :          0 :                 call = file->event_call;
    1108                 :          0 :                 if (!trace_event_name(call) || !call->class || !call->class->reg)
    1109                 :          0 :                         continue;
    1110                 :            : 
    1111                 :          0 :                 if (system && strcmp(call->class->system, system->name) != 0)
    1112                 :          0 :                         continue;
    1113                 :            : 
    1114                 :            :                 /*
    1115                 :            :                  * We need to find out if all the events are set
    1116                 :            :                  * or if all events or cleared, or if we have
    1117                 :            :                  * a mixture.
    1118                 :            :                  */
    1119                 :          0 :                 set |= (1 << !!(file->flags & EVENT_FILE_FL_ENABLED));
    1120                 :            : 
    1121                 :            :                 /*
    1122                 :            :                  * If we have a mixture, no need to look further.
    1123                 :            :                  */
    1124                 :          0 :                 if (set == 3)
    1125                 :            :                         break;
    1126                 :            :         }
    1127                 :          0 :         mutex_unlock(&event_mutex);
    1128                 :            : 
    1129                 :          0 :         buf[0] = set_to_char[set];
    1130                 :          0 :         buf[1] = '\n';
    1131                 :            : 
    1132                 :          0 :         ret = simple_read_from_buffer(ubuf, cnt, ppos, buf, 2);
    1133                 :            : 
    1134                 :          0 :         return ret;
    1135                 :            : }
    1136                 :            : 
    1137                 :            : static ssize_t
    1138                 :          0 : system_enable_write(struct file *filp, const char __user *ubuf, size_t cnt,
    1139                 :            :                     loff_t *ppos)
    1140                 :            : {
    1141                 :          0 :         struct trace_subsystem_dir *dir = filp->private_data;
    1142                 :          0 :         struct event_subsystem *system = dir->subsystem;
    1143                 :            :         const char *name = NULL;
    1144                 :            :         unsigned long val;
    1145                 :            :         ssize_t ret;
    1146                 :            : 
    1147                 :          0 :         ret = kstrtoul_from_user(ubuf, cnt, 10, &val);
    1148                 :          0 :         if (ret)
    1149                 :            :                 return ret;
    1150                 :            : 
    1151                 :          0 :         ret = tracing_update_buffers();
    1152                 :          0 :         if (ret < 0)
    1153                 :            :                 return ret;
    1154                 :            : 
    1155                 :          0 :         if (val != 0 && val != 1)
    1156                 :            :                 return -EINVAL;
    1157                 :            : 
    1158                 :            :         /*
    1159                 :            :          * Opening of "enable" adds a ref count to system,
    1160                 :            :          * so the name is safe to use.
    1161                 :            :          */
    1162                 :          0 :         if (system)
    1163                 :          0 :                 name = system->name;
    1164                 :            : 
    1165                 :          0 :         ret = __ftrace_set_clr_event(dir->tr, NULL, name, NULL, val);
    1166                 :          0 :         if (ret)
    1167                 :            :                 goto out;
    1168                 :            : 
    1169                 :          0 :         ret = cnt;
    1170                 :            : 
    1171                 :            : out:
    1172                 :          0 :         *ppos += cnt;
    1173                 :            : 
    1174                 :          0 :         return ret;
    1175                 :            : }
    1176                 :            : 
    1177                 :            : enum {
    1178                 :            :         FORMAT_HEADER           = 1,
    1179                 :            :         FORMAT_FIELD_SEPERATOR  = 2,
    1180                 :            :         FORMAT_PRINTFMT         = 3,
    1181                 :            : };
    1182                 :            : 
    1183                 :          0 : static void *f_next(struct seq_file *m, void *v, loff_t *pos)
    1184                 :            : {
    1185                 :          0 :         struct trace_event_call *call = event_file_data(m->private);
    1186                 :            :         struct list_head *common_head = &ftrace_common_fields;
    1187                 :            :         struct list_head *head = trace_get_fields(call);
    1188                 :            :         struct list_head *node = v;
    1189                 :            : 
    1190                 :          0 :         (*pos)++;
    1191                 :            : 
    1192                 :          0 :         switch ((unsigned long)v) {
    1193                 :            :         case FORMAT_HEADER:
    1194                 :            :                 node = common_head;
    1195                 :          0 :                 break;
    1196                 :            : 
    1197                 :            :         case FORMAT_FIELD_SEPERATOR:
    1198                 :            :                 node = head;
    1199                 :          0 :                 break;
    1200                 :            : 
    1201                 :            :         case FORMAT_PRINTFMT:
    1202                 :            :                 /* all done */
    1203                 :            :                 return NULL;
    1204                 :            :         }
    1205                 :            : 
    1206                 :          0 :         node = node->prev;
    1207                 :          0 :         if (node == common_head)
    1208                 :            :                 return (void *)FORMAT_FIELD_SEPERATOR;
    1209                 :          0 :         else if (node == head)
    1210                 :            :                 return (void *)FORMAT_PRINTFMT;
    1211                 :            :         else
    1212                 :          0 :                 return node;
    1213                 :            : }
    1214                 :            : 
    1215                 :          0 : static int f_show(struct seq_file *m, void *v)
    1216                 :            : {
    1217                 :          0 :         struct trace_event_call *call = event_file_data(m->private);
    1218                 :            :         struct ftrace_event_field *field;
    1219                 :            :         const char *array_descriptor;
    1220                 :            : 
    1221                 :          0 :         switch ((unsigned long)v) {
    1222                 :            :         case FORMAT_HEADER:
    1223                 :          0 :                 seq_printf(m, "name: %s\n", trace_event_name(call));
    1224                 :          0 :                 seq_printf(m, "ID: %d\n", call->event.type);
    1225                 :          0 :                 seq_puts(m, "format:\n");
    1226                 :          0 :                 return 0;
    1227                 :            : 
    1228                 :            :         case FORMAT_FIELD_SEPERATOR:
    1229                 :          0 :                 seq_putc(m, '\n');
    1230                 :          0 :                 return 0;
    1231                 :            : 
    1232                 :            :         case FORMAT_PRINTFMT:
    1233                 :          0 :                 seq_printf(m, "\nprint fmt: %s\n",
    1234                 :            :                            call->print_fmt);
    1235                 :          0 :                 return 0;
    1236                 :            :         }
    1237                 :            : 
    1238                 :            :         field = list_entry(v, struct ftrace_event_field, link);
    1239                 :            :         /*
    1240                 :            :          * Smartly shows the array type(except dynamic array).
    1241                 :            :          * Normal:
    1242                 :            :          *      field:TYPE VAR
    1243                 :            :          * If TYPE := TYPE[LEN], it is shown:
    1244                 :            :          *      field:TYPE VAR[LEN]
    1245                 :            :          */
    1246                 :          0 :         array_descriptor = strchr(field->type, '[');
    1247                 :            : 
    1248                 :          0 :         if (str_has_prefix(field->type, "__data_loc"))
    1249                 :            :                 array_descriptor = NULL;
    1250                 :            : 
    1251                 :          0 :         if (!array_descriptor)
    1252                 :          0 :                 seq_printf(m, "\tfield:%s %s;\toffset:%u;\tsize:%u;\tsigned:%d;\n",
    1253                 :            :                            field->type, field->name, field->offset,
    1254                 :          0 :                            field->size, !!field->is_signed);
    1255                 :            :         else
    1256                 :          0 :                 seq_printf(m, "\tfield:%.*s %s%s;\toffset:%u;\tsize:%u;\tsigned:%d;\n",
    1257                 :            :                            (int)(array_descriptor - field->type),
    1258                 :            :                            field->type, field->name,
    1259                 :            :                            array_descriptor, field->offset,
    1260                 :          0 :                            field->size, !!field->is_signed);
    1261                 :            : 
    1262                 :            :         return 0;
    1263                 :            : }
    1264                 :            : 
    1265                 :          0 : static void *f_start(struct seq_file *m, loff_t *pos)
    1266                 :            : {
    1267                 :            :         void *p = (void *)FORMAT_HEADER;
    1268                 :          0 :         loff_t l = 0;
    1269                 :            : 
    1270                 :            :         /* ->stop() is called even if ->start() fails */
    1271                 :          0 :         mutex_lock(&event_mutex);
    1272                 :          0 :         if (!event_file_data(m->private))
    1273                 :            :                 return ERR_PTR(-ENODEV);
    1274                 :            : 
    1275                 :          0 :         while (l < *pos && p)
    1276                 :          0 :                 p = f_next(m, p, &l);
    1277                 :            : 
    1278                 :          0 :         return p;
    1279                 :            : }
    1280                 :            : 
    1281                 :          0 : static void f_stop(struct seq_file *m, void *p)
    1282                 :            : {
    1283                 :          0 :         mutex_unlock(&event_mutex);
    1284                 :          0 : }
    1285                 :            : 
    1286                 :            : static const struct seq_operations trace_format_seq_ops = {
    1287                 :            :         .start          = f_start,
    1288                 :            :         .next           = f_next,
    1289                 :            :         .stop           = f_stop,
    1290                 :            :         .show           = f_show,
    1291                 :            : };
    1292                 :            : 
    1293                 :          0 : static int trace_format_open(struct inode *inode, struct file *file)
    1294                 :            : {
    1295                 :            :         struct seq_file *m;
    1296                 :            :         int ret;
    1297                 :            : 
    1298                 :            :         /* Do we want to hide event format files on tracefs lockdown? */
    1299                 :            : 
    1300                 :          0 :         ret = seq_open(file, &trace_format_seq_ops);
    1301                 :          0 :         if (ret < 0)
    1302                 :            :                 return ret;
    1303                 :            : 
    1304                 :          0 :         m = file->private_data;
    1305                 :          0 :         m->private = file;
    1306                 :            : 
    1307                 :          0 :         return 0;
    1308                 :            : }
    1309                 :            : 
    1310                 :            : static ssize_t
    1311                 :          0 : event_id_read(struct file *filp, char __user *ubuf, size_t cnt, loff_t *ppos)
    1312                 :            : {
    1313                 :          0 :         int id = (long)event_file_data(filp);
    1314                 :            :         char buf[32];
    1315                 :            :         int len;
    1316                 :            : 
    1317                 :          0 :         if (unlikely(!id))
    1318                 :            :                 return -ENODEV;
    1319                 :            : 
    1320                 :          0 :         len = sprintf(buf, "%d\n", id);
    1321                 :            : 
    1322                 :          0 :         return simple_read_from_buffer(ubuf, cnt, ppos, buf, len);
    1323                 :            : }
    1324                 :            : 
    1325                 :            : static ssize_t
    1326                 :          0 : event_filter_read(struct file *filp, char __user *ubuf, size_t cnt,
    1327                 :            :                   loff_t *ppos)
    1328                 :            : {
    1329                 :            :         struct trace_event_file *file;
    1330                 :            :         struct trace_seq *s;
    1331                 :            :         int r = -ENODEV;
    1332                 :            : 
    1333                 :          0 :         if (*ppos)
    1334                 :            :                 return 0;
    1335                 :            : 
    1336                 :            :         s = kmalloc(sizeof(*s), GFP_KERNEL);
    1337                 :            : 
    1338                 :          0 :         if (!s)
    1339                 :            :                 return -ENOMEM;
    1340                 :            : 
    1341                 :            :         trace_seq_init(s);
    1342                 :            : 
    1343                 :          0 :         mutex_lock(&event_mutex);
    1344                 :            :         file = event_file_data(filp);
    1345                 :          0 :         if (file)
    1346                 :          0 :                 print_event_filter(file, s);
    1347                 :          0 :         mutex_unlock(&event_mutex);
    1348                 :            : 
    1349                 :          0 :         if (file)
    1350                 :          0 :                 r = simple_read_from_buffer(ubuf, cnt, ppos,
    1351                 :            :                                             s->buffer, trace_seq_used(s));
    1352                 :            : 
    1353                 :          0 :         kfree(s);
    1354                 :            : 
    1355                 :          0 :         return r;
    1356                 :            : }
    1357                 :            : 
    1358                 :            : static ssize_t
    1359                 :          0 : event_filter_write(struct file *filp, const char __user *ubuf, size_t cnt,
    1360                 :            :                    loff_t *ppos)
    1361                 :            : {
    1362                 :            :         struct trace_event_file *file;
    1363                 :            :         char *buf;
    1364                 :            :         int err = -ENODEV;
    1365                 :            : 
    1366                 :          0 :         if (cnt >= PAGE_SIZE)
    1367                 :            :                 return -EINVAL;
    1368                 :            : 
    1369                 :          0 :         buf = memdup_user_nul(ubuf, cnt);
    1370                 :          0 :         if (IS_ERR(buf))
    1371                 :          0 :                 return PTR_ERR(buf);
    1372                 :            : 
    1373                 :          0 :         mutex_lock(&event_mutex);
    1374                 :            :         file = event_file_data(filp);
    1375                 :          0 :         if (file)
    1376                 :          0 :                 err = apply_event_filter(file, buf);
    1377                 :          0 :         mutex_unlock(&event_mutex);
    1378                 :            : 
    1379                 :          0 :         kfree(buf);
    1380                 :          0 :         if (err < 0)
    1381                 :            :                 return err;
    1382                 :            : 
    1383                 :          0 :         *ppos += cnt;
    1384                 :            : 
    1385                 :          0 :         return cnt;
    1386                 :            : }
    1387                 :            : 
    1388                 :            : static LIST_HEAD(event_subsystems);
    1389                 :            : 
    1390                 :          0 : static int subsystem_open(struct inode *inode, struct file *filp)
    1391                 :            : {
    1392                 :            :         struct event_subsystem *system = NULL;
    1393                 :            :         struct trace_subsystem_dir *dir = NULL; /* Initialize for gcc */
    1394                 :            :         struct trace_array *tr;
    1395                 :            :         int ret;
    1396                 :            : 
    1397                 :          0 :         if (tracing_is_disabled())
    1398                 :            :                 return -ENODEV;
    1399                 :            : 
    1400                 :            :         /* Make sure the system still exists */
    1401                 :          0 :         mutex_lock(&event_mutex);
    1402                 :          0 :         mutex_lock(&trace_types_lock);
    1403                 :          0 :         list_for_each_entry(tr, &ftrace_trace_arrays, list) {
    1404                 :          0 :                 list_for_each_entry(dir, &tr->systems, list) {
    1405                 :          0 :                         if (dir == inode->i_private) {
    1406                 :            :                                 /* Don't open systems with no events */
    1407                 :          0 :                                 if (dir->nr_events) {
    1408                 :          0 :                                         __get_system_dir(dir);
    1409                 :          0 :                                         system = dir->subsystem;
    1410                 :            :                                 }
    1411                 :            :                                 goto exit_loop;
    1412                 :            :                         }
    1413                 :            :                 }
    1414                 :            :         }
    1415                 :            :  exit_loop:
    1416                 :          0 :         mutex_unlock(&trace_types_lock);
    1417                 :          0 :         mutex_unlock(&event_mutex);
    1418                 :            : 
    1419                 :          0 :         if (!system)
    1420                 :            :                 return -ENODEV;
    1421                 :            : 
    1422                 :            :         /* Some versions of gcc think dir can be uninitialized here */
    1423                 :          0 :         WARN_ON(!dir);
    1424                 :            : 
    1425                 :            :         /* Still need to increment the ref count of the system */
    1426                 :          0 :         if (trace_array_get(tr) < 0) {
    1427                 :          0 :                 put_system(dir);
    1428                 :          0 :                 return -ENODEV;
    1429                 :            :         }
    1430                 :            : 
    1431                 :          0 :         ret = tracing_open_generic(inode, filp);
    1432                 :          0 :         if (ret < 0) {
    1433                 :          0 :                 trace_array_put(tr);
    1434                 :          0 :                 put_system(dir);
    1435                 :            :         }
    1436                 :            : 
    1437                 :          0 :         return ret;
    1438                 :            : }
    1439                 :            : 
    1440                 :          0 : static int system_tr_open(struct inode *inode, struct file *filp)
    1441                 :            : {
    1442                 :            :         struct trace_subsystem_dir *dir;
    1443                 :          0 :         struct trace_array *tr = inode->i_private;
    1444                 :            :         int ret;
    1445                 :            : 
    1446                 :            :         /* Make a temporary dir that has no system but points to tr */
    1447                 :          0 :         dir = kzalloc(sizeof(*dir), GFP_KERNEL);
    1448                 :          0 :         if (!dir)
    1449                 :            :                 return -ENOMEM;
    1450                 :            : 
    1451                 :          0 :         ret = tracing_open_generic_tr(inode, filp);
    1452                 :          0 :         if (ret < 0) {
    1453                 :          0 :                 kfree(dir);
    1454                 :          0 :                 return ret;
    1455                 :            :         }
    1456                 :          0 :         dir->tr = tr;
    1457                 :          0 :         filp->private_data = dir;
    1458                 :            : 
    1459                 :          0 :         return 0;
    1460                 :            : }
    1461                 :            : 
    1462                 :          0 : static int subsystem_release(struct inode *inode, struct file *file)
    1463                 :            : {
    1464                 :          0 :         struct trace_subsystem_dir *dir = file->private_data;
    1465                 :            : 
    1466                 :          0 :         trace_array_put(dir->tr);
    1467                 :            : 
    1468                 :            :         /*
    1469                 :            :          * If dir->subsystem is NULL, then this is a temporary
    1470                 :            :          * descriptor that was made for a trace_array to enable
    1471                 :            :          * all subsystems.
    1472                 :            :          */
    1473                 :          0 :         if (dir->subsystem)
    1474                 :          0 :                 put_system(dir);
    1475                 :            :         else
    1476                 :          0 :                 kfree(dir);
    1477                 :            : 
    1478                 :          0 :         return 0;
    1479                 :            : }
    1480                 :            : 
    1481                 :            : static ssize_t
    1482                 :          0 : subsystem_filter_read(struct file *filp, char __user *ubuf, size_t cnt,
    1483                 :            :                       loff_t *ppos)
    1484                 :            : {
    1485                 :          0 :         struct trace_subsystem_dir *dir = filp->private_data;
    1486                 :          0 :         struct event_subsystem *system = dir->subsystem;
    1487                 :            :         struct trace_seq *s;
    1488                 :            :         int r;
    1489                 :            : 
    1490                 :          0 :         if (*ppos)
    1491                 :            :                 return 0;
    1492                 :            : 
    1493                 :            :         s = kmalloc(sizeof(*s), GFP_KERNEL);
    1494                 :          0 :         if (!s)
    1495                 :            :                 return -ENOMEM;
    1496                 :            : 
    1497                 :            :         trace_seq_init(s);
    1498                 :            : 
    1499                 :          0 :         print_subsystem_event_filter(system, s);
    1500                 :          0 :         r = simple_read_from_buffer(ubuf, cnt, ppos,
    1501                 :            :                                     s->buffer, trace_seq_used(s));
    1502                 :            : 
    1503                 :          0 :         kfree(s);
    1504                 :            : 
    1505                 :          0 :         return r;
    1506                 :            : }
    1507                 :            : 
    1508                 :            : static ssize_t
    1509                 :          0 : subsystem_filter_write(struct file *filp, const char __user *ubuf, size_t cnt,
    1510                 :            :                        loff_t *ppos)
    1511                 :            : {
    1512                 :          0 :         struct trace_subsystem_dir *dir = filp->private_data;
    1513                 :            :         char *buf;
    1514                 :            :         int err;
    1515                 :            : 
    1516                 :          0 :         if (cnt >= PAGE_SIZE)
    1517                 :            :                 return -EINVAL;
    1518                 :            : 
    1519                 :          0 :         buf = memdup_user_nul(ubuf, cnt);
    1520                 :          0 :         if (IS_ERR(buf))
    1521                 :          0 :                 return PTR_ERR(buf);
    1522                 :            : 
    1523                 :          0 :         err = apply_subsystem_event_filter(dir, buf);
    1524                 :          0 :         kfree(buf);
    1525                 :          0 :         if (err < 0)
    1526                 :            :                 return err;
    1527                 :            : 
    1528                 :          0 :         *ppos += cnt;
    1529                 :            : 
    1530                 :          0 :         return cnt;
    1531                 :            : }
    1532                 :            : 
    1533                 :            : static ssize_t
    1534                 :          0 : show_header(struct file *filp, char __user *ubuf, size_t cnt, loff_t *ppos)
    1535                 :            : {
    1536                 :          0 :         int (*func)(struct trace_seq *s) = filp->private_data;
    1537                 :            :         struct trace_seq *s;
    1538                 :            :         int r;
    1539                 :            : 
    1540                 :          0 :         if (*ppos)
    1541                 :            :                 return 0;
    1542                 :            : 
    1543                 :            :         s = kmalloc(sizeof(*s), GFP_KERNEL);
    1544                 :          0 :         if (!s)
    1545                 :            :                 return -ENOMEM;
    1546                 :            : 
    1547                 :            :         trace_seq_init(s);
    1548                 :            : 
    1549                 :          0 :         func(s);
    1550                 :          0 :         r = simple_read_from_buffer(ubuf, cnt, ppos,
    1551                 :            :                                     s->buffer, trace_seq_used(s));
    1552                 :            : 
    1553                 :          0 :         kfree(s);
    1554                 :            : 
    1555                 :          0 :         return r;
    1556                 :            : }
    1557                 :            : 
    1558                 :          0 : static void ignore_task_cpu(void *data)
    1559                 :            : {
    1560                 :            :         struct trace_array *tr = data;
    1561                 :            :         struct trace_pid_list *pid_list;
    1562                 :            : 
    1563                 :            :         /*
    1564                 :            :          * This function is called by on_each_cpu() while the
    1565                 :            :          * event_mutex is held.
    1566                 :            :          */
    1567                 :          0 :         pid_list = rcu_dereference_protected(tr->filtered_pids,
    1568                 :            :                                              mutex_is_locked(&event_mutex));
    1569                 :            : 
    1570                 :          0 :         this_cpu_write(tr->trace_buffer.data->ignore_pid,
    1571                 :            :                        trace_ignore_this_task(pid_list, current));
    1572                 :          0 : }
    1573                 :            : 
    1574                 :            : static ssize_t
    1575                 :          0 : ftrace_event_pid_write(struct file *filp, const char __user *ubuf,
    1576                 :            :                        size_t cnt, loff_t *ppos)
    1577                 :            : {
    1578                 :          0 :         struct seq_file *m = filp->private_data;
    1579                 :          0 :         struct trace_array *tr = m->private;
    1580                 :            :         struct trace_pid_list *filtered_pids = NULL;
    1581                 :            :         struct trace_pid_list *pid_list;
    1582                 :            :         struct trace_event_file *file;
    1583                 :            :         ssize_t ret;
    1584                 :            : 
    1585                 :          0 :         if (!cnt)
    1586                 :            :                 return 0;
    1587                 :            : 
    1588                 :          0 :         ret = tracing_update_buffers();
    1589                 :          0 :         if (ret < 0)
    1590                 :            :                 return ret;
    1591                 :            : 
    1592                 :          0 :         mutex_lock(&event_mutex);
    1593                 :            : 
    1594                 :          0 :         filtered_pids = rcu_dereference_protected(tr->filtered_pids,
    1595                 :            :                                              lockdep_is_held(&event_mutex));
    1596                 :            : 
    1597                 :          0 :         ret = trace_pid_write(filtered_pids, &pid_list, ubuf, cnt);
    1598                 :          0 :         if (ret < 0)
    1599                 :            :                 goto out;
    1600                 :            : 
    1601                 :          0 :         rcu_assign_pointer(tr->filtered_pids, pid_list);
    1602                 :            : 
    1603                 :          0 :         list_for_each_entry(file, &tr->events, list) {
    1604                 :          0 :                 set_bit(EVENT_FILE_FL_PID_FILTER_BIT, &file->flags);
    1605                 :            :         }
    1606                 :            : 
    1607                 :          0 :         if (filtered_pids) {
    1608                 :            :                 tracepoint_synchronize_unregister();
    1609                 :          0 :                 trace_free_pid_list(filtered_pids);
    1610                 :          0 :         } else if (pid_list) {
    1611                 :            :                 /*
    1612                 :            :                  * Register a probe that is called before all other probes
    1613                 :            :                  * to set ignore_pid if next or prev do not match.
    1614                 :            :                  * Register a probe this is called after all other probes
    1615                 :            :                  * to only keep ignore_pid set if next pid matches.
    1616                 :            :                  */
    1617                 :            :                 register_trace_prio_sched_switch(event_filter_pid_sched_switch_probe_pre,
    1618                 :            :                                                  tr, INT_MAX);
    1619                 :            :                 register_trace_prio_sched_switch(event_filter_pid_sched_switch_probe_post,
    1620                 :            :                                                  tr, 0);
    1621                 :            : 
    1622                 :            :                 register_trace_prio_sched_wakeup(event_filter_pid_sched_wakeup_probe_pre,
    1623                 :            :                                                  tr, INT_MAX);
    1624                 :            :                 register_trace_prio_sched_wakeup(event_filter_pid_sched_wakeup_probe_post,
    1625                 :            :                                                  tr, 0);
    1626                 :            : 
    1627                 :            :                 register_trace_prio_sched_wakeup_new(event_filter_pid_sched_wakeup_probe_pre,
    1628                 :            :                                                      tr, INT_MAX);
    1629                 :            :                 register_trace_prio_sched_wakeup_new(event_filter_pid_sched_wakeup_probe_post,
    1630                 :            :                                                      tr, 0);
    1631                 :            : 
    1632                 :            :                 register_trace_prio_sched_waking(event_filter_pid_sched_wakeup_probe_pre,
    1633                 :            :                                                  tr, INT_MAX);
    1634                 :            :                 register_trace_prio_sched_waking(event_filter_pid_sched_wakeup_probe_post,
    1635                 :            :                                                  tr, 0);
    1636                 :            :         }
    1637                 :            : 
    1638                 :            :         /*
    1639                 :            :          * Ignoring of pids is done at task switch. But we have to
    1640                 :            :          * check for those tasks that are currently running.
    1641                 :            :          * Always do this in case a pid was appended or removed.
    1642                 :            :          */
    1643                 :          0 :         on_each_cpu(ignore_task_cpu, tr, 1);
    1644                 :            : 
    1645                 :            :  out:
    1646                 :          0 :         mutex_unlock(&event_mutex);
    1647                 :            : 
    1648                 :          0 :         if (ret > 0)
    1649                 :          0 :                 *ppos += ret;
    1650                 :            : 
    1651                 :          0 :         return ret;
    1652                 :            : }
    1653                 :            : 
    1654                 :            : static int ftrace_event_avail_open(struct inode *inode, struct file *file);
    1655                 :            : static int ftrace_event_set_open(struct inode *inode, struct file *file);
    1656                 :            : static int ftrace_event_set_pid_open(struct inode *inode, struct file *file);
    1657                 :            : static int ftrace_event_release(struct inode *inode, struct file *file);
    1658                 :            : 
    1659                 :            : static const struct seq_operations show_event_seq_ops = {
    1660                 :            :         .start = t_start,
    1661                 :            :         .next = t_next,
    1662                 :            :         .show = t_show,
    1663                 :            :         .stop = t_stop,
    1664                 :            : };
    1665                 :            : 
    1666                 :            : static const struct seq_operations show_set_event_seq_ops = {
    1667                 :            :         .start = s_start,
    1668                 :            :         .next = s_next,
    1669                 :            :         .show = t_show,
    1670                 :            :         .stop = t_stop,
    1671                 :            : };
    1672                 :            : 
    1673                 :            : static const struct seq_operations show_set_pid_seq_ops = {
    1674                 :            :         .start = p_start,
    1675                 :            :         .next = p_next,
    1676                 :            :         .show = trace_pid_show,
    1677                 :            :         .stop = p_stop,
    1678                 :            : };
    1679                 :            : 
    1680                 :            : static const struct file_operations ftrace_avail_fops = {
    1681                 :            :         .open = ftrace_event_avail_open,
    1682                 :            :         .read = seq_read,
    1683                 :            :         .llseek = seq_lseek,
    1684                 :            :         .release = seq_release,
    1685                 :            : };
    1686                 :            : 
    1687                 :            : static const struct file_operations ftrace_set_event_fops = {
    1688                 :            :         .open = ftrace_event_set_open,
    1689                 :            :         .read = seq_read,
    1690                 :            :         .write = ftrace_event_write,
    1691                 :            :         .llseek = seq_lseek,
    1692                 :            :         .release = ftrace_event_release,
    1693                 :            : };
    1694                 :            : 
    1695                 :            : static const struct file_operations ftrace_set_event_pid_fops = {
    1696                 :            :         .open = ftrace_event_set_pid_open,
    1697                 :            :         .read = seq_read,
    1698                 :            :         .write = ftrace_event_pid_write,
    1699                 :            :         .llseek = seq_lseek,
    1700                 :            :         .release = ftrace_event_release,
    1701                 :            : };
    1702                 :            : 
    1703                 :            : static const struct file_operations ftrace_enable_fops = {
    1704                 :            :         .open = tracing_open_generic,
    1705                 :            :         .read = event_enable_read,
    1706                 :            :         .write = event_enable_write,
    1707                 :            :         .llseek = default_llseek,
    1708                 :            : };
    1709                 :            : 
    1710                 :            : static const struct file_operations ftrace_event_format_fops = {
    1711                 :            :         .open = trace_format_open,
    1712                 :            :         .read = seq_read,
    1713                 :            :         .llseek = seq_lseek,
    1714                 :            :         .release = seq_release,
    1715                 :            : };
    1716                 :            : 
    1717                 :            : static const struct file_operations ftrace_event_id_fops = {
    1718                 :            :         .read = event_id_read,
    1719                 :            :         .llseek = default_llseek,
    1720                 :            : };
    1721                 :            : 
    1722                 :            : static const struct file_operations ftrace_event_filter_fops = {
    1723                 :            :         .open = tracing_open_generic,
    1724                 :            :         .read = event_filter_read,
    1725                 :            :         .write = event_filter_write,
    1726                 :            :         .llseek = default_llseek,
    1727                 :            : };
    1728                 :            : 
    1729                 :            : static const struct file_operations ftrace_subsystem_filter_fops = {
    1730                 :            :         .open = subsystem_open,
    1731                 :            :         .read = subsystem_filter_read,
    1732                 :            :         .write = subsystem_filter_write,
    1733                 :            :         .llseek = default_llseek,
    1734                 :            :         .release = subsystem_release,
    1735                 :            : };
    1736                 :            : 
    1737                 :            : static const struct file_operations ftrace_system_enable_fops = {
    1738                 :            :         .open = subsystem_open,
    1739                 :            :         .read = system_enable_read,
    1740                 :            :         .write = system_enable_write,
    1741                 :            :         .llseek = default_llseek,
    1742                 :            :         .release = subsystem_release,
    1743                 :            : };
    1744                 :            : 
    1745                 :            : static const struct file_operations ftrace_tr_enable_fops = {
    1746                 :            :         .open = system_tr_open,
    1747                 :            :         .read = system_enable_read,
    1748                 :            :         .write = system_enable_write,
    1749                 :            :         .llseek = default_llseek,
    1750                 :            :         .release = subsystem_release,
    1751                 :            : };
    1752                 :            : 
    1753                 :            : static const struct file_operations ftrace_show_header_fops = {
    1754                 :            :         .open = tracing_open_generic,
    1755                 :            :         .read = show_header,
    1756                 :            :         .llseek = default_llseek,
    1757                 :            : };
    1758                 :            : 
    1759                 :            : static int
    1760                 :          0 : ftrace_event_open(struct inode *inode, struct file *file,
    1761                 :            :                   const struct seq_operations *seq_ops)
    1762                 :            : {
    1763                 :            :         struct seq_file *m;
    1764                 :            :         int ret;
    1765                 :            : 
    1766                 :          0 :         ret = security_locked_down(LOCKDOWN_TRACEFS);
    1767                 :          0 :         if (ret)
    1768                 :            :                 return ret;
    1769                 :            : 
    1770                 :          0 :         ret = seq_open(file, seq_ops);
    1771                 :          0 :         if (ret < 0)
    1772                 :            :                 return ret;
    1773                 :          0 :         m = file->private_data;
    1774                 :            :         /* copy tr over to seq ops */
    1775                 :          0 :         m->private = inode->i_private;
    1776                 :            : 
    1777                 :          0 :         return ret;
    1778                 :            : }
    1779                 :            : 
    1780                 :          0 : static int ftrace_event_release(struct inode *inode, struct file *file)
    1781                 :            : {
    1782                 :          0 :         struct trace_array *tr = inode->i_private;
    1783                 :            : 
    1784                 :          0 :         trace_array_put(tr);
    1785                 :            : 
    1786                 :          0 :         return seq_release(inode, file);
    1787                 :            : }
    1788                 :            : 
    1789                 :            : static int
    1790                 :          0 : ftrace_event_avail_open(struct inode *inode, struct file *file)
    1791                 :            : {
    1792                 :            :         const struct seq_operations *seq_ops = &show_event_seq_ops;
    1793                 :            : 
    1794                 :            :         /* Checks for tracefs lockdown */
    1795                 :          0 :         return ftrace_event_open(inode, file, seq_ops);
    1796                 :            : }
    1797                 :            : 
    1798                 :            : static int
    1799                 :          0 : ftrace_event_set_open(struct inode *inode, struct file *file)
    1800                 :            : {
    1801                 :            :         const struct seq_operations *seq_ops = &show_set_event_seq_ops;
    1802                 :          0 :         struct trace_array *tr = inode->i_private;
    1803                 :            :         int ret;
    1804                 :            : 
    1805                 :          0 :         ret = tracing_check_open_get_tr(tr);
    1806                 :          0 :         if (ret)
    1807                 :            :                 return ret;
    1808                 :            : 
    1809                 :          0 :         if ((file->f_mode & FMODE_WRITE) &&
    1810                 :          0 :             (file->f_flags & O_TRUNC))
    1811                 :          0 :                 ftrace_clear_events(tr);
    1812                 :            : 
    1813                 :          0 :         ret = ftrace_event_open(inode, file, seq_ops);
    1814                 :          0 :         if (ret < 0)
    1815                 :          0 :                 trace_array_put(tr);
    1816                 :          0 :         return ret;
    1817                 :            : }
    1818                 :            : 
    1819                 :            : static int
    1820                 :          0 : ftrace_event_set_pid_open(struct inode *inode, struct file *file)
    1821                 :            : {
    1822                 :            :         const struct seq_operations *seq_ops = &show_set_pid_seq_ops;
    1823                 :          0 :         struct trace_array *tr = inode->i_private;
    1824                 :            :         int ret;
    1825                 :            : 
    1826                 :          0 :         ret = tracing_check_open_get_tr(tr);
    1827                 :          0 :         if (ret)
    1828                 :            :                 return ret;
    1829                 :            : 
    1830                 :          0 :         if ((file->f_mode & FMODE_WRITE) &&
    1831                 :          0 :             (file->f_flags & O_TRUNC))
    1832                 :          0 :                 ftrace_clear_event_pids(tr);
    1833                 :            : 
    1834                 :          0 :         ret = ftrace_event_open(inode, file, seq_ops);
    1835                 :          0 :         if (ret < 0)
    1836                 :          0 :                 trace_array_put(tr);
    1837                 :          0 :         return ret;
    1838                 :            : }
    1839                 :            : 
    1840                 :            : static struct event_subsystem *
    1841                 :          3 : create_new_subsystem(const char *name)
    1842                 :            : {
    1843                 :            :         struct event_subsystem *system;
    1844                 :            : 
    1845                 :            :         /* need to create new entry */
    1846                 :            :         system = kmalloc(sizeof(*system), GFP_KERNEL);
    1847                 :          3 :         if (!system)
    1848                 :            :                 return NULL;
    1849                 :            : 
    1850                 :          3 :         system->ref_count = 1;
    1851                 :            : 
    1852                 :            :         /* Only allocate if dynamic (kprobes and modules) */
    1853                 :          3 :         system->name = kstrdup_const(name, GFP_KERNEL);
    1854                 :          3 :         if (!system->name)
    1855                 :            :                 goto out_free;
    1856                 :            : 
    1857                 :          3 :         system->filter = NULL;
    1858                 :            : 
    1859                 :          3 :         system->filter = kzalloc(sizeof(struct event_filter), GFP_KERNEL);
    1860                 :          3 :         if (!system->filter)
    1861                 :            :                 goto out_free;
    1862                 :            : 
    1863                 :          3 :         list_add(&system->list, &event_subsystems);
    1864                 :            : 
    1865                 :          3 :         return system;
    1866                 :            : 
    1867                 :            :  out_free:
    1868                 :          0 :         kfree_const(system->name);
    1869                 :          0 :         kfree(system);
    1870                 :          0 :         return NULL;
    1871                 :            : }
    1872                 :            : 
    1873                 :            : static struct dentry *
    1874                 :          3 : event_subsystem_dir(struct trace_array *tr, const char *name,
    1875                 :            :                     struct trace_event_file *file, struct dentry *parent)
    1876                 :            : {
    1877                 :            :         struct trace_subsystem_dir *dir;
    1878                 :            :         struct event_subsystem *system;
    1879                 :            :         struct dentry *entry;
    1880                 :            : 
    1881                 :            :         /* First see if we did not already create this dir */
    1882                 :          3 :         list_for_each_entry(dir, &tr->systems, list) {
    1883                 :          3 :                 system = dir->subsystem;
    1884                 :          3 :                 if (strcmp(system->name, name) == 0) {
    1885                 :          3 :                         dir->nr_events++;
    1886                 :          3 :                         file->system = dir;
    1887                 :          3 :                         return dir->entry;
    1888                 :            :                 }
    1889                 :            :         }
    1890                 :            : 
    1891                 :            :         /* Now see if the system itself exists. */
    1892                 :          3 :         list_for_each_entry(system, &event_subsystems, list) {
    1893                 :          3 :                 if (strcmp(system->name, name) == 0)
    1894                 :            :                         break;
    1895                 :            :         }
    1896                 :            :         /* Reset system variable when not found */
    1897                 :          3 :         if (&system->list == &event_subsystems)
    1898                 :            :                 system = NULL;
    1899                 :            : 
    1900                 :            :         dir = kmalloc(sizeof(*dir), GFP_KERNEL);
    1901                 :          3 :         if (!dir)
    1902                 :            :                 goto out_fail;
    1903                 :            : 
    1904                 :          3 :         if (!system) {
    1905                 :          3 :                 system = create_new_subsystem(name);
    1906                 :          3 :                 if (!system)
    1907                 :            :                         goto out_free;
    1908                 :            :         } else
    1909                 :          0 :                 __get_system(system);
    1910                 :            : 
    1911                 :          3 :         dir->entry = tracefs_create_dir(name, parent);
    1912                 :          3 :         if (!dir->entry) {
    1913                 :          0 :                 pr_warn("Failed to create system directory %s\n", name);
    1914                 :          0 :                 __put_system(system);
    1915                 :          0 :                 goto out_free;
    1916                 :            :         }
    1917                 :            : 
    1918                 :          3 :         dir->tr = tr;
    1919                 :          3 :         dir->ref_count = 1;
    1920                 :          3 :         dir->nr_events = 1;
    1921                 :          3 :         dir->subsystem = system;
    1922                 :          3 :         file->system = dir;
    1923                 :            : 
    1924                 :          3 :         entry = tracefs_create_file("filter", 0644, dir->entry, dir,
    1925                 :            :                                     &ftrace_subsystem_filter_fops);
    1926                 :          3 :         if (!entry) {
    1927                 :          0 :                 kfree(system->filter);
    1928                 :          0 :                 system->filter = NULL;
    1929                 :          0 :                 pr_warn("Could not create tracefs '%s/filter' entry\n", name);
    1930                 :            :         }
    1931                 :            : 
    1932                 :          3 :         trace_create_file("enable", 0644, dir->entry, dir,
    1933                 :            :                           &ftrace_system_enable_fops);
    1934                 :            : 
    1935                 :          3 :         list_add(&dir->list, &tr->systems);
    1936                 :            : 
    1937                 :          3 :         return dir->entry;
    1938                 :            : 
    1939                 :            :  out_free:
    1940                 :          0 :         kfree(dir);
    1941                 :            :  out_fail:
    1942                 :            :         /* Only print this message if failed on memory allocation */
    1943                 :          0 :         if (!dir || !system)
    1944                 :          0 :                 pr_warn("No memory to create event subsystem %s\n", name);
    1945                 :            :         return NULL;
    1946                 :            : }
    1947                 :            : 
    1948                 :            : static int
    1949                 :          3 : event_create_dir(struct dentry *parent, struct trace_event_file *file)
    1950                 :            : {
    1951                 :          3 :         struct trace_event_call *call = file->event_call;
    1952                 :          3 :         struct trace_array *tr = file->tr;
    1953                 :            :         struct list_head *head;
    1954                 :            :         struct dentry *d_events;
    1955                 :            :         const char *name;
    1956                 :            :         int ret;
    1957                 :            : 
    1958                 :            :         /*
    1959                 :            :          * If the trace point header did not define TRACE_SYSTEM
    1960                 :            :          * then the system would be called "TRACE_SYSTEM".
    1961                 :            :          */
    1962                 :          3 :         if (strcmp(call->class->system, TRACE_SYSTEM) != 0) {
    1963                 :          3 :                 d_events = event_subsystem_dir(tr, call->class->system, file, parent);
    1964                 :          3 :                 if (!d_events)
    1965                 :            :                         return -ENOMEM;
    1966                 :            :         } else
    1967                 :            :                 d_events = parent;
    1968                 :            : 
    1969                 :            :         name = trace_event_name(call);
    1970                 :          3 :         file->dir = tracefs_create_dir(name, d_events);
    1971                 :          3 :         if (!file->dir) {
    1972                 :          0 :                 pr_warn("Could not create tracefs '%s' directory\n", name);
    1973                 :          0 :                 return -1;
    1974                 :            :         }
    1975                 :            : 
    1976                 :          3 :         if (call->class->reg && !(call->flags & TRACE_EVENT_FL_IGNORE_ENABLE))
    1977                 :          3 :                 trace_create_file("enable", 0644, file->dir, file,
    1978                 :            :                                   &ftrace_enable_fops);
    1979                 :            : 
    1980                 :            : #ifdef CONFIG_PERF_EVENTS
    1981                 :          3 :         if (call->event.type && call->class->reg)
    1982                 :          3 :                 trace_create_file("id", 0444, file->dir,
    1983                 :            :                                   (void *)(long)call->event.type,
    1984                 :            :                                   &ftrace_event_id_fops);
    1985                 :            : #endif
    1986                 :            : 
    1987                 :            :         /*
    1988                 :            :          * Other events may have the same class. Only update
    1989                 :            :          * the fields if they are not already defined.
    1990                 :            :          */
    1991                 :            :         head = trace_get_fields(call);
    1992                 :          3 :         if (list_empty(head)) {
    1993                 :          3 :                 ret = call->class->define_fields(call);
    1994                 :          3 :                 if (ret < 0) {
    1995                 :          0 :                         pr_warn("Could not initialize trace point events/%s\n",
    1996                 :            :                                 name);
    1997                 :          0 :                         return -1;
    1998                 :            :                 }
    1999                 :            :         }
    2000                 :            : 
    2001                 :            :         /*
    2002                 :            :          * Only event directories that can be enabled should have
    2003                 :            :          * triggers or filters.
    2004                 :            :          */
    2005                 :          3 :         if (!(call->flags & TRACE_EVENT_FL_IGNORE_ENABLE)) {
    2006                 :          3 :                 trace_create_file("filter", 0644, file->dir, file,
    2007                 :            :                                   &ftrace_event_filter_fops);
    2008                 :            : 
    2009                 :          3 :                 trace_create_file("trigger", 0644, file->dir, file,
    2010                 :            :                                   &event_trigger_fops);
    2011                 :            :         }
    2012                 :            : 
    2013                 :            : #ifdef CONFIG_HIST_TRIGGERS
    2014                 :            :         trace_create_file("hist", 0444, file->dir, file,
    2015                 :            :                           &event_hist_fops);
    2016                 :            : #endif
    2017                 :          3 :         trace_create_file("format", 0444, file->dir, call,
    2018                 :            :                           &ftrace_event_format_fops);
    2019                 :            : 
    2020                 :          3 :         return 0;
    2021                 :            : }
    2022                 :            : 
    2023                 :          0 : static void remove_event_from_tracers(struct trace_event_call *call)
    2024                 :            : {
    2025                 :            :         struct trace_event_file *file;
    2026                 :            :         struct trace_array *tr;
    2027                 :            : 
    2028                 :          0 :         do_for_each_event_file_safe(tr, file) {
    2029                 :          0 :                 if (file->event_call != call)
    2030                 :          0 :                         continue;
    2031                 :            : 
    2032                 :          0 :                 remove_event_file_dir(file);
    2033                 :            :                 /*
    2034                 :            :                  * The do_for_each_event_file_safe() is
    2035                 :            :                  * a double loop. After finding the call for this
    2036                 :            :                  * trace_array, we use break to jump to the next
    2037                 :            :                  * trace_array.
    2038                 :            :                  */
    2039                 :          0 :                 break;
    2040                 :            :         } while_for_each_event_file();
    2041                 :          0 : }
    2042                 :            : 
    2043                 :          0 : static void event_remove(struct trace_event_call *call)
    2044                 :            : {
    2045                 :            :         struct trace_array *tr;
    2046                 :            :         struct trace_event_file *file;
    2047                 :            : 
    2048                 :          0 :         do_for_each_event_file(tr, file) {
    2049                 :          0 :                 if (file->event_call != call)
    2050                 :          0 :                         continue;
    2051                 :            : 
    2052                 :          0 :                 if (file->flags & EVENT_FILE_FL_WAS_ENABLED)
    2053                 :          0 :                         tr->clear_trace = true;
    2054                 :            : 
    2055                 :            :                 ftrace_event_enable_disable(file, 0);
    2056                 :            :                 /*
    2057                 :            :                  * The do_for_each_event_file() is
    2058                 :            :                  * a double loop. After finding the call for this
    2059                 :            :                  * trace_array, we use break to jump to the next
    2060                 :            :                  * trace_array.
    2061                 :            :                  */
    2062                 :            :                 break;
    2063                 :            :         } while_for_each_event_file();
    2064                 :            : 
    2065                 :          0 :         if (call->event.funcs)
    2066                 :          0 :                 __unregister_trace_event(&call->event);
    2067                 :          0 :         remove_event_from_tracers(call);
    2068                 :            :         list_del(&call->list);
    2069                 :          0 : }
    2070                 :            : 
    2071                 :          3 : static int event_init(struct trace_event_call *call)
    2072                 :            : {
    2073                 :            :         int ret = 0;
    2074                 :            :         const char *name;
    2075                 :            : 
    2076                 :            :         name = trace_event_name(call);
    2077                 :          3 :         if (WARN_ON(!name))
    2078                 :            :                 return -EINVAL;
    2079                 :            : 
    2080                 :          3 :         if (call->class->raw_init) {
    2081                 :          3 :                 ret = call->class->raw_init(call);
    2082                 :          3 :                 if (ret < 0 && ret != -ENOSYS)
    2083                 :          0 :                         pr_warn("Could not initialize trace events/%s\n", name);
    2084                 :            :         }
    2085                 :            : 
    2086                 :          3 :         return ret;
    2087                 :            : }
    2088                 :            : 
    2089                 :            : static int
    2090                 :          3 : __register_event(struct trace_event_call *call, struct module *mod)
    2091                 :            : {
    2092                 :            :         int ret;
    2093                 :            : 
    2094                 :          3 :         ret = event_init(call);
    2095                 :          3 :         if (ret < 0)
    2096                 :            :                 return ret;
    2097                 :            : 
    2098                 :          3 :         list_add(&call->list, &ftrace_events);
    2099                 :          3 :         call->mod = mod;
    2100                 :            : 
    2101                 :          3 :         return 0;
    2102                 :            : }
    2103                 :            : 
    2104                 :          3 : static char *eval_replace(char *ptr, struct trace_eval_map *map, int len)
    2105                 :            : {
    2106                 :            :         int rlen;
    2107                 :            :         int elen;
    2108                 :            : 
    2109                 :            :         /* Find the length of the eval value as a string */
    2110                 :          3 :         elen = snprintf(ptr, 0, "%ld", map->eval_value);
    2111                 :            :         /* Make sure there's enough room to replace the string with the value */
    2112                 :          3 :         if (len < elen)
    2113                 :            :                 return NULL;
    2114                 :            : 
    2115                 :          3 :         snprintf(ptr, elen + 1, "%ld", map->eval_value);
    2116                 :            : 
    2117                 :            :         /* Get the rest of the string of ptr */
    2118                 :          3 :         rlen = strlen(ptr + len);
    2119                 :          3 :         memmove(ptr + elen, ptr + len, rlen);
    2120                 :            :         /* Make sure we end the new string */
    2121                 :          3 :         ptr[elen + rlen] = 0;
    2122                 :            : 
    2123                 :          3 :         return ptr + elen;
    2124                 :            : }
    2125                 :            : 
    2126                 :          3 : static void update_event_printk(struct trace_event_call *call,
    2127                 :            :                                 struct trace_eval_map *map)
    2128                 :            : {
    2129                 :            :         char *ptr;
    2130                 :            :         int quote = 0;
    2131                 :          3 :         int len = strlen(map->eval_string);
    2132                 :            : 
    2133                 :          3 :         for (ptr = call->print_fmt; *ptr; ptr++) {
    2134                 :          3 :                 if (*ptr == '\\') {
    2135                 :          0 :                         ptr++;
    2136                 :            :                         /* paranoid */
    2137                 :          0 :                         if (!*ptr)
    2138                 :            :                                 break;
    2139                 :          0 :                         continue;
    2140                 :            :                 }
    2141                 :          3 :                 if (*ptr == '"') {
    2142                 :          3 :                         quote ^= 1;
    2143                 :          3 :                         continue;
    2144                 :            :                 }
    2145                 :          3 :                 if (quote)
    2146                 :          3 :                         continue;
    2147                 :          3 :                 if (isdigit(*ptr)) {
    2148                 :            :                         /* skip numbers */
    2149                 :            :                         do {
    2150                 :          3 :                                 ptr++;
    2151                 :            :                                 /* Check for alpha chars like ULL */
    2152                 :          3 :                         } while (isalnum(*ptr));
    2153                 :          3 :                         if (!*ptr)
    2154                 :            :                                 break;
    2155                 :            :                         /*
    2156                 :            :                          * A number must have some kind of delimiter after
    2157                 :            :                          * it, and we can ignore that too.
    2158                 :            :                          */
    2159                 :          3 :                         continue;
    2160                 :            :                 }
    2161                 :          3 :                 if (isalpha(*ptr) || *ptr == '_') {
    2162                 :          3 :                         if (strncmp(map->eval_string, ptr, len) == 0 &&
    2163                 :          3 :                             !isalnum(ptr[len]) && ptr[len] != '_') {
    2164                 :          3 :                                 ptr = eval_replace(ptr, map, len);
    2165                 :            :                                 /* enum/sizeof string smaller than value */
    2166                 :          3 :                                 if (WARN_ON_ONCE(!ptr))
    2167                 :          3 :                                         return;
    2168                 :            :                                 /*
    2169                 :            :                                  * No need to decrement here, as eval_replace()
    2170                 :            :                                  * returns the pointer to the character passed
    2171                 :            :                                  * the eval, and two evals can not be placed
    2172                 :            :                                  * back to back without something in between.
    2173                 :            :                                  * We can skip that something in between.
    2174                 :            :                                  */
    2175                 :          3 :                                 continue;
    2176                 :            :                         }
    2177                 :            :                 skip_more:
    2178                 :            :                         do {
    2179                 :          3 :                                 ptr++;
    2180                 :          3 :                         } while (isalnum(*ptr) || *ptr == '_');
    2181                 :          3 :                         if (!*ptr)
    2182                 :            :                                 break;
    2183                 :            :                         /*
    2184                 :            :                          * If what comes after this variable is a '.' or
    2185                 :            :                          * '->' then we can continue to ignore that string.
    2186                 :            :                          */
    2187                 :          3 :                         if (*ptr == '.' || (ptr[0] == '-' && ptr[1] == '>')) {
    2188                 :          3 :                                 ptr += *ptr == '.' ? 1 : 2;
    2189                 :          3 :                                 if (!*ptr)
    2190                 :            :                                         break;
    2191                 :            :                                 goto skip_more;
    2192                 :            :                         }
    2193                 :            :                         /*
    2194                 :            :                          * Once again, we can skip the delimiter that came
    2195                 :            :                          * after the string.
    2196                 :            :                          */
    2197                 :          3 :                         continue;
    2198                 :            :                 }
    2199                 :            :         }
    2200                 :            : }
    2201                 :            : 
    2202                 :          3 : void trace_event_eval_update(struct trace_eval_map **map, int len)
    2203                 :            : {
    2204                 :            :         struct trace_event_call *call, *p;
    2205                 :            :         const char *last_system = NULL;
    2206                 :            :         bool first = false;
    2207                 :            :         int last_i;
    2208                 :            :         int i;
    2209                 :            : 
    2210                 :          3 :         down_write(&trace_event_sem);
    2211                 :          3 :         list_for_each_entry_safe(call, p, &ftrace_events, list) {
    2212                 :            :                 /* events are usually grouped together with systems */
    2213                 :          3 :                 if (!last_system || call->class->system != last_system) {
    2214                 :            :                         first = true;
    2215                 :            :                         last_i = 0;
    2216                 :          3 :                         last_system = call->class->system;
    2217                 :            :                 }
    2218                 :            : 
    2219                 :            :                 /*
    2220                 :            :                  * Since calls are grouped by systems, the likelyhood that the
    2221                 :            :                  * next call in the iteration belongs to the same system as the
    2222                 :            :                  * previous call is high. As an optimization, we skip seaching
    2223                 :            :                  * for a map[] that matches the call's system if the last call
    2224                 :            :                  * was from the same system. That's what last_i is for. If the
    2225                 :            :                  * call has the same system as the previous call, then last_i
    2226                 :            :                  * will be the index of the first map[] that has a matching
    2227                 :            :                  * system.
    2228                 :            :                  */
    2229                 :          3 :                 for (i = last_i; i < len; i++) {
    2230                 :          3 :                         if (call->class->system == map[i]->system) {
    2231                 :            :                                 /* Save the first system if need be */
    2232                 :          3 :                                 if (first) {
    2233                 :            :                                         last_i = i;
    2234                 :            :                                         first = false;
    2235                 :            :                                 }
    2236                 :          3 :                                 update_event_printk(call, map[i]);
    2237                 :            :                         }
    2238                 :            :                 }
    2239                 :            :         }
    2240                 :          3 :         up_write(&trace_event_sem);
    2241                 :          3 : }
    2242                 :            : 
    2243                 :            : static struct trace_event_file *
    2244                 :          3 : trace_create_new_event(struct trace_event_call *call,
    2245                 :            :                        struct trace_array *tr)
    2246                 :            : {
    2247                 :            :         struct trace_event_file *file;
    2248                 :            : 
    2249                 :          3 :         file = kmem_cache_alloc(file_cachep, GFP_TRACE);
    2250                 :          3 :         if (!file)
    2251                 :            :                 return NULL;
    2252                 :            : 
    2253                 :          3 :         file->event_call = call;
    2254                 :          3 :         file->tr = tr;
    2255                 :            :         atomic_set(&file->sm_ref, 0);
    2256                 :            :         atomic_set(&file->tm_ref, 0);
    2257                 :          3 :         INIT_LIST_HEAD(&file->triggers);
    2258                 :          3 :         list_add(&file->list, &tr->events);
    2259                 :            : 
    2260                 :          3 :         return file;
    2261                 :            : }
    2262                 :            : 
    2263                 :            : /* Add an event to a trace directory */
    2264                 :            : static int
    2265                 :          3 : __trace_add_new_event(struct trace_event_call *call, struct trace_array *tr)
    2266                 :            : {
    2267                 :            :         struct trace_event_file *file;
    2268                 :            : 
    2269                 :          3 :         file = trace_create_new_event(call, tr);
    2270                 :          3 :         if (!file)
    2271                 :            :                 return -ENOMEM;
    2272                 :            : 
    2273                 :          3 :         return event_create_dir(tr->event_dir, file);
    2274                 :            : }
    2275                 :            : 
    2276                 :            : /*
    2277                 :            :  * Just create a decriptor for early init. A descriptor is required
    2278                 :            :  * for enabling events at boot. We want to enable events before
    2279                 :            :  * the filesystem is initialized.
    2280                 :            :  */
    2281                 :            : static __init int
    2282                 :          3 : __trace_early_add_new_event(struct trace_event_call *call,
    2283                 :            :                             struct trace_array *tr)
    2284                 :            : {
    2285                 :            :         struct trace_event_file *file;
    2286                 :            : 
    2287                 :          3 :         file = trace_create_new_event(call, tr);
    2288                 :          3 :         if (!file)
    2289                 :            :                 return -ENOMEM;
    2290                 :            : 
    2291                 :          3 :         return 0;
    2292                 :            : }
    2293                 :            : 
    2294                 :            : struct ftrace_module_file_ops;
    2295                 :            : static void __add_event_to_tracers(struct trace_event_call *call);
    2296                 :            : 
    2297                 :            : /* Add an additional event_call dynamically */
    2298                 :          0 : int trace_add_event_call(struct trace_event_call *call)
    2299                 :            : {
    2300                 :            :         int ret;
    2301                 :            :         lockdep_assert_held(&event_mutex);
    2302                 :            : 
    2303                 :          0 :         mutex_lock(&trace_types_lock);
    2304                 :            : 
    2305                 :          0 :         ret = __register_event(call, NULL);
    2306                 :          0 :         if (ret >= 0)
    2307                 :            :                 __add_event_to_tracers(call);
    2308                 :            : 
    2309                 :          0 :         mutex_unlock(&trace_types_lock);
    2310                 :          0 :         return ret;
    2311                 :            : }
    2312                 :            : 
    2313                 :            : /*
    2314                 :            :  * Must be called under locking of trace_types_lock, event_mutex and
    2315                 :            :  * trace_event_sem.
    2316                 :            :  */
    2317                 :          0 : static void __trace_remove_event_call(struct trace_event_call *call)
    2318                 :            : {
    2319                 :          0 :         event_remove(call);
    2320                 :          0 :         trace_destroy_fields(call);
    2321                 :          0 :         free_event_filter(call->filter);
    2322                 :          0 :         call->filter = NULL;
    2323                 :          0 : }
    2324                 :            : 
    2325                 :          0 : static int probe_remove_event_call(struct trace_event_call *call)
    2326                 :            : {
    2327                 :            :         struct trace_array *tr;
    2328                 :            :         struct trace_event_file *file;
    2329                 :            : 
    2330                 :            : #ifdef CONFIG_PERF_EVENTS
    2331                 :          0 :         if (call->perf_refcount)
    2332                 :            :                 return -EBUSY;
    2333                 :            : #endif
    2334                 :          0 :         do_for_each_event_file(tr, file) {
    2335                 :          0 :                 if (file->event_call != call)
    2336                 :          0 :                         continue;
    2337                 :            :                 /*
    2338                 :            :                  * We can't rely on ftrace_event_enable_disable(enable => 0)
    2339                 :            :                  * we are going to do, EVENT_FILE_FL_SOFT_MODE can suppress
    2340                 :            :                  * TRACE_REG_UNREGISTER.
    2341                 :            :                  */
    2342                 :          0 :                 if (file->flags & EVENT_FILE_FL_ENABLED)
    2343                 :            :                         return -EBUSY;
    2344                 :            :                 /*
    2345                 :            :                  * The do_for_each_event_file_safe() is
    2346                 :            :                  * a double loop. After finding the call for this
    2347                 :            :                  * trace_array, we use break to jump to the next
    2348                 :            :                  * trace_array.
    2349                 :            :                  */
    2350                 :            :                 break;
    2351                 :            :         } while_for_each_event_file();
    2352                 :            : 
    2353                 :          0 :         __trace_remove_event_call(call);
    2354                 :            : 
    2355                 :          0 :         return 0;
    2356                 :            : }
    2357                 :            : 
    2358                 :            : /* Remove an event_call */
    2359                 :          0 : int trace_remove_event_call(struct trace_event_call *call)
    2360                 :            : {
    2361                 :            :         int ret;
    2362                 :            : 
    2363                 :            :         lockdep_assert_held(&event_mutex);
    2364                 :            : 
    2365                 :          0 :         mutex_lock(&trace_types_lock);
    2366                 :          0 :         down_write(&trace_event_sem);
    2367                 :          0 :         ret = probe_remove_event_call(call);
    2368                 :          0 :         up_write(&trace_event_sem);
    2369                 :          0 :         mutex_unlock(&trace_types_lock);
    2370                 :            : 
    2371                 :          0 :         return ret;
    2372                 :            : }
    2373                 :            : 
    2374                 :            : #define for_each_event(event, start, end)                       \
    2375                 :            :         for (event = start;                                     \
    2376                 :            :              (unsigned long)event < (unsigned long)end;              \
    2377                 :            :              event++)
    2378                 :            : 
    2379                 :            : #ifdef CONFIG_MODULES
    2380                 :            : 
    2381                 :          3 : static void trace_module_add_events(struct module *mod)
    2382                 :            : {
    2383                 :            :         struct trace_event_call **call, **start, **end;
    2384                 :            : 
    2385                 :          3 :         if (!mod->num_trace_events)
    2386                 :            :                 return;
    2387                 :            : 
    2388                 :            :         /* Don't add infrastructure for mods without tracepoints */
    2389                 :          3 :         if (trace_module_has_bad_taint(mod)) {
    2390                 :          0 :                 pr_err("%s: module has bad taint, not creating trace events\n",
    2391                 :            :                        mod->name);
    2392                 :          0 :                 return;
    2393                 :            :         }
    2394                 :            : 
    2395                 :          3 :         start = mod->trace_events;
    2396                 :          3 :         end = mod->trace_events + mod->num_trace_events;
    2397                 :            : 
    2398                 :          3 :         for_each_event(call, start, end) {
    2399                 :          3 :                 __register_event(*call, mod);
    2400                 :          3 :                 __add_event_to_tracers(*call);
    2401                 :            :         }
    2402                 :            : }
    2403                 :            : 
    2404                 :          0 : static void trace_module_remove_events(struct module *mod)
    2405                 :            : {
    2406                 :            :         struct trace_event_call *call, *p;
    2407                 :            : 
    2408                 :          0 :         down_write(&trace_event_sem);
    2409                 :          0 :         list_for_each_entry_safe(call, p, &ftrace_events, list) {
    2410                 :          0 :                 if (call->mod == mod)
    2411                 :          0 :                         __trace_remove_event_call(call);
    2412                 :            :         }
    2413                 :          0 :         up_write(&trace_event_sem);
    2414                 :            : 
    2415                 :            :         /*
    2416                 :            :          * It is safest to reset the ring buffer if the module being unloaded
    2417                 :            :          * registered any events that were used. The only worry is if
    2418                 :            :          * a new module gets loaded, and takes on the same id as the events
    2419                 :            :          * of this module. When printing out the buffer, traced events left
    2420                 :            :          * over from this module may be passed to the new module events and
    2421                 :            :          * unexpected results may occur.
    2422                 :            :          */
    2423                 :          0 :         tracing_reset_all_online_cpus();
    2424                 :          0 : }
    2425                 :            : 
    2426                 :          3 : static int trace_module_notify(struct notifier_block *self,
    2427                 :            :                                unsigned long val, void *data)
    2428                 :            : {
    2429                 :            :         struct module *mod = data;
    2430                 :            : 
    2431                 :          3 :         mutex_lock(&event_mutex);
    2432                 :          3 :         mutex_lock(&trace_types_lock);
    2433                 :          3 :         switch (val) {
    2434                 :            :         case MODULE_STATE_COMING:
    2435                 :          3 :                 trace_module_add_events(mod);
    2436                 :          3 :                 break;
    2437                 :            :         case MODULE_STATE_GOING:
    2438                 :          0 :                 trace_module_remove_events(mod);
    2439                 :          0 :                 break;
    2440                 :            :         }
    2441                 :          3 :         mutex_unlock(&trace_types_lock);
    2442                 :          3 :         mutex_unlock(&event_mutex);
    2443                 :            : 
    2444                 :          3 :         return 0;
    2445                 :            : }
    2446                 :            : 
    2447                 :            : static struct notifier_block trace_module_nb = {
    2448                 :            :         .notifier_call = trace_module_notify,
    2449                 :            :         .priority = 1, /* higher than trace.c module notify */
    2450                 :            : };
    2451                 :            : #endif /* CONFIG_MODULES */
    2452                 :            : 
    2453                 :            : /* Create a new event directory structure for a trace directory. */
    2454                 :            : static void
    2455                 :          0 : __trace_add_event_dirs(struct trace_array *tr)
    2456                 :            : {
    2457                 :            :         struct trace_event_call *call;
    2458                 :            :         int ret;
    2459                 :            : 
    2460                 :          0 :         list_for_each_entry(call, &ftrace_events, list) {
    2461                 :          0 :                 ret = __trace_add_new_event(call, tr);
    2462                 :          0 :                 if (ret < 0)
    2463                 :          0 :                         pr_warn("Could not create directory for event %s\n",
    2464                 :            :                                 trace_event_name(call));
    2465                 :            :         }
    2466                 :          0 : }
    2467                 :            : 
    2468                 :            : /* Returns any file that matches the system and event */
    2469                 :            : struct trace_event_file *
    2470                 :          3 : __find_event_file(struct trace_array *tr, const char *system, const char *event)
    2471                 :            : {
    2472                 :            :         struct trace_event_file *file;
    2473                 :            :         struct trace_event_call *call;
    2474                 :            :         const char *name;
    2475                 :            : 
    2476                 :          3 :         list_for_each_entry(file, &tr->events, list) {
    2477                 :            : 
    2478                 :          3 :                 call = file->event_call;
    2479                 :            :                 name = trace_event_name(call);
    2480                 :            : 
    2481                 :          3 :                 if (!name || !call->class)
    2482                 :          0 :                         continue;
    2483                 :            : 
    2484                 :          3 :                 if (strcmp(event, name) == 0 &&
    2485                 :          3 :                     strcmp(system, call->class->system) == 0)
    2486                 :          3 :                         return file;
    2487                 :            :         }
    2488                 :            :         return NULL;
    2489                 :            : }
    2490                 :            : 
    2491                 :            : /* Returns valid trace event files that match system and event */
    2492                 :            : struct trace_event_file *
    2493                 :          0 : find_event_file(struct trace_array *tr, const char *system, const char *event)
    2494                 :            : {
    2495                 :            :         struct trace_event_file *file;
    2496                 :            : 
    2497                 :          0 :         file = __find_event_file(tr, system, event);
    2498                 :          0 :         if (!file || !file->event_call->class->reg ||
    2499                 :          0 :             file->event_call->flags & TRACE_EVENT_FL_IGNORE_ENABLE)
    2500                 :            :                 return NULL;
    2501                 :            : 
    2502                 :          0 :         return file;
    2503                 :            : }
    2504                 :            : 
    2505                 :            : #ifdef CONFIG_DYNAMIC_FTRACE
    2506                 :            : 
    2507                 :            : /* Avoid typos */
    2508                 :            : #define ENABLE_EVENT_STR        "enable_event"
    2509                 :            : #define DISABLE_EVENT_STR       "disable_event"
    2510                 :            : 
    2511                 :            : struct event_probe_data {
    2512                 :            :         struct trace_event_file *file;
    2513                 :            :         unsigned long                   count;
    2514                 :            :         int                             ref;
    2515                 :            :         bool                            enable;
    2516                 :            : };
    2517                 :            : 
    2518                 :          0 : static void update_event_probe(struct event_probe_data *data)
    2519                 :            : {
    2520                 :          0 :         if (data->enable)
    2521                 :          0 :                 clear_bit(EVENT_FILE_FL_SOFT_DISABLED_BIT, &data->file->flags);
    2522                 :            :         else
    2523                 :          0 :                 set_bit(EVENT_FILE_FL_SOFT_DISABLED_BIT, &data->file->flags);
    2524                 :          0 : }
    2525                 :            : 
    2526                 :            : static void
    2527                 :          0 : event_enable_probe(unsigned long ip, unsigned long parent_ip,
    2528                 :            :                    struct trace_array *tr, struct ftrace_probe_ops *ops,
    2529                 :            :                    void *data)
    2530                 :            : {
    2531                 :            :         struct ftrace_func_mapper *mapper = data;
    2532                 :            :         struct event_probe_data *edata;
    2533                 :            :         void **pdata;
    2534                 :            : 
    2535                 :          0 :         pdata = ftrace_func_mapper_find_ip(mapper, ip);
    2536                 :          0 :         if (!pdata || !*pdata)
    2537                 :          0 :                 return;
    2538                 :            : 
    2539                 :            :         edata = *pdata;
    2540                 :          0 :         update_event_probe(edata);
    2541                 :            : }
    2542                 :            : 
    2543                 :            : static void
    2544                 :          0 : event_enable_count_probe(unsigned long ip, unsigned long parent_ip,
    2545                 :            :                          struct trace_array *tr, struct ftrace_probe_ops *ops,
    2546                 :            :                          void *data)
    2547                 :            : {
    2548                 :            :         struct ftrace_func_mapper *mapper = data;
    2549                 :            :         struct event_probe_data *edata;
    2550                 :            :         void **pdata;
    2551                 :            : 
    2552                 :          0 :         pdata = ftrace_func_mapper_find_ip(mapper, ip);
    2553                 :          0 :         if (!pdata || !*pdata)
    2554                 :            :                 return;
    2555                 :            : 
    2556                 :            :         edata = *pdata;
    2557                 :            : 
    2558                 :          0 :         if (!edata->count)
    2559                 :            :                 return;
    2560                 :            : 
    2561                 :            :         /* Skip if the event is in a state we want to switch to */
    2562                 :          0 :         if (edata->enable == !(edata->file->flags & EVENT_FILE_FL_SOFT_DISABLED))
    2563                 :            :                 return;
    2564                 :            : 
    2565                 :          0 :         if (edata->count != -1)
    2566                 :          0 :                 (edata->count)--;
    2567                 :            : 
    2568                 :          0 :         update_event_probe(edata);
    2569                 :            : }
    2570                 :            : 
    2571                 :            : static int
    2572                 :          0 : event_enable_print(struct seq_file *m, unsigned long ip,
    2573                 :            :                    struct ftrace_probe_ops *ops, void *data)
    2574                 :            : {
    2575                 :            :         struct ftrace_func_mapper *mapper = data;
    2576                 :            :         struct event_probe_data *edata;
    2577                 :            :         void **pdata;
    2578                 :            : 
    2579                 :          0 :         pdata = ftrace_func_mapper_find_ip(mapper, ip);
    2580                 :            : 
    2581                 :          0 :         if (WARN_ON_ONCE(!pdata || !*pdata))
    2582                 :            :                 return 0;
    2583                 :            : 
    2584                 :          0 :         edata = *pdata;
    2585                 :            : 
    2586                 :          0 :         seq_printf(m, "%ps:", (void *)ip);
    2587                 :            : 
    2588                 :          0 :         seq_printf(m, "%s:%s:%s",
    2589                 :          0 :                    edata->enable ? ENABLE_EVENT_STR : DISABLE_EVENT_STR,
    2590                 :          0 :                    edata->file->event_call->class->system,
    2591                 :            :                    trace_event_name(edata->file->event_call));
    2592                 :            : 
    2593                 :          0 :         if (edata->count == -1)
    2594                 :          0 :                 seq_puts(m, ":unlimited\n");
    2595                 :            :         else
    2596                 :          0 :                 seq_printf(m, ":count=%ld\n", edata->count);
    2597                 :            : 
    2598                 :            :         return 0;
    2599                 :            : }
    2600                 :            : 
    2601                 :            : static int
    2602                 :          0 : event_enable_init(struct ftrace_probe_ops *ops, struct trace_array *tr,
    2603                 :            :                   unsigned long ip, void *init_data, void **data)
    2604                 :            : {
    2605                 :          0 :         struct ftrace_func_mapper *mapper = *data;
    2606                 :            :         struct event_probe_data *edata = init_data;
    2607                 :            :         int ret;
    2608                 :            : 
    2609                 :          0 :         if (!mapper) {
    2610                 :          0 :                 mapper = allocate_ftrace_func_mapper();
    2611                 :          0 :                 if (!mapper)
    2612                 :            :                         return -ENODEV;
    2613                 :          0 :                 *data = mapper;
    2614                 :            :         }
    2615                 :            : 
    2616                 :          0 :         ret = ftrace_func_mapper_add_ip(mapper, ip, edata);
    2617                 :          0 :         if (ret < 0)
    2618                 :            :                 return ret;
    2619                 :            : 
    2620                 :          0 :         edata->ref++;
    2621                 :            : 
    2622                 :          0 :         return 0;
    2623                 :            : }
    2624                 :            : 
    2625                 :          0 : static int free_probe_data(void *data)
    2626                 :            : {
    2627                 :            :         struct event_probe_data *edata = data;
    2628                 :            : 
    2629                 :          0 :         edata->ref--;
    2630                 :          0 :         if (!edata->ref) {
    2631                 :            :                 /* Remove the SOFT_MODE flag */
    2632                 :          0 :                 __ftrace_event_enable_disable(edata->file, 0, 1);
    2633                 :          0 :                 module_put(edata->file->event_call->mod);
    2634                 :          0 :                 kfree(edata);
    2635                 :            :         }
    2636                 :          0 :         return 0;
    2637                 :            : }
    2638                 :            : 
    2639                 :            : static void
    2640                 :          0 : event_enable_free(struct ftrace_probe_ops *ops, struct trace_array *tr,
    2641                 :            :                   unsigned long ip, void *data)
    2642                 :            : {
    2643                 :            :         struct ftrace_func_mapper *mapper = data;
    2644                 :            :         struct event_probe_data *edata;
    2645                 :            : 
    2646                 :          0 :         if (!ip) {
    2647                 :          0 :                 if (!mapper)
    2648                 :            :                         return;
    2649                 :          0 :                 free_ftrace_func_mapper(mapper, free_probe_data);
    2650                 :          0 :                 return;
    2651                 :            :         }
    2652                 :            : 
    2653                 :          0 :         edata = ftrace_func_mapper_remove_ip(mapper, ip);
    2654                 :            : 
    2655                 :          0 :         if (WARN_ON_ONCE(!edata))
    2656                 :            :                 return;
    2657                 :            : 
    2658                 :          0 :         if (WARN_ON_ONCE(edata->ref <= 0))
    2659                 :            :                 return;
    2660                 :            : 
    2661                 :          0 :         free_probe_data(edata);
    2662                 :            : }
    2663                 :            : 
    2664                 :            : static struct ftrace_probe_ops event_enable_probe_ops = {
    2665                 :            :         .func                   = event_enable_probe,
    2666                 :            :         .print                  = event_enable_print,
    2667                 :            :         .init                   = event_enable_init,
    2668                 :            :         .free                   = event_enable_free,
    2669                 :            : };
    2670                 :            : 
    2671                 :            : static struct ftrace_probe_ops event_enable_count_probe_ops = {
    2672                 :            :         .func                   = event_enable_count_probe,
    2673                 :            :         .print                  = event_enable_print,
    2674                 :            :         .init                   = event_enable_init,
    2675                 :            :         .free                   = event_enable_free,
    2676                 :            : };
    2677                 :            : 
    2678                 :            : static struct ftrace_probe_ops event_disable_probe_ops = {
    2679                 :            :         .func                   = event_enable_probe,
    2680                 :            :         .print                  = event_enable_print,
    2681                 :            :         .init                   = event_enable_init,
    2682                 :            :         .free                   = event_enable_free,
    2683                 :            : };
    2684                 :            : 
    2685                 :            : static struct ftrace_probe_ops event_disable_count_probe_ops = {
    2686                 :            :         .func                   = event_enable_count_probe,
    2687                 :            :         .print                  = event_enable_print,
    2688                 :            :         .init                   = event_enable_init,
    2689                 :            :         .free                   = event_enable_free,
    2690                 :            : };
    2691                 :            : 
    2692                 :            : static int
    2693                 :          0 : event_enable_func(struct trace_array *tr, struct ftrace_hash *hash,
    2694                 :            :                   char *glob, char *cmd, char *param, int enabled)
    2695                 :            : {
    2696                 :            :         struct trace_event_file *file;
    2697                 :            :         struct ftrace_probe_ops *ops;
    2698                 :            :         struct event_probe_data *data;
    2699                 :            :         const char *system;
    2700                 :            :         const char *event;
    2701                 :            :         char *number;
    2702                 :            :         bool enable;
    2703                 :            :         int ret;
    2704                 :            : 
    2705                 :          0 :         if (!tr)
    2706                 :            :                 return -ENODEV;
    2707                 :            : 
    2708                 :            :         /* hash funcs only work with set_ftrace_filter */
    2709                 :          0 :         if (!enabled || !param)
    2710                 :            :                 return -EINVAL;
    2711                 :            : 
    2712                 :          0 :         system = strsep(&param, ":");
    2713                 :          0 :         if (!param)
    2714                 :            :                 return -EINVAL;
    2715                 :            : 
    2716                 :          0 :         event = strsep(&param, ":");
    2717                 :            : 
    2718                 :          0 :         mutex_lock(&event_mutex);
    2719                 :            : 
    2720                 :            :         ret = -EINVAL;
    2721                 :          0 :         file = find_event_file(tr, system, event);
    2722                 :          0 :         if (!file)
    2723                 :            :                 goto out;
    2724                 :            : 
    2725                 :          0 :         enable = strcmp(cmd, ENABLE_EVENT_STR) == 0;
    2726                 :            : 
    2727                 :          0 :         if (enable)
    2728                 :          0 :                 ops = param ? &event_enable_count_probe_ops : &event_enable_probe_ops;
    2729                 :            :         else
    2730                 :          0 :                 ops = param ? &event_disable_count_probe_ops : &event_disable_probe_ops;
    2731                 :            : 
    2732                 :          0 :         if (glob[0] == '!') {
    2733                 :          0 :                 ret = unregister_ftrace_function_probe_func(glob+1, tr, ops);
    2734                 :          0 :                 goto out;
    2735                 :            :         }
    2736                 :            : 
    2737                 :            :         ret = -ENOMEM;
    2738                 :            : 
    2739                 :          0 :         data = kzalloc(sizeof(*data), GFP_KERNEL);
    2740                 :          0 :         if (!data)
    2741                 :            :                 goto out;
    2742                 :            : 
    2743                 :          0 :         data->enable = enable;
    2744                 :          0 :         data->count = -1;
    2745                 :          0 :         data->file = file;
    2746                 :            : 
    2747                 :          0 :         if (!param)
    2748                 :            :                 goto out_reg;
    2749                 :            : 
    2750                 :          0 :         number = strsep(&param, ":");
    2751                 :            : 
    2752                 :            :         ret = -EINVAL;
    2753                 :          0 :         if (!strlen(number))
    2754                 :            :                 goto out_free;
    2755                 :            : 
    2756                 :            :         /*
    2757                 :            :          * We use the callback data field (which is a pointer)
    2758                 :            :          * as our counter.
    2759                 :            :          */
    2760                 :          0 :         ret = kstrtoul(number, 0, &data->count);
    2761                 :          0 :         if (ret)
    2762                 :            :                 goto out_free;
    2763                 :            : 
    2764                 :            :  out_reg:
    2765                 :            :         /* Don't let event modules unload while probe registered */
    2766                 :          0 :         ret = try_module_get(file->event_call->mod);
    2767                 :          0 :         if (!ret) {
    2768                 :            :                 ret = -EBUSY;
    2769                 :            :                 goto out_free;
    2770                 :            :         }
    2771                 :            : 
    2772                 :          0 :         ret = __ftrace_event_enable_disable(file, 1, 1);
    2773                 :          0 :         if (ret < 0)
    2774                 :            :                 goto out_put;
    2775                 :            : 
    2776                 :          0 :         ret = register_ftrace_function_probe(glob, tr, ops, data);
    2777                 :            :         /*
    2778                 :            :          * The above returns on success the # of functions enabled,
    2779                 :            :          * but if it didn't find any functions it returns zero.
    2780                 :            :          * Consider no functions a failure too.
    2781                 :            :          */
    2782                 :          0 :         if (!ret) {
    2783                 :            :                 ret = -ENOENT;
    2784                 :            :                 goto out_disable;
    2785                 :          0 :         } else if (ret < 0)
    2786                 :            :                 goto out_disable;
    2787                 :            :         /* Just return zero, not the number of enabled functions */
    2788                 :            :         ret = 0;
    2789                 :            :  out:
    2790                 :          0 :         mutex_unlock(&event_mutex);
    2791                 :          0 :         return ret;
    2792                 :            : 
    2793                 :            :  out_disable:
    2794                 :          0 :         __ftrace_event_enable_disable(file, 0, 1);
    2795                 :            :  out_put:
    2796                 :          0 :         module_put(file->event_call->mod);
    2797                 :            :  out_free:
    2798                 :          0 :         kfree(data);
    2799                 :          0 :         goto out;
    2800                 :            : }
    2801                 :            : 
    2802                 :            : static struct ftrace_func_command event_enable_cmd = {
    2803                 :            :         .name                   = ENABLE_EVENT_STR,
    2804                 :            :         .func                   = event_enable_func,
    2805                 :            : };
    2806                 :            : 
    2807                 :            : static struct ftrace_func_command event_disable_cmd = {
    2808                 :            :         .name                   = DISABLE_EVENT_STR,
    2809                 :            :         .func                   = event_enable_func,
    2810                 :            : };
    2811                 :            : 
    2812                 :          3 : static __init int register_event_cmds(void)
    2813                 :            : {
    2814                 :            :         int ret;
    2815                 :            : 
    2816                 :          3 :         ret = register_ftrace_command(&event_enable_cmd);
    2817                 :          3 :         if (WARN_ON(ret < 0))
    2818                 :            :                 return ret;
    2819                 :          3 :         ret = register_ftrace_command(&event_disable_cmd);
    2820                 :          3 :         if (WARN_ON(ret < 0))
    2821                 :          0 :                 unregister_ftrace_command(&event_enable_cmd);
    2822                 :          3 :         return ret;
    2823                 :            : }
    2824                 :            : #else
    2825                 :            : static inline int register_event_cmds(void) { return 0; }
    2826                 :            : #endif /* CONFIG_DYNAMIC_FTRACE */
    2827                 :            : 
    2828                 :            : /*
    2829                 :            :  * The top level array has already had its trace_event_file
    2830                 :            :  * descriptors created in order to allow for early events to
    2831                 :            :  * be recorded. This function is called after the tracefs has been
    2832                 :            :  * initialized, and we now have to create the files associated
    2833                 :            :  * to the events.
    2834                 :            :  */
    2835                 :            : static __init void
    2836                 :          3 : __trace_early_add_event_dirs(struct trace_array *tr)
    2837                 :            : {
    2838                 :            :         struct trace_event_file *file;
    2839                 :            :         int ret;
    2840                 :            : 
    2841                 :            : 
    2842                 :          3 :         list_for_each_entry(file, &tr->events, list) {
    2843                 :          3 :                 ret = event_create_dir(tr->event_dir, file);
    2844                 :          3 :                 if (ret < 0)
    2845                 :          0 :                         pr_warn("Could not create directory for event %s\n",
    2846                 :            :                                 trace_event_name(file->event_call));
    2847                 :            :         }
    2848                 :          3 : }
    2849                 :            : 
    2850                 :            : /*
    2851                 :            :  * For early boot up, the top trace array requires to have
    2852                 :            :  * a list of events that can be enabled. This must be done before
    2853                 :            :  * the filesystem is set up in order to allow events to be traced
    2854                 :            :  * early.
    2855                 :            :  */
    2856                 :            : static __init void
    2857                 :          3 : __trace_early_add_events(struct trace_array *tr)
    2858                 :            : {
    2859                 :            :         struct trace_event_call *call;
    2860                 :            :         int ret;
    2861                 :            : 
    2862                 :          3 :         list_for_each_entry(call, &ftrace_events, list) {
    2863                 :            :                 /* Early boot up should not have any modules loaded */
    2864                 :          3 :                 if (WARN_ON_ONCE(call->mod))
    2865                 :          0 :                         continue;
    2866                 :            : 
    2867                 :          3 :                 ret = __trace_early_add_new_event(call, tr);
    2868                 :          3 :                 if (ret < 0)
    2869                 :          0 :                         pr_warn("Could not create early event %s\n",
    2870                 :            :                                 trace_event_name(call));
    2871                 :            :         }
    2872                 :          3 : }
    2873                 :            : 
    2874                 :            : /* Remove the event directory structure for a trace directory. */
    2875                 :            : static void
    2876                 :            : __trace_remove_event_dirs(struct trace_array *tr)
    2877                 :            : {
    2878                 :            :         struct trace_event_file *file, *next;
    2879                 :            : 
    2880                 :          0 :         list_for_each_entry_safe(file, next, &tr->events, list)
    2881                 :          0 :                 remove_event_file_dir(file);
    2882                 :            : }
    2883                 :            : 
    2884                 :            : static void __add_event_to_tracers(struct trace_event_call *call)
    2885                 :            : {
    2886                 :            :         struct trace_array *tr;
    2887                 :            : 
    2888                 :          3 :         list_for_each_entry(tr, &ftrace_trace_arrays, list)
    2889                 :          3 :                 __trace_add_new_event(call, tr);
    2890                 :            : }
    2891                 :            : 
    2892                 :            : extern struct trace_event_call *__start_ftrace_events[];
    2893                 :            : extern struct trace_event_call *__stop_ftrace_events[];
    2894                 :            : 
    2895                 :            : static char bootup_event_buf[COMMAND_LINE_SIZE] __initdata;
    2896                 :            : 
    2897                 :          0 : static __init int setup_trace_event(char *str)
    2898                 :            : {
    2899                 :          0 :         strlcpy(bootup_event_buf, str, COMMAND_LINE_SIZE);
    2900                 :          0 :         ring_buffer_expanded = true;
    2901                 :          0 :         tracing_selftest_disabled = true;
    2902                 :            : 
    2903                 :          0 :         return 1;
    2904                 :            : }
    2905                 :            : __setup("trace_event=", setup_trace_event);
    2906                 :            : 
    2907                 :            : /* Expects to have event_mutex held when called */
    2908                 :            : static int
    2909                 :          3 : create_event_toplevel_files(struct dentry *parent, struct trace_array *tr)
    2910                 :            : {
    2911                 :            :         struct dentry *d_events;
    2912                 :            :         struct dentry *entry;
    2913                 :            : 
    2914                 :          3 :         entry = tracefs_create_file("set_event", 0644, parent,
    2915                 :            :                                     tr, &ftrace_set_event_fops);
    2916                 :          3 :         if (!entry) {
    2917                 :          0 :                 pr_warn("Could not create tracefs 'set_event' entry\n");
    2918                 :          0 :                 return -ENOMEM;
    2919                 :            :         }
    2920                 :            : 
    2921                 :          3 :         d_events = tracefs_create_dir("events", parent);
    2922                 :          3 :         if (!d_events) {
    2923                 :          0 :                 pr_warn("Could not create tracefs 'events' directory\n");
    2924                 :          0 :                 return -ENOMEM;
    2925                 :            :         }
    2926                 :            : 
    2927                 :          3 :         entry = trace_create_file("enable", 0644, d_events,
    2928                 :            :                                   tr, &ftrace_tr_enable_fops);
    2929                 :          3 :         if (!entry) {
    2930                 :          0 :                 pr_warn("Could not create tracefs 'enable' entry\n");
    2931                 :          0 :                 return -ENOMEM;
    2932                 :            :         }
    2933                 :            : 
    2934                 :            :         /* There are not as crucial, just warn if they are not created */
    2935                 :            : 
    2936                 :          3 :         entry = tracefs_create_file("set_event_pid", 0644, parent,
    2937                 :            :                                     tr, &ftrace_set_event_pid_fops);
    2938                 :          3 :         if (!entry)
    2939                 :          0 :                 pr_warn("Could not create tracefs 'set_event_pid' entry\n");
    2940                 :            : 
    2941                 :            :         /* ring buffer internal formats */
    2942                 :          3 :         entry = trace_create_file("header_page", 0444, d_events,
    2943                 :            :                                   ring_buffer_print_page_header,
    2944                 :            :                                   &ftrace_show_header_fops);
    2945                 :          3 :         if (!entry)
    2946                 :          0 :                 pr_warn("Could not create tracefs 'header_page' entry\n");
    2947                 :            : 
    2948                 :          3 :         entry = trace_create_file("header_event", 0444, d_events,
    2949                 :            :                                   ring_buffer_print_entry_header,
    2950                 :            :                                   &ftrace_show_header_fops);
    2951                 :          3 :         if (!entry)
    2952                 :          0 :                 pr_warn("Could not create tracefs 'header_event' entry\n");
    2953                 :            : 
    2954                 :          3 :         tr->event_dir = d_events;
    2955                 :            : 
    2956                 :          3 :         return 0;
    2957                 :            : }
    2958                 :            : 
    2959                 :            : /**
    2960                 :            :  * event_trace_add_tracer - add a instance of a trace_array to events
    2961                 :            :  * @parent: The parent dentry to place the files/directories for events in
    2962                 :            :  * @tr: The trace array associated with these events
    2963                 :            :  *
    2964                 :            :  * When a new instance is created, it needs to set up its events
    2965                 :            :  * directory, as well as other files associated with events. It also
    2966                 :            :  * creates the event hierachry in the @parent/events directory.
    2967                 :            :  *
    2968                 :            :  * Returns 0 on success.
    2969                 :            :  *
    2970                 :            :  * Must be called with event_mutex held.
    2971                 :            :  */
    2972                 :          0 : int event_trace_add_tracer(struct dentry *parent, struct trace_array *tr)
    2973                 :            : {
    2974                 :            :         int ret;
    2975                 :            : 
    2976                 :            :         lockdep_assert_held(&event_mutex);
    2977                 :            : 
    2978                 :          0 :         ret = create_event_toplevel_files(parent, tr);
    2979                 :          0 :         if (ret)
    2980                 :            :                 goto out;
    2981                 :            : 
    2982                 :          0 :         down_write(&trace_event_sem);
    2983                 :          0 :         __trace_add_event_dirs(tr);
    2984                 :          0 :         up_write(&trace_event_sem);
    2985                 :            : 
    2986                 :            :  out:
    2987                 :          0 :         return ret;
    2988                 :            : }
    2989                 :            : 
    2990                 :            : /*
    2991                 :            :  * The top trace array already had its file descriptors created.
    2992                 :            :  * Now the files themselves need to be created.
    2993                 :            :  */
    2994                 :            : static __init int
    2995                 :          3 : early_event_add_tracer(struct dentry *parent, struct trace_array *tr)
    2996                 :            : {
    2997                 :            :         int ret;
    2998                 :            : 
    2999                 :          3 :         mutex_lock(&event_mutex);
    3000                 :            : 
    3001                 :          3 :         ret = create_event_toplevel_files(parent, tr);
    3002                 :          3 :         if (ret)
    3003                 :            :                 goto out_unlock;
    3004                 :            : 
    3005                 :          3 :         down_write(&trace_event_sem);
    3006                 :          3 :         __trace_early_add_event_dirs(tr);
    3007                 :          3 :         up_write(&trace_event_sem);
    3008                 :            : 
    3009                 :            :  out_unlock:
    3010                 :          3 :         mutex_unlock(&event_mutex);
    3011                 :            : 
    3012                 :          3 :         return ret;
    3013                 :            : }
    3014                 :            : 
    3015                 :            : /* Must be called with event_mutex held */
    3016                 :          0 : int event_trace_del_tracer(struct trace_array *tr)
    3017                 :            : {
    3018                 :            :         lockdep_assert_held(&event_mutex);
    3019                 :            : 
    3020                 :            :         /* Disable any event triggers and associated soft-disabled events */
    3021                 :          0 :         clear_event_triggers(tr);
    3022                 :            : 
    3023                 :            :         /* Clear the pid list */
    3024                 :          0 :         __ftrace_clear_event_pids(tr);
    3025                 :            : 
    3026                 :            :         /* Disable any running events */
    3027                 :          0 :         __ftrace_set_clr_event_nolock(tr, NULL, NULL, NULL, 0);
    3028                 :            : 
    3029                 :            :         /* Make sure no more events are being executed */
    3030                 :            :         tracepoint_synchronize_unregister();
    3031                 :            : 
    3032                 :          0 :         down_write(&trace_event_sem);
    3033                 :            :         __trace_remove_event_dirs(tr);
    3034                 :          0 :         tracefs_remove_recursive(tr->event_dir);
    3035                 :          0 :         up_write(&trace_event_sem);
    3036                 :            : 
    3037                 :          0 :         tr->event_dir = NULL;
    3038                 :            : 
    3039                 :          0 :         return 0;
    3040                 :            : }
    3041                 :            : 
    3042                 :          3 : static __init int event_trace_memsetup(void)
    3043                 :            : {
    3044                 :          3 :         field_cachep = KMEM_CACHE(ftrace_event_field, SLAB_PANIC);
    3045                 :          3 :         file_cachep = KMEM_CACHE(trace_event_file, SLAB_PANIC);
    3046                 :          3 :         return 0;
    3047                 :            : }
    3048                 :            : 
    3049                 :            : static __init void
    3050                 :          3 : early_enable_events(struct trace_array *tr, bool disable_first)
    3051                 :            : {
    3052                 :          3 :         char *buf = bootup_event_buf;
    3053                 :            :         char *token;
    3054                 :            :         int ret;
    3055                 :            : 
    3056                 :            :         while (true) {
    3057                 :          3 :                 token = strsep(&buf, ",");
    3058                 :            : 
    3059                 :          3 :                 if (!token)
    3060                 :            :                         break;
    3061                 :            : 
    3062                 :          3 :                 if (*token) {
    3063                 :            :                         /* Restarting syscalls requires that we stop them first */
    3064                 :          0 :                         if (disable_first)
    3065                 :          0 :                                 ftrace_set_clr_event(tr, token, 0);
    3066                 :            : 
    3067                 :          0 :                         ret = ftrace_set_clr_event(tr, token, 1);
    3068                 :          0 :                         if (ret)
    3069                 :          0 :                                 pr_warn("Failed to enable trace event: %s\n", token);
    3070                 :            :                 }
    3071                 :            : 
    3072                 :            :                 /* Put back the comma to allow this to be called again */
    3073                 :          3 :                 if (buf)
    3074                 :          0 :                         *(buf - 1) = ',';
    3075                 :            :         }
    3076                 :          3 : }
    3077                 :            : 
    3078                 :          3 : static __init int event_trace_enable(void)
    3079                 :            : {
    3080                 :          3 :         struct trace_array *tr = top_trace_array();
    3081                 :            :         struct trace_event_call **iter, *call;
    3082                 :            :         int ret;
    3083                 :            : 
    3084                 :          3 :         if (!tr)
    3085                 :            :                 return -ENODEV;
    3086                 :            : 
    3087                 :          3 :         for_each_event(iter, __start_ftrace_events, __stop_ftrace_events) {
    3088                 :            : 
    3089                 :          3 :                 call = *iter;
    3090                 :          3 :                 ret = event_init(call);
    3091                 :          3 :                 if (!ret)
    3092                 :          3 :                         list_add(&call->list, &ftrace_events);
    3093                 :            :         }
    3094                 :            : 
    3095                 :            :         /*
    3096                 :            :          * We need the top trace array to have a working set of trace
    3097                 :            :          * points at early init, before the debug files and directories
    3098                 :            :          * are created. Create the file entries now, and attach them
    3099                 :            :          * to the actual file dentries later.
    3100                 :            :          */
    3101                 :          3 :         __trace_early_add_events(tr);
    3102                 :            : 
    3103                 :          3 :         early_enable_events(tr, false);
    3104                 :            : 
    3105                 :          3 :         trace_printk_start_comm();
    3106                 :            : 
    3107                 :          3 :         register_event_cmds();
    3108                 :            : 
    3109                 :          3 :         register_trigger_cmds();
    3110                 :            : 
    3111                 :          3 :         return 0;
    3112                 :            : }
    3113                 :            : 
    3114                 :            : /*
    3115                 :            :  * event_trace_enable() is called from trace_event_init() first to
    3116                 :            :  * initialize events and perhaps start any events that are on the
    3117                 :            :  * command line. Unfortunately, there are some events that will not
    3118                 :            :  * start this early, like the system call tracepoints that need
    3119                 :            :  * to set the TIF_SYSCALL_TRACEPOINT flag of pid 1. But event_trace_enable()
    3120                 :            :  * is called before pid 1 starts, and this flag is never set, making
    3121                 :            :  * the syscall tracepoint never get reached, but the event is enabled
    3122                 :            :  * regardless (and not doing anything).
    3123                 :            :  */
    3124                 :          3 : static __init int event_trace_enable_again(void)
    3125                 :            : {
    3126                 :            :         struct trace_array *tr;
    3127                 :            : 
    3128                 :          3 :         tr = top_trace_array();
    3129                 :          3 :         if (!tr)
    3130                 :            :                 return -ENODEV;
    3131                 :            : 
    3132                 :          3 :         early_enable_events(tr, true);
    3133                 :            : 
    3134                 :          3 :         return 0;
    3135                 :            : }
    3136                 :            : 
    3137                 :            : early_initcall(event_trace_enable_again);
    3138                 :            : 
    3139                 :          3 : __init int event_trace_init(void)
    3140                 :            : {
    3141                 :            :         struct trace_array *tr;
    3142                 :            :         struct dentry *d_tracer;
    3143                 :            :         struct dentry *entry;
    3144                 :            :         int ret;
    3145                 :            : 
    3146                 :          3 :         tr = top_trace_array();
    3147                 :          3 :         if (!tr)
    3148                 :            :                 return -ENODEV;
    3149                 :            : 
    3150                 :          3 :         d_tracer = tracing_init_dentry();
    3151                 :          3 :         if (IS_ERR(d_tracer))
    3152                 :            :                 return 0;
    3153                 :            : 
    3154                 :          3 :         entry = tracefs_create_file("available_events", 0444, d_tracer,
    3155                 :            :                                     tr, &ftrace_avail_fops);
    3156                 :          3 :         if (!entry)
    3157                 :          0 :                 pr_warn("Could not create tracefs 'available_events' entry\n");
    3158                 :            : 
    3159                 :          3 :         if (trace_define_generic_fields())
    3160                 :          0 :                 pr_warn("tracing: Failed to allocated generic fields");
    3161                 :            : 
    3162                 :          3 :         if (trace_define_common_fields())
    3163                 :          0 :                 pr_warn("tracing: Failed to allocate common fields");
    3164                 :            : 
    3165                 :          3 :         ret = early_event_add_tracer(d_tracer, tr);
    3166                 :          3 :         if (ret)
    3167                 :            :                 return ret;
    3168                 :            : 
    3169                 :            : #ifdef CONFIG_MODULES
    3170                 :          3 :         ret = register_module_notifier(&trace_module_nb);
    3171                 :          3 :         if (ret)
    3172                 :          0 :                 pr_warn("Failed to register trace events module notifier\n");
    3173                 :            : #endif
    3174                 :            :         return 0;
    3175                 :            : }
    3176                 :            : 
    3177                 :          3 : void __init trace_event_init(void)
    3178                 :            : {
    3179                 :          3 :         event_trace_memsetup();
    3180                 :            :         init_ftrace_syscalls();
    3181                 :          3 :         event_trace_enable();
    3182                 :          3 : }
    3183                 :            : 
    3184                 :            : #ifdef CONFIG_EVENT_TRACE_STARTUP_TEST
    3185                 :            : 
    3186                 :            : static DEFINE_SPINLOCK(test_spinlock);
    3187                 :            : static DEFINE_SPINLOCK(test_spinlock_irq);
    3188                 :            : static DEFINE_MUTEX(test_mutex);
    3189                 :            : 
    3190                 :            : static __init void test_work(struct work_struct *dummy)
    3191                 :            : {
    3192                 :            :         spin_lock(&test_spinlock);
    3193                 :            :         spin_lock_irq(&test_spinlock_irq);
    3194                 :            :         udelay(1);
    3195                 :            :         spin_unlock_irq(&test_spinlock_irq);
    3196                 :            :         spin_unlock(&test_spinlock);
    3197                 :            : 
    3198                 :            :         mutex_lock(&test_mutex);
    3199                 :            :         msleep(1);
    3200                 :            :         mutex_unlock(&test_mutex);
    3201                 :            : }
    3202                 :            : 
    3203                 :            : static __init int event_test_thread(void *unused)
    3204                 :            : {
    3205                 :            :         void *test_malloc;
    3206                 :            : 
    3207                 :            :         test_malloc = kmalloc(1234, GFP_KERNEL);
    3208                 :            :         if (!test_malloc)
    3209                 :            :                 pr_info("failed to kmalloc\n");
    3210                 :            : 
    3211                 :            :         schedule_on_each_cpu(test_work);
    3212                 :            : 
    3213                 :            :         kfree(test_malloc);
    3214                 :            : 
    3215                 :            :         set_current_state(TASK_INTERRUPTIBLE);
    3216                 :            :         while (!kthread_should_stop()) {
    3217                 :            :                 schedule();
    3218                 :            :                 set_current_state(TASK_INTERRUPTIBLE);
    3219                 :            :         }
    3220                 :            :         __set_current_state(TASK_RUNNING);
    3221                 :            : 
    3222                 :            :         return 0;
    3223                 :            : }
    3224                 :            : 
    3225                 :            : /*
    3226                 :            :  * Do various things that may trigger events.
    3227                 :            :  */
    3228                 :            : static __init void event_test_stuff(void)
    3229                 :            : {
    3230                 :            :         struct task_struct *test_thread;
    3231                 :            : 
    3232                 :            :         test_thread = kthread_run(event_test_thread, NULL, "test-events");
    3233                 :            :         msleep(1);
    3234                 :            :         kthread_stop(test_thread);
    3235                 :            : }
    3236                 :            : 
    3237                 :            : /*
    3238                 :            :  * For every trace event defined, we will test each trace point separately,
    3239                 :            :  * and then by groups, and finally all trace points.
    3240                 :            :  */
    3241                 :            : static __init void event_trace_self_tests(void)
    3242                 :            : {
    3243                 :            :         struct trace_subsystem_dir *dir;
    3244                 :            :         struct trace_event_file *file;
    3245                 :            :         struct trace_event_call *call;
    3246                 :            :         struct event_subsystem *system;
    3247                 :            :         struct trace_array *tr;
    3248                 :            :         int ret;
    3249                 :            : 
    3250                 :            :         tr = top_trace_array();
    3251                 :            :         if (!tr)
    3252                 :            :                 return;
    3253                 :            : 
    3254                 :            :         pr_info("Running tests on trace events:\n");
    3255                 :            : 
    3256                 :            :         list_for_each_entry(file, &tr->events, list) {
    3257                 :            : 
    3258                 :            :                 call = file->event_call;
    3259                 :            : 
    3260                 :            :                 /* Only test those that have a probe */
    3261                 :            :                 if (!call->class || !call->class->probe)
    3262                 :            :                         continue;
    3263                 :            : 
    3264                 :            : /*
    3265                 :            :  * Testing syscall events here is pretty useless, but
    3266                 :            :  * we still do it if configured. But this is time consuming.
    3267                 :            :  * What we really need is a user thread to perform the
    3268                 :            :  * syscalls as we test.
    3269                 :            :  */
    3270                 :            : #ifndef CONFIG_EVENT_TRACE_TEST_SYSCALLS
    3271                 :            :                 if (call->class->system &&
    3272                 :            :                     strcmp(call->class->system, "syscalls") == 0)
    3273                 :            :                         continue;
    3274                 :            : #endif
    3275                 :            : 
    3276                 :            :                 pr_info("Testing event %s: ", trace_event_name(call));
    3277                 :            : 
    3278                 :            :                 /*
    3279                 :            :                  * If an event is already enabled, someone is using
    3280                 :            :                  * it and the self test should not be on.
    3281                 :            :                  */
    3282                 :            :                 if (file->flags & EVENT_FILE_FL_ENABLED) {
    3283                 :            :                         pr_warn("Enabled event during self test!\n");
    3284                 :            :                         WARN_ON_ONCE(1);
    3285                 :            :                         continue;
    3286                 :            :                 }
    3287                 :            : 
    3288                 :            :                 ftrace_event_enable_disable(file, 1);
    3289                 :            :                 event_test_stuff();
    3290                 :            :                 ftrace_event_enable_disable(file, 0);
    3291                 :            : 
    3292                 :            :                 pr_cont("OK\n");
    3293                 :            :         }
    3294                 :            : 
    3295                 :            :         /* Now test at the sub system level */
    3296                 :            : 
    3297                 :            :         pr_info("Running tests on trace event systems:\n");
    3298                 :            : 
    3299                 :            :         list_for_each_entry(dir, &tr->systems, list) {
    3300                 :            : 
    3301                 :            :                 system = dir->subsystem;
    3302                 :            : 
    3303                 :            :                 /* the ftrace system is special, skip it */
    3304                 :            :                 if (strcmp(system->name, "ftrace") == 0)
    3305                 :            :                         continue;
    3306                 :            : 
    3307                 :            :                 pr_info("Testing event system %s: ", system->name);
    3308                 :            : 
    3309                 :            :                 ret = __ftrace_set_clr_event(tr, NULL, system->name, NULL, 1);
    3310                 :            :                 if (WARN_ON_ONCE(ret)) {
    3311                 :            :                         pr_warn("error enabling system %s\n",
    3312                 :            :                                 system->name);
    3313                 :            :                         continue;
    3314                 :            :                 }
    3315                 :            : 
    3316                 :            :                 event_test_stuff();
    3317                 :            : 
    3318                 :            :                 ret = __ftrace_set_clr_event(tr, NULL, system->name, NULL, 0);
    3319                 :            :                 if (WARN_ON_ONCE(ret)) {
    3320                 :            :                         pr_warn("error disabling system %s\n",
    3321                 :            :                                 system->name);
    3322                 :            :                         continue;
    3323                 :            :                 }
    3324                 :            : 
    3325                 :            :                 pr_cont("OK\n");
    3326                 :            :         }
    3327                 :            : 
    3328                 :            :         /* Test with all events enabled */
    3329                 :            : 
    3330                 :            :         pr_info("Running tests on all trace events:\n");
    3331                 :            :         pr_info("Testing all events: ");
    3332                 :            : 
    3333                 :            :         ret = __ftrace_set_clr_event(tr, NULL, NULL, NULL, 1);
    3334                 :            :         if (WARN_ON_ONCE(ret)) {
    3335                 :            :                 pr_warn("error enabling all events\n");
    3336                 :            :                 return;
    3337                 :            :         }
    3338                 :            : 
    3339                 :            :         event_test_stuff();
    3340                 :            : 
    3341                 :            :         /* reset sysname */
    3342                 :            :         ret = __ftrace_set_clr_event(tr, NULL, NULL, NULL, 0);
    3343                 :            :         if (WARN_ON_ONCE(ret)) {
    3344                 :            :                 pr_warn("error disabling all events\n");
    3345                 :            :                 return;
    3346                 :            :         }
    3347                 :            : 
    3348                 :            :         pr_cont("OK\n");
    3349                 :            : }
    3350                 :            : 
    3351                 :            : #ifdef CONFIG_FUNCTION_TRACER
    3352                 :            : 
    3353                 :            : static DEFINE_PER_CPU(atomic_t, ftrace_test_event_disable);
    3354                 :            : 
    3355                 :            : static struct trace_event_file event_trace_file __initdata;
    3356                 :            : 
    3357                 :            : static void __init
    3358                 :            : function_test_events_call(unsigned long ip, unsigned long parent_ip,
    3359                 :            :                           struct ftrace_ops *op, struct pt_regs *pt_regs)
    3360                 :            : {
    3361                 :            :         struct ring_buffer_event *event;
    3362                 :            :         struct ring_buffer *buffer;
    3363                 :            :         struct ftrace_entry *entry;
    3364                 :            :         unsigned long flags;
    3365                 :            :         long disabled;
    3366                 :            :         int cpu;
    3367                 :            :         int pc;
    3368                 :            : 
    3369                 :            :         pc = preempt_count();
    3370                 :            :         preempt_disable_notrace();
    3371                 :            :         cpu = raw_smp_processor_id();
    3372                 :            :         disabled = atomic_inc_return(&per_cpu(ftrace_test_event_disable, cpu));
    3373                 :            : 
    3374                 :            :         if (disabled != 1)
    3375                 :            :                 goto out;
    3376                 :            : 
    3377                 :            :         local_save_flags(flags);
    3378                 :            : 
    3379                 :            :         event = trace_event_buffer_lock_reserve(&buffer, &event_trace_file,
    3380                 :            :                                                 TRACE_FN, sizeof(*entry),
    3381                 :            :                                                 flags, pc);
    3382                 :            :         if (!event)
    3383                 :            :                 goto out;
    3384                 :            :         entry   = ring_buffer_event_data(event);
    3385                 :            :         entry->ip                    = ip;
    3386                 :            :         entry->parent_ip             = parent_ip;
    3387                 :            : 
    3388                 :            :         event_trigger_unlock_commit(&event_trace_file, buffer, event,
    3389                 :            :                                     entry, flags, pc);
    3390                 :            :  out:
    3391                 :            :         atomic_dec(&per_cpu(ftrace_test_event_disable, cpu));
    3392                 :            :         preempt_enable_notrace();
    3393                 :            : }
    3394                 :            : 
    3395                 :            : static struct ftrace_ops trace_ops __initdata  =
    3396                 :            : {
    3397                 :            :         .func = function_test_events_call,
    3398                 :            :         .flags = FTRACE_OPS_FL_RECURSION_SAFE,
    3399                 :            : };
    3400                 :            : 
    3401                 :            : static __init void event_trace_self_test_with_function(void)
    3402                 :            : {
    3403                 :            :         int ret;
    3404                 :            : 
    3405                 :            :         event_trace_file.tr = top_trace_array();
    3406                 :            :         if (WARN_ON(!event_trace_file.tr))
    3407                 :            :                 return;
    3408                 :            : 
    3409                 :            :         ret = register_ftrace_function(&trace_ops);
    3410                 :            :         if (WARN_ON(ret < 0)) {
    3411                 :            :                 pr_info("Failed to enable function tracer for event tests\n");
    3412                 :            :                 return;
    3413                 :            :         }
    3414                 :            :         pr_info("Running tests again, along with the function tracer\n");
    3415                 :            :         event_trace_self_tests();
    3416                 :            :         unregister_ftrace_function(&trace_ops);
    3417                 :            : }
    3418                 :            : #else
    3419                 :            : static __init void event_trace_self_test_with_function(void)
    3420                 :            : {
    3421                 :            : }
    3422                 :            : #endif
    3423                 :            : 
    3424                 :            : static __init int event_trace_self_tests_init(void)
    3425                 :            : {
    3426                 :            :         if (!tracing_selftest_disabled) {
    3427                 :            :                 event_trace_self_tests();
    3428                 :            :                 event_trace_self_test_with_function();
    3429                 :            :         }
    3430                 :            : 
    3431                 :            :         return 0;
    3432                 :            : }
    3433                 :            : 
    3434                 :            : late_initcall(event_trace_self_tests_init);
    3435                 :            : 
    3436                 :            : #endif
    

Generated by: LCOV version 1.14