trace_events.c (16419098e8b301417173d8d2cbfa94a56ac9900b) trace_events.c (5790b1fb3d672d9a1fe3881a7181dfdbe741568f)
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>.

--- 970 unchanged lines hidden (view full) ---

979}
980
981static void remove_subsystem(struct trace_subsystem_dir *dir)
982{
983 if (!dir)
984 return;
985
986 if (!--dir->nr_events) {
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>.

--- 970 unchanged lines hidden (view full) ---

979}
980
981static void remove_subsystem(struct trace_subsystem_dir *dir)
982{
983 if (!dir)
984 return;
985
986 if (!--dir->nr_events) {
987 eventfs_remove(dir->ef);
987 eventfs_remove_dir(dir->ei);
988 list_del(&dir->list);
989 __put_system_dir(dir);
990 }
991}
992
993static void remove_event_file_dir(struct trace_event_file *file)
994{
988 list_del(&dir->list);
989 __put_system_dir(dir);
990 }
991}
992
993static void remove_event_file_dir(struct trace_event_file *file)
994{
995 eventfs_remove(file->ef);
995 eventfs_remove_dir(file->ei);
996 list_del(&file->list);
997 remove_subsystem(file->system);
998 free_event_filter(file->filter);
999 kmem_cache_free(file_cachep, file);
1000}
1001
1002/*
1003 * __ftrace_set_clr_event(NULL, NULL, NULL, set) will set/unset all events.

--- 157 unchanged lines hidden (view full) ---

1161 struct trace_parser parser;
1162 struct seq_file *m = file->private_data;
1163 struct trace_array *tr = m->private;
1164 ssize_t read, ret;
1165
1166 if (!cnt)
1167 return 0;
1168
996 list_del(&file->list);
997 remove_subsystem(file->system);
998 free_event_filter(file->filter);
999 kmem_cache_free(file_cachep, file);
1000}
1001
1002/*
1003 * __ftrace_set_clr_event(NULL, NULL, NULL, set) will set/unset all events.

--- 157 unchanged lines hidden (view full) ---

1161 struct trace_parser parser;
1162 struct seq_file *m = file->private_data;
1163 struct trace_array *tr = m->private;
1164 ssize_t read, ret;
1165
1166 if (!cnt)
1167 return 0;
1168
1169 ret = tracing_update_buffers();
1169 ret = tracing_update_buffers(tr);
1170 if (ret < 0)
1171 return ret;
1172
1173 if (trace_parser_get_init(&parser, EVENT_BUF_SIZE + 1))
1174 return -ENOMEM;
1175
1176 read = trace_get_user(&parser, ubuf, cnt, ppos);
1177

--- 214 unchanged lines hidden (view full) ---

1392 struct trace_event_file *file;
1393 unsigned long val;
1394 int ret;
1395
1396 ret = kstrtoul_from_user(ubuf, cnt, 10, &val);
1397 if (ret)
1398 return ret;
1399
1170 if (ret < 0)
1171 return ret;
1172
1173 if (trace_parser_get_init(&parser, EVENT_BUF_SIZE + 1))
1174 return -ENOMEM;
1175
1176 read = trace_get_user(&parser, ubuf, cnt, ppos);
1177

--- 214 unchanged lines hidden (view full) ---

1392 struct trace_event_file *file;
1393 unsigned long val;
1394 int ret;
1395
1396 ret = kstrtoul_from_user(ubuf, cnt, 10, &val);
1397 if (ret)
1398 return ret;
1399
1400 ret = tracing_update_buffers();
1401 if (ret < 0)
1402 return ret;
1403
1404 switch (val) {
1405 case 0:
1406 case 1:
1407 ret = -ENODEV;
1408 mutex_lock(&event_mutex);
1409 file = event_file_data(filp);
1400 switch (val) {
1401 case 0:
1402 case 1:
1403 ret = -ENODEV;
1404 mutex_lock(&event_mutex);
1405 file = event_file_data(filp);
1410 if (likely(file))
1406 if (likely(file)) {
1407 ret = tracing_update_buffers(file->tr);
1408 if (ret < 0) {
1409 mutex_unlock(&event_mutex);
1410 return ret;
1411 }
1411 ret = ftrace_event_enable_disable(file, val);
1412 ret = ftrace_event_enable_disable(file, val);
1413 }
1412 mutex_unlock(&event_mutex);
1413 break;
1414
1415 default:
1416 return -EINVAL;
1417 }
1418
1419 *ppos += cnt;

--- 57 unchanged lines hidden (view full) ---

1477 const char *name = NULL;
1478 unsigned long val;
1479 ssize_t ret;
1480
1481 ret = kstrtoul_from_user(ubuf, cnt, 10, &val);
1482 if (ret)
1483 return ret;
1484
1414 mutex_unlock(&event_mutex);
1415 break;
1416
1417 default:
1418 return -EINVAL;
1419 }
1420
1421 *ppos += cnt;

--- 57 unchanged lines hidden (view full) ---

1479 const char *name = NULL;
1480 unsigned long val;
1481 ssize_t ret;
1482
1483 ret = kstrtoul_from_user(ubuf, cnt, 10, &val);
1484 if (ret)
1485 return ret;
1486
1485 ret = tracing_update_buffers();
1487 ret = tracing_update_buffers(dir->tr);
1486 if (ret < 0)
1487 return ret;
1488
1489 if (val != 0 && val != 1)
1490 return -EINVAL;
1491
1492 /*
1493 * Opening of "enable" adds a ref count to system,

--- 457 unchanged lines hidden (view full) ---

1951 struct trace_pid_list *other_pids = NULL;
1952 struct trace_pid_list *pid_list;
1953 struct trace_event_file *file;
1954 ssize_t ret;
1955
1956 if (!cnt)
1957 return 0;
1958
1488 if (ret < 0)
1489 return ret;
1490
1491 if (val != 0 && val != 1)
1492 return -EINVAL;
1493
1494 /*
1495 * Opening of "enable" adds a ref count to system,

--- 457 unchanged lines hidden (view full) ---

1953 struct trace_pid_list *other_pids = NULL;
1954 struct trace_pid_list *pid_list;
1955 struct trace_event_file *file;
1956 ssize_t ret;
1957
1958 if (!cnt)
1959 return 0;
1960
1959 ret = tracing_update_buffers();
1961 ret = tracing_update_buffers(tr);
1960 if (ret < 0)
1961 return ret;
1962
1963 mutex_lock(&event_mutex);
1964
1965 if (type == TRACE_PIDS) {
1966 filtered_pids = rcu_dereference_protected(tr->filtered_pids,
1967 lockdep_is_held(&event_mutex));

--- 307 unchanged lines hidden (view full) ---

2275 return system;
2276
2277 out_free:
2278 kfree_const(system->name);
2279 kfree(system);
2280 return NULL;
2281}
2282
1962 if (ret < 0)
1963 return ret;
1964
1965 mutex_lock(&event_mutex);
1966
1967 if (type == TRACE_PIDS) {
1968 filtered_pids = rcu_dereference_protected(tr->filtered_pids,
1969 lockdep_is_held(&event_mutex));

--- 307 unchanged lines hidden (view full) ---

2277 return system;
2278
2279 out_free:
2280 kfree_const(system->name);
2281 kfree(system);
2282 return NULL;
2283}
2284
2283static struct eventfs_file *
2285int system_callback(const char *name, umode_t *mode, void **data,
2286 const struct file_operations **fops)
2287{
2288 if (strcmp(name, "filter") == 0)
2289 *fops = &ftrace_subsystem_filter_fops;
2290
2291 else if (strcmp(name, "enable") == 0)
2292 *fops = &ftrace_system_enable_fops;
2293
2294 else
2295 return 0;
2296
2297 *mode = TRACE_MODE_WRITE;
2298 return 1;
2299}
2300
2301static struct eventfs_inode *
2284event_subsystem_dir(struct trace_array *tr, const char *name,
2302event_subsystem_dir(struct trace_array *tr, const char *name,
2285 struct trace_event_file *file, struct dentry *parent)
2303 struct trace_event_file *file, struct eventfs_inode *parent)
2286{
2287 struct event_subsystem *system, *iter;
2288 struct trace_subsystem_dir *dir;
2304{
2305 struct event_subsystem *system, *iter;
2306 struct trace_subsystem_dir *dir;
2289 struct eventfs_file *ef;
2290 int res;
2307 struct eventfs_inode *ei;
2308 int nr_entries;
2309 static struct eventfs_entry system_entries[] = {
2310 {
2311 .name = "filter",
2312 .callback = system_callback,
2313 },
2314 {
2315 .name = "enable",
2316 .callback = system_callback,
2317 }
2318 };
2291
2292 /* First see if we did not already create this dir */
2293 list_for_each_entry(dir, &tr->systems, list) {
2294 system = dir->subsystem;
2295 if (strcmp(system->name, name) == 0) {
2296 dir->nr_events++;
2297 file->system = dir;
2319
2320 /* First see if we did not already create this dir */
2321 list_for_each_entry(dir, &tr->systems, list) {
2322 system = dir->subsystem;
2323 if (strcmp(system->name, name) == 0) {
2324 dir->nr_events++;
2325 file->system = dir;
2298 return dir->ef;
2326 return dir->ei;
2299 }
2300 }
2301
2302 /* Now see if the system itself exists. */
2303 system = NULL;
2304 list_for_each_entry(iter, &event_subsystems, list) {
2305 if (strcmp(iter->name, name) == 0) {
2306 system = iter;

--- 7 unchanged lines hidden (view full) ---

2314
2315 if (!system) {
2316 system = create_new_subsystem(name);
2317 if (!system)
2318 goto out_free;
2319 } else
2320 __get_system(system);
2321
2327 }
2328 }
2329
2330 /* Now see if the system itself exists. */
2331 system = NULL;
2332 list_for_each_entry(iter, &event_subsystems, list) {
2333 if (strcmp(iter->name, name) == 0) {
2334 system = iter;

--- 7 unchanged lines hidden (view full) ---

2342
2343 if (!system) {
2344 system = create_new_subsystem(name);
2345 if (!system)
2346 goto out_free;
2347 } else
2348 __get_system(system);
2349
2322 ef = eventfs_add_subsystem_dir(name, parent);
2323 if (IS_ERR(ef)) {
2350 /* ftrace only has directories no files */
2351 if (strcmp(name, "ftrace") == 0)
2352 nr_entries = 0;
2353 else
2354 nr_entries = ARRAY_SIZE(system_entries);
2355
2356 ei = eventfs_create_dir(name, parent, system_entries, nr_entries, dir);
2357 if (!ei) {
2324 pr_warn("Failed to create system directory %s\n", name);
2325 __put_system(system);
2326 goto out_free;
2327 }
2328
2358 pr_warn("Failed to create system directory %s\n", name);
2359 __put_system(system);
2360 goto out_free;
2361 }
2362
2329 dir->ef = ef;
2363 dir->ei = ei;
2330 dir->tr = tr;
2331 dir->ref_count = 1;
2332 dir->nr_events = 1;
2333 dir->subsystem = system;
2334 file->system = dir;
2335
2364 dir->tr = tr;
2365 dir->ref_count = 1;
2366 dir->nr_events = 1;
2367 dir->subsystem = system;
2368 file->system = dir;
2369
2336 /* the ftrace system is special, do not create enable or filter files */
2337 if (strcmp(name, "ftrace") != 0) {
2338
2339 res = eventfs_add_file("filter", TRACE_MODE_WRITE,
2340 dir->ef, dir,
2341 &ftrace_subsystem_filter_fops);
2342 if (res) {
2343 kfree(system->filter);
2344 system->filter = NULL;
2345 pr_warn("Could not create tracefs '%s/filter' entry\n", name);
2346 }
2347
2348 eventfs_add_file("enable", TRACE_MODE_WRITE, dir->ef, dir,
2349 &ftrace_system_enable_fops);
2350 }
2351
2352 list_add(&dir->list, &tr->systems);
2353
2370 list_add(&dir->list, &tr->systems);
2371
2354 return dir->ef;
2372 return dir->ei;
2355
2356 out_free:
2357 kfree(dir);
2358 out_fail:
2359 /* Only print this message if failed on memory allocation */
2360 if (!dir || !system)
2361 pr_warn("No memory to create event subsystem %s\n", name);
2362 return NULL;

--- 32 unchanged lines hidden (view full) ---

2395
2396 offset += field->size;
2397 }
2398 }
2399
2400 return ret;
2401}
2402
2373
2374 out_free:
2375 kfree(dir);
2376 out_fail:
2377 /* Only print this message if failed on memory allocation */
2378 if (!dir || !system)
2379 pr_warn("No memory to create event subsystem %s\n", name);
2380 return NULL;

--- 32 unchanged lines hidden (view full) ---

2413
2414 offset += field->size;
2415 }
2416 }
2417
2418 return ret;
2419}
2420
2421static int event_callback(const char *name, umode_t *mode, void **data,
2422 const struct file_operations **fops)
2423{
2424 struct trace_event_file *file = *data;
2425 struct trace_event_call *call = file->event_call;
2426
2427 if (strcmp(name, "format") == 0) {
2428 *mode = TRACE_MODE_READ;
2429 *fops = &ftrace_event_format_fops;
2430 *data = call;
2431 return 1;
2432 }
2433
2434 /*
2435 * Only event directories that can be enabled should have
2436 * triggers or filters, with the exception of the "print"
2437 * event that can have a "trigger" file.
2438 */
2439 if (!(call->flags & TRACE_EVENT_FL_IGNORE_ENABLE)) {
2440 if (call->class->reg && strcmp(name, "enable") == 0) {
2441 *mode = TRACE_MODE_WRITE;
2442 *fops = &ftrace_enable_fops;
2443 return 1;
2444 }
2445
2446 if (strcmp(name, "filter") == 0) {
2447 *mode = TRACE_MODE_WRITE;
2448 *fops = &ftrace_event_filter_fops;
2449 return 1;
2450 }
2451 }
2452
2453 if (!(call->flags & TRACE_EVENT_FL_IGNORE_ENABLE) ||
2454 strcmp(trace_event_name(call), "print") == 0) {
2455 if (strcmp(name, "trigger") == 0) {
2456 *mode = TRACE_MODE_WRITE;
2457 *fops = &event_trigger_fops;
2458 return 1;
2459 }
2460 }
2461
2462#ifdef CONFIG_PERF_EVENTS
2463 if (call->event.type && call->class->reg &&
2464 strcmp(name, "id") == 0) {
2465 *mode = TRACE_MODE_READ;
2466 *data = (void *)(long)call->event.type;
2467 *fops = &ftrace_event_id_fops;
2468 return 1;
2469 }
2470#endif
2471
2472#ifdef CONFIG_HIST_TRIGGERS
2473 if (strcmp(name, "hist") == 0) {
2474 *mode = TRACE_MODE_READ;
2475 *fops = &event_hist_fops;
2476 return 1;
2477 }
2478#endif
2479#ifdef CONFIG_HIST_TRIGGERS_DEBUG
2480 if (strcmp(name, "hist_debug") == 0) {
2481 *mode = TRACE_MODE_READ;
2482 *fops = &event_hist_debug_fops;
2483 return 1;
2484 }
2485#endif
2486#ifdef CONFIG_TRACE_EVENT_INJECT
2487 if (call->event.type && call->class->reg &&
2488 strcmp(name, "inject") == 0) {
2489 *mode = 0200;
2490 *fops = &event_inject_fops;
2491 return 1;
2492 }
2493#endif
2494 return 0;
2495}
2496
2403static int
2497static int
2404event_create_dir(struct dentry *parent, struct trace_event_file *file)
2498event_create_dir(struct eventfs_inode *parent, struct trace_event_file *file)
2405{
2406 struct trace_event_call *call = file->event_call;
2499{
2500 struct trace_event_call *call = file->event_call;
2407 struct eventfs_file *ef_subsystem = NULL;
2408 struct trace_array *tr = file->tr;
2501 struct trace_array *tr = file->tr;
2409 struct eventfs_file *ef;
2502 struct eventfs_inode *e_events;
2503 struct eventfs_inode *ei;
2410 const char *name;
2504 const char *name;
2505 int nr_entries;
2411 int ret;
2506 int ret;
2507 static struct eventfs_entry event_entries[] = {
2508 {
2509 .name = "enable",
2510 .callback = event_callback,
2511 },
2512 {
2513 .name = "filter",
2514 .callback = event_callback,
2515 },
2516 {
2517 .name = "trigger",
2518 .callback = event_callback,
2519 },
2520 {
2521 .name = "format",
2522 .callback = event_callback,
2523 },
2524#ifdef CONFIG_PERF_EVENTS
2525 {
2526 .name = "id",
2527 .callback = event_callback,
2528 },
2529#endif
2530#ifdef CONFIG_HIST_TRIGGERS
2531 {
2532 .name = "hist",
2533 .callback = event_callback,
2534 },
2535#endif
2536#ifdef CONFIG_HIST_TRIGGERS_DEBUG
2537 {
2538 .name = "hist_debug",
2539 .callback = event_callback,
2540 },
2541#endif
2542#ifdef CONFIG_TRACE_EVENT_INJECT
2543 {
2544 .name = "inject",
2545 .callback = event_callback,
2546 },
2547#endif
2548 };
2412
2413 /*
2414 * If the trace point header did not define TRACE_SYSTEM
2415 * then the system would be called "TRACE_SYSTEM". This should
2416 * never happen.
2417 */
2418 if (WARN_ON_ONCE(strcmp(call->class->system, TRACE_SYSTEM) == 0))
2419 return -ENODEV;
2420
2549
2550 /*
2551 * If the trace point header did not define TRACE_SYSTEM
2552 * then the system would be called "TRACE_SYSTEM". This should
2553 * never happen.
2554 */
2555 if (WARN_ON_ONCE(strcmp(call->class->system, TRACE_SYSTEM) == 0))
2556 return -ENODEV;
2557
2421 ef_subsystem = event_subsystem_dir(tr, call->class->system, file, parent);
2422 if (!ef_subsystem)
2558 e_events = event_subsystem_dir(tr, call->class->system, file, parent);
2559 if (!e_events)
2423 return -ENOMEM;
2424
2560 return -ENOMEM;
2561
2562 nr_entries = ARRAY_SIZE(event_entries);
2563
2425 name = trace_event_name(call);
2564 name = trace_event_name(call);
2426 ef = eventfs_add_dir(name, ef_subsystem);
2427 if (IS_ERR(ef)) {
2565 ei = eventfs_create_dir(name, e_events, event_entries, nr_entries, file);
2566 if (IS_ERR(ei)) {
2428 pr_warn("Could not create tracefs '%s' directory\n", name);
2429 return -1;
2430 }
2431
2567 pr_warn("Could not create tracefs '%s' directory\n", name);
2568 return -1;
2569 }
2570
2432 file->ef = ef;
2571 file->ei = ei;
2433
2572
2434 if (call->class->reg && !(call->flags & TRACE_EVENT_FL_IGNORE_ENABLE))
2435 eventfs_add_file("enable", TRACE_MODE_WRITE, file->ef, file,
2436 &ftrace_enable_fops);
2437
2438#ifdef CONFIG_PERF_EVENTS
2439 if (call->event.type && call->class->reg)
2440 eventfs_add_file("id", TRACE_MODE_READ, file->ef,
2441 (void *)(long)call->event.type,
2442 &ftrace_event_id_fops);
2443#endif
2444
2445 ret = event_define_fields(call);
2446 if (ret < 0) {
2447 pr_warn("Could not initialize trace point events/%s\n", name);
2448 return ret;
2449 }
2450
2573 ret = event_define_fields(call);
2574 if (ret < 0) {
2575 pr_warn("Could not initialize trace point events/%s\n", name);
2576 return ret;
2577 }
2578
2451 /*
2452 * Only event directories that can be enabled should have
2453 * triggers or filters.
2454 */
2455 if (!(call->flags & TRACE_EVENT_FL_IGNORE_ENABLE)) {
2456 eventfs_add_file("filter", TRACE_MODE_WRITE, file->ef,
2457 file, &ftrace_event_filter_fops);
2458
2459 eventfs_add_file("trigger", TRACE_MODE_WRITE, file->ef,
2460 file, &event_trigger_fops);
2461 }
2462
2463#ifdef CONFIG_HIST_TRIGGERS
2464 eventfs_add_file("hist", TRACE_MODE_READ, file->ef, file,
2465 &event_hist_fops);
2466#endif
2467#ifdef CONFIG_HIST_TRIGGERS_DEBUG
2468 eventfs_add_file("hist_debug", TRACE_MODE_READ, file->ef, file,
2469 &event_hist_debug_fops);
2470#endif
2471 eventfs_add_file("format", TRACE_MODE_READ, file->ef, call,
2472 &ftrace_event_format_fops);
2473
2474#ifdef CONFIG_TRACE_EVENT_INJECT
2475 if (call->event.type && call->class->reg)
2476 eventfs_add_file("inject", 0200, file->ef, file,
2477 &event_inject_fops);
2478#endif
2479
2480 return 0;
2481}
2482
2483static void remove_event_from_tracers(struct trace_event_call *call)
2484{
2485 struct trace_event_file *file;
2486 struct trace_array *tr;
2487

--- 277 unchanged lines hidden (view full) ---

2765 if (first) {
2766 last_i = i;
2767 first = false;
2768 }
2769 update_event_printk(call, map[i]);
2770 update_event_fields(call, map[i]);
2771 }
2772 }
2579 return 0;
2580}
2581
2582static void remove_event_from_tracers(struct trace_event_call *call)
2583{
2584 struct trace_event_file *file;
2585 struct trace_array *tr;
2586

--- 277 unchanged lines hidden (view full) ---

2864 if (first) {
2865 last_i = i;
2866 first = false;
2867 }
2868 update_event_printk(call, map[i]);
2869 update_event_fields(call, map[i]);
2870 }
2871 }
2872 cond_resched();
2773 }
2774 up_write(&trace_event_sem);
2775}
2776
2777static struct trace_event_file *
2778trace_create_new_event(struct trace_event_call *call,
2779 struct trace_array *tr)
2780{

--- 37 unchanged lines hidden (view full) ---

2818
2819static __init int setup_trace_triggers(char *str)
2820{
2821 char *trigger;
2822 char *buf;
2823 int i;
2824
2825 strscpy(bootup_trigger_buf, str, COMMAND_LINE_SIZE);
2873 }
2874 up_write(&trace_event_sem);
2875}
2876
2877static struct trace_event_file *
2878trace_create_new_event(struct trace_event_call *call,
2879 struct trace_array *tr)
2880{

--- 37 unchanged lines hidden (view full) ---

2918
2919static __init int setup_trace_triggers(char *str)
2920{
2921 char *trigger;
2922 char *buf;
2923 int i;
2924
2925 strscpy(bootup_trigger_buf, str, COMMAND_LINE_SIZE);
2826 ring_buffer_expanded = true;
2926 trace_set_ring_buffer_expanded(NULL);
2827 disable_tracing_selftest("running event triggers");
2828
2829 buf = bootup_trigger_buf;
2830 for (i = 0; i < MAX_BOOT_TRIGGERS; i++) {
2831 trigger = strsep(&buf, ",");
2832 if (!trigger)
2833 break;
2834 bootup_triggers[i].event = strsep(&trigger, ".");

--- 773 unchanged lines hidden (view full) ---

3608extern struct trace_event_call *__start_ftrace_events[];
3609extern struct trace_event_call *__stop_ftrace_events[];
3610
3611static char bootup_event_buf[COMMAND_LINE_SIZE] __initdata;
3612
3613static __init int setup_trace_event(char *str)
3614{
3615 strscpy(bootup_event_buf, str, COMMAND_LINE_SIZE);
2927 disable_tracing_selftest("running event triggers");
2928
2929 buf = bootup_trigger_buf;
2930 for (i = 0; i < MAX_BOOT_TRIGGERS; i++) {
2931 trigger = strsep(&buf, ",");
2932 if (!trigger)
2933 break;
2934 bootup_triggers[i].event = strsep(&trigger, ".");

--- 773 unchanged lines hidden (view full) ---

3708extern struct trace_event_call *__start_ftrace_events[];
3709extern struct trace_event_call *__stop_ftrace_events[];
3710
3711static char bootup_event_buf[COMMAND_LINE_SIZE] __initdata;
3712
3713static __init int setup_trace_event(char *str)
3714{
3715 strscpy(bootup_event_buf, str, COMMAND_LINE_SIZE);
3616 ring_buffer_expanded = true;
3716 trace_set_ring_buffer_expanded(NULL);
3617 disable_tracing_selftest("running event tracing");
3618
3619 return 1;
3620}
3621__setup("trace_event=", setup_trace_event);
3622
3717 disable_tracing_selftest("running event tracing");
3718
3719 return 1;
3720}
3721__setup("trace_event=", setup_trace_event);
3722
3723static int events_callback(const char *name, umode_t *mode, void **data,
3724 const struct file_operations **fops)
3725{
3726 if (strcmp(name, "enable") == 0) {
3727 *mode = TRACE_MODE_WRITE;
3728 *fops = &ftrace_tr_enable_fops;
3729 return 1;
3730 }
3731
3732 if (strcmp(name, "header_page") == 0)
3733 *data = ring_buffer_print_page_header;
3734
3735 else if (strcmp(name, "header_event") == 0)
3736 *data = ring_buffer_print_entry_header;
3737
3738 else
3739 return 0;
3740
3741 *mode = TRACE_MODE_READ;
3742 *fops = &ftrace_show_header_fops;
3743 return 1;
3744}
3745
3623/* Expects to have event_mutex held when called */
3624static int
3625create_event_toplevel_files(struct dentry *parent, struct trace_array *tr)
3626{
3746/* Expects to have event_mutex held when called */
3747static int
3748create_event_toplevel_files(struct dentry *parent, struct trace_array *tr)
3749{
3627 struct dentry *d_events;
3750 struct eventfs_inode *e_events;
3628 struct dentry *entry;
3751 struct dentry *entry;
3629 int error = 0;
3752 int nr_entries;
3753 static struct eventfs_entry events_entries[] = {
3754 {
3755 .name = "enable",
3756 .callback = events_callback,
3757 },
3758 {
3759 .name = "header_page",
3760 .callback = events_callback,
3761 },
3762 {
3763 .name = "header_event",
3764 .callback = events_callback,
3765 },
3766 };
3630
3631 entry = trace_create_file("set_event", TRACE_MODE_WRITE, parent,
3632 tr, &ftrace_set_event_fops);
3633 if (!entry)
3634 return -ENOMEM;
3635
3767
3768 entry = trace_create_file("set_event", TRACE_MODE_WRITE, parent,
3769 tr, &ftrace_set_event_fops);
3770 if (!entry)
3771 return -ENOMEM;
3772
3636 d_events = eventfs_create_events_dir("events", parent);
3637 if (IS_ERR(d_events)) {
3773 nr_entries = ARRAY_SIZE(events_entries);
3774
3775 e_events = eventfs_create_events_dir("events", parent, events_entries,
3776 nr_entries, tr);
3777 if (IS_ERR(e_events)) {
3638 pr_warn("Could not create tracefs 'events' directory\n");
3639 return -ENOMEM;
3640 }
3641
3778 pr_warn("Could not create tracefs 'events' directory\n");
3779 return -ENOMEM;
3780 }
3781
3642 error = eventfs_add_events_file("enable", TRACE_MODE_WRITE, d_events,
3643 tr, &ftrace_tr_enable_fops);
3644 if (error)
3645 return -ENOMEM;
3646
3647 /* There are not as crucial, just warn if they are not created */
3648
3649 trace_create_file("set_event_pid", TRACE_MODE_WRITE, parent,
3650 tr, &ftrace_set_event_pid_fops);
3651
3652 trace_create_file("set_event_notrace_pid",
3653 TRACE_MODE_WRITE, parent, tr,
3654 &ftrace_set_event_notrace_pid_fops);
3655
3782 /* There are not as crucial, just warn if they are not created */
3783
3784 trace_create_file("set_event_pid", TRACE_MODE_WRITE, parent,
3785 tr, &ftrace_set_event_pid_fops);
3786
3787 trace_create_file("set_event_notrace_pid",
3788 TRACE_MODE_WRITE, parent, tr,
3789 &ftrace_set_event_notrace_pid_fops);
3790
3656 /* ring buffer internal formats */
3657 eventfs_add_events_file("header_page", TRACE_MODE_READ, d_events,
3658 ring_buffer_print_page_header,
3659 &ftrace_show_header_fops);
3791 tr->event_dir = e_events;
3660
3792
3661 eventfs_add_events_file("header_event", TRACE_MODE_READ, d_events,
3662 ring_buffer_print_entry_header,
3663 &ftrace_show_header_fops);
3664
3665 tr->event_dir = d_events;
3666
3667 return 0;
3668}
3669
3670/**
3671 * event_trace_add_tracer - add a instance of a trace_array to events
3672 * @parent: The parent dentry to place the files/directories for events in
3673 * @tr: The trace array associated with these events
3674 *

--- 66 unchanged lines hidden (view full) ---

3741 /* Disable any running events */
3742 __ftrace_set_clr_event_nolock(tr, NULL, NULL, NULL, 0);
3743
3744 /* Make sure no more events are being executed */
3745 tracepoint_synchronize_unregister();
3746
3747 down_write(&trace_event_sem);
3748 __trace_remove_event_dirs(tr);
3793 return 0;
3794}
3795
3796/**
3797 * event_trace_add_tracer - add a instance of a trace_array to events
3798 * @parent: The parent dentry to place the files/directories for events in
3799 * @tr: The trace array associated with these events
3800 *

--- 66 unchanged lines hidden (view full) ---

3867 /* Disable any running events */
3868 __ftrace_set_clr_event_nolock(tr, NULL, NULL, NULL, 0);
3869
3870 /* Make sure no more events are being executed */
3871 tracepoint_synchronize_unregister();
3872
3873 down_write(&trace_event_sem);
3874 __trace_remove_event_dirs(tr);
3749 eventfs_remove_events_dir(tr->event_dir);
3875 eventfs_remove_dir(tr->event_dir);
3750 up_write(&trace_event_sem);
3751
3752 tr->event_dir = NULL;
3753
3754 return 0;
3755}
3756
3757static __init int event_trace_memsetup(void)

--- 392 unchanged lines hidden --- 		3876 up_write(&trace_event_sem);
3877
3878 tr->event_dir = NULL;
3879
3880 return 0;
3881}
3882
3883static __init int event_trace_memsetup(void)

--- 392 unchanged lines hidden ---