tracing: Remove get_trigger_ops() and add count_func() from trigger ops

+18 -8

kernel/trace/trace.h

··· 1791 1791 1792 1792 enum { 1793 1793 EVENT_TRIGGER_FL_PROBE = BIT(0), 1794 + EVENT_TRIGGER_FL_COUNT = BIT(1), 1794 1795 }; 1795 1796 1796 1797 struct event_trigger_data { ··· 1822 1821 bool enable; 1823 1822 bool hist; 1824 1823 }; 1824 + 1825 + bool event_trigger_count(struct event_trigger_data *data, 1826 + struct trace_buffer *buffer, void *rec, 1827 + struct ring_buffer_event *event); 1825 1828 1826 1829 extern int event_enable_trigger_print(struct seq_file *m, 1827 1830 struct event_trigger_data *data); ··· 1914 1909 * registered the trigger (see struct event_command) along with 1915 1910 * the trace record, rec. 1916 1911 * 1912 + * @count_func: If defined and a numeric parameter is passed to the 1913 + * trigger, then this function will be called before @trigger 1914 + * is called. If this function returns false, then @trigger is not 1915 + * executed. 1916 + * 1917 1917 * @init: An optional initialization function called for the trigger 1918 1918 * when the trigger is registered (via the event_command reg() 1919 1919 * function). This can be used to perform per-trigger ··· 1946 1936 struct trace_buffer *buffer, 1947 1937 void *rec, 1948 1938 struct ring_buffer_event *rbe); 1939 + bool (*count_func)(struct event_trigger_data *data, 1940 + struct trace_buffer *buffer, 1941 + void *rec, 1942 + struct ring_buffer_event *rbe); 1949 1943 int (*init)(struct event_trigger_data *data); 1950 1944 void (*free)(struct event_trigger_data *data); 1951 1945 int (*print)(struct seq_file *m, ··· 1975 1961 * 1976 1962 * @name: The unique name that identifies the event command. This is 1977 1963 * the name used when setting triggers via trigger files. 1964 + * 1965 + * @trigger_ops: The event_trigger_ops implementation associated with 1966 + * the command. 1978 1967 * 1979 1968 * @trigger_type: A unique id that identifies the event command 1980 1969 * 'type'. This value has two purposes, the first to ensure that ··· 2030 2013 * event command, filters set by the user for the command will be 2031 2014 * ignored. This is usually implemented by the generic utility 2032 2015 * function @set_trigger_filter() (see trace_event_triggers.c). 2033 - * 2034 - * @get_trigger_ops: The callback function invoked to retrieve the 2035 - * event_trigger_ops implementation associated with the command. 2036 - * This callback function allows a single event_command to 2037 - * support multiple trigger implementations via different sets of 2038 - * event_trigger_ops, depending on the value of the @param 2039 - * string. 2040 2016 */ 2041 2017 struct event_command { 2042 2018 struct list_head list; 2043 2019 char *name; 2020 + const struct event_trigger_ops *trigger_ops; 2044 2021 enum event_trigger_type trigger_type; 2045 2022 int flags; 2046 2023 int (*parse)(struct event_command *cmd_ops, ··· 2051 2040 int (*set_filter)(char *filter_str, 2052 2041 struct event_trigger_data *data, 2053 2042 struct trace_event_file *file); 2054 - const struct event_trigger_ops *(*get_trigger_ops)(char *cmd, char *param); 2055 2043 }; 2056 2044 2057 2045 /**

+1 -7

kernel/trace/trace_eprobe.c

··· 513 513 514 514 } 515 515 516 - static const struct event_trigger_ops *eprobe_trigger_get_ops(char *cmd, 517 - char *param) 518 - { 519 - return &eprobe_trigger_ops; 520 - } 521 - 522 516 static struct event_command event_trigger_cmd = { 523 517 .name = "eprobe", 524 518 .trigger_type = ETT_EVENT_EPROBE, 525 519 .flags = EVENT_CMD_FL_NEEDS_REC, 520 + .trigger_ops = &eprobe_trigger_ops, 526 521 .parse = eprobe_trigger_cmd_parse, 527 522 .reg = eprobe_trigger_reg_func, 528 523 .unreg = eprobe_trigger_unreg_func, 529 524 .unreg_all = NULL, 530 - .get_trigger_ops = eprobe_trigger_get_ops, 531 525 .set_filter = NULL, 532 526 }; 533 527

+5 -55

kernel/trace/trace_events_hist.c

··· 6363 6363 .free = event_hist_trigger_named_free, 6364 6364 }; 6365 6365 6366 - static const struct event_trigger_ops *event_hist_get_trigger_ops(char *cmd, 6367 - char *param) 6368 - { 6369 - return &event_hist_trigger_ops; 6370 - } 6371 - 6372 6366 static void hist_clear(struct event_trigger_data *data) 6373 6367 { 6374 6368 struct hist_trigger_data *hist_data = data->private_data; ··· 6902 6908 .name = "hist", 6903 6909 .trigger_type = ETT_EVENT_HIST, 6904 6910 .flags = EVENT_CMD_FL_NEEDS_REC, 6911 + .trigger_ops = &event_hist_trigger_ops, 6905 6912 .parse = event_hist_trigger_parse, 6906 6913 .reg = hist_register_trigger, 6907 6914 .unreg = hist_unregister_trigger, 6908 6915 .unreg_all = hist_unreg_all, 6909 - .get_trigger_ops = event_hist_get_trigger_ops, 6910 6916 .set_filter = set_trigger_filter, 6911 6917 }; 6912 6918 ··· 6939 6945 } 6940 6946 } 6941 6947 6942 - static void 6943 - hist_enable_count_trigger(struct event_trigger_data *data, 6944 - struct trace_buffer *buffer, void *rec, 6945 - struct ring_buffer_event *event) 6946 - { 6947 - if (!data->count) 6948 - return; 6949 - 6950 - if (data->count != -1) 6951 - (data->count)--; 6952 - 6953 - hist_enable_trigger(data, buffer, rec, event); 6954 - } 6955 - 6956 6948 static const struct event_trigger_ops hist_enable_trigger_ops = { 6957 6949 .trigger = hist_enable_trigger, 6958 - .print = event_enable_trigger_print, 6959 - .init = event_trigger_init, 6960 - .free = event_enable_trigger_free, 6961 - }; 6962 - 6963 - static const struct event_trigger_ops hist_enable_count_trigger_ops = { 6964 - .trigger = hist_enable_count_trigger, 6950 + .count_func = event_trigger_count, 6965 6951 .print = event_enable_trigger_print, 6966 6952 .init = event_trigger_init, 6967 6953 .free = event_enable_trigger_free, ··· 6949 6975 6950 6976 static const struct event_trigger_ops hist_disable_trigger_ops = { 6951 6977 .trigger = hist_enable_trigger, 6978 + .count_func = event_trigger_count, 6952 6979 .print = event_enable_trigger_print, 6953 6980 .init = event_trigger_init, 6954 6981 .free = event_enable_trigger_free, 6955 6982 }; 6956 - 6957 - static const struct event_trigger_ops hist_disable_count_trigger_ops = { 6958 - .trigger = hist_enable_count_trigger, 6959 - .print = event_enable_trigger_print, 6960 - .init = event_trigger_init, 6961 - .free = event_enable_trigger_free, 6962 - }; 6963 - 6964 - static const struct event_trigger_ops * 6965 - hist_enable_get_trigger_ops(char *cmd, char *param) 6966 - { 6967 - const struct event_trigger_ops *ops; 6968 - bool enable; 6969 - 6970 - enable = (strcmp(cmd, ENABLE_HIST_STR) == 0); 6971 - 6972 - if (enable) 6973 - ops = param ? &hist_enable_count_trigger_ops : 6974 - &hist_enable_trigger_ops; 6975 - else 6976 - ops = param ? &hist_disable_count_trigger_ops : 6977 - &hist_disable_trigger_ops; 6978 - 6979 - return ops; 6980 - } 6981 6983 6982 6984 static void hist_enable_unreg_all(struct trace_event_file *file) 6983 6985 { ··· 6973 7023 static struct event_command trigger_hist_enable_cmd = { 6974 7024 .name = ENABLE_HIST_STR, 6975 7025 .trigger_type = ETT_HIST_ENABLE, 7026 + .trigger_ops = &hist_enable_trigger_ops, 6976 7027 .parse = event_enable_trigger_parse, 6977 7028 .reg = event_enable_register_trigger, 6978 7029 .unreg = event_enable_unregister_trigger, 6979 7030 .unreg_all = hist_enable_unreg_all, 6980 - .get_trigger_ops = hist_enable_get_trigger_ops, 6981 7031 .set_filter = set_trigger_filter, 6982 7032 }; 6983 7033 6984 7034 static struct event_command trigger_hist_disable_cmd = { 6985 7035 .name = DISABLE_HIST_STR, 6986 7036 .trigger_type = ETT_HIST_ENABLE, 7037 + .trigger_ops = &hist_disable_trigger_ops, 6987 7038 .parse = event_enable_trigger_parse, 6988 7039 .reg = event_enable_register_trigger, 6989 7040 .unreg = event_enable_unregister_trigger, 6990 7041 .unreg_all = hist_enable_unreg_all, 6991 - .get_trigger_ops = hist_enable_get_trigger_ops, 6992 7042 .set_filter = set_trigger_filter, 6993 7043 }; 6994 7044

+92 -165

kernel/trace/trace_events_trigger.c

··· 28 28 kfree(data); 29 29 } 30 30 31 + static inline void data_ops_trigger(struct event_trigger_data *data, 32 + struct trace_buffer *buffer, void *rec, 33 + struct ring_buffer_event *event) 34 + { 35 + const struct event_trigger_ops *ops = data->ops; 36 + 37 + if (data->flags & EVENT_TRIGGER_FL_COUNT) { 38 + if (!ops->count_func(data, buffer, rec, event)) 39 + return; 40 + } 41 + 42 + ops->trigger(data, buffer, rec, event); 43 + } 44 + 31 45 /** 32 46 * event_triggers_call - Call triggers associated with a trace event 33 47 * @file: The trace_event_file associated with the event ··· 84 70 if (data->paused) 85 71 continue; 86 72 if (!rec) { 87 - data->ops->trigger(data, buffer, rec, event); 73 + data_ops_trigger(data, buffer, rec, event); 88 74 continue; 89 75 } 90 76 filter = rcu_dereference_sched(data->filter); ··· 94 80 tt |= data->cmd_ops->trigger_type; 95 81 continue; 96 82 } 97 - data->ops->trigger(data, buffer, rec, event); 83 + data_ops_trigger(data, buffer, rec, event); 98 84 } 99 85 return tt; 100 86 } ··· 136 122 if (data->paused) 137 123 continue; 138 124 if (data->cmd_ops->trigger_type & tt) 139 - data->ops->trigger(data, NULL, NULL, NULL); 125 + data_ops_trigger(data, NULL, NULL, NULL); 140 126 } 141 127 } 142 128 EXPORT_SYMBOL_GPL(event_triggers_post_call); ··· 389 375 } 390 376 391 377 return -ENODEV; 378 + } 379 + 380 + /** 381 + * event_trigger_count - Optional count function for event triggers 382 + * @data: Trigger-specific data 383 + * @buffer: The ring buffer that the event is being written to 384 + * @rec: The trace entry for the event, NULL for unconditional invocation 385 + * @event: The event meta data in the ring buffer 386 + * 387 + * For triggers that can take a count parameter that doesn't do anything 388 + * special, they can use this function to assign to their .count_func 389 + * field. 390 + * 391 + * This simply does a count down of the @data->count field. 392 + * 393 + * If the @data->count is greater than zero, it will decrement it. 394 + * 395 + * Returns false if @data->count is zero, otherwise true. 396 + */ 397 + bool event_trigger_count(struct event_trigger_data *data, 398 + struct trace_buffer *buffer, void *rec, 399 + struct ring_buffer_event *event) 400 + { 401 + if (!data->count) 402 + return false; 403 + 404 + if (data->count != -1) 405 + (data->count)--; 406 + 407 + return true; 392 408 } 393 409 394 410 /** ··· 851 807 * @private_data: User data to associate with the event trigger 852 808 * 853 809 * Allocate an event_trigger_data instance and initialize it. The 854 - * @cmd_ops are used along with the @cmd and @param to get the 855 - * trigger_ops to assign to the event_trigger_data. @private_data can 856 - * also be passed in and associated with the event_trigger_data. 810 + * @cmd_ops defines how the trigger will operate. If @param is set, 811 + * and @cmd_ops->trigger_ops->count_func is non NULL, then the 812 + * data->count is set to @param and before the trigger is executed, the 813 + * @cmd_ops->trigger_ops->count_func() is called. If that function returns 814 + * false, the @cmd_ops->trigger_ops->trigger() function will not be called. 815 + * @private_data can also be passed in and associated with the 816 + * event_trigger_data. 857 817 * 858 818 * Use trigger_data_free() to free an event_trigger_data object. 859 819 * ··· 869 821 void *private_data) 870 822 { 871 823 struct event_trigger_data *trigger_data; 872 - const struct event_trigger_ops *trigger_ops; 873 - 874 - trigger_ops = cmd_ops->get_trigger_ops(cmd, param); 875 824 876 825 trigger_data = kzalloc(sizeof(*trigger_data), GFP_KERNEL); 877 826 if (!trigger_data) 878 827 return NULL; 879 828 880 829 trigger_data->count = -1; 881 - trigger_data->ops = trigger_ops; 830 + trigger_data->ops = cmd_ops->trigger_ops; 882 831 trigger_data->cmd_ops = cmd_ops; 883 832 trigger_data->private_data = private_data; 833 + if (param && cmd_ops->trigger_ops->count_func) 834 + trigger_data->flags |= EVENT_TRIGGER_FL_COUNT; 884 835 885 836 INIT_LIST_HEAD(&trigger_data->list); 886 837 INIT_LIST_HEAD(&trigger_data->named_list); ··· 1318 1271 tracing_on(); 1319 1272 } 1320 1273 1321 - static void 1322 - traceon_count_trigger(struct event_trigger_data *data, 1323 - struct trace_buffer *buffer, void *rec, 1324 - struct ring_buffer_event *event) 1274 + static bool 1275 + traceon_count_func(struct event_trigger_data *data, 1276 + struct trace_buffer *buffer, void *rec, 1277 + struct ring_buffer_event *event) 1325 1278 { 1326 1279 struct trace_event_file *file = data->private_data; 1327 1280 1328 1281 if (file) { 1329 1282 if (tracer_tracing_is_on(file->tr)) 1330 - return; 1283 + return false; 1331 1284 } else { 1332 1285 if (tracing_is_on()) 1333 - return; 1286 + return false; 1334 1287 } 1335 1288 1336 1289 if (!data->count) 1337 - return; 1290 + return false; 1338 1291 1339 1292 if (data->count != -1) 1340 1293 (data->count)--; 1341 1294 1342 - if (file) 1343 - tracer_tracing_on(file->tr); 1344 - else 1345 - tracing_on(); 1295 + return true; 1346 1296 } 1347 1297 1348 1298 static void ··· 1363 1319 tracing_off(); 1364 1320 } 1365 1321 1366 - static void 1367 - traceoff_count_trigger(struct event_trigger_data *data, 1368 - struct trace_buffer *buffer, void *rec, 1369 - struct ring_buffer_event *event) 1322 + static bool 1323 + traceoff_count_func(struct event_trigger_data *data, 1324 + struct trace_buffer *buffer, void *rec, 1325 + struct ring_buffer_event *event) 1370 1326 { 1371 1327 struct trace_event_file *file = data->private_data; 1372 1328 1373 1329 if (file) { 1374 1330 if (!tracer_tracing_is_on(file->tr)) 1375 - return; 1331 + return false; 1376 1332 } else { 1377 1333 if (!tracing_is_on()) 1378 - return; 1334 + return false; 1379 1335 } 1380 1336 1381 1337 if (!data->count) 1382 - return; 1338 + return false; 1383 1339 1384 1340 if (data->count != -1) 1385 1341 (data->count)--; 1386 1342 1387 - if (file) 1388 - tracer_tracing_off(file->tr); 1389 - else 1390 - tracing_off(); 1343 + return true; 1391 1344 } 1392 1345 1393 1346 static int ··· 1403 1362 1404 1363 static const struct event_trigger_ops traceon_trigger_ops = { 1405 1364 .trigger = traceon_trigger, 1406 - .print = traceon_trigger_print, 1407 - .init = event_trigger_init, 1408 - .free = event_trigger_free, 1409 - }; 1410 - 1411 - static const struct event_trigger_ops traceon_count_trigger_ops = { 1412 - .trigger = traceon_count_trigger, 1365 + .count_func = traceon_count_func, 1413 1366 .print = traceon_trigger_print, 1414 1367 .init = event_trigger_init, 1415 1368 .free = event_trigger_free, ··· 1411 1376 1412 1377 static const struct event_trigger_ops traceoff_trigger_ops = { 1413 1378 .trigger = traceoff_trigger, 1379 + .count_func = traceoff_count_func, 1414 1380 .print = traceoff_trigger_print, 1415 1381 .init = event_trigger_init, 1416 1382 .free = event_trigger_free, 1417 1383 }; 1418 - 1419 - static const struct event_trigger_ops traceoff_count_trigger_ops = { 1420 - .trigger = traceoff_count_trigger, 1421 - .print = traceoff_trigger_print, 1422 - .init = event_trigger_init, 1423 - .free = event_trigger_free, 1424 - }; 1425 - 1426 - static const struct event_trigger_ops * 1427 - onoff_get_trigger_ops(char *cmd, char *param) 1428 - { 1429 - const struct event_trigger_ops *ops; 1430 - 1431 - /* we register both traceon and traceoff to this callback */ 1432 - if (strcmp(cmd, "traceon") == 0) 1433 - ops = param ? &traceon_count_trigger_ops : 1434 - &traceon_trigger_ops; 1435 - else 1436 - ops = param ? &traceoff_count_trigger_ops : 1437 - &traceoff_trigger_ops; 1438 - 1439 - return ops; 1440 - } 1441 1384 1442 1385 static struct event_command trigger_traceon_cmd = { 1443 1386 .name = "traceon", 1444 1387 .trigger_type = ETT_TRACE_ONOFF, 1388 + .trigger_ops = &traceon_trigger_ops, 1445 1389 .parse = event_trigger_parse, 1446 1390 .reg = register_trigger, 1447 1391 .unreg = unregister_trigger, 1448 - .get_trigger_ops = onoff_get_trigger_ops, 1449 1392 .set_filter = set_trigger_filter, 1450 1393 }; 1451 1394 ··· 1431 1418 .name = "traceoff", 1432 1419 .trigger_type = ETT_TRACE_ONOFF, 1433 1420 .flags = EVENT_CMD_FL_POST_TRIGGER, 1421 + .trigger_ops = &traceoff_trigger_ops, 1434 1422 .parse = event_trigger_parse, 1435 1423 .reg = register_trigger, 1436 1424 .unreg = unregister_trigger, 1437 - .get_trigger_ops = onoff_get_trigger_ops, 1438 1425 .set_filter = set_trigger_filter, 1439 1426 }; 1440 1427 ··· 1450 1437 tracing_snapshot_instance(file->tr); 1451 1438 else 1452 1439 tracing_snapshot(); 1453 - } 1454 - 1455 - static void 1456 - snapshot_count_trigger(struct event_trigger_data *data, 1457 - struct trace_buffer *buffer, void *rec, 1458 - struct ring_buffer_event *event) 1459 - { 1460 - if (!data->count) 1461 - return; 1462 - 1463 - if (data->count != -1) 1464 - (data->count)--; 1465 - 1466 - snapshot_trigger(data, buffer, rec, event); 1467 1440 } 1468 1441 1469 1442 static int ··· 1485 1486 1486 1487 static const struct event_trigger_ops snapshot_trigger_ops = { 1487 1488 .trigger = snapshot_trigger, 1489 + .count_func = event_trigger_count, 1488 1490 .print = snapshot_trigger_print, 1489 1491 .init = event_trigger_init, 1490 1492 .free = event_trigger_free, 1491 1493 }; 1492 - 1493 - static const struct event_trigger_ops snapshot_count_trigger_ops = { 1494 - .trigger = snapshot_count_trigger, 1495 - .print = snapshot_trigger_print, 1496 - .init = event_trigger_init, 1497 - .free = event_trigger_free, 1498 - }; 1499 - 1500 - static const struct event_trigger_ops * 1501 - snapshot_get_trigger_ops(char *cmd, char *param) 1502 - { 1503 - return param ? &snapshot_count_trigger_ops : &snapshot_trigger_ops; 1504 - } 1505 1494 1506 1495 static struct event_command trigger_snapshot_cmd = { 1507 1496 .name = "snapshot", 1508 1497 .trigger_type = ETT_SNAPSHOT, 1498 + .trigger_ops = &snapshot_trigger_ops, 1509 1499 .parse = event_trigger_parse, 1510 1500 .reg = register_snapshot_trigger, 1511 1501 .unreg = unregister_snapshot_trigger, 1512 - .get_trigger_ops = snapshot_get_trigger_ops, 1513 1502 .set_filter = set_trigger_filter, 1514 1503 }; 1515 1504 ··· 1545 1558 trace_dump_stack(STACK_SKIP); 1546 1559 } 1547 1560 1548 - static void 1549 - stacktrace_count_trigger(struct event_trigger_data *data, 1550 - struct trace_buffer *buffer, void *rec, 1551 - struct ring_buffer_event *event) 1552 - { 1553 - if (!data->count) 1554 - return; 1555 - 1556 - if (data->count != -1) 1557 - (data->count)--; 1558 - 1559 - stacktrace_trigger(data, buffer, rec, event); 1560 - } 1561 - 1562 1561 static int 1563 1562 stacktrace_trigger_print(struct seq_file *m, struct event_trigger_data *data) 1564 1563 { ··· 1554 1581 1555 1582 static const struct event_trigger_ops stacktrace_trigger_ops = { 1556 1583 .trigger = stacktrace_trigger, 1584 + .count_func = event_trigger_count, 1557 1585 .print = stacktrace_trigger_print, 1558 1586 .init = event_trigger_init, 1559 1587 .free = event_trigger_free, 1560 1588 }; 1561 - 1562 - static const struct event_trigger_ops stacktrace_count_trigger_ops = { 1563 - .trigger = stacktrace_count_trigger, 1564 - .print = stacktrace_trigger_print, 1565 - .init = event_trigger_init, 1566 - .free = event_trigger_free, 1567 - }; 1568 - 1569 - static const struct event_trigger_ops * 1570 - stacktrace_get_trigger_ops(char *cmd, char *param) 1571 - { 1572 - return param ? &stacktrace_count_trigger_ops : &stacktrace_trigger_ops; 1573 - } 1574 1589 1575 1590 static struct event_command trigger_stacktrace_cmd = { 1576 1591 .name = "stacktrace", 1577 1592 .trigger_type = ETT_STACKTRACE, 1593 + .trigger_ops = &stacktrace_trigger_ops, 1578 1594 .flags = EVENT_CMD_FL_POST_TRIGGER, 1579 1595 .parse = event_trigger_parse, 1580 1596 .reg = register_trigger, 1581 1597 .unreg = unregister_trigger, 1582 - .get_trigger_ops = stacktrace_get_trigger_ops, 1583 1598 .set_filter = set_trigger_filter, 1584 1599 }; 1585 1600 ··· 1603 1642 set_bit(EVENT_FILE_FL_SOFT_DISABLED_BIT, &enable_data->file->flags); 1604 1643 } 1605 1644 1606 - static void 1607 - event_enable_count_trigger(struct event_trigger_data *data, 1608 - struct trace_buffer *buffer, void *rec, 1609 - struct ring_buffer_event *event) 1645 + static bool 1646 + event_enable_count_func(struct event_trigger_data *data, 1647 + struct trace_buffer *buffer, void *rec, 1648 + struct ring_buffer_event *event) 1610 1649 { 1611 1650 struct enable_trigger_data *enable_data = data->private_data; 1612 1651 1613 1652 if (!data->count) 1614 - return; 1653 + return false; 1615 1654 1616 1655 /* Skip if the event is in a state we want to switch to */ 1617 1656 if (enable_data->enable == !(enable_data->file->flags & EVENT_FILE_FL_SOFT_DISABLED)) 1618 - return; 1657 + return false; 1619 1658 1620 1659 if (data->count != -1) 1621 1660 (data->count)--; 1622 1661 1623 - event_enable_trigger(data, buffer, rec, event); 1662 + return true; 1624 1663 } 1625 1664 1626 1665 int event_enable_trigger_print(struct seq_file *m, ··· 1667 1706 1668 1707 static const struct event_trigger_ops event_enable_trigger_ops = { 1669 1708 .trigger = event_enable_trigger, 1670 - .print = event_enable_trigger_print, 1671 - .init = event_trigger_init, 1672 - .free = event_enable_trigger_free, 1673 - }; 1674 - 1675 - static const struct event_trigger_ops event_enable_count_trigger_ops = { 1676 - .trigger = event_enable_count_trigger, 1709 + .count_func = event_enable_count_func, 1677 1710 .print = event_enable_trigger_print, 1678 1711 .init = event_trigger_init, 1679 1712 .free = event_enable_trigger_free, ··· 1675 1720 1676 1721 static const struct event_trigger_ops event_disable_trigger_ops = { 1677 1722 .trigger = event_enable_trigger, 1678 - .print = event_enable_trigger_print, 1679 - .init = event_trigger_init, 1680 - .free = event_enable_trigger_free, 1681 - }; 1682 - 1683 - static const struct event_trigger_ops event_disable_count_trigger_ops = { 1684 - .trigger = event_enable_count_trigger, 1723 + .count_func = event_enable_count_func, 1685 1724 .print = event_enable_trigger_print, 1686 1725 .init = event_trigger_init, 1687 1726 .free = event_enable_trigger_free, ··· 1855 1906 data->ops->free(data); 1856 1907 } 1857 1908 1858 - static const struct event_trigger_ops * 1859 - event_enable_get_trigger_ops(char *cmd, char *param) 1860 - { 1861 - const struct event_trigger_ops *ops; 1862 - bool enable; 1863 - 1864 - #ifdef CONFIG_HIST_TRIGGERS 1865 - enable = ((strcmp(cmd, ENABLE_EVENT_STR) == 0) || 1866 - (strcmp(cmd, ENABLE_HIST_STR) == 0)); 1867 - #else 1868 - enable = strcmp(cmd, ENABLE_EVENT_STR) == 0; 1869 - #endif 1870 - if (enable) 1871 - ops = param ? &event_enable_count_trigger_ops : 1872 - &event_enable_trigger_ops; 1873 - else 1874 - ops = param ? &event_disable_count_trigger_ops : 1875 - &event_disable_trigger_ops; 1876 - 1877 - return ops; 1878 - } 1879 - 1880 1909 static struct event_command trigger_enable_cmd = { 1881 1910 .name = ENABLE_EVENT_STR, 1882 1911 .trigger_type = ETT_EVENT_ENABLE, 1912 + .trigger_ops = &event_enable_trigger_ops, 1883 1913 .parse = event_enable_trigger_parse, 1884 1914 .reg = event_enable_register_trigger, 1885 1915 .unreg = event_enable_unregister_trigger, 1886 - .get_trigger_ops = event_enable_get_trigger_ops, 1887 1916 .set_filter = set_trigger_filter, 1888 1917 }; 1889 1918 1890 1919 static struct event_command trigger_disable_cmd = { 1891 1920 .name = DISABLE_EVENT_STR, 1892 1921 .trigger_type = ETT_EVENT_ENABLE, 1922 + .trigger_ops = &event_disable_trigger_ops, 1893 1923 .parse = event_enable_trigger_parse, 1894 1924 .reg = event_enable_register_trigger, 1895 1925 .unreg = event_enable_unregister_trigger, 1896 - .get_trigger_ops = event_enable_get_trigger_ops, 1897 1926 .set_filter = set_trigger_filter, 1898 1927 }; 1899 1928

Configure Feed

Configure Feed