tracing: Merge struct event_trigger_ops into struct event_command

+79 -103

kernel/trace/trace.h

··· 1798 1798 unsigned long count; 1799 1799 int ref; 1800 1800 int flags; 1801 - const struct event_trigger_ops *ops; 1802 1801 struct event_command *cmd_ops; 1803 1802 struct event_filter __rcu *filter; 1804 1803 char *filter_str; ··· 1889 1890 extern void event_file_put(struct trace_event_file *file); 1890 1891 1891 1892 /** 1892 - * struct event_trigger_ops - callbacks for trace event triggers 1893 + * struct event_command - callbacks and data members for event commands 1893 1894 * 1894 - * The methods in this structure provide per-event trigger hooks for 1895 - * various trigger operations. 1895 + * Event commands are invoked by users by writing the command name 1896 + * into the 'trigger' file associated with a trace event. The 1897 + * parameters associated with a specific invocation of an event 1898 + * command are used to create an event trigger instance, which is 1899 + * added to the list of trigger instances associated with that trace 1900 + * event. When the event is hit, the set of triggers associated with 1901 + * that event is invoked. 1896 1902 * 1897 - * The @init and @free methods are used during trigger setup and 1898 - * teardown, typically called from an event_command's @parse() 1899 - * function implementation. 1903 + * The data members in this structure provide per-event command data 1904 + * for various event commands. 1900 1905 * 1901 - * The @print method is used to print the trigger spec. 1906 + * All the data members below, except for @post_trigger, must be set 1907 + * for each event command. 1902 1908 * 1903 - * The @trigger method is the function that actually implements the 1904 - * trigger and is called in the context of the triggering event 1905 - * whenever that event occurs. 1909 + * @name: The unique name that identifies the event command. This is 1910 + * the name used when setting triggers via trigger files. 1911 + * 1912 + * @trigger_type: A unique id that identifies the event command 1913 + * 'type'. This value has two purposes, the first to ensure that 1914 + * only one trigger of the same type can be set at a given time 1915 + * for a particular event e.g. it doesn't make sense to have both 1916 + * a traceon and traceoff trigger attached to a single event at 1917 + * the same time, so traceon and traceoff have the same type 1918 + * though they have different names. The @trigger_type value is 1919 + * also used as a bit value for deferring the actual trigger 1920 + * action until after the current event is finished. Some 1921 + * commands need to do this if they themselves log to the trace 1922 + * buffer (see the @post_trigger() member below). @trigger_type 1923 + * values are defined by adding new values to the trigger_type 1924 + * enum in include/linux/trace_events.h. 1925 + * 1926 + * @flags: See the enum event_command_flags below. 1927 + * 1928 + * All the methods below, except for @set_filter() and @unreg_all(), 1929 + * must be implemented. 1930 + * 1931 + * @parse: The callback function responsible for parsing and 1932 + * registering the trigger written to the 'trigger' file by the 1933 + * user. It allocates the trigger instance and registers it with 1934 + * the appropriate trace event. It makes use of the other 1935 + * event_command callback functions to orchestrate this, and is 1936 + * usually implemented by the generic utility function 1937 + * @event_trigger_callback() (see trace_event_triggers.c). 1938 + * 1939 + * @reg: Adds the trigger to the list of triggers associated with the 1940 + * event, and enables the event trigger itself, after 1941 + * initializing it (via the event_command @init() function). 1942 + * This is also where commands can use the @trigger_type value to 1943 + * make the decision as to whether or not multiple instances of 1944 + * the trigger should be allowed. This is usually implemented by 1945 + * the generic utility function @register_trigger() (see 1946 + * trace_event_triggers.c). 1947 + * 1948 + * @unreg: Removes the trigger from the list of triggers associated 1949 + * with the event, and disables the event trigger itself, after 1950 + * initializing it (via the event_command @free() function). 1951 + * This is usually implemented by the generic utility function 1952 + * @unregister_trigger() (see trace_event_triggers.c). 1953 + * 1954 + * @unreg_all: An optional function called to remove all the triggers 1955 + * from the list of triggers associated with the event. Called 1956 + * when a trigger file is opened in truncate mode. 1957 + * 1958 + * @set_filter: An optional function called to parse and set a filter 1959 + * for the trigger. If no @set_filter() method is set for the 1960 + * event command, filters set by the user for the command will be 1961 + * ignored. This is usually implemented by the generic utility 1962 + * function @set_trigger_filter() (see trace_event_triggers.c). 1906 1963 * 1907 1964 * All the methods below, except for @init() and @free(), must be 1908 1965 * implemented. ··· 1996 1941 * that calls the generic utility function @event_trigger_print() 1997 1942 * (see trace_event_triggers.c). 1998 1943 */ 1999 - struct event_trigger_ops { 2000 - void (*trigger)(struct event_trigger_data *data, 2001 - struct trace_buffer *buffer, 2002 - void *rec, 2003 - struct ring_buffer_event *rbe); 2004 - bool (*count_func)(struct event_trigger_data *data, 2005 - struct trace_buffer *buffer, 2006 - void *rec, 2007 - struct ring_buffer_event *rbe); 2008 - int (*init)(struct event_trigger_data *data); 2009 - void (*free)(struct event_trigger_data *data); 2010 - int (*print)(struct seq_file *m, 2011 - struct event_trigger_data *data); 2012 - }; 2013 - 2014 - /** 2015 - * struct event_command - callbacks and data members for event commands 2016 - * 2017 - * Event commands are invoked by users by writing the command name 2018 - * into the 'trigger' file associated with a trace event. The 2019 - * parameters associated with a specific invocation of an event 2020 - * command are used to create an event trigger instance, which is 2021 - * added to the list of trigger instances associated with that trace 2022 - * event. When the event is hit, the set of triggers associated with 2023 - * that event is invoked. 2024 - * 2025 - * The data members in this structure provide per-event command data 2026 - * for various event commands. 2027 - * 2028 - * All the data members below, except for @post_trigger, must be set 2029 - * for each event command. 2030 - * 2031 - * @name: The unique name that identifies the event command. This is 2032 - * the name used when setting triggers via trigger files. 2033 - * 2034 - * @trigger_ops: The event_trigger_ops implementation associated with 2035 - * the command. 2036 - * 2037 - * @trigger_type: A unique id that identifies the event command 2038 - * 'type'. This value has two purposes, the first to ensure that 2039 - * only one trigger of the same type can be set at a given time 2040 - * for a particular event e.g. it doesn't make sense to have both 2041 - * a traceon and traceoff trigger attached to a single event at 2042 - * the same time, so traceon and traceoff have the same type 2043 - * though they have different names. The @trigger_type value is 2044 - * also used as a bit value for deferring the actual trigger 2045 - * action until after the current event is finished. Some 2046 - * commands need to do this if they themselves log to the trace 2047 - * buffer (see the @post_trigger() member below). @trigger_type 2048 - * values are defined by adding new values to the trigger_type 2049 - * enum in include/linux/trace_events.h. 2050 - * 2051 - * @flags: See the enum event_command_flags below. 2052 - * 2053 - * All the methods below, except for @set_filter() and @unreg_all(), 2054 - * must be implemented. 2055 - * 2056 - * @parse: The callback function responsible for parsing and 2057 - * registering the trigger written to the 'trigger' file by the 2058 - * user. It allocates the trigger instance and registers it with 2059 - * the appropriate trace event. It makes use of the other 2060 - * event_command callback functions to orchestrate this, and is 2061 - * usually implemented by the generic utility function 2062 - * @event_trigger_callback() (see trace_event_triggers.c). 2063 - * 2064 - * @reg: Adds the trigger to the list of triggers associated with the 2065 - * event, and enables the event trigger itself, after 2066 - * initializing it (via the event_trigger_ops @init() function). 2067 - * This is also where commands can use the @trigger_type value to 2068 - * make the decision as to whether or not multiple instances of 2069 - * the trigger should be allowed. This is usually implemented by 2070 - * the generic utility function @register_trigger() (see 2071 - * trace_event_triggers.c). 2072 - * 2073 - * @unreg: Removes the trigger from the list of triggers associated 2074 - * with the event, and disables the event trigger itself, after 2075 - * initializing it (via the event_trigger_ops @free() function). 2076 - * This is usually implemented by the generic utility function 2077 - * @unregister_trigger() (see trace_event_triggers.c). 2078 - * 2079 - * @unreg_all: An optional function called to remove all the triggers 2080 - * from the list of triggers associated with the event. Called 2081 - * when a trigger file is opened in truncate mode. 2082 - * 2083 - * @set_filter: An optional function called to parse and set a filter 2084 - * for the trigger. If no @set_filter() method is set for the 2085 - * event command, filters set by the user for the command will be 2086 - * ignored. This is usually implemented by the generic utility 2087 - * function @set_trigger_filter() (see trace_event_triggers.c). 2088 - */ 2089 1944 struct event_command { 2090 1945 struct list_head list; 2091 1946 char *name; 2092 - const struct event_trigger_ops *trigger_ops; 2093 1947 enum event_trigger_type trigger_type; 2094 1948 int flags; 2095 1949 int (*parse)(struct event_command *cmd_ops, ··· 2015 2051 int (*set_filter)(char *filter_str, 2016 2052 struct event_trigger_data *data, 2017 2053 struct trace_event_file *file); 2054 + void (*trigger)(struct event_trigger_data *data, 2055 + struct trace_buffer *buffer, 2056 + void *rec, 2057 + struct ring_buffer_event *rbe); 2058 + bool (*count_func)(struct event_trigger_data *data, 2059 + struct trace_buffer *buffer, 2060 + void *rec, 2061 + struct ring_buffer_event *rbe); 2062 + int (*init)(struct event_trigger_data *data); 2063 + void (*free)(struct event_trigger_data *data); 2064 + int (*print)(struct seq_file *m, 2065 + struct event_trigger_data *data); 2018 2066 }; 2019 2067 2020 2068 /** ··· 2047 2071 * either committed or discarded. At that point, if any commands 2048 2072 * have deferred their triggers, those commands are finally 2049 2073 * invoked following the close of the current event. In other 2050 - * words, if the event_trigger_ops @func() probe implementation 2074 + * words, if the event_command @func() probe implementation 2051 2075 * itself logs to the trace buffer, this flag should be set, 2052 2076 * otherwise it can be left unspecified. 2053 2077 *

+4 -9

kernel/trace/trace_eprobe.c

··· 484 484 __eprobe_trace_func(edata, rec); 485 485 } 486 486 487 - static const struct event_trigger_ops eprobe_trigger_ops = { 488 - .trigger = eprobe_trigger_func, 489 - .print = eprobe_trigger_print, 490 - .init = eprobe_trigger_init, 491 - .free = eprobe_trigger_free, 492 - }; 493 - 494 487 static int eprobe_trigger_cmd_parse(struct event_command *cmd_ops, 495 488 struct trace_event_file *file, 496 489 char *glob, char *cmd, ··· 510 517 .name = "eprobe", 511 518 .trigger_type = ETT_EVENT_EPROBE, 512 519 .flags = EVENT_CMD_FL_NEEDS_REC, 513 - .trigger_ops = &eprobe_trigger_ops, 514 520 .parse = eprobe_trigger_cmd_parse, 515 521 .reg = eprobe_trigger_reg_func, 516 522 .unreg = eprobe_trigger_unreg_func, 517 523 .unreg_all = NULL, 518 524 .set_filter = NULL, 525 + .trigger = eprobe_trigger_func, 526 + .print = eprobe_trigger_print, 527 + .init = eprobe_trigger_init, 528 + .free = eprobe_trigger_free, 519 529 }; 520 530 521 531 static struct event_trigger_data * ··· 538 542 539 543 trigger->flags = EVENT_TRIGGER_FL_PROBE; 540 544 trigger->count = -1; 541 - trigger->ops = &eprobe_trigger_ops; 542 545 543 546 /* 544 547 * EVENT PROBE triggers are not registered as commands with

+48 -45

kernel/trace/trace_events_hist.c

··· 5694 5694 seq_puts(m, "\n\n"); 5695 5695 5696 5696 seq_puts(m, "# event histogram\n#\n# trigger info: "); 5697 - data->ops->print(m, data); 5697 + data->cmd_ops->print(m, data); 5698 5698 seq_puts(m, "#\n\n"); 5699 5699 5700 5700 hist_data = data->private_data; ··· 6016 6016 seq_puts(m, "\n\n"); 6017 6017 6018 6018 seq_puts(m, "# event histogram\n#\n# trigger info: "); 6019 - data->ops->print(m, data); 6019 + data->cmd_ops->print(m, data); 6020 6020 seq_puts(m, "#\n\n"); 6021 6021 6022 6022 hist_data = data->private_data; ··· 6326 6326 free_hist_pad(); 6327 6327 } 6328 6328 6329 - static const struct event_trigger_ops event_hist_trigger_ops = { 6330 - .trigger = event_hist_trigger, 6331 - .print = event_hist_trigger_print, 6332 - .init = event_hist_trigger_init, 6333 - .free = event_hist_trigger_free, 6334 - }; 6335 - 6336 6329 static int event_hist_trigger_named_init(struct event_trigger_data *data) 6337 6330 { 6331 + int ret; 6332 + 6338 6333 data->ref++; 6339 6334 6340 6335 save_named_trigger(data->named_data->name, data); 6341 6336 6342 - return event_hist_trigger_init(data->named_data); 6337 + ret = event_hist_trigger_init(data->named_data); 6338 + if (ret < 0) { 6339 + kfree(data->cmd_ops); 6340 + data->cmd_ops = &trigger_hist_cmd; 6341 + } 6342 + 6343 + return ret; 6343 6344 } 6344 6345 6345 6346 static void event_hist_trigger_named_free(struct event_trigger_data *data) ··· 6352 6351 6353 6352 data->ref--; 6354 6353 if (!data->ref) { 6354 + struct event_command *cmd_ops = data->cmd_ops; 6355 + 6355 6356 del_named_trigger(data); 6356 6357 trigger_data_free(data); 6358 + kfree(cmd_ops); 6357 6359 } 6358 6360 } 6359 - 6360 - static const struct event_trigger_ops event_hist_trigger_named_ops = { 6361 - .trigger = event_hist_trigger, 6362 - .print = event_hist_trigger_print, 6363 - .init = event_hist_trigger_named_init, 6364 - .free = event_hist_trigger_named_free, 6365 - }; 6366 6361 6367 6362 static void hist_clear(struct event_trigger_data *data) 6368 6363 { ··· 6553 6556 data->paused = true; 6554 6557 6555 6558 if (named_data) { 6559 + struct event_command *cmd_ops; 6560 + 6556 6561 data->private_data = named_data->private_data; 6557 6562 set_named_trigger_data(data, named_data); 6558 - data->ops = &event_hist_trigger_named_ops; 6563 + /* Copy the command ops and update some of the functions */ 6564 + cmd_ops = kmalloc(sizeof(*cmd_ops), GFP_KERNEL); 6565 + if (!cmd_ops) { 6566 + ret = -ENOMEM; 6567 + goto out; 6568 + } 6569 + *cmd_ops = *data->cmd_ops; 6570 + cmd_ops->init = event_hist_trigger_named_init; 6571 + cmd_ops->free = event_hist_trigger_named_free; 6572 + data->cmd_ops = cmd_ops; 6559 6573 } 6560 6574 6561 - if (data->ops->init) { 6562 - ret = data->ops->init(data); 6575 + if (data->cmd_ops->init) { 6576 + ret = data->cmd_ops->init(data); 6563 6577 if (ret < 0) 6564 6578 goto out; 6565 6579 } ··· 6684 6676 } 6685 6677 } 6686 6678 6687 - if (test && test->ops->free) 6688 - test->ops->free(test); 6679 + if (test && test->cmd_ops->free) 6680 + test->cmd_ops->free(test); 6689 6681 6690 6682 if (hist_data->enable_timestamps) { 6691 6683 if (!hist_data->remove || test) ··· 6737 6729 update_cond_flag(file); 6738 6730 if (hist_data->enable_timestamps) 6739 6731 tracing_set_filter_buffering(file->tr, false); 6740 - if (test->ops->free) 6741 - test->ops->free(test); 6732 + if (test->cmd_ops->free) 6733 + test->cmd_ops->free(test); 6742 6734 } 6743 6735 } 6744 6736 } ··· 6910 6902 .name = "hist", 6911 6903 .trigger_type = ETT_EVENT_HIST, 6912 6904 .flags = EVENT_CMD_FL_NEEDS_REC, 6913 - .trigger_ops = &event_hist_trigger_ops, 6914 6905 .parse = event_hist_trigger_parse, 6915 6906 .reg = hist_register_trigger, 6916 6907 .unreg = hist_unregister_trigger, 6917 6908 .unreg_all = hist_unreg_all, 6918 6909 .set_filter = set_trigger_filter, 6910 + .trigger = event_hist_trigger, 6911 + .print = event_hist_trigger_print, 6912 + .init = event_hist_trigger_init, 6913 + .free = event_hist_trigger_free, 6919 6914 }; 6920 6915 6921 6916 __init int register_trigger_hist_cmd(void) ··· 6950 6939 } 6951 6940 } 6952 6941 6953 - static const struct event_trigger_ops hist_enable_trigger_ops = { 6954 - .trigger = hist_enable_trigger, 6955 - .count_func = event_trigger_count, 6956 - .print = event_enable_trigger_print, 6957 - .init = event_trigger_init, 6958 - .free = event_enable_trigger_free, 6959 - }; 6960 - 6961 - static const struct event_trigger_ops hist_disable_trigger_ops = { 6962 - .trigger = hist_enable_trigger, 6963 - .count_func = event_trigger_count, 6964 - .print = event_enable_trigger_print, 6965 - .init = event_trigger_init, 6966 - .free = event_enable_trigger_free, 6967 - }; 6968 - 6969 6942 static void hist_enable_unreg_all(struct trace_event_file *file) 6970 6943 { 6971 6944 struct event_trigger_data *test, *n; ··· 6959 6964 list_del_rcu(&test->list); 6960 6965 update_cond_flag(file); 6961 6966 trace_event_trigger_enable_disable(file, 0); 6962 - if (test->ops->free) 6963 - test->ops->free(test); 6967 + if (test->cmd_ops->free) 6968 + test->cmd_ops->free(test); 6964 6969 } 6965 6970 } 6966 6971 } ··· 6968 6973 static struct event_command trigger_hist_enable_cmd = { 6969 6974 .name = ENABLE_HIST_STR, 6970 6975 .trigger_type = ETT_HIST_ENABLE, 6971 - .trigger_ops = &hist_enable_trigger_ops, 6972 6976 .parse = event_enable_trigger_parse, 6973 6977 .reg = event_enable_register_trigger, 6974 6978 .unreg = event_enable_unregister_trigger, 6975 6979 .unreg_all = hist_enable_unreg_all, 6976 6980 .set_filter = set_trigger_filter, 6981 + .trigger = hist_enable_trigger, 6982 + .count_func = event_trigger_count, 6983 + .print = event_enable_trigger_print, 6984 + .init = event_trigger_init, 6985 + .free = event_enable_trigger_free, 6977 6986 }; 6978 6987 6979 6988 static struct event_command trigger_hist_disable_cmd = { 6980 6989 .name = DISABLE_HIST_STR, 6981 6990 .trigger_type = ETT_HIST_ENABLE, 6982 - .trigger_ops = &hist_disable_trigger_ops, 6983 6991 .parse = event_enable_trigger_parse, 6984 6992 .reg = event_enable_register_trigger, 6985 6993 .unreg = event_enable_unregister_trigger, 6986 6994 .unreg_all = hist_enable_unreg_all, 6987 6995 .set_filter = set_trigger_filter, 6996 + .trigger = hist_enable_trigger, 6997 + .count_func = event_trigger_count, 6998 + .print = event_enable_trigger_print, 6999 + .init = event_trigger_init, 7000 + .free = event_enable_trigger_free, 6988 7001 }; 6989 7002 6990 7003 static __init void unregister_trigger_hist_enable_disable_cmds(void)

+55 -80

kernel/trace/trace_events_trigger.c

··· 32 32 struct trace_buffer *buffer, void *rec, 33 33 struct ring_buffer_event *event) 34 34 { 35 - const struct event_trigger_ops *ops = data->ops; 35 + const struct event_command *cmd_ops = data->cmd_ops; 36 36 37 37 if (data->flags & EVENT_TRIGGER_FL_COUNT) { 38 - if (!ops->count_func(data, buffer, rec, event)) 38 + if (!cmd_ops->count_func(data, buffer, rec, event)) 39 39 return; 40 40 } 41 41 42 - ops->trigger(data, buffer, rec, event); 42 + cmd_ops->trigger(data, buffer, rec, event); 43 43 } 44 44 45 45 /** ··· 205 205 } 206 206 207 207 data = list_entry(v, struct event_trigger_data, list); 208 - data->ops->print(m, data); 208 + data->cmd_ops->print(m, data); 209 209 210 210 return 0; 211 211 } ··· 422 422 } 423 423 424 424 /** 425 - * event_trigger_print - Generic event_trigger_ops @print implementation 425 + * event_trigger_print - Generic event_command @print implementation 426 426 * @name: The name of the event trigger 427 427 * @m: The seq_file being printed to 428 428 * @data: Trigger-specific data ··· 457 457 } 458 458 459 459 /** 460 - * event_trigger_init - Generic event_trigger_ops @init implementation 460 + * event_trigger_init - Generic event_command @init implementation 461 461 * @data: Trigger-specific data 462 462 * 463 463 * Common implementation of event trigger initialization. ··· 474 474 } 475 475 476 476 /** 477 - * event_trigger_free - Generic event_trigger_ops @free implementation 477 + * event_trigger_free - Generic event_command @free implementation 478 478 * @data: Trigger-specific data 479 479 * 480 480 * Common implementation of event trigger de-initialization. ··· 536 536 list_for_each_entry_safe(data, n, &file->triggers, list) { 537 537 trace_event_trigger_enable_disable(file, 0); 538 538 list_del_rcu(&data->list); 539 - if (data->ops->free) 540 - data->ops->free(data); 539 + if (data->cmd_ops->free) 540 + data->cmd_ops->free(data); 541 541 } 542 542 } 543 543 } ··· 600 600 return -EEXIST; 601 601 } 602 602 603 - if (data->ops->init) { 604 - ret = data->ops->init(data); 603 + if (data->cmd_ops->init) { 604 + ret = data->cmd_ops->init(data); 605 605 if (ret < 0) 606 606 return ret; 607 607 } ··· 639 639 } 640 640 641 641 if (data) { 642 - if (data->ops->free) 643 - data->ops->free(data); 642 + if (data->cmd_ops->free) 643 + data->cmd_ops->free(data); 644 644 645 645 return true; 646 646 } ··· 875 875 return NULL; 876 876 877 877 trigger_data->count = -1; 878 - trigger_data->ops = cmd_ops->trigger_ops; 879 878 trigger_data->cmd_ops = cmd_ops; 880 879 trigger_data->private_data = private_data; 881 - if (param && cmd_ops->trigger_ops->count_func) 880 + if (param && cmd_ops->count_func) 882 881 trigger_data->flags |= EVENT_TRIGGER_FL_COUNT; 883 882 884 883 INIT_LIST_HEAD(&trigger_data->list); ··· 1400 1401 data->filter_str); 1401 1402 } 1402 1403 1403 - static const struct event_trigger_ops traceon_trigger_ops = { 1404 + static struct event_command trigger_traceon_cmd = { 1405 + .name = "traceon", 1406 + .trigger_type = ETT_TRACE_ONOFF, 1407 + .parse = event_trigger_parse, 1408 + .reg = register_trigger, 1409 + .unreg = unregister_trigger, 1410 + .set_filter = set_trigger_filter, 1404 1411 .trigger = traceon_trigger, 1405 1412 .count_func = traceon_count_func, 1406 1413 .print = traceon_trigger_print, ··· 1414 1409 .free = event_trigger_free, 1415 1410 }; 1416 1411 1417 - static const struct event_trigger_ops traceoff_trigger_ops = { 1412 + static struct event_command trigger_traceoff_cmd = { 1413 + .name = "traceoff", 1414 + .trigger_type = ETT_TRACE_ONOFF, 1415 + .flags = EVENT_CMD_FL_POST_TRIGGER, 1416 + .parse = event_trigger_parse, 1417 + .reg = register_trigger, 1418 + .unreg = unregister_trigger, 1419 + .set_filter = set_trigger_filter, 1418 1420 .trigger = traceoff_trigger, 1419 1421 .count_func = traceoff_count_func, 1420 1422 .print = traceoff_trigger_print, 1421 1423 .init = event_trigger_init, 1422 1424 .free = event_trigger_free, 1423 - }; 1424 - 1425 - static struct event_command trigger_traceon_cmd = { 1426 - .name = "traceon", 1427 - .trigger_type = ETT_TRACE_ONOFF, 1428 - .trigger_ops = &traceon_trigger_ops, 1429 - .parse = event_trigger_parse, 1430 - .reg = register_trigger, 1431 - .unreg = unregister_trigger, 1432 - .set_filter = set_trigger_filter, 1433 - }; 1434 - 1435 - static struct event_command trigger_traceoff_cmd = { 1436 - .name = "traceoff", 1437 - .trigger_type = ETT_TRACE_ONOFF, 1438 - .flags = EVENT_CMD_FL_POST_TRIGGER, 1439 - .trigger_ops = &traceoff_trigger_ops, 1440 - .parse = event_trigger_parse, 1441 - .reg = register_trigger, 1442 - .unreg = unregister_trigger, 1443 - .set_filter = set_trigger_filter, 1444 1425 }; 1445 1426 1446 1427 #ifdef CONFIG_TRACER_SNAPSHOT ··· 1474 1483 data->filter_str); 1475 1484 } 1476 1485 1477 - static const struct event_trigger_ops snapshot_trigger_ops = { 1486 + static struct event_command trigger_snapshot_cmd = { 1487 + .name = "snapshot", 1488 + .trigger_type = ETT_SNAPSHOT, 1489 + .parse = event_trigger_parse, 1490 + .reg = register_snapshot_trigger, 1491 + .unreg = unregister_snapshot_trigger, 1492 + .set_filter = set_trigger_filter, 1478 1493 .trigger = snapshot_trigger, 1479 1494 .count_func = event_trigger_count, 1480 1495 .print = snapshot_trigger_print, 1481 1496 .init = event_trigger_init, 1482 1497 .free = event_trigger_free, 1483 - }; 1484 - 1485 - static struct event_command trigger_snapshot_cmd = { 1486 - .name = "snapshot", 1487 - .trigger_type = ETT_SNAPSHOT, 1488 - .trigger_ops = &snapshot_trigger_ops, 1489 - .parse = event_trigger_parse, 1490 - .reg = register_snapshot_trigger, 1491 - .unreg = unregister_snapshot_trigger, 1492 - .set_filter = set_trigger_filter, 1493 1498 }; 1494 1499 1495 1500 static __init int register_trigger_snapshot_cmd(void) ··· 1539 1552 data->filter_str); 1540 1553 } 1541 1554 1542 - static const struct event_trigger_ops stacktrace_trigger_ops = { 1543 - .trigger = stacktrace_trigger, 1544 - .count_func = event_trigger_count, 1545 - .print = stacktrace_trigger_print, 1546 - .init = event_trigger_init, 1547 - .free = event_trigger_free, 1548 - }; 1549 - 1550 1555 static struct event_command trigger_stacktrace_cmd = { 1551 1556 .name = "stacktrace", 1552 1557 .trigger_type = ETT_STACKTRACE, 1553 - .trigger_ops = &stacktrace_trigger_ops, 1554 1558 .flags = EVENT_CMD_FL_POST_TRIGGER, 1555 1559 .parse = event_trigger_parse, 1556 1560 .reg = register_trigger, 1557 1561 .unreg = unregister_trigger, 1558 1562 .set_filter = set_trigger_filter, 1563 + .trigger = stacktrace_trigger, 1564 + .count_func = event_trigger_count, 1565 + .print = stacktrace_trigger_print, 1566 + .init = event_trigger_init, 1567 + .free = event_trigger_free, 1559 1568 }; 1560 1569 1561 1570 static __init int register_trigger_stacktrace_cmd(void) ··· 1647 1664 kfree(enable_data); 1648 1665 } 1649 1666 } 1650 - 1651 - static const struct event_trigger_ops event_enable_trigger_ops = { 1652 - .trigger = event_enable_trigger, 1653 - .count_func = event_enable_count_func, 1654 - .print = event_enable_trigger_print, 1655 - .init = event_trigger_init, 1656 - .free = event_enable_trigger_free, 1657 - }; 1658 - 1659 - static const struct event_trigger_ops event_disable_trigger_ops = { 1660 - .trigger = event_enable_trigger, 1661 - .count_func = event_enable_count_func, 1662 - .print = event_enable_trigger_print, 1663 - .init = event_trigger_init, 1664 - .free = event_enable_trigger_free, 1665 - }; 1666 1667 1667 1668 int event_enable_trigger_parse(struct event_command *cmd_ops, 1668 1669 struct trace_event_file *file, ··· 1777 1810 } 1778 1811 } 1779 1812 1780 - if (data->ops->init) { 1781 - ret = data->ops->init(data); 1813 + if (data->cmd_ops->init) { 1814 + ret = data->cmd_ops->init(data); 1782 1815 if (ret < 0) 1783 1816 return ret; 1784 1817 } ··· 1818 1851 } 1819 1852 } 1820 1853 1821 - if (data && data->ops->free) 1822 - data->ops->free(data); 1854 + if (data && data->cmd_ops->free) 1855 + data->cmd_ops->free(data); 1823 1856 } 1824 1857 1825 1858 static struct event_command trigger_enable_cmd = { 1826 1859 .name = ENABLE_EVENT_STR, 1827 1860 .trigger_type = ETT_EVENT_ENABLE, 1828 - .trigger_ops = &event_enable_trigger_ops, 1829 1861 .parse = event_enable_trigger_parse, 1830 1862 .reg = event_enable_register_trigger, 1831 1863 .unreg = event_enable_unregister_trigger, 1832 1864 .set_filter = set_trigger_filter, 1865 + .trigger = event_enable_trigger, 1866 + .count_func = event_enable_count_func, 1867 + .print = event_enable_trigger_print, 1868 + .init = event_trigger_init, 1869 + .free = event_enable_trigger_free, 1833 1870 }; 1834 1871 1835 1872 static struct event_command trigger_disable_cmd = { 1836 1873 .name = DISABLE_EVENT_STR, 1837 1874 .trigger_type = ETT_EVENT_ENABLE, 1838 - .trigger_ops = &event_disable_trigger_ops, 1839 1875 .parse = event_enable_trigger_parse, 1840 1876 .reg = event_enable_register_trigger, 1841 1877 .unreg = event_enable_unregister_trigger, 1842 1878 .set_filter = set_trigger_filter, 1879 + .trigger = event_enable_trigger, 1880 + .count_func = event_enable_count_func, 1881 + .print = event_enable_trigger_print, 1882 + .init = event_trigger_init, 1883 + .free = event_enable_trigger_free, 1843 1884 }; 1844 1885 1845 1886 static __init void unregister_trigger_enable_disable_cmds(void)

Configure Feed

Configure Feed