History

tracing: Have existing event_command.parse() implementations use helpers

Simplify the existing event_command.parse() implementations by having them make use of the helper functions previously introduced. Link: https://lkml.kernel.org/r/b353e3427a81f9d3adafd98fd7d73e78a8209f43.1644010576.git.zanussi@kernel.org

Tom Zanussi committed 4 years ago

Commit e1f187d1 parent 47670544 files · +69 −151Browse files

Unified · Split

4 files
  1. kernel/trace/trace.h +2 −1
  2. kernel/trace/trace_eprobe.c +2 −1
  3. kernel/trace/trace_events_hist.c +24 −40
  4. kernel/trace/trace_events_trigger.c +41 −109
kernel/trace/trace.h+2−1
@@ -1577,7 +1577,8 @@ extern int event_enable_trigger_print(struct seq_file *m, · 1576 unmodified lines
15771577 extern void event_enable_trigger_free(struct event_trigger_data *data);
15781578 extern int event_enable_trigger_parse(struct event_command *cmd_ops,
15791579 struct trace_event_file *file,
1580− char *glob, char *cmd, char *param);
1580+ char *glob, char *cmd,
1581+ char *param_and_filter);
15811582 extern int event_enable_register_trigger(char *glob,
15821583 struct event_trigger_data *data,
15831584 struct trace_event_file *file);
kernel/trace/trace_eprobe.c+2−1
@@ -546,7 +546,8 @@ static struct event_trigger_ops eprobe_trigger_ops = { · 545 unmodified lines
546546
547547 static int eprobe_trigger_cmd_parse(struct event_command *cmd_ops,
548548 struct trace_event_file *file,
549− char *glob, char *cmd, char *param)
549+ char *glob, char *cmd,
550+ char *param_and_filter)
550551 {
551552 return -1;
552553 }
kernel/trace/trace_events_hist.c+24−40
@@ -2785,7 +2785,8 @@ static char *find_trigger_filter(struct hist_trigger_data *hist_data, · 2784 unmodified lines
27852785 static struct event_command trigger_hist_cmd;
27862786 static int event_hist_trigger_parse(struct event_command *cmd_ops,
27872787 struct trace_event_file *file,
2788− char *glob, char *cmd, char *param);
2788+ char *glob, char *cmd,
2789+ char *param_and_filter);
27892790
27902791 static bool compatible_keys(struct hist_trigger_data *target_hist_data,
27912792 struct hist_trigger_data *hist_data,
@@ -6166,17 +6167,17 @@ static void hist_unreg_all(struct trace_event_file *file) · 3374 unmodified lines
61666167
61676168 static int event_hist_trigger_parse(struct event_command *cmd_ops,
61686169 struct trace_event_file *file,
6169− char *glob, char *cmd, char *param)
6170+ char *glob, char *cmd,
6171+ char *param_and_filter)
61706172 {
61716173 unsigned int hist_trigger_bits = TRACING_MAP_BITS_DEFAULT;
61726174 struct event_trigger_data *trigger_data;
61736175 struct hist_trigger_attrs *attrs;
6174− struct event_trigger_ops *trigger_ops;
61756176 struct hist_trigger_data *hist_data;
6177+ char *param, *filter, *p, *start;
61766178 struct synth_event *se;
61776179 const char *se_name;
6178− bool remove = false;
6179− char *trigger, *p, *start;
6180+ bool remove;
61806181 int ret = 0;
61816182
61826183 lockdep_assert_held(&event_mutex);
@@ -6185,31 +6186,30 @@ static int event_hist_trigger_parse(struct event_command *cmd_ops, · 2 unmodified lines
61856186
61866187 if (strlen(glob)) {
61876188 hist_err_clear();
6188− last_cmd_set(file, param);
6189+ last_cmd_set(file, param_and_filter);
61896190 }
61906191
6191− if (!param)
6192− return -EINVAL;
6192+ remove = event_trigger_check_remove(glob);
61936193
6194− if (glob[0] == '!')
6195− remove = true;
6194+ if (event_trigger_empty_param(param_and_filter))
6195+ return -EINVAL;
61966196
61976197 /*
61986198 * separate the trigger from the filter (k:v [if filter])
61996199 * allowing for whitespace in the trigger
62006200 */
6201− p = trigger = param;
6201+ p = param = param_and_filter;
62026202 do {
62036203 p = strstr(p, "if");
62046204 if (!p)
62056205 break;
6206− if (p == param)
6206+ if (p == param_and_filter)
62076207 return -EINVAL;
62086208 if (*(p - 1) != ' ' && *(p - 1) != '\t') {
62096209 p++;
62106210 continue;
62116211 }
6212− if (p >= param + strlen(param) - (sizeof("if") - 1) - 1)
6212+ if (p >= param_and_filter + strlen(param_and_filter) - (sizeof("if") - 1) - 1)
62136213 return -EINVAL;
62146214 if (*(p + sizeof("if") - 1) != ' ' && *(p + sizeof("if") - 1) != '\t') {
62156215 p++;
@@ -6219,24 +6219,24 @@ static int event_hist_trigger_parse(struct event_command *cmd_ops, · 3 unmodified lines
62196219 } while (1);
62206220
62216221 if (!p)
6222− param = NULL;
6222+ filter = NULL;
62236223 else {
62246224 *(p - 1) = '\0';
6225− param = strstrip(p);
6226− trigger = strstrip(trigger);
6225+ filter = strstrip(p);
6226+ param = strstrip(param);
62276227 }
62286228
62296229 /*
62306230 * To simplify arithmetic expression parsing, replace occurrences of
62316231 * '.sym-offset' modifier with '.symXoffset'
62326232 */
6233− start = strstr(trigger, ".sym-offset");
6233+ start = strstr(param, ".sym-offset");
62346234 while (start) {
62356235 *(start + 4) = 'X';
62366236 start = strstr(start + 11, ".sym-offset");
62376237 }
62386238
6239− attrs = parse_hist_trigger_attrs(file->tr, trigger);
6239+ attrs = parse_hist_trigger_attrs(file->tr, param);
62406240 if (IS_ERR(attrs))
62416241 return PTR_ERR(attrs);
62426242
@@ -6249,29 +6249,15 @@ static int event_hist_trigger_parse(struct event_command *cmd_ops, · 6 unmodified lines
62496249 return PTR_ERR(hist_data);
62506250 }
62516251
6252− trigger_ops = cmd_ops->get_trigger_ops(cmd, trigger);
6253−
6254− trigger_data = kzalloc(sizeof(*trigger_data), GFP_KERNEL);
6252+ trigger_data = event_trigger_alloc(cmd_ops, cmd, param, hist_data);
62556253 if (!trigger_data) {
62566254 ret = -ENOMEM;
62576255 goto out_free;
62586256 }
62596257
6260− trigger_data->count = -1;
6261− trigger_data->ops = trigger_ops;
6262− trigger_data->cmd_ops = cmd_ops;
6263−
6264− INIT_LIST_HEAD(&trigger_data->list);
6265− RCU_INIT_POINTER(trigger_data->filter, NULL);
6266−
6267− trigger_data->private_data = hist_data;
6268−
6269− /* if param is non-empty, it's supposed to be a filter */
6270− if (param && cmd_ops->set_filter) {
6271− ret = cmd_ops->set_filter(param, trigger_data, file);
6272− if (ret < 0)
6273− goto out_free;
6274− }
6258+ ret = event_trigger_set_filter(cmd_ops, file, filter, trigger_data);
6259+ if (ret < 0)
6260+ goto out_free;
62756261
62766262 if (remove) {
62776263 if (!have_hist_trigger_match(trigger_data, file))
@@ -6298,8 +6284,7 @@ static int event_hist_trigger_parse(struct event_command *cmd_ops, · 20 unmodified lines
62986284 if (!(attrs->pause || attrs->cont || attrs->clear))
62996285 ret = -ENOENT;
63006286 goto out_free;
6301− } else if (ret < 0)
6302− goto out_free;
6287+ }
63036288
63046289 if (get_named_trigger_data(trigger_data))
63056290 goto enable;
@@ -6331,8 +6316,7 @@ enable: · 25 unmodified lines
63316316 out_unreg:
63326317 event_trigger_unregister(cmd_ops, file, glob+1, trigger_data);
63336318 out_free:
6334− if (cmd_ops->set_filter)
6335− cmd_ops->set_filter(NULL, trigger_data, NULL);
6319+ event_trigger_reset_filter(cmd_ops, trigger_data);
63366320
63376321 remove_hist_vars(hist_data);
63386322
kernel/trace/trace_events_trigger.c+41−109
@@ -965,7 +965,7 @@ void event_trigger_unregister(struct event_command *cmd_ops, · 964 unmodified lines
965965 * @file: The trace_event_file associated with the event
966966 * @glob: The raw string used to register the trigger
967967 * @cmd: The cmd portion of the string used to register the trigger
968− * @param: The params portion of the string used to register the trigger
968+ * @param_and_filter: The param and filter portion of the string used to register the trigger
969969 *
970970 * Common implementation for event command parsing and trigger
971971 * instantiation.
@@ -978,72 +978,39 @@ void event_trigger_unregister(struct event_command *cmd_ops, · 6 unmodified lines
978978 static int
979979 event_trigger_parse(struct event_command *cmd_ops,
980980 struct trace_event_file *file,
981− char *glob, char *cmd, char *param)
981+ char *glob, char *cmd, char *param_and_filter)
982982 {
983983 struct event_trigger_data *trigger_data;
984− struct event_trigger_ops *trigger_ops;
985− char *trigger = NULL;
986− char *number;
984+ char *param, *filter;
985+ bool remove;
987986 int ret;
988987
989− /* separate the trigger from the filter (t:n [if filter]) */
990− if (param && isdigit(param[0])) {
991− trigger = strsep(&param, " \t");
992− if (param) {
993− param = skip_spaces(param);
994− if (!*param)
995− param = NULL;
996− }
997− }
988+ remove = event_trigger_check_remove(glob);
998989
999− trigger_ops = cmd_ops->get_trigger_ops(cmd, trigger);
990+ ret = event_trigger_separate_filter(param_and_filter, &param, &filter, false);
991+ if (ret)
992+ return ret;
1000993
1001994 ret = -ENOMEM;
1002− trigger_data = kzalloc(sizeof(*trigger_data), GFP_KERNEL);
995+ trigger_data = event_trigger_alloc(cmd_ops, cmd, param, file);
1003996 if (!trigger_data)
1004997 goto out;
1005998
1006− trigger_data->count = -1;
1007− trigger_data->ops = trigger_ops;
1008− trigger_data->cmd_ops = cmd_ops;
1009− trigger_data->private_data = file;
1010− INIT_LIST_HEAD(&trigger_data->list);
1011− INIT_LIST_HEAD(&trigger_data->named_list);
1012−
1013− if (glob[0] == '!') {
999+ if (remove) {
10141000 event_trigger_unregister(cmd_ops, file, glob+1, trigger_data);
10151001 kfree(trigger_data);
10161002 ret = 0;
10171003 goto out;
10181004 }
10191005
1020− if (trigger) {
1021− number = strsep(&trigger, ":");
1022−
1023− ret = -EINVAL;
1024− if (!strlen(number))
1025− goto out_free;
1026−
1027− /*
1028− * We use the callback data field (which is a pointer)
1029− * as our counter.
1030− */
1031− ret = kstrtoul(number, 0, &trigger_data->count);
1032− if (ret)
1033− goto out_free;
1034− }
1035−
1036− if (!param) /* if param is non-empty, it's supposed to be a filter */
1037− goto out_reg;
1038−
1039− if (!cmd_ops->set_filter)
1040− goto out_reg;
1006+ ret = event_trigger_parse_num(param, trigger_data);
1007+ if (ret)
1008+ goto out_free;
10411009
1042− ret = cmd_ops->set_filter(param, trigger_data, file);
1010+ ret = event_trigger_set_filter(cmd_ops, file, filter, trigger_data);
10431011 if (ret < 0)
10441012 goto out_free;
10451013
1046− out_reg:
10471014 /* Up the trigger_data count to make sure reg doesn't free it on failure */
10481015 event_trigger_init(trigger_data);
10491016
@@ -1057,8 +1024,7 @@ event_trigger_parse(struct event_command *cmd_ops, · 7 unmodified lines
10571024 return ret;
10581025
10591026 out_free:
1060− if (cmd_ops->set_filter)
1061− cmd_ops->set_filter(NULL, trigger_data, NULL);
1027+ event_trigger_reset_filter(cmd_ops, trigger_data);
10621028 kfree(trigger_data);
10631029 goto out;
10641030 }
@@ -1752,39 +1718,33 @@ static struct event_trigger_ops event_disable_count_trigger_ops = { · 687 unmodified lines
17521718
17531719 int event_enable_trigger_parse(struct event_command *cmd_ops,
17541720 struct trace_event_file *file,
1755− char *glob, char *cmd, char *param)
1721+ char *glob, char *cmd, char *param_and_filter)
17561722 {
17571723 struct trace_event_file *event_enable_file;
17581724 struct enable_trigger_data *enable_data;
17591725 struct event_trigger_data *trigger_data;
1760− struct event_trigger_ops *trigger_ops;
17611726 struct trace_array *tr = file->tr;
1727+ char *param, *filter;
1728+ bool enable, remove;
17621729 const char *system;
17631730 const char *event;
17641731 bool hist = false;
1765− char *trigger;
1766− char *number;
1767− bool enable;
17681732 int ret;
17691733
1770− if (!param)
1771− return -EINVAL;
1734+ remove = event_trigger_check_remove(glob);
17721735
1773− /* separate the trigger from the filter (s:e:n [if filter]) */
1774− trigger = strsep(&param, " \t");
1775− if (!trigger)
1736+ if (event_trigger_empty_param(param_and_filter))
17761737 return -EINVAL;
1777− if (param) {
1778− param = skip_spaces(param);
1779− if (!*param)
1780− param = NULL;
1781− }
17821738
1783− system = strsep(&trigger, ":");
1784− if (!trigger)
1739+ ret = event_trigger_separate_filter(param_and_filter, &param, &filter, true);
1740+ if (ret)
1741+ return ret;
1742+
1743+ system = strsep(&param, ":");
1744+ if (!param)
17851745 return -EINVAL;
17861746
1787− event = strsep(&trigger, ":");
1747+ event = strsep(&param, ":");
17881748
17891749 ret = -EINVAL;
17901750 event_enable_file = find_event_file(tr, system, event);
@@ -1800,31 +1760,23 @@ int event_enable_trigger_parse(struct event_command *cmd_ops, · 9 unmodified lines
18001760 #else
18011761 enable = strcmp(cmd, ENABLE_EVENT_STR) == 0;
18021762 #endif
1803− trigger_ops = cmd_ops->get_trigger_ops(cmd, trigger);
1804−
18051763 ret = -ENOMEM;
1806− trigger_data = kzalloc(sizeof(*trigger_data), GFP_KERNEL);
1807− if (!trigger_data)
1808− goto out;
18091764
18101765 enable_data = kzalloc(sizeof(*enable_data), GFP_KERNEL);
1811− if (!enable_data) {
1812− kfree(trigger_data);
1766+ if (!enable_data)
18131767 goto out;
1814− }
1815−
1816− trigger_data->count = -1;
1817− trigger_data->ops = trigger_ops;
1818− trigger_data->cmd_ops = cmd_ops;
1819− INIT_LIST_HEAD(&trigger_data->list);
1820− RCU_INIT_POINTER(trigger_data->filter, NULL);
18211768
18221769 enable_data->hist = hist;
18231770 enable_data->enable = enable;
18241771 enable_data->file = event_enable_file;
1825− trigger_data->private_data = enable_data;
18261772
1827− if (glob[0] == '!') {
1773+ trigger_data = event_trigger_alloc(cmd_ops, cmd, param, enable_data);
1774+ if (!trigger_data) {
1775+ kfree(enable_data);
1776+ goto out;
1777+ }
1778+
1779+ if (remove) {
18281780 event_trigger_unregister(cmd_ops, file, glob+1, trigger_data);
18291781 kfree(trigger_data);
18301782 kfree(enable_data);
@@ -1835,33 +1787,14 @@ int event_enable_trigger_parse(struct event_command *cmd_ops, · 4 unmodified lines
18351787 /* Up the trigger_data count to make sure nothing frees it on failure */
18361788 event_trigger_init(trigger_data);
18371789
1838− if (trigger) {
1839− number = strsep(&trigger, ":");
1840−
1841− ret = -EINVAL;
1842− if (!strlen(number))
1843− goto out_free;
1844−
1845− /*
1846− * We use the callback data field (which is a pointer)
1847− * as our counter.
1848− */
1849− ret = kstrtoul(number, 0, &trigger_data->count);
1850− if (ret)
1851− goto out_free;
1852− }
1853−
1854− if (!param) /* if param is non-empty, it's supposed to be a filter */
1855− goto out_reg;
1856−
1857− if (!cmd_ops->set_filter)
1858− goto out_reg;
1790+ ret = event_trigger_parse_num(param, trigger_data);
1791+ if (ret)
1792+ goto out_free;
18591793
1860− ret = cmd_ops->set_filter(param, trigger_data, file);
1794+ ret = event_trigger_set_filter(cmd_ops, file, filter, trigger_data);
18611795 if (ret < 0)
18621796 goto out_free;
18631797
1864− out_reg:
18651798 /* Don't let event modules unload while probe registered */
18661799 ret = trace_event_try_get_ref(event_enable_file->event_call);
18671800 if (!ret) {
@@ -1880,16 +1813,15 @@ int event_enable_trigger_parse(struct event_command *cmd_ops, · 12 unmodified lines
18801813 event_trigger_free(trigger_data);
18811814 out:
18821815 return ret;
1883−
18841816 out_disable:
18851817 trace_event_enable_disable(event_enable_file, 0, 1);
18861818 out_put:
18871819 trace_event_put_ref(event_enable_file->event_call);
18881820 out_free:
1889− if (cmd_ops->set_filter)
1890− cmd_ops->set_filter(NULL, trigger_data, NULL);
1821+ event_trigger_reset_filter(cmd_ops, trigger_data);
18911822 event_trigger_free(trigger_data);
18921823 kfree(enable_data);
1824+
18931825 goto out;
18941826 }
18951827

Keyboard shortcuts

General

Show keyboard shortcuts
?
Focus the current search
/

Issues and pull requests

Open filters
f

Issues, pull requests and Inbox

Select next item
j↓
Select previous item
k↑
Open selected item
Enter
Dismiss filters or clear selection
Esc

Repository code

Go to file
t