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

Showing the changes to kernel (4 of 4 files). Show all

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
1577extern void event_enable_trigger_free(struct event_trigger_data *data);1577extern void event_enable_trigger_free(struct event_trigger_data *data);
1578extern int event_enable_trigger_parse(struct event_command *cmd_ops,1578extern int event_enable_trigger_parse(struct event_command *cmd_ops,
1579 struct trace_event_file *file,1579 struct trace_event_file *file,
1580 char *glob, char *cmd, char *param);1580 char *glob, char *cmd,
1581 char *param_and_filter);
1581extern int event_enable_register_trigger(char *glob,1582extern int event_enable_register_trigger(char *glob,
1582 struct event_trigger_data *data,1583 struct event_trigger_data *data,
1583 struct trace_event_file *file);1584 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
546 546
547static int eprobe_trigger_cmd_parse(struct event_command *cmd_ops,547static int eprobe_trigger_cmd_parse(struct event_command *cmd_ops,
548 struct trace_event_file *file,548 struct trace_event_file *file,
549 char *glob, char *cmd, char *param)549 char *glob, char *cmd,
550 char *param_and_filter)
550{551{
551 return -1;552 return -1;
552}553}
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
2785static struct event_command trigger_hist_cmd;2785static struct event_command trigger_hist_cmd;
2786static int event_hist_trigger_parse(struct event_command *cmd_ops,2786static int event_hist_trigger_parse(struct event_command *cmd_ops,
2787 struct trace_event_file *file,2787 struct trace_event_file *file,
2788 char *glob, char *cmd, char *param);2788 char *glob, char *cmd,
2789 char *param_and_filter);
2789 2790
2790static bool compatible_keys(struct hist_trigger_data *target_hist_data,2791static bool compatible_keys(struct hist_trigger_data *target_hist_data,
2791 struct hist_trigger_data *hist_data,2792 struct hist_trigger_data *hist_data,
@@ -6166,17 +6167,17 @@ static void hist_unreg_all(struct trace_event_file *file) · 3374 unmodified lines
6166 6167
6167static int event_hist_trigger_parse(struct event_command *cmd_ops,6168static int event_hist_trigger_parse(struct event_command *cmd_ops,
6168 struct trace_event_file *file,6169 struct trace_event_file *file,
6169 char *glob, char *cmd, char *param)6170 char *glob, char *cmd,
6171 char *param_and_filter)
6170{6172{
6171 unsigned int hist_trigger_bits = TRACING_MAP_BITS_DEFAULT;6173 unsigned int hist_trigger_bits = TRACING_MAP_BITS_DEFAULT;
6172 struct event_trigger_data *trigger_data;6174 struct event_trigger_data *trigger_data;
6173 struct hist_trigger_attrs *attrs;6175 struct hist_trigger_attrs *attrs;
6174 struct event_trigger_ops *trigger_ops;
6175 struct hist_trigger_data *hist_data;6176 struct hist_trigger_data *hist_data;
6177 char *param, *filter, *p, *start;
6176 struct synth_event *se;6178 struct synth_event *se;
6177 const char *se_name;6179 const char *se_name;
6178 bool remove = false;6180 bool remove;
6179 char *trigger, *p, *start;
6180 int ret = 0;6181 int ret = 0;
6181 6182
6182 lockdep_assert_held(&event_mutex);6183 lockdep_assert_held(&event_mutex);
@@ -6185,31 +6186,30 @@ static int event_hist_trigger_parse(struct event_command *cmd_ops, · 2 unmodified lines
6185 6186
6186 if (strlen(glob)) {6187 if (strlen(glob)) {
6187 hist_err_clear();6188 hist_err_clear();
6188 last_cmd_set(file, param);6189 last_cmd_set(file, param_and_filter);
6189 }6190 }
6190 6191
6191 if (!param)6192 remove = event_trigger_check_remove(glob);
6192 return -EINVAL;
6193 6193
6194 if (glob[0] == '!')6194 if (event_trigger_empty_param(param_and_filter))
6195 remove = true;6195 return -EINVAL;
6196 6196
6197 /*6197 /*
6198 * separate the trigger from the filter (k:v [if filter])6198 * separate the trigger from the filter (k:v [if filter])
6199 * allowing for whitespace in the trigger6199 * allowing for whitespace in the trigger
6200 */6200 */
6201 p = trigger = param;6201 p = param = param_and_filter;
6202 do {6202 do {
6203 p = strstr(p, "if");6203 p = strstr(p, "if");
6204 if (!p)6204 if (!p)
6205 break;6205 break;
6206 if (p == param)6206 if (p == param_and_filter)
6207 return -EINVAL;6207 return -EINVAL;
6208 if (*(p - 1) != ' ' && *(p - 1) != '\t') {6208 if (*(p - 1) != ' ' && *(p - 1) != '\t') {
6209 p++;6209 p++;
6210 continue;6210 continue;
6211 }6211 }
6212 if (p >= param + strlen(param) - (sizeof("if") - 1) - 1)6212 if (p >= param_and_filter + strlen(param_and_filter) - (sizeof("if") - 1) - 1)
6213 return -EINVAL;6213 return -EINVAL;
6214 if (*(p + sizeof("if") - 1) != ' ' && *(p + sizeof("if") - 1) != '\t') {6214 if (*(p + sizeof("if") - 1) != ' ' && *(p + sizeof("if") - 1) != '\t') {
6215 p++;6215 p++;
@@ -6219,24 +6219,24 @@ static int event_hist_trigger_parse(struct event_command *cmd_ops, · 3 unmodified lines
6219 } while (1);6219 } while (1);
6220 6220
6221 if (!p)6221 if (!p)
6222 param = NULL;6222 filter = NULL;
6223 else {6223 else {
6224 *(p - 1) = '\0';6224 *(p - 1) = '\0';
6225 param = strstrip(p);6225 filter = strstrip(p);
6226 trigger = strstrip(trigger);6226 param = strstrip(param);
6227 }6227 }
6228 6228
6229 /*6229 /*
6230 * To simplify arithmetic expression parsing, replace occurrences of6230 * To simplify arithmetic expression parsing, replace occurrences of
6231 * '.sym-offset' modifier with '.symXoffset'6231 * '.sym-offset' modifier with '.symXoffset'
6232 */6232 */
6233 start = strstr(trigger, ".sym-offset");6233 start = strstr(param, ".sym-offset");
6234 while (start) {6234 while (start) {
6235 *(start + 4) = 'X';6235 *(start + 4) = 'X';
6236 start = strstr(start + 11, ".sym-offset");6236 start = strstr(start + 11, ".sym-offset");
6237 }6237 }
6238 6238
6239 attrs = parse_hist_trigger_attrs(file->tr, trigger);6239 attrs = parse_hist_trigger_attrs(file->tr, param);
6240 if (IS_ERR(attrs))6240 if (IS_ERR(attrs))
6241 return PTR_ERR(attrs);6241 return PTR_ERR(attrs);
6242 6242
@@ -6249,29 +6249,15 @@ static int event_hist_trigger_parse(struct event_command *cmd_ops, · 6 unmodified lines
6249 return PTR_ERR(hist_data);6249 return PTR_ERR(hist_data);
6250 }6250 }
6251 6251
6252 trigger_ops = cmd_ops->get_trigger_ops(cmd, trigger);6252 trigger_data = event_trigger_alloc(cmd_ops, cmd, param, hist_data);
6253
6254 trigger_data = kzalloc(sizeof(*trigger_data), GFP_KERNEL);
6255 if (!trigger_data) {6253 if (!trigger_data) {
6256 ret = -ENOMEM;6254 ret = -ENOMEM;
6257 goto out_free;6255 goto out_free;
6258 }6256 }
6259 6257
6260 trigger_data->count = -1;6258 ret = event_trigger_set_filter(cmd_ops, file, filter, trigger_data);
6261 trigger_data->ops = trigger_ops;6259 if (ret < 0)
6262 trigger_data->cmd_ops = cmd_ops;6260 goto out_free;
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 }
6275 6261
6276 if (remove) {6262 if (remove) {
6277 if (!have_hist_trigger_match(trigger_data, file))6263 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
6298 if (!(attrs->pause || attrs->cont || attrs->clear))6284 if (!(attrs->pause || attrs->cont || attrs->clear))
6299 ret = -ENOENT;6285 ret = -ENOENT;
6300 goto out_free;6286 goto out_free;
6301 } else if (ret < 0)6287 }
6302 goto out_free;
6303 6288
6304 if (get_named_trigger_data(trigger_data))6289 if (get_named_trigger_data(trigger_data))
6305 goto enable;6290 goto enable;
@@ -6331,8 +6316,7 @@ enable: · 25 unmodified lines
6331 out_unreg:6316 out_unreg:
6332 event_trigger_unregister(cmd_ops, file, glob+1, trigger_data);6317 event_trigger_unregister(cmd_ops, file, glob+1, trigger_data);
6333 out_free:6318 out_free:
6334 if (cmd_ops->set_filter)6319 event_trigger_reset_filter(cmd_ops, trigger_data);
6335 cmd_ops->set_filter(NULL, trigger_data, NULL);
6336 6320
6337 remove_hist_vars(hist_data);6321 remove_hist_vars(hist_data);
6338 6322
kernel/trace/trace_events_trigger.c+41−109
@@ -965,7 +965,7 @@ void event_trigger_unregister(struct event_command *cmd_ops, · 964 unmodified lines
965 * @file: The trace_event_file associated with the event965 * @file: The trace_event_file associated with the event
966 * @glob: The raw string used to register the trigger966 * @glob: The raw string used to register the trigger
967 * @cmd: The cmd portion of the string used to register the trigger967 * @cmd: The cmd portion of the string used to register the trigger
968 * @param: The params portion of the string used to register the trigger968 * @param_and_filter: The param and filter portion of the string used to register the trigger
969 *969 *
970 * Common implementation for event command parsing and trigger970 * Common implementation for event command parsing and trigger
971 * instantiation.971 * instantiation.
@@ -978,72 +978,39 @@ void event_trigger_unregister(struct event_command *cmd_ops, · 6 unmodified lines
978static int978static int
979event_trigger_parse(struct event_command *cmd_ops,979event_trigger_parse(struct event_command *cmd_ops,
980 struct trace_event_file *file,980 struct trace_event_file *file,
981 char *glob, char *cmd, char *param)981 char *glob, char *cmd, char *param_and_filter)
982{982{
983 struct event_trigger_data *trigger_data;983 struct event_trigger_data *trigger_data;
984 struct event_trigger_ops *trigger_ops;984 char *param, *filter;
985 char *trigger = NULL;985 bool remove;
986 char *number;
987 int ret;986 int ret;
988 987
989 /* separate the trigger from the filter (t:n [if filter]) */988 remove = event_trigger_check_remove(glob);
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 }
998 989
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;
1000 993
1001 ret = -ENOMEM;994 ret = -ENOMEM;
1002 trigger_data = kzalloc(sizeof(*trigger_data), GFP_KERNEL);995 trigger_data = event_trigger_alloc(cmd_ops, cmd, param, file);
1003 if (!trigger_data)996 if (!trigger_data)
1004 goto out;997 goto out;
1005 998
1006 trigger_data->count = -1;999 if (remove) {
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] == '!') {
1014 event_trigger_unregister(cmd_ops, file, glob+1, trigger_data);1000 event_trigger_unregister(cmd_ops, file, glob+1, trigger_data);
1015 kfree(trigger_data);1001 kfree(trigger_data);
1016 ret = 0;1002 ret = 0;
1017 goto out;1003 goto out;
1018 }1004 }
1019 1005
1020 if (trigger) {1006 ret = event_trigger_parse_num(param, trigger_data);
1021 number = strsep(&trigger, ":");1007 if (ret)
1022 1008 goto out_free;
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;
1041 1009
1042 ret = cmd_ops->set_filter(param, trigger_data, file);1010 ret = event_trigger_set_filter(cmd_ops, file, filter, trigger_data);
1043 if (ret < 0)1011 if (ret < 0)
1044 goto out_free;1012 goto out_free;
1045 1013
1046 out_reg:
1047 /* Up the trigger_data count to make sure reg doesn't free it on failure */1014 /* Up the trigger_data count to make sure reg doesn't free it on failure */
1048 event_trigger_init(trigger_data);1015 event_trigger_init(trigger_data);
1049 1016
@@ -1057,8 +1024,7 @@ event_trigger_parse(struct event_command *cmd_ops, · 7 unmodified lines
1057 return ret;1024 return ret;
1058 1025
1059 out_free:1026 out_free:
1060 if (cmd_ops->set_filter)1027 event_trigger_reset_filter(cmd_ops, trigger_data);
1061 cmd_ops->set_filter(NULL, trigger_data, NULL);
1062 kfree(trigger_data);1028 kfree(trigger_data);
1063 goto out;1029 goto out;
1064}1030}
@@ -1752,39 +1718,33 @@ static struct event_trigger_ops event_disable_count_trigger_ops = { · 687 unmodified lines
1752 1718
1753int event_enable_trigger_parse(struct event_command *cmd_ops,1719int event_enable_trigger_parse(struct event_command *cmd_ops,
1754 struct trace_event_file *file,1720 struct trace_event_file *file,
1755 char *glob, char *cmd, char *param)1721 char *glob, char *cmd, char *param_and_filter)
1756{1722{
1757 struct trace_event_file *event_enable_file;1723 struct trace_event_file *event_enable_file;
1758 struct enable_trigger_data *enable_data;1724 struct enable_trigger_data *enable_data;
1759 struct event_trigger_data *trigger_data;1725 struct event_trigger_data *trigger_data;
1760 struct event_trigger_ops *trigger_ops;
1761 struct trace_array *tr = file->tr;1726 struct trace_array *tr = file->tr;
1727 char *param, *filter;
1728 bool enable, remove;
1762 const char *system;1729 const char *system;
1763 const char *event;1730 const char *event;
1764 bool hist = false;1731 bool hist = false;
1765 char *trigger;
1766 char *number;
1767 bool enable;
1768 int ret;1732 int ret;
1769 1733
1770 if (!param)1734 remove = event_trigger_check_remove(glob);
1771 return -EINVAL;
1772 1735
1773 /* separate the trigger from the filter (s:e:n [if filter]) */1736 if (event_trigger_empty_param(param_and_filter))
1774 trigger = strsep(&param, " \t");
1775 if (!trigger)
1776 return -EINVAL;1737 return -EINVAL;
1777 if (param) {
1778 param = skip_spaces(param);
1779 if (!*param)
1780 param = NULL;
1781 }
1782 1738
1783 system = strsep(&trigger, ":");1739 ret = event_trigger_separate_filter(param_and_filter, &param, &filter, true);
1784 if (!trigger)1740 if (ret)
1741 return ret;
1742
1743 system = strsep(&param, ":");
1744 if (!param)
1785 return -EINVAL;1745 return -EINVAL;
1786 1746
1787 event = strsep(&trigger, ":");1747 event = strsep(&param, ":");
1788 1748
1789 ret = -EINVAL;1749 ret = -EINVAL;
1790 event_enable_file = find_event_file(tr, system, event);1750 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
1800#else1760#else
1801 enable = strcmp(cmd, ENABLE_EVENT_STR) == 0;1761 enable = strcmp(cmd, ENABLE_EVENT_STR) == 0;
1802#endif1762#endif
1803 trigger_ops = cmd_ops->get_trigger_ops(cmd, trigger);
1804
1805 ret = -ENOMEM;1763 ret = -ENOMEM;
1806 trigger_data = kzalloc(sizeof(*trigger_data), GFP_KERNEL);
1807 if (!trigger_data)
1808 goto out;
1809 1764
1810 enable_data = kzalloc(sizeof(*enable_data), GFP_KERNEL);1765 enable_data = kzalloc(sizeof(*enable_data), GFP_KERNEL);
1811 if (!enable_data) {1766 if (!enable_data)
1812 kfree(trigger_data);
1813 goto out;1767 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);
1821 1768
1822 enable_data->hist = hist;1769 enable_data->hist = hist;
1823 enable_data->enable = enable;1770 enable_data->enable = enable;
1824 enable_data->file = event_enable_file;1771 enable_data->file = event_enable_file;
1825 trigger_data->private_data = enable_data;
1826 1772
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) {
1828 event_trigger_unregister(cmd_ops, file, glob+1, trigger_data);1780 event_trigger_unregister(cmd_ops, file, glob+1, trigger_data);
1829 kfree(trigger_data);1781 kfree(trigger_data);
1830 kfree(enable_data);1782 kfree(enable_data);
@@ -1835,33 +1787,14 @@ int event_enable_trigger_parse(struct event_command *cmd_ops, · 4 unmodified lines
1835 /* Up the trigger_data count to make sure nothing frees it on failure */1787 /* Up the trigger_data count to make sure nothing frees it on failure */
1836 event_trigger_init(trigger_data);1788 event_trigger_init(trigger_data);
1837 1789
1838 if (trigger) {1790 ret = event_trigger_parse_num(param, trigger_data);
1839 number = strsep(&trigger, ":");1791 if (ret)
1840 1792 goto out_free;
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;
1859 1793
1860 ret = cmd_ops->set_filter(param, trigger_data, file);1794 ret = event_trigger_set_filter(cmd_ops, file, filter, trigger_data);
1861 if (ret < 0)1795 if (ret < 0)
1862 goto out_free;1796 goto out_free;
1863 1797
1864 out_reg:
1865 /* Don't let event modules unload while probe registered */1798 /* Don't let event modules unload while probe registered */
1866 ret = trace_event_try_get_ref(event_enable_file->event_call);1799 ret = trace_event_try_get_ref(event_enable_file->event_call);
1867 if (!ret) {1800 if (!ret) {
@@ -1880,16 +1813,15 @@ int event_enable_trigger_parse(struct event_command *cmd_ops, · 12 unmodified lines
1880 event_trigger_free(trigger_data);1813 event_trigger_free(trigger_data);
1881 out:1814 out:
1882 return ret;1815 return ret;
1883
1884 out_disable:1816 out_disable:
1885 trace_event_enable_disable(event_enable_file, 0, 1);1817 trace_event_enable_disable(event_enable_file, 0, 1);
1886 out_put:1818 out_put:
1887 trace_event_put_ref(event_enable_file->event_call);1819 trace_event_put_ref(event_enable_file->event_call);
1888 out_free:1820 out_free:
1889 if (cmd_ops->set_filter)1821 event_trigger_reset_filter(cmd_ops, trigger_data);
1890 cmd_ops->set_filter(NULL, trigger_data, NULL);
1891 event_trigger_free(trigger_data);1822 event_trigger_free(trigger_data);
1892 kfree(enable_data);1823 kfree(enable_data);
1824
1893 goto out;1825 goto out;
1894}1826}
1895 1827

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