Lines Matching defs:event
109 * tracing is active, only save the comm when a trace event
387 struct ring_buffer_event *event, int flag)
393 entry = ring_buffer_event_data(event);
394 size = ring_buffer_event_length(event);
431 static void ftrace_exports(struct ring_buffer_event *event, int flag)
439 trace_process_export(export, event, flag);
1061 trace_event_setup(struct ring_buffer_event *event,
1064 struct trace_entry *ent = ring_buffer_event_data(event);
1075 struct ring_buffer_event *event;
1077 event = ring_buffer_lock_reserve(buffer, len);
1078 if (event != NULL)
1079 trace_event_setup(event, type, trace_ctx);
1081 return event;
1113 __buffer_unlock_commit(struct trace_buffer *buffer, struct ring_buffer_event *event)
1118 if (this_cpu_read(trace_buffered_event) == event) {
1119 /* Length is in event->array[0] */
1120 ring_buffer_write(buffer, event->array[0], &event->array[1]);
1132 struct ring_buffer_event *event;
1152 event = __trace_buffer_lock_reserve(buffer, TRACE_PRINT, alloc,
1154 if (!event)
1157 entry = ring_buffer_event_data(event);
1169 __buffer_unlock_commit(buffer, event);
1195 struct ring_buffer_event *event;
1214 event = __trace_buffer_lock_reserve(buffer, TRACE_BPUTS, size,
1216 if (!event)
1219 entry = ring_buffer_event_data(event);
1223 __buffer_unlock_commit(buffer, event);
2621 * buffer to write the event data into if there's a likely chance
2626 * When an event is to be filtered, allocate per cpu buffers to
2627 * write the event data into, and if the event is filtered and discarded
2633 struct ring_buffer_event *event;
2647 pr_err("Failed to allocate event buffer\n");
2651 event = page_address(page);
2652 memset(event, 0, sizeof(*event));
2654 per_cpu(trace_buffered_event, cpu) = event;
2709 * their event buffer only after the previous synchronize_rcu() call and
2764 * back to the old method of allocating the event
2793 * we still need to look at the event data. Use the temp_buffer
2794 * to store the trace event for the trigger to use. It's recursive
2813 struct trace_event *event;
2822 if (!event_call || !event_call->event.funcs ||
2823 !event_call->event.funcs->trace)
2832 event = &fbuffer->trace_file->event_call->event;
2837 event_call->event.funcs->trace(iter, 0, event);
2879 if (__event_trigger_test_discard(file, fbuffer->buffer, fbuffer->event,
2887 ftrace_exports(fbuffer->event, TRACE_EXPORT_EVENT);
2890 fbuffer->event, fbuffer->trace_ctx, fbuffer->regs);
2910 struct ring_buffer_event *event,
2914 __buffer_unlock_commit(buffer, event);
2931 struct ring_buffer_event *event)
2933 __buffer_unlock_commit(buffer, event);
2941 struct ring_buffer_event *event;
2947 event = __trace_buffer_lock_reserve(buffer, TRACE_FN, size,
2949 if (!event)
2951 entry = ring_buffer_event_data(event);
2963 ftrace_exports(event, TRACE_EXPORT_FUNCTION);
2964 __buffer_unlock_commit(buffer, event);
2991 struct ring_buffer_event *event;
3047 event = __trace_buffer_lock_reserve(buffer, TRACE_STACK,
3050 if (!event)
3052 entry = ring_buffer_event_data(event);
3058 __buffer_unlock_commit(buffer, event);
3129 struct ring_buffer_event *event;
3152 event = __trace_buffer_lock_reserve(buffer, TRACE_USER_STACK,
3154 if (!event)
3156 entry = ring_buffer_event_data(event);
3162 __buffer_unlock_commit(buffer, event);
3191 struct ring_buffer_event *event;
3194 event = __trace_buffer_lock_reserve(buffer, TRACE_FUNC_REPEATS,
3196 if (!event)
3199 delta = ring_buffer_event_time_stamp(buffer, event) -
3202 entry = ring_buffer_event_data(event);
3208 __buffer_unlock_commit(buffer, event);
3329 struct ring_buffer_event *event;
3363 event = __trace_buffer_lock_reserve(buffer, TRACE_BPRINT, size,
3365 if (!event)
3367 entry = ring_buffer_event_data(event);
3372 __buffer_unlock_commit(buffer, event);
3389 struct ring_buffer_event *event;
3415 event = __trace_buffer_lock_reserve(buffer, TRACE_PRINT, size,
3417 if (!event)
3419 entry = ring_buffer_event_data(event);
3423 __buffer_unlock_commit(buffer, event);
3542 struct ring_buffer_event *event;
3546 event = ring_buffer_iter_peek(buf_iter, ts);
3551 event = ring_buffer_peek(iter->array_buffer->buffer, cpu, ts,
3555 if (event) {
3556 iter->ent_size = ring_buffer_event_length(event);
3557 return ring_buffer_event_data(event);
3647 /* Returns true if the string is safe to dereference from an event */
3652 struct trace_event_call *event;
3654 /* OK if part of the event data */
3672 * Now this could be a module event, referencing core module
3682 event = container_of(trace_event, struct trace_event_call, event);
3683 if ((event->flags & TRACE_EVENT_FL_DYNAMIC) || !event->module)
3687 if (within_module_core(addr, event->module))
3695 * @iter: The iterator that holds the seq buffer and the event being printed
3697 * At boot up, test_event_printk() will flag any event that dereferences
3705 * This function will check if the event has any fields flagged as needing
3711 * @return: true if the event is unsafe and should be ignored,
3718 struct trace_event_call *event;
3732 event = container_of(trace_event, struct trace_event_call, event);
3733 if (!(event->flags & TRACE_EVENT_FL_TEST_STR))
3736 head = trace_get_fields(event);
3739 trace_event_name(event));
3743 /* Offsets are from the iter->ent that points to the raw event */
3759 * trace event in question used %s on a string that
3760 * was saved at the time of the event, but may not be
3766 if (WARN_ONCE(!good, "event '%s' has unsafe pointer field '%s'",
3767 trace_event_name(event), field->name)) {
3769 trace_event_name(event), field->name);
4218 struct trace_event *event;
4224 event = ftrace_find_event(entry->type);
4236 if (event) {
4238 return print_event_fields(iter, event);
4245 event->type > __TRACE_LAST_TYPE)
4246 return print_event_fields(iter, event);
4248 return event->funcs->trace(iter, sym_flags, event);
4261 struct trace_event *event;
4272 event = ftrace_find_event(entry->type);
4273 if (event)
4274 return event->funcs->raw(iter, 0, event);
4287 struct trace_event *event;
4299 event = ftrace_find_event(entry->type);
4300 if (event) {
4301 enum print_line_t ret = event->funcs->hex(iter, 0, event);
4316 struct trace_event *event;
4328 event = ftrace_find_event(entry->type);
4329 return event ? event->funcs->binary(iter, 0, event) :
4632 * instead of hash value. However, that is only for the event
5444 "\t\t enable_event:<system>:<event>\n"
5445 "\t\t disable_event:<system>:<event>\n"
5511 "\t accepts: event-definitions (one definition per line)\n"
5513 "\t Format: p[:[<group>/][<event>]] <place> [<args>]\n"
5514 "\t r[maxactive][:[<group>/][<event>]] <place> [<args>]\n"
5517 "\t f[:[<group>/][<event>]] <func-name>[%return] [<args>]\n"
5518 "\t t[:[<group>/][<event>]] <tracepoint> [<args>]\n"
5521 "\t s:[synthetic/]<event> <field> [<field>]\n"
5523 "\t e[:[<group>/][<event>]] <attached-group>.<attached-event> [<args>] [if <filter>]\n"
5524 "\t -:[<group>/][<event>]\n"
5552 "\t efield: For event probes ('e' types), the field is on of the fields\n"
5553 "\t of the <attached-group>/<attached-event>.\n"
5557 " events/\t\t- Directory containing all trace event subsystems:\n"
5563 " events/<system>/<event>/\t- Directory containing control files for\n"
5564 "\t\t\t <event>:\n"
5565 " enable\t\t- Write 0/1 to enable/disable tracing of <event>\n"
5567 " trigger\t\t- If set, a command to perform when event is hit\n"
5570 "\t enable_event:<system>:<event>\n"
5571 "\t disable_event:<system>:<event>\n"
5573 "\t enable_hist:<system>:<event>\n"
5574 "\t disable_hist:<system>:<event>\n"
5591 "\t The third enables the kmalloc event the first 3 times block_unplug\n"
5592 "\t is hit and has value of greater than 1 for the 'nr_rq' event field.\n"
5596 "\t echo '!<trigger> > <system>/<event>/trigger\n"
5598 "\t echo '!<trigger>:0 > <system>/<event>/trigger\n"
5601 " hist trigger\t- If set, event hits are aggregated into a hash table\n"
5614 "\t common_cpu - to record the CPU the event happened on\n"
5626 "\t When a matching event is hit, an entry is added to a hash\n"
5629 "\t correspond to fields in the event's format description. Keys\n"
5641 "\t Reading the 'hist' file for the event will dump the hash\n"
5643 "\t triggers attached to an event, there will be a table for each\n"
5669 "\t have one event conditionally start and stop another event's\n"
5676 "\t onmatch(matching.event) - invoke on addition or update\n"
5680 "\t trace(<synthetic_event>,param list) - generate synthetic event\n"
5681 "\t save(field,...) - save current event fields\n"
6725 * this event next time, resulting in an infinite loop.
7159 struct ring_buffer_event *event;
7181 event = __trace_buffer_lock_reserve(buffer, TRACE_PRINT, size,
7183 if (unlikely(!event)) {
7203 entry = ring_buffer_event_data(event);
7217 tt = event_triggers_call(tr->trace_marker_file, buffer, entry, event);
7227 ftrace_exports(event, TRACE_EXPORT_MARKER);
7228 __buffer_unlock_commit(buffer, event);
7277 struct ring_buffer_event *event;
7295 event = __trace_buffer_lock_reserve(buffer, TRACE_RAW_DATA, size,
7297 if (!event)
7301 entry = ring_buffer_event_data(event);
7311 __buffer_unlock_commit(buffer, event);
8671 trace_seq_printf(s, "oldest event ts: %5llu.%06lu\n",
8679 trace_seq_printf(s, "oldest event ts: %llu\n",
9948 * @systems: A list of systems to create event directories for (NULL for all)
11017 /* Used for event triggers */