Lines Matching refs:user
45 * probes to print out to the user.
47 * These do not reflect the mapped bytes between the user and kernel space.
201 typedef void (*user_event_func_t) (struct user_event *user, struct iov_iter *i,
209 static struct user_event_mm *user_event_mm_get_all(struct user_event *user);
211 static int destroy_user_event(struct user_event *user);
212 static bool user_fields_match(struct user_event *user, int argc,
231 static struct user_event *user_event_get(struct user_event *user)
233 refcount_inc(&user->refcnt);
235 return user;
240 struct user_event *user = container_of(
245 if (!refcount_dec_and_test(&user->refcnt))
248 if (destroy_user_event(user)) {
256 refcount_set(&user->refcnt, 1);
262 static void user_event_put(struct user_event *user, bool locked)
266 if (unlikely(!user))
282 delete = refcount_dec_and_mutex_lock(&user->refcnt, &event_mutex);
285 delete = refcount_dec_and_test(&user->refcnt);
298 if (user->reg_flags & USER_EVENT_REG_PERSIST) {
309 INIT_WORK(&user->put_work, delayed_destroy_user_event);
315 * needed because a user-process could register the same event in
319 * user process would fail a register because the trace_event_call
322 refcount_set(&user->refcnt, 1);
324 if (WARN_ON_ONCE(!schedule_work(&user->put_work))) {
418 * bad user processes to cause excessive looping.
456 struct user_event *user = enabler->event;
459 mm->mm, (unsigned long long)uaddr, EVENT_NAME(user));
567 /* Update bit atomically, user tracers must be atomic as well */
592 static void user_event_enabler_update(struct user_event *user)
612 mm = user_event_mm_get_all(user);
619 if (enabler->event == user) {
664 static struct user_event_mm *user_event_mm_get_all(struct user_event *user)
674 * when user based events are most wanted for diagnostics.
686 * Each user mm returned has a ref inc to handle remove RCU races.
692 if (enabler->event == user) {
882 *user_event_enabler_create(struct user_reg *reg, struct user_event *user,
900 enabler->event = user;
928 user_event_get(user);
949 bool user_event_last_ref(struct user_event *user)
953 if (user->reg_flags & USER_EVENT_REG_PERSIST)
956 return refcount_read(&user->refcnt) == last;
975 struct user_event *user = (struct user_event *)call->data;
977 return &user->fields;
988 * NOTE: Offsets are from the user data perspective, they are not from the
990 * sizes to the offset for the user.
1044 /* long is not allowed from a user, since it's ambigious in size */
1086 static void user_event_destroy_validators(struct user_event *user)
1089 struct list_head *head = &user->validators;
1097 static void user_event_destroy_fields(struct user_event *user)
1100 struct list_head *head = &user->fields;
1108 static int user_event_add_field(struct user_event *user, const char *type,
1146 list_add_tail(&validator->user_event_link, &user->validators);
1159 list_add(&field->link, &user->fields);
1162 * Min size from user writes that are required, this does not include
1165 user->min_size = (offset + size) - sizeof(struct trace_entry);
1174 static int user_event_parse_field(char *field, struct user_event *user,
1261 return user_event_add_field(user, type, name, saved_offset, size,
1265 static int user_event_parse_fields(struct user_event *user, char *args)
1275 ret = user_event_parse_field(field, user, &offset);
1386 static int user_event_set_print_fmt(struct user_event *user, char *buf, int len)
1389 struct list_head *head = &user->fields;
1420 static int user_event_create_print_fmt(struct user_event *user)
1425 len = user_event_set_print_fmt(user, NULL, 0);
1432 user_event_set_print_fmt(user, print_fmt, len);
1434 user->call.print_fmt = print_fmt;
1450 static int user_event_set_call_visible(struct user_event *user, bool visible)
1475 ret = trace_add_event_call(&user->call);
1477 ret = trace_remove_event_call(&user->call);
1485 static int destroy_user_event(struct user_event *user)
1492 user_event_destroy_fields(user);
1494 ret = user_event_set_call_visible(user, false);
1499 dyn_event_remove(&user->devent);
1500 hash_del(&user->node);
1502 user_event_destroy_validators(user);
1505 if (EVENT_NAME(user) != EVENT_TP_NAME(user))
1506 kfree(EVENT_TP_NAME(user));
1508 kfree(user->call.print_fmt);
1509 kfree(EVENT_NAME(user));
1510 kfree(user);
1524 struct user_event *user;
1529 hash_for_each_possible(group->register_table, user, node, key) {
1535 if (EVENT_MULTI_FORMAT(flags) != EVENT_MULTI_FORMAT(user->reg_flags))
1538 if (strcmp(EVENT_NAME(user), name))
1541 if (user_fields_match(user, argc, argv))
1542 return user_event_get(user);
1554 static int user_event_validate(struct user_event *user, void *data, int len)
1556 struct list_head *head = &user->validators;
1588 * Writes the user supplied payload out to a trace file.
1590 static void user_event_ftrace(struct user_event *user, struct iov_iter *i,
1614 if (!list_empty(&user->validators) &&
1615 unlikely(user_event_validate(user, entry, size)))
1629 * Writes the user supplied payload out to perf ring buffer.
1631 static void user_event_perf(struct user_event *user, struct iov_iter *i,
1636 perf_head = this_cpu_ptr(user->call.perf_events);
1655 if (!list_empty(&user->validators) &&
1656 unlikely(user_event_validate(user, perf_entry, size)))
1660 user->call.event.type, 1, regs,
1672 * Update the enabled bit among all user processes.
1674 static void update_enable_bit_for(struct user_event *user)
1676 struct tracepoint *tp = &user->tracepoint;
1705 user->status = status;
1707 user_event_enabler_update(user);
1717 struct user_event *user = (struct user_event *)call->data;
1720 if (!user)
1763 user_event_get(user);
1764 update_enable_bit_for(user);
1767 update_enable_bit_for(user);
1768 user_event_put(user, true);
1775 struct user_event *user;
1800 ret = user_event_parse_cmd(group, name, &user, USER_EVENT_REG_PERSIST);
1803 user_event_put(user, false);
1815 struct user_event *user = container_of(ev, struct user_event, devent);
1820 seq_printf(m, "%s%s", USER_EVENTS_PREFIX, EVENT_NAME(user));
1822 head = trace_get_fields(&user->call);
1845 struct user_event *user = container_of(ev, struct user_event, devent);
1847 return !user_event_last_ref(user);
1852 struct user_event *user = container_of(ev, struct user_event, devent);
1854 if (!user_event_last_ref(user))
1857 if (!user_event_capable(user->reg_flags))
1860 return destroy_user_event(user);
1900 static bool user_fields_match(struct user_event *user, int argc,
1904 struct list_head *head = &user->fields;
1924 struct user_event *user = container_of(ev, struct user_event, devent);
1927 match = strcmp(EVENT_NAME(user), event) == 0;
1930 match = strcmp(system, user->group->system_name) == 0 ||
1931 strcmp(system, user->group->system_multi_name) == 0;
1935 match = user_fields_match(user, argc, argv);
1948 static int user_event_trace_register(struct user_event *user)
1952 ret = register_trace_event(&user->call.event);
1957 ret = user_event_set_call_visible(user, true);
1960 unregister_trace_event(&user->call.event);
1965 static int user_event_set_tp_name(struct user_event *user)
1967 lockdep_assert_held(&user->group->reg_mutex);
1969 if (EVENT_MULTI_FORMAT(user->reg_flags)) {
1973 user->reg_name, user->group->multi_id);
1978 user->call.name = multi_name;
1979 user->tracepoint.name = multi_name;
1982 user->group->multi_id++;
1985 user->call.name = user->reg_name;
1986 user->tracepoint.name = user->reg_name;
2001 struct user_event *user;
2023 user = find_user_event(group, name, argc, (const char **)argv,
2030 if (IS_ERR(user))
2031 return PTR_ERR(user);
2033 if (user) {
2034 *newuser = user;
2044 user = kzalloc(sizeof(*user), GFP_KERNEL_ACCOUNT);
2046 if (!user)
2049 INIT_LIST_HEAD(&user->class.fields);
2050 INIT_LIST_HEAD(&user->fields);
2051 INIT_LIST_HEAD(&user->validators);
2053 user->group = group;
2054 user->reg_name = name;
2055 user->reg_flags = reg_flags;
2057 ret = user_event_set_tp_name(user);
2062 ret = user_event_parse_fields(user, args);
2067 ret = user_event_create_print_fmt(user);
2072 user->call.data = user;
2073 user->call.class = &user->class;
2074 user->call.flags = TRACE_EVENT_FL_TRACEPOINT;
2075 user->call.tp = &user->tracepoint;
2076 user->call.event.funcs = &user_event_funcs;
2078 if (EVENT_MULTI_FORMAT(user->reg_flags))
2079 user->class.system = group->system_multi_name;
2081 user->class.system = group->system_name;
2083 user->class.fields_array = user_event_fields_array;
2084 user->class.get_fields = user_event_get_fields;
2085 user->class.reg = user_event_reg;
2086 user->class.probe = user_event_ftrace;
2088 user->class.perf_probe = user_event_perf;
2098 ret = user_event_trace_register(user);
2103 if (user->reg_flags & USER_EVENT_REG_PERSIST) {
2105 refcount_set(&user->refcnt, 2);
2108 refcount_set(&user->refcnt, 1);
2111 dyn_event_init(&user->devent, &user_event_dops);
2112 dyn_event_add(&user->devent, &user->call);
2113 hash_add(group->register_table, &user->node, key);
2118 *newuser = user;
2123 user_event_destroy_fields(user);
2124 user_event_destroy_validators(user);
2125 kfree(user->call.print_fmt);
2128 if (EVENT_NAME(user) != EVENT_TP_NAME(user))
2129 kfree(EVENT_TP_NAME(user));
2131 kfree(user);
2140 struct user_event *user;
2146 hash_for_each_possible_safe(group->register_table, user, tmp, node, key) {
2147 if (strcmp(EVENT_NAME(user), name))
2150 if (!user_event_last_ref(user))
2153 if (!user_event_capable(user->reg_flags))
2156 ret = destroy_user_event(user);
2166 * Validates the user payload and writes via iterator.
2172 struct user_event *user = NULL;
2189 * added. But the user retrieved from indexing into the events array
2193 user = refs->events[idx];
2197 if (unlikely(user == NULL))
2200 if (unlikely(i->count < user->min_size))
2203 tp = &user->tracepoint;
2230 probe_func(user, ©, tpdata, &faulted);
2286 struct user_event *user)
2299 if (refs->events[i] == user)
2315 new_refs->events[i] = user_event_get(user);
2383 * Registers a user_event on behalf of a user process.
2390 struct user_event *user;
2404 * for user processes that is far easier to debug if this is explictly
2419 ret = user_event_parse_cmd(info->group, name, &user, reg.flags);
2426 ret = user_events_ref_add(info, user);
2429 user_event_put(user, false);
2447 enabler = user_event_enabler_create(®, user, &write_result);
2462 * Deletes a user_event on behalf of a user process.
2544 * Unregisters an enablement address/bit within a task/user mm.
2593 /* Ensure bit is now cleared for user, regardless of event status */
2602 * Handles the ioctl from user mode to register or alter operations.
2635 * Handles the final close of the file from user mode.
2708 struct user_event *user;
2717 hash_for_each(group->register_table, i, user, node) {
2718 status = user->status;
2720 seq_printf(m, "%s", EVENT_TP_NAME(user));
2786 * Creates a set of tracefs files to allow user mode interactions.