mirror of
https://git.kernel.org/pub/scm/linux/kernel/git/stable/linux.git
synced 2024-08-23 09:19:51 +00:00
![Linus Torvalds](/assets/img/avatar_default.png)
- Add "onchange(var)" histogram handler that executes a action when $var changes. - Add new "snapshot()" action for histogram handlers, that causes a snapshot of the ring buffer when triggered. ie. onchange(var).snapshot() will trigger a snapshot if var changes. - Add alternative for "trace()" action. Currently, to trigger a synthetic event, the name of that event is used as the handler name, which is inconsistent with the other actions. onchange(var).synthetic(param) where it can now be onchange(var).trace(synthetic, param). The older method will still be allowed, as long as the synthetic events do not overlap with other handler names. - The histogram documentation at testcases were updated for the new changes. Added a quicker way to enable set_ftrace_filter files, that will make it much quicker to bisect tracing a function that shouldn't be traced and crashes the kernel. (You can echo in numbers to set_ftrace_filter, and it will select the corresponding function that is in available_filter_functions). Some better displaying of the tracing data (and more information was added). The rest are small fixes and more clean ups to the code. -----BEGIN PGP SIGNATURE----- iIoEABYIADIWIQRRSw7ePDh/lE+zeZMp5XQQmuv6qgUCXIXXjRQccm9zdGVkdEBn b29kbWlzLm9yZwAKCRAp5XQQmuv6qrSJAQCbGXAvZE+shfKRhbU1cu1C1nwRMHhH eeRecJs1RChGFgD/TwatD4FzARQPjfk7snQD5KWPpoRc9grUACC2cZcaWwQ= =LVBI -----END PGP SIGNATURE----- Merge tag 'trace-v5.1' of git://git.kernel.org/pub/scm/linux/kernel/git/rostedt/linux-trace Pull tracing updates from Steven Rostedt: "The biggest change for this release is in the histogram code: - Add "onchange(var)" histogram handler that executes a action when $var changes. - Add new "snapshot()" action for histogram handlers, that causes a snapshot of the ring buffer when triggered. ie. onchange(var).snapshot() will trigger a snapshot if var changes. - Add alternative for "trace()" action. Currently, to trigger a synthetic event, the name of that event is used as the handler name, which is inconsistent with the other actions. onchange(var).synthetic(param) where it can now be onchange(var).trace(synthetic, param). The older method will still be allowed, as long as the synthetic events do not overlap with other handler names. - The histogram documentation at testcases were updated for the new changes. Outside of the histogram code, we have: - Added a quicker way to enable set_ftrace_filter files, that will make it much quicker to bisect tracing a function that shouldn't be traced and crashes the kernel. (You can echo in numbers to set_ftrace_filter, and it will select the corresponding function that is in available_filter_functions). - Some better displaying of the tracing data (and more information was added). The rest are small fixes and more clean ups to the code" * tag 'trace-v5.1' of git://git.kernel.org/pub/scm/linux/kernel/git/rostedt/linux-trace: (37 commits) tracing: Use strncpy instead of memcpy when copying comm in trace.c tracing: Use strncpy instead of memcpy when copying comm for hist triggers tracing: Use strncpy instead of memcpy for string keys in hist triggers tracing: Use str_has_prefix() in synth_event_create() x86/ftrace: Fix warning and considate ftrace_jmp_replace() and ftrace_call_replace() tracing/perf: Use strndup_user() instead of buggy open-coded version doc: trace: Fix documentation for uprobe_profile tracing: Fix spelling mistake: "analagous" -> "analogous" tracing: Comment why cond_snapshot is checked outside of max_lock protection tracing: Add hist trigger action 'expected fail' test case tracing: Add alternative synthetic event trace action test case tracing: Add hist trigger onchange() handler test case tracing: Add hist trigger snapshot() action test case tracing: Add SPDX license GPL-2.0 license identifier to inter-event testcases tracing: Add alternative synthetic event trace action syntax tracing: Add hist trigger onchange() handler Documentation tracing: Add hist trigger onchange() handler tracing: Add hist trigger snapshot() action Documentation tracing: Add hist trigger snapshot() action tracing: Add conditional snapshot ...
2256 lines
55 KiB
C
2256 lines
55 KiB
C
// SPDX-License-Identifier: GPL-2.0
|
|
/*
|
|
* trace_events_filter - generic event filtering
|
|
*
|
|
* Copyright (C) 2009 Tom Zanussi <tzanussi@gmail.com>
|
|
*/
|
|
|
|
#include <linux/module.h>
|
|
#include <linux/ctype.h>
|
|
#include <linux/mutex.h>
|
|
#include <linux/perf_event.h>
|
|
#include <linux/slab.h>
|
|
|
|
#include "trace.h"
|
|
#include "trace_output.h"
|
|
|
|
#define DEFAULT_SYS_FILTER_MESSAGE \
|
|
"### global filter ###\n" \
|
|
"# Use this to set filters for multiple events.\n" \
|
|
"# Only events with the given fields will be affected.\n" \
|
|
"# If no events are modified, an error message will be displayed here"
|
|
|
|
/* Due to token parsing '<=' must be before '<' and '>=' must be before '>' */
|
|
#define OPS \
|
|
C( OP_GLOB, "~" ), \
|
|
C( OP_NE, "!=" ), \
|
|
C( OP_EQ, "==" ), \
|
|
C( OP_LE, "<=" ), \
|
|
C( OP_LT, "<" ), \
|
|
C( OP_GE, ">=" ), \
|
|
C( OP_GT, ">" ), \
|
|
C( OP_BAND, "&" ), \
|
|
C( OP_MAX, NULL )
|
|
|
|
#undef C
|
|
#define C(a, b) a
|
|
|
|
enum filter_op_ids { OPS };
|
|
|
|
#undef C
|
|
#define C(a, b) b
|
|
|
|
static const char * ops[] = { OPS };
|
|
|
|
/*
|
|
* pred functions are OP_LE, OP_LT, OP_GE, OP_GT, and OP_BAND
|
|
* pred_funcs_##type below must match the order of them above.
|
|
*/
|
|
#define PRED_FUNC_START OP_LE
|
|
#define PRED_FUNC_MAX (OP_BAND - PRED_FUNC_START)
|
|
|
|
#define ERRORS \
|
|
C(NONE, "No error"), \
|
|
C(INVALID_OP, "Invalid operator"), \
|
|
C(TOO_MANY_OPEN, "Too many '('"), \
|
|
C(TOO_MANY_CLOSE, "Too few '('"), \
|
|
C(MISSING_QUOTE, "Missing matching quote"), \
|
|
C(OPERAND_TOO_LONG, "Operand too long"), \
|
|
C(EXPECT_STRING, "Expecting string field"), \
|
|
C(EXPECT_DIGIT, "Expecting numeric field"), \
|
|
C(ILLEGAL_FIELD_OP, "Illegal operation for field type"), \
|
|
C(FIELD_NOT_FOUND, "Field not found"), \
|
|
C(ILLEGAL_INTVAL, "Illegal integer value"), \
|
|
C(BAD_SUBSYS_FILTER, "Couldn't find or set field in one of a subsystem's events"), \
|
|
C(TOO_MANY_PREDS, "Too many terms in predicate expression"), \
|
|
C(INVALID_FILTER, "Meaningless filter expression"), \
|
|
C(IP_FIELD_ONLY, "Only 'ip' field is supported for function trace"), \
|
|
C(INVALID_VALUE, "Invalid value (did you forget quotes)?"), \
|
|
C(NO_FILTER, "No filter found"),
|
|
|
|
#undef C
|
|
#define C(a, b) FILT_ERR_##a
|
|
|
|
enum { ERRORS };
|
|
|
|
#undef C
|
|
#define C(a, b) b
|
|
|
|
static char *err_text[] = { ERRORS };
|
|
|
|
/* Called after a '!' character but "!=" and "!~" are not "not"s */
|
|
static bool is_not(const char *str)
|
|
{
|
|
switch (str[1]) {
|
|
case '=':
|
|
case '~':
|
|
return false;
|
|
}
|
|
return true;
|
|
}
|
|
|
|
/**
|
|
* prog_entry - a singe entry in the filter program
|
|
* @target: Index to jump to on a branch (actually one minus the index)
|
|
* @when_to_branch: The value of the result of the predicate to do a branch
|
|
* @pred: The predicate to execute.
|
|
*/
|
|
struct prog_entry {
|
|
int target;
|
|
int when_to_branch;
|
|
struct filter_pred *pred;
|
|
};
|
|
|
|
/**
|
|
* update_preds- assign a program entry a label target
|
|
* @prog: The program array
|
|
* @N: The index of the current entry in @prog
|
|
* @when_to_branch: What to assign a program entry for its branch condition
|
|
*
|
|
* The program entry at @N has a target that points to the index of a program
|
|
* entry that can have its target and when_to_branch fields updated.
|
|
* Update the current program entry denoted by index @N target field to be
|
|
* that of the updated entry. This will denote the entry to update if
|
|
* we are processing an "||" after an "&&"
|
|
*/
|
|
static void update_preds(struct prog_entry *prog, int N, int invert)
|
|
{
|
|
int t, s;
|
|
|
|
t = prog[N].target;
|
|
s = prog[t].target;
|
|
prog[t].when_to_branch = invert;
|
|
prog[t].target = N;
|
|
prog[N].target = s;
|
|
}
|
|
|
|
struct filter_parse_error {
|
|
int lasterr;
|
|
int lasterr_pos;
|
|
};
|
|
|
|
static void parse_error(struct filter_parse_error *pe, int err, int pos)
|
|
{
|
|
pe->lasterr = err;
|
|
pe->lasterr_pos = pos;
|
|
}
|
|
|
|
typedef int (*parse_pred_fn)(const char *str, void *data, int pos,
|
|
struct filter_parse_error *pe,
|
|
struct filter_pred **pred);
|
|
|
|
enum {
|
|
INVERT = 1,
|
|
PROCESS_AND = 2,
|
|
PROCESS_OR = 4,
|
|
};
|
|
|
|
/*
|
|
* Without going into a formal proof, this explains the method that is used in
|
|
* parsing the logical expressions.
|
|
*
|
|
* For example, if we have: "a && !(!b || (c && g)) || d || e && !f"
|
|
* The first pass will convert it into the following program:
|
|
*
|
|
* n1: r=a; l1: if (!r) goto l4;
|
|
* n2: r=b; l2: if (!r) goto l4;
|
|
* n3: r=c; r=!r; l3: if (r) goto l4;
|
|
* n4: r=g; r=!r; l4: if (r) goto l5;
|
|
* n5: r=d; l5: if (r) goto T
|
|
* n6: r=e; l6: if (!r) goto l7;
|
|
* n7: r=f; r=!r; l7: if (!r) goto F
|
|
* T: return TRUE
|
|
* F: return FALSE
|
|
*
|
|
* To do this, we use a data structure to represent each of the above
|
|
* predicate and conditions that has:
|
|
*
|
|
* predicate, when_to_branch, invert, target
|
|
*
|
|
* The "predicate" will hold the function to determine the result "r".
|
|
* The "when_to_branch" denotes what "r" should be if a branch is to be taken
|
|
* "&&" would contain "!r" or (0) and "||" would contain "r" or (1).
|
|
* The "invert" holds whether the value should be reversed before testing.
|
|
* The "target" contains the label "l#" to jump to.
|
|
*
|
|
* A stack is created to hold values when parentheses are used.
|
|
*
|
|
* To simplify the logic, the labels will start at 0 and not 1.
|
|
*
|
|
* The possible invert values are 1 and 0. The number of "!"s that are in scope
|
|
* before the predicate determines the invert value, if the number is odd then
|
|
* the invert value is 1 and 0 otherwise. This means the invert value only
|
|
* needs to be toggled when a new "!" is introduced compared to what is stored
|
|
* on the stack, where parentheses were used.
|
|
*
|
|
* The top of the stack and "invert" are initialized to zero.
|
|
*
|
|
* ** FIRST PASS **
|
|
*
|
|
* #1 A loop through all the tokens is done:
|
|
*
|
|
* #2 If the token is an "(", the stack is push, and the current stack value
|
|
* gets the current invert value, and the loop continues to the next token.
|
|
* The top of the stack saves the "invert" value to keep track of what
|
|
* the current inversion is. As "!(a && !b || c)" would require all
|
|
* predicates being affected separately by the "!" before the parentheses.
|
|
* And that would end up being equivalent to "(!a || b) && !c"
|
|
*
|
|
* #3 If the token is an "!", the current "invert" value gets inverted, and
|
|
* the loop continues. Note, if the next token is a predicate, then
|
|
* this "invert" value is only valid for the current program entry,
|
|
* and does not affect other predicates later on.
|
|
*
|
|
* The only other acceptable token is the predicate string.
|
|
*
|
|
* #4 A new entry into the program is added saving: the predicate and the
|
|
* current value of "invert". The target is currently assigned to the
|
|
* previous program index (this will not be its final value).
|
|
*
|
|
* #5 We now enter another loop and look at the next token. The only valid
|
|
* tokens are ")", "&&", "||" or end of the input string "\0".
|
|
*
|
|
* #6 The invert variable is reset to the current value saved on the top of
|
|
* the stack.
|
|
*
|
|
* #7 The top of the stack holds not only the current invert value, but also
|
|
* if a "&&" or "||" needs to be processed. Note, the "&&" takes higher
|
|
* precedence than "||". That is "a && b || c && d" is equivalent to
|
|
* "(a && b) || (c && d)". Thus the first thing to do is to see if "&&" needs
|
|
* to be processed. This is the case if an "&&" was the last token. If it was
|
|
* then we call update_preds(). This takes the program, the current index in
|
|
* the program, and the current value of "invert". More will be described
|
|
* below about this function.
|
|
*
|
|
* #8 If the next token is "&&" then we set a flag in the top of the stack
|
|
* that denotes that "&&" needs to be processed, break out of this loop
|
|
* and continue with the outer loop.
|
|
*
|
|
* #9 Otherwise, if a "||" needs to be processed then update_preds() is called.
|
|
* This is called with the program, the current index in the program, but
|
|
* this time with an inverted value of "invert" (that is !invert). This is
|
|
* because the value taken will become the "when_to_branch" value of the
|
|
* program.
|
|
* Note, this is called when the next token is not an "&&". As stated before,
|
|
* "&&" takes higher precedence, and "||" should not be processed yet if the
|
|
* next logical operation is "&&".
|
|
*
|
|
* #10 If the next token is "||" then we set a flag in the top of the stack
|
|
* that denotes that "||" needs to be processed, break out of this loop
|
|
* and continue with the outer loop.
|
|
*
|
|
* #11 If this is the end of the input string "\0" then we break out of both
|
|
* loops.
|
|
*
|
|
* #12 Otherwise, the next token is ")", where we pop the stack and continue
|
|
* this inner loop.
|
|
*
|
|
* Now to discuss the update_pred() function, as that is key to the setting up
|
|
* of the program. Remember the "target" of the program is initialized to the
|
|
* previous index and not the "l" label. The target holds the index into the
|
|
* program that gets affected by the operand. Thus if we have something like
|
|
* "a || b && c", when we process "a" the target will be "-1" (undefined).
|
|
* When we process "b", its target is "0", which is the index of "a", as that's
|
|
* the predicate that is affected by "||". But because the next token after "b"
|
|
* is "&&" we don't call update_preds(). Instead continue to "c". As the
|
|
* next token after "c" is not "&&" but the end of input, we first process the
|
|
* "&&" by calling update_preds() for the "&&" then we process the "||" by
|
|
* callin updates_preds() with the values for processing "||".
|
|
*
|
|
* What does that mean? What update_preds() does is to first save the "target"
|
|
* of the program entry indexed by the current program entry's "target"
|
|
* (remember the "target" is initialized to previous program entry), and then
|
|
* sets that "target" to the current index which represents the label "l#".
|
|
* That entry's "when_to_branch" is set to the value passed in (the "invert"
|
|
* or "!invert"). Then it sets the current program entry's target to the saved
|
|
* "target" value (the old value of the program that had its "target" updated
|
|
* to the label).
|
|
*
|
|
* Looking back at "a || b && c", we have the following steps:
|
|
* "a" - prog[0] = { "a", X, -1 } // pred, when_to_branch, target
|
|
* "||" - flag that we need to process "||"; continue outer loop
|
|
* "b" - prog[1] = { "b", X, 0 }
|
|
* "&&" - flag that we need to process "&&"; continue outer loop
|
|
* (Notice we did not process "||")
|
|
* "c" - prog[2] = { "c", X, 1 }
|
|
* update_preds(prog, 2, 0); // invert = 0 as we are processing "&&"
|
|
* t = prog[2].target; // t = 1
|
|
* s = prog[t].target; // s = 0
|
|
* prog[t].target = 2; // Set target to "l2"
|
|
* prog[t].when_to_branch = 0;
|
|
* prog[2].target = s;
|
|
* update_preds(prog, 2, 1); // invert = 1 as we are now processing "||"
|
|
* t = prog[2].target; // t = 0
|
|
* s = prog[t].target; // s = -1
|
|
* prog[t].target = 2; // Set target to "l2"
|
|
* prog[t].when_to_branch = 1;
|
|
* prog[2].target = s;
|
|
*
|
|
* #13 Which brings us to the final step of the first pass, which is to set
|
|
* the last program entry's when_to_branch and target, which will be
|
|
* when_to_branch = 0; target = N; ( the label after the program entry after
|
|
* the last program entry processed above).
|
|
*
|
|
* If we denote "TRUE" to be the entry after the last program entry processed,
|
|
* and "FALSE" the program entry after that, we are now done with the first
|
|
* pass.
|
|
*
|
|
* Making the above "a || b && c" have a progam of:
|
|
* prog[0] = { "a", 1, 2 }
|
|
* prog[1] = { "b", 0, 2 }
|
|
* prog[2] = { "c", 0, 3 }
|
|
*
|
|
* Which translates into:
|
|
* n0: r = a; l0: if (r) goto l2;
|
|
* n1: r = b; l1: if (!r) goto l2;
|
|
* n2: r = c; l2: if (!r) goto l3; // Which is the same as "goto F;"
|
|
* T: return TRUE; l3:
|
|
* F: return FALSE
|
|
*
|
|
* Although, after the first pass, the program is correct, it is
|
|
* inefficient. The simple sample of "a || b && c" could be easily been
|
|
* converted into:
|
|
* n0: r = a; if (r) goto T
|
|
* n1: r = b; if (!r) goto F
|
|
* n2: r = c; if (!r) goto F
|
|
* T: return TRUE;
|
|
* F: return FALSE;
|
|
*
|
|
* The First Pass is over the input string. The next too passes are over
|
|
* the program itself.
|
|
*
|
|
* ** SECOND PASS **
|
|
*
|
|
* Which brings us to the second pass. If a jump to a label has the
|
|
* same condition as that label, it can instead jump to its target.
|
|
* The original example of "a && !(!b || (c && g)) || d || e && !f"
|
|
* where the first pass gives us:
|
|
*
|
|
* n1: r=a; l1: if (!r) goto l4;
|
|
* n2: r=b; l2: if (!r) goto l4;
|
|
* n3: r=c; r=!r; l3: if (r) goto l4;
|
|
* n4: r=g; r=!r; l4: if (r) goto l5;
|
|
* n5: r=d; l5: if (r) goto T
|
|
* n6: r=e; l6: if (!r) goto l7;
|
|
* n7: r=f; r=!r; l7: if (!r) goto F:
|
|
* T: return TRUE;
|
|
* F: return FALSE
|
|
*
|
|
* We can see that "l3: if (r) goto l4;" and at l4, we have "if (r) goto l5;".
|
|
* And "l5: if (r) goto T", we could optimize this by converting l3 and l4
|
|
* to go directly to T. To accomplish this, we start from the last
|
|
* entry in the program and work our way back. If the target of the entry
|
|
* has the same "when_to_branch" then we could use that entry's target.
|
|
* Doing this, the above would end up as:
|
|
*
|
|
* n1: r=a; l1: if (!r) goto l4;
|
|
* n2: r=b; l2: if (!r) goto l4;
|
|
* n3: r=c; r=!r; l3: if (r) goto T;
|
|
* n4: r=g; r=!r; l4: if (r) goto T;
|
|
* n5: r=d; l5: if (r) goto T;
|
|
* n6: r=e; l6: if (!r) goto F;
|
|
* n7: r=f; r=!r; l7: if (!r) goto F;
|
|
* T: return TRUE
|
|
* F: return FALSE
|
|
*
|
|
* In that same pass, if the "when_to_branch" doesn't match, we can simply
|
|
* go to the program entry after the label. That is, "l2: if (!r) goto l4;"
|
|
* where "l4: if (r) goto T;", then we can convert l2 to be:
|
|
* "l2: if (!r) goto n5;".
|
|
*
|
|
* This will have the second pass give us:
|
|
* n1: r=a; l1: if (!r) goto n5;
|
|
* n2: r=b; l2: if (!r) goto n5;
|
|
* n3: r=c; r=!r; l3: if (r) goto T;
|
|
* n4: r=g; r=!r; l4: if (r) goto T;
|
|
* n5: r=d; l5: if (r) goto T
|
|
* n6: r=e; l6: if (!r) goto F;
|
|
* n7: r=f; r=!r; l7: if (!r) goto F
|
|
* T: return TRUE
|
|
* F: return FALSE
|
|
*
|
|
* Notice, all the "l#" labels are no longer used, and they can now
|
|
* be discarded.
|
|
*
|
|
* ** THIRD PASS **
|
|
*
|
|
* For the third pass we deal with the inverts. As they simply just
|
|
* make the "when_to_branch" get inverted, a simple loop over the
|
|
* program to that does: "when_to_branch ^= invert;" will do the
|
|
* job, leaving us with:
|
|
* n1: r=a; if (!r) goto n5;
|
|
* n2: r=b; if (!r) goto n5;
|
|
* n3: r=c: if (!r) goto T;
|
|
* n4: r=g; if (!r) goto T;
|
|
* n5: r=d; if (r) goto T
|
|
* n6: r=e; if (!r) goto F;
|
|
* n7: r=f; if (r) goto F
|
|
* T: return TRUE
|
|
* F: return FALSE
|
|
*
|
|
* As "r = a; if (!r) goto n5;" is obviously the same as
|
|
* "if (!a) goto n5;" without doing anything we can interperate the
|
|
* program as:
|
|
* n1: if (!a) goto n5;
|
|
* n2: if (!b) goto n5;
|
|
* n3: if (!c) goto T;
|
|
* n4: if (!g) goto T;
|
|
* n5: if (d) goto T
|
|
* n6: if (!e) goto F;
|
|
* n7: if (f) goto F
|
|
* T: return TRUE
|
|
* F: return FALSE
|
|
*
|
|
* Since the inverts are discarded at the end, there's no reason to store
|
|
* them in the program array (and waste memory). A separate array to hold
|
|
* the inverts is used and freed at the end.
|
|
*/
|
|
static struct prog_entry *
|
|
predicate_parse(const char *str, int nr_parens, int nr_preds,
|
|
parse_pred_fn parse_pred, void *data,
|
|
struct filter_parse_error *pe)
|
|
{
|
|
struct prog_entry *prog_stack;
|
|
struct prog_entry *prog;
|
|
const char *ptr = str;
|
|
char *inverts = NULL;
|
|
int *op_stack;
|
|
int *top;
|
|
int invert = 0;
|
|
int ret = -ENOMEM;
|
|
int len;
|
|
int N = 0;
|
|
int i;
|
|
|
|
nr_preds += 2; /* For TRUE and FALSE */
|
|
|
|
op_stack = kmalloc_array(nr_parens, sizeof(*op_stack), GFP_KERNEL);
|
|
if (!op_stack)
|
|
return ERR_PTR(-ENOMEM);
|
|
prog_stack = kmalloc_array(nr_preds, sizeof(*prog_stack), GFP_KERNEL);
|
|
if (!prog_stack) {
|
|
parse_error(pe, -ENOMEM, 0);
|
|
goto out_free;
|
|
}
|
|
inverts = kmalloc_array(nr_preds, sizeof(*inverts), GFP_KERNEL);
|
|
if (!inverts) {
|
|
parse_error(pe, -ENOMEM, 0);
|
|
goto out_free;
|
|
}
|
|
|
|
top = op_stack;
|
|
prog = prog_stack;
|
|
*top = 0;
|
|
|
|
/* First pass */
|
|
while (*ptr) { /* #1 */
|
|
const char *next = ptr++;
|
|
|
|
if (isspace(*next))
|
|
continue;
|
|
|
|
switch (*next) {
|
|
case '(': /* #2 */
|
|
if (top - op_stack > nr_parens)
|
|
return ERR_PTR(-EINVAL);
|
|
*(++top) = invert;
|
|
continue;
|
|
case '!': /* #3 */
|
|
if (!is_not(next))
|
|
break;
|
|
invert = !invert;
|
|
continue;
|
|
}
|
|
|
|
if (N >= nr_preds) {
|
|
parse_error(pe, FILT_ERR_TOO_MANY_PREDS, next - str);
|
|
goto out_free;
|
|
}
|
|
|
|
inverts[N] = invert; /* #4 */
|
|
prog[N].target = N-1;
|
|
|
|
len = parse_pred(next, data, ptr - str, pe, &prog[N].pred);
|
|
if (len < 0) {
|
|
ret = len;
|
|
goto out_free;
|
|
}
|
|
ptr = next + len;
|
|
|
|
N++;
|
|
|
|
ret = -1;
|
|
while (1) { /* #5 */
|
|
next = ptr++;
|
|
if (isspace(*next))
|
|
continue;
|
|
|
|
switch (*next) {
|
|
case ')':
|
|
case '\0':
|
|
break;
|
|
case '&':
|
|
case '|':
|
|
/* accepting only "&&" or "||" */
|
|
if (next[1] == next[0]) {
|
|
ptr++;
|
|
break;
|
|
}
|
|
/* fall through */
|
|
default:
|
|
parse_error(pe, FILT_ERR_TOO_MANY_PREDS,
|
|
next - str);
|
|
goto out_free;
|
|
}
|
|
|
|
invert = *top & INVERT;
|
|
|
|
if (*top & PROCESS_AND) { /* #7 */
|
|
update_preds(prog, N - 1, invert);
|
|
*top &= ~PROCESS_AND;
|
|
}
|
|
if (*next == '&') { /* #8 */
|
|
*top |= PROCESS_AND;
|
|
break;
|
|
}
|
|
if (*top & PROCESS_OR) { /* #9 */
|
|
update_preds(prog, N - 1, !invert);
|
|
*top &= ~PROCESS_OR;
|
|
}
|
|
if (*next == '|') { /* #10 */
|
|
*top |= PROCESS_OR;
|
|
break;
|
|
}
|
|
if (!*next) /* #11 */
|
|
goto out;
|
|
|
|
if (top == op_stack) {
|
|
ret = -1;
|
|
/* Too few '(' */
|
|
parse_error(pe, FILT_ERR_TOO_MANY_CLOSE, ptr - str);
|
|
goto out_free;
|
|
}
|
|
top--; /* #12 */
|
|
}
|
|
}
|
|
out:
|
|
if (top != op_stack) {
|
|
/* Too many '(' */
|
|
parse_error(pe, FILT_ERR_TOO_MANY_OPEN, ptr - str);
|
|
goto out_free;
|
|
}
|
|
|
|
if (!N) {
|
|
/* No program? */
|
|
ret = -EINVAL;
|
|
parse_error(pe, FILT_ERR_NO_FILTER, ptr - str);
|
|
goto out_free;
|
|
}
|
|
|
|
prog[N].pred = NULL; /* #13 */
|
|
prog[N].target = 1; /* TRUE */
|
|
prog[N+1].pred = NULL;
|
|
prog[N+1].target = 0; /* FALSE */
|
|
prog[N-1].target = N;
|
|
prog[N-1].when_to_branch = false;
|
|
|
|
/* Second Pass */
|
|
for (i = N-1 ; i--; ) {
|
|
int target = prog[i].target;
|
|
if (prog[i].when_to_branch == prog[target].when_to_branch)
|
|
prog[i].target = prog[target].target;
|
|
}
|
|
|
|
/* Third Pass */
|
|
for (i = 0; i < N; i++) {
|
|
invert = inverts[i] ^ prog[i].when_to_branch;
|
|
prog[i].when_to_branch = invert;
|
|
/* Make sure the program always moves forward */
|
|
if (WARN_ON(prog[i].target <= i)) {
|
|
ret = -EINVAL;
|
|
goto out_free;
|
|
}
|
|
}
|
|
|
|
kfree(op_stack);
|
|
kfree(inverts);
|
|
return prog;
|
|
out_free:
|
|
kfree(op_stack);
|
|
kfree(inverts);
|
|
kfree(prog_stack);
|
|
return ERR_PTR(ret);
|
|
}
|
|
|
|
#define DEFINE_COMPARISON_PRED(type) \
|
|
static int filter_pred_LT_##type(struct filter_pred *pred, void *event) \
|
|
{ \
|
|
type *addr = (type *)(event + pred->offset); \
|
|
type val = (type)pred->val; \
|
|
return *addr < val; \
|
|
} \
|
|
static int filter_pred_LE_##type(struct filter_pred *pred, void *event) \
|
|
{ \
|
|
type *addr = (type *)(event + pred->offset); \
|
|
type val = (type)pred->val; \
|
|
return *addr <= val; \
|
|
} \
|
|
static int filter_pred_GT_##type(struct filter_pred *pred, void *event) \
|
|
{ \
|
|
type *addr = (type *)(event + pred->offset); \
|
|
type val = (type)pred->val; \
|
|
return *addr > val; \
|
|
} \
|
|
static int filter_pred_GE_##type(struct filter_pred *pred, void *event) \
|
|
{ \
|
|
type *addr = (type *)(event + pred->offset); \
|
|
type val = (type)pred->val; \
|
|
return *addr >= val; \
|
|
} \
|
|
static int filter_pred_BAND_##type(struct filter_pred *pred, void *event) \
|
|
{ \
|
|
type *addr = (type *)(event + pred->offset); \
|
|
type val = (type)pred->val; \
|
|
return !!(*addr & val); \
|
|
} \
|
|
static const filter_pred_fn_t pred_funcs_##type[] = { \
|
|
filter_pred_LE_##type, \
|
|
filter_pred_LT_##type, \
|
|
filter_pred_GE_##type, \
|
|
filter_pred_GT_##type, \
|
|
filter_pred_BAND_##type, \
|
|
};
|
|
|
|
#define DEFINE_EQUALITY_PRED(size) \
|
|
static int filter_pred_##size(struct filter_pred *pred, void *event) \
|
|
{ \
|
|
u##size *addr = (u##size *)(event + pred->offset); \
|
|
u##size val = (u##size)pred->val; \
|
|
int match; \
|
|
\
|
|
match = (val == *addr) ^ pred->not; \
|
|
\
|
|
return match; \
|
|
}
|
|
|
|
DEFINE_COMPARISON_PRED(s64);
|
|
DEFINE_COMPARISON_PRED(u64);
|
|
DEFINE_COMPARISON_PRED(s32);
|
|
DEFINE_COMPARISON_PRED(u32);
|
|
DEFINE_COMPARISON_PRED(s16);
|
|
DEFINE_COMPARISON_PRED(u16);
|
|
DEFINE_COMPARISON_PRED(s8);
|
|
DEFINE_COMPARISON_PRED(u8);
|
|
|
|
DEFINE_EQUALITY_PRED(64);
|
|
DEFINE_EQUALITY_PRED(32);
|
|
DEFINE_EQUALITY_PRED(16);
|
|
DEFINE_EQUALITY_PRED(8);
|
|
|
|
/* Filter predicate for fixed sized arrays of characters */
|
|
static int filter_pred_string(struct filter_pred *pred, void *event)
|
|
{
|
|
char *addr = (char *)(event + pred->offset);
|
|
int cmp, match;
|
|
|
|
cmp = pred->regex.match(addr, &pred->regex, pred->regex.field_len);
|
|
|
|
match = cmp ^ pred->not;
|
|
|
|
return match;
|
|
}
|
|
|
|
/* Filter predicate for char * pointers */
|
|
static int filter_pred_pchar(struct filter_pred *pred, void *event)
|
|
{
|
|
char **addr = (char **)(event + pred->offset);
|
|
int cmp, match;
|
|
int len = strlen(*addr) + 1; /* including tailing '\0' */
|
|
|
|
cmp = pred->regex.match(*addr, &pred->regex, len);
|
|
|
|
match = cmp ^ pred->not;
|
|
|
|
return match;
|
|
}
|
|
|
|
/*
|
|
* Filter predicate for dynamic sized arrays of characters.
|
|
* These are implemented through a list of strings at the end
|
|
* of the entry.
|
|
* Also each of these strings have a field in the entry which
|
|
* contains its offset from the beginning of the entry.
|
|
* We have then first to get this field, dereference it
|
|
* and add it to the address of the entry, and at last we have
|
|
* the address of the string.
|
|
*/
|
|
static int filter_pred_strloc(struct filter_pred *pred, void *event)
|
|
{
|
|
u32 str_item = *(u32 *)(event + pred->offset);
|
|
int str_loc = str_item & 0xffff;
|
|
int str_len = str_item >> 16;
|
|
char *addr = (char *)(event + str_loc);
|
|
int cmp, match;
|
|
|
|
cmp = pred->regex.match(addr, &pred->regex, str_len);
|
|
|
|
match = cmp ^ pred->not;
|
|
|
|
return match;
|
|
}
|
|
|
|
/* Filter predicate for CPUs. */
|
|
static int filter_pred_cpu(struct filter_pred *pred, void *event)
|
|
{
|
|
int cpu, cmp;
|
|
|
|
cpu = raw_smp_processor_id();
|
|
cmp = pred->val;
|
|
|
|
switch (pred->op) {
|
|
case OP_EQ:
|
|
return cpu == cmp;
|
|
case OP_NE:
|
|
return cpu != cmp;
|
|
case OP_LT:
|
|
return cpu < cmp;
|
|
case OP_LE:
|
|
return cpu <= cmp;
|
|
case OP_GT:
|
|
return cpu > cmp;
|
|
case OP_GE:
|
|
return cpu >= cmp;
|
|
default:
|
|
return 0;
|
|
}
|
|
}
|
|
|
|
/* Filter predicate for COMM. */
|
|
static int filter_pred_comm(struct filter_pred *pred, void *event)
|
|
{
|
|
int cmp;
|
|
|
|
cmp = pred->regex.match(current->comm, &pred->regex,
|
|
TASK_COMM_LEN);
|
|
return cmp ^ pred->not;
|
|
}
|
|
|
|
static int filter_pred_none(struct filter_pred *pred, void *event)
|
|
{
|
|
return 0;
|
|
}
|
|
|
|
/*
|
|
* regex_match_foo - Basic regex callbacks
|
|
*
|
|
* @str: the string to be searched
|
|
* @r: the regex structure containing the pattern string
|
|
* @len: the length of the string to be searched (including '\0')
|
|
*
|
|
* Note:
|
|
* - @str might not be NULL-terminated if it's of type DYN_STRING
|
|
* or STATIC_STRING, unless @len is zero.
|
|
*/
|
|
|
|
static int regex_match_full(char *str, struct regex *r, int len)
|
|
{
|
|
/* len of zero means str is dynamic and ends with '\0' */
|
|
if (!len)
|
|
return strcmp(str, r->pattern) == 0;
|
|
|
|
return strncmp(str, r->pattern, len) == 0;
|
|
}
|
|
|
|
static int regex_match_front(char *str, struct regex *r, int len)
|
|
{
|
|
if (len && len < r->len)
|
|
return 0;
|
|
|
|
return strncmp(str, r->pattern, r->len) == 0;
|
|
}
|
|
|
|
static int regex_match_middle(char *str, struct regex *r, int len)
|
|
{
|
|
if (!len)
|
|
return strstr(str, r->pattern) != NULL;
|
|
|
|
return strnstr(str, r->pattern, len) != NULL;
|
|
}
|
|
|
|
static int regex_match_end(char *str, struct regex *r, int len)
|
|
{
|
|
int strlen = len - 1;
|
|
|
|
if (strlen >= r->len &&
|
|
memcmp(str + strlen - r->len, r->pattern, r->len) == 0)
|
|
return 1;
|
|
return 0;
|
|
}
|
|
|
|
static int regex_match_glob(char *str, struct regex *r, int len __maybe_unused)
|
|
{
|
|
if (glob_match(r->pattern, str))
|
|
return 1;
|
|
return 0;
|
|
}
|
|
|
|
/**
|
|
* filter_parse_regex - parse a basic regex
|
|
* @buff: the raw regex
|
|
* @len: length of the regex
|
|
* @search: will point to the beginning of the string to compare
|
|
* @not: tell whether the match will have to be inverted
|
|
*
|
|
* This passes in a buffer containing a regex and this function will
|
|
* set search to point to the search part of the buffer and
|
|
* return the type of search it is (see enum above).
|
|
* This does modify buff.
|
|
*
|
|
* Returns enum type.
|
|
* search returns the pointer to use for comparison.
|
|
* not returns 1 if buff started with a '!'
|
|
* 0 otherwise.
|
|
*/
|
|
enum regex_type filter_parse_regex(char *buff, int len, char **search, int *not)
|
|
{
|
|
int type = MATCH_FULL;
|
|
int i;
|
|
|
|
if (buff[0] == '!') {
|
|
*not = 1;
|
|
buff++;
|
|
len--;
|
|
} else
|
|
*not = 0;
|
|
|
|
*search = buff;
|
|
|
|
if (isdigit(buff[0]))
|
|
return MATCH_INDEX;
|
|
|
|
for (i = 0; i < len; i++) {
|
|
if (buff[i] == '*') {
|
|
if (!i) {
|
|
type = MATCH_END_ONLY;
|
|
} else if (i == len - 1) {
|
|
if (type == MATCH_END_ONLY)
|
|
type = MATCH_MIDDLE_ONLY;
|
|
else
|
|
type = MATCH_FRONT_ONLY;
|
|
buff[i] = 0;
|
|
break;
|
|
} else { /* pattern continues, use full glob */
|
|
return MATCH_GLOB;
|
|
}
|
|
} else if (strchr("[?\\", buff[i])) {
|
|
return MATCH_GLOB;
|
|
}
|
|
}
|
|
if (buff[0] == '*')
|
|
*search = buff + 1;
|
|
|
|
return type;
|
|
}
|
|
|
|
static void filter_build_regex(struct filter_pred *pred)
|
|
{
|
|
struct regex *r = &pred->regex;
|
|
char *search;
|
|
enum regex_type type = MATCH_FULL;
|
|
|
|
if (pred->op == OP_GLOB) {
|
|
type = filter_parse_regex(r->pattern, r->len, &search, &pred->not);
|
|
r->len = strlen(search);
|
|
memmove(r->pattern, search, r->len+1);
|
|
}
|
|
|
|
switch (type) {
|
|
/* MATCH_INDEX should not happen, but if it does, match full */
|
|
case MATCH_INDEX:
|
|
case MATCH_FULL:
|
|
r->match = regex_match_full;
|
|
break;
|
|
case MATCH_FRONT_ONLY:
|
|
r->match = regex_match_front;
|
|
break;
|
|
case MATCH_MIDDLE_ONLY:
|
|
r->match = regex_match_middle;
|
|
break;
|
|
case MATCH_END_ONLY:
|
|
r->match = regex_match_end;
|
|
break;
|
|
case MATCH_GLOB:
|
|
r->match = regex_match_glob;
|
|
break;
|
|
}
|
|
}
|
|
|
|
/* return 1 if event matches, 0 otherwise (discard) */
|
|
int filter_match_preds(struct event_filter *filter, void *rec)
|
|
{
|
|
struct prog_entry *prog;
|
|
int i;
|
|
|
|
/* no filter is considered a match */
|
|
if (!filter)
|
|
return 1;
|
|
|
|
/* Protected by either SRCU(tracepoint_srcu) or preempt_disable */
|
|
prog = rcu_dereference_raw(filter->prog);
|
|
if (!prog)
|
|
return 1;
|
|
|
|
for (i = 0; prog[i].pred; i++) {
|
|
struct filter_pred *pred = prog[i].pred;
|
|
int match = pred->fn(pred, rec);
|
|
if (match == prog[i].when_to_branch)
|
|
i = prog[i].target;
|
|
}
|
|
return prog[i].target;
|
|
}
|
|
EXPORT_SYMBOL_GPL(filter_match_preds);
|
|
|
|
static void remove_filter_string(struct event_filter *filter)
|
|
{
|
|
if (!filter)
|
|
return;
|
|
|
|
kfree(filter->filter_string);
|
|
filter->filter_string = NULL;
|
|
}
|
|
|
|
static void append_filter_err(struct filter_parse_error *pe,
|
|
struct event_filter *filter)
|
|
{
|
|
struct trace_seq *s;
|
|
int pos = pe->lasterr_pos;
|
|
char *buf;
|
|
int len;
|
|
|
|
if (WARN_ON(!filter->filter_string))
|
|
return;
|
|
|
|
s = kmalloc(sizeof(*s), GFP_KERNEL);
|
|
if (!s)
|
|
return;
|
|
trace_seq_init(s);
|
|
|
|
len = strlen(filter->filter_string);
|
|
if (pos > len)
|
|
pos = len;
|
|
|
|
/* indexing is off by one */
|
|
if (pos)
|
|
pos++;
|
|
|
|
trace_seq_puts(s, filter->filter_string);
|
|
if (pe->lasterr > 0) {
|
|
trace_seq_printf(s, "\n%*s", pos, "^");
|
|
trace_seq_printf(s, "\nparse_error: %s\n", err_text[pe->lasterr]);
|
|
} else {
|
|
trace_seq_printf(s, "\nError: (%d)\n", pe->lasterr);
|
|
}
|
|
trace_seq_putc(s, 0);
|
|
buf = kmemdup_nul(s->buffer, s->seq.len, GFP_KERNEL);
|
|
if (buf) {
|
|
kfree(filter->filter_string);
|
|
filter->filter_string = buf;
|
|
}
|
|
kfree(s);
|
|
}
|
|
|
|
static inline struct event_filter *event_filter(struct trace_event_file *file)
|
|
{
|
|
return file->filter;
|
|
}
|
|
|
|
/* caller must hold event_mutex */
|
|
void print_event_filter(struct trace_event_file *file, struct trace_seq *s)
|
|
{
|
|
struct event_filter *filter = event_filter(file);
|
|
|
|
if (filter && filter->filter_string)
|
|
trace_seq_printf(s, "%s\n", filter->filter_string);
|
|
else
|
|
trace_seq_puts(s, "none\n");
|
|
}
|
|
|
|
void print_subsystem_event_filter(struct event_subsystem *system,
|
|
struct trace_seq *s)
|
|
{
|
|
struct event_filter *filter;
|
|
|
|
mutex_lock(&event_mutex);
|
|
filter = system->filter;
|
|
if (filter && filter->filter_string)
|
|
trace_seq_printf(s, "%s\n", filter->filter_string);
|
|
else
|
|
trace_seq_puts(s, DEFAULT_SYS_FILTER_MESSAGE "\n");
|
|
mutex_unlock(&event_mutex);
|
|
}
|
|
|
|
static void free_prog(struct event_filter *filter)
|
|
{
|
|
struct prog_entry *prog;
|
|
int i;
|
|
|
|
prog = rcu_access_pointer(filter->prog);
|
|
if (!prog)
|
|
return;
|
|
|
|
for (i = 0; prog[i].pred; i++)
|
|
kfree(prog[i].pred);
|
|
kfree(prog);
|
|
}
|
|
|
|
static void filter_disable(struct trace_event_file *file)
|
|
{
|
|
unsigned long old_flags = file->flags;
|
|
|
|
file->flags &= ~EVENT_FILE_FL_FILTERED;
|
|
|
|
if (old_flags != file->flags)
|
|
trace_buffered_event_disable();
|
|
}
|
|
|
|
static void __free_filter(struct event_filter *filter)
|
|
{
|
|
if (!filter)
|
|
return;
|
|
|
|
free_prog(filter);
|
|
kfree(filter->filter_string);
|
|
kfree(filter);
|
|
}
|
|
|
|
void free_event_filter(struct event_filter *filter)
|
|
{
|
|
__free_filter(filter);
|
|
}
|
|
|
|
static inline void __remove_filter(struct trace_event_file *file)
|
|
{
|
|
filter_disable(file);
|
|
remove_filter_string(file->filter);
|
|
}
|
|
|
|
static void filter_free_subsystem_preds(struct trace_subsystem_dir *dir,
|
|
struct trace_array *tr)
|
|
{
|
|
struct trace_event_file *file;
|
|
|
|
list_for_each_entry(file, &tr->events, list) {
|
|
if (file->system != dir)
|
|
continue;
|
|
__remove_filter(file);
|
|
}
|
|
}
|
|
|
|
static inline void __free_subsystem_filter(struct trace_event_file *file)
|
|
{
|
|
__free_filter(file->filter);
|
|
file->filter = NULL;
|
|
}
|
|
|
|
static void filter_free_subsystem_filters(struct trace_subsystem_dir *dir,
|
|
struct trace_array *tr)
|
|
{
|
|
struct trace_event_file *file;
|
|
|
|
list_for_each_entry(file, &tr->events, list) {
|
|
if (file->system != dir)
|
|
continue;
|
|
__free_subsystem_filter(file);
|
|
}
|
|
}
|
|
|
|
int filter_assign_type(const char *type)
|
|
{
|
|
if (strstr(type, "__data_loc") && strstr(type, "char"))
|
|
return FILTER_DYN_STRING;
|
|
|
|
if (strchr(type, '[') && strstr(type, "char"))
|
|
return FILTER_STATIC_STRING;
|
|
|
|
return FILTER_OTHER;
|
|
}
|
|
|
|
static filter_pred_fn_t select_comparison_fn(enum filter_op_ids op,
|
|
int field_size, int field_is_signed)
|
|
{
|
|
filter_pred_fn_t fn = NULL;
|
|
int pred_func_index = -1;
|
|
|
|
switch (op) {
|
|
case OP_EQ:
|
|
case OP_NE:
|
|
break;
|
|
default:
|
|
if (WARN_ON_ONCE(op < PRED_FUNC_START))
|
|
return NULL;
|
|
pred_func_index = op - PRED_FUNC_START;
|
|
if (WARN_ON_ONCE(pred_func_index > PRED_FUNC_MAX))
|
|
return NULL;
|
|
}
|
|
|
|
switch (field_size) {
|
|
case 8:
|
|
if (pred_func_index < 0)
|
|
fn = filter_pred_64;
|
|
else if (field_is_signed)
|
|
fn = pred_funcs_s64[pred_func_index];
|
|
else
|
|
fn = pred_funcs_u64[pred_func_index];
|
|
break;
|
|
case 4:
|
|
if (pred_func_index < 0)
|
|
fn = filter_pred_32;
|
|
else if (field_is_signed)
|
|
fn = pred_funcs_s32[pred_func_index];
|
|
else
|
|
fn = pred_funcs_u32[pred_func_index];
|
|
break;
|
|
case 2:
|
|
if (pred_func_index < 0)
|
|
fn = filter_pred_16;
|
|
else if (field_is_signed)
|
|
fn = pred_funcs_s16[pred_func_index];
|
|
else
|
|
fn = pred_funcs_u16[pred_func_index];
|
|
break;
|
|
case 1:
|
|
if (pred_func_index < 0)
|
|
fn = filter_pred_8;
|
|
else if (field_is_signed)
|
|
fn = pred_funcs_s8[pred_func_index];
|
|
else
|
|
fn = pred_funcs_u8[pred_func_index];
|
|
break;
|
|
}
|
|
|
|
return fn;
|
|
}
|
|
|
|
/* Called when a predicate is encountered by predicate_parse() */
|
|
static int parse_pred(const char *str, void *data,
|
|
int pos, struct filter_parse_error *pe,
|
|
struct filter_pred **pred_ptr)
|
|
{
|
|
struct trace_event_call *call = data;
|
|
struct ftrace_event_field *field;
|
|
struct filter_pred *pred = NULL;
|
|
char num_buf[24]; /* Big enough to hold an address */
|
|
char *field_name;
|
|
char q;
|
|
u64 val;
|
|
int len;
|
|
int ret;
|
|
int op;
|
|
int s;
|
|
int i = 0;
|
|
|
|
/* First find the field to associate to */
|
|
while (isspace(str[i]))
|
|
i++;
|
|
s = i;
|
|
|
|
while (isalnum(str[i]) || str[i] == '_')
|
|
i++;
|
|
|
|
len = i - s;
|
|
|
|
if (!len)
|
|
return -1;
|
|
|
|
field_name = kmemdup_nul(str + s, len, GFP_KERNEL);
|
|
if (!field_name)
|
|
return -ENOMEM;
|
|
|
|
/* Make sure that the field exists */
|
|
|
|
field = trace_find_event_field(call, field_name);
|
|
kfree(field_name);
|
|
if (!field) {
|
|
parse_error(pe, FILT_ERR_FIELD_NOT_FOUND, pos + i);
|
|
return -EINVAL;
|
|
}
|
|
|
|
while (isspace(str[i]))
|
|
i++;
|
|
|
|
/* Make sure this op is supported */
|
|
for (op = 0; ops[op]; op++) {
|
|
/* This is why '<=' must come before '<' in ops[] */
|
|
if (strncmp(str + i, ops[op], strlen(ops[op])) == 0)
|
|
break;
|
|
}
|
|
|
|
if (!ops[op]) {
|
|
parse_error(pe, FILT_ERR_INVALID_OP, pos + i);
|
|
goto err_free;
|
|
}
|
|
|
|
i += strlen(ops[op]);
|
|
|
|
while (isspace(str[i]))
|
|
i++;
|
|
|
|
s = i;
|
|
|
|
pred = kzalloc(sizeof(*pred), GFP_KERNEL);
|
|
if (!pred)
|
|
return -ENOMEM;
|
|
|
|
pred->field = field;
|
|
pred->offset = field->offset;
|
|
pred->op = op;
|
|
|
|
if (ftrace_event_is_function(call)) {
|
|
/*
|
|
* Perf does things different with function events.
|
|
* It only allows an "ip" field, and expects a string.
|
|
* But the string does not need to be surrounded by quotes.
|
|
* If it is a string, the assigned function as a nop,
|
|
* (perf doesn't use it) and grab everything.
|
|
*/
|
|
if (strcmp(field->name, "ip") != 0) {
|
|
parse_error(pe, FILT_ERR_IP_FIELD_ONLY, pos + i);
|
|
goto err_free;
|
|
}
|
|
pred->fn = filter_pred_none;
|
|
|
|
/*
|
|
* Quotes are not required, but if they exist then we need
|
|
* to read them till we hit a matching one.
|
|
*/
|
|
if (str[i] == '\'' || str[i] == '"')
|
|
q = str[i];
|
|
else
|
|
q = 0;
|
|
|
|
for (i++; str[i]; i++) {
|
|
if (q && str[i] == q)
|
|
break;
|
|
if (!q && (str[i] == ')' || str[i] == '&' ||
|
|
str[i] == '|'))
|
|
break;
|
|
}
|
|
/* Skip quotes */
|
|
if (q)
|
|
s++;
|
|
len = i - s;
|
|
if (len >= MAX_FILTER_STR_VAL) {
|
|
parse_error(pe, FILT_ERR_OPERAND_TOO_LONG, pos + i);
|
|
goto err_free;
|
|
}
|
|
|
|
pred->regex.len = len;
|
|
strncpy(pred->regex.pattern, str + s, len);
|
|
pred->regex.pattern[len] = 0;
|
|
|
|
/* This is either a string, or an integer */
|
|
} else if (str[i] == '\'' || str[i] == '"') {
|
|
char q = str[i];
|
|
|
|
/* Make sure the op is OK for strings */
|
|
switch (op) {
|
|
case OP_NE:
|
|
pred->not = 1;
|
|
/* Fall through */
|
|
case OP_GLOB:
|
|
case OP_EQ:
|
|
break;
|
|
default:
|
|
parse_error(pe, FILT_ERR_ILLEGAL_FIELD_OP, pos + i);
|
|
goto err_free;
|
|
}
|
|
|
|
/* Make sure the field is OK for strings */
|
|
if (!is_string_field(field)) {
|
|
parse_error(pe, FILT_ERR_EXPECT_DIGIT, pos + i);
|
|
goto err_free;
|
|
}
|
|
|
|
for (i++; str[i]; i++) {
|
|
if (str[i] == q)
|
|
break;
|
|
}
|
|
if (!str[i]) {
|
|
parse_error(pe, FILT_ERR_MISSING_QUOTE, pos + i);
|
|
goto err_free;
|
|
}
|
|
|
|
/* Skip quotes */
|
|
s++;
|
|
len = i - s;
|
|
if (len >= MAX_FILTER_STR_VAL) {
|
|
parse_error(pe, FILT_ERR_OPERAND_TOO_LONG, pos + i);
|
|
goto err_free;
|
|
}
|
|
|
|
pred->regex.len = len;
|
|
strncpy(pred->regex.pattern, str + s, len);
|
|
pred->regex.pattern[len] = 0;
|
|
|
|
filter_build_regex(pred);
|
|
|
|
if (field->filter_type == FILTER_COMM) {
|
|
pred->fn = filter_pred_comm;
|
|
|
|
} else if (field->filter_type == FILTER_STATIC_STRING) {
|
|
pred->fn = filter_pred_string;
|
|
pred->regex.field_len = field->size;
|
|
|
|
} else if (field->filter_type == FILTER_DYN_STRING)
|
|
pred->fn = filter_pred_strloc;
|
|
else
|
|
pred->fn = filter_pred_pchar;
|
|
/* go past the last quote */
|
|
i++;
|
|
|
|
} else if (isdigit(str[i]) || str[i] == '-') {
|
|
|
|
/* Make sure the field is not a string */
|
|
if (is_string_field(field)) {
|
|
parse_error(pe, FILT_ERR_EXPECT_STRING, pos + i);
|
|
goto err_free;
|
|
}
|
|
|
|
if (op == OP_GLOB) {
|
|
parse_error(pe, FILT_ERR_ILLEGAL_FIELD_OP, pos + i);
|
|
goto err_free;
|
|
}
|
|
|
|
if (str[i] == '-')
|
|
i++;
|
|
|
|
/* We allow 0xDEADBEEF */
|
|
while (isalnum(str[i]))
|
|
i++;
|
|
|
|
len = i - s;
|
|
/* 0xfeedfacedeadbeef is 18 chars max */
|
|
if (len >= sizeof(num_buf)) {
|
|
parse_error(pe, FILT_ERR_OPERAND_TOO_LONG, pos + i);
|
|
goto err_free;
|
|
}
|
|
|
|
strncpy(num_buf, str + s, len);
|
|
num_buf[len] = 0;
|
|
|
|
/* Make sure it is a value */
|
|
if (field->is_signed)
|
|
ret = kstrtoll(num_buf, 0, &val);
|
|
else
|
|
ret = kstrtoull(num_buf, 0, &val);
|
|
if (ret) {
|
|
parse_error(pe, FILT_ERR_ILLEGAL_INTVAL, pos + s);
|
|
goto err_free;
|
|
}
|
|
|
|
pred->val = val;
|
|
|
|
if (field->filter_type == FILTER_CPU)
|
|
pred->fn = filter_pred_cpu;
|
|
else {
|
|
pred->fn = select_comparison_fn(pred->op, field->size,
|
|
field->is_signed);
|
|
if (pred->op == OP_NE)
|
|
pred->not = 1;
|
|
}
|
|
|
|
} else {
|
|
parse_error(pe, FILT_ERR_INVALID_VALUE, pos + i);
|
|
goto err_free;
|
|
}
|
|
|
|
*pred_ptr = pred;
|
|
return i;
|
|
|
|
err_free:
|
|
kfree(pred);
|
|
return -EINVAL;
|
|
}
|
|
|
|
enum {
|
|
TOO_MANY_CLOSE = -1,
|
|
TOO_MANY_OPEN = -2,
|
|
MISSING_QUOTE = -3,
|
|
};
|
|
|
|
/*
|
|
* Read the filter string once to calculate the number of predicates
|
|
* as well as how deep the parentheses go.
|
|
*
|
|
* Returns:
|
|
* 0 - everything is fine (err is undefined)
|
|
* -1 - too many ')'
|
|
* -2 - too many '('
|
|
* -3 - No matching quote
|
|
*/
|
|
static int calc_stack(const char *str, int *parens, int *preds, int *err)
|
|
{
|
|
bool is_pred = false;
|
|
int nr_preds = 0;
|
|
int open = 1; /* Count the expression as "(E)" */
|
|
int last_quote = 0;
|
|
int max_open = 1;
|
|
int quote = 0;
|
|
int i;
|
|
|
|
*err = 0;
|
|
|
|
for (i = 0; str[i]; i++) {
|
|
if (isspace(str[i]))
|
|
continue;
|
|
if (quote) {
|
|
if (str[i] == quote)
|
|
quote = 0;
|
|
continue;
|
|
}
|
|
|
|
switch (str[i]) {
|
|
case '\'':
|
|
case '"':
|
|
quote = str[i];
|
|
last_quote = i;
|
|
break;
|
|
case '|':
|
|
case '&':
|
|
if (str[i+1] != str[i])
|
|
break;
|
|
is_pred = false;
|
|
continue;
|
|
case '(':
|
|
is_pred = false;
|
|
open++;
|
|
if (open > max_open)
|
|
max_open = open;
|
|
continue;
|
|
case ')':
|
|
is_pred = false;
|
|
if (open == 1) {
|
|
*err = i;
|
|
return TOO_MANY_CLOSE;
|
|
}
|
|
open--;
|
|
continue;
|
|
}
|
|
if (!is_pred) {
|
|
nr_preds++;
|
|
is_pred = true;
|
|
}
|
|
}
|
|
|
|
if (quote) {
|
|
*err = last_quote;
|
|
return MISSING_QUOTE;
|
|
}
|
|
|
|
if (open != 1) {
|
|
int level = open;
|
|
|
|
/* find the bad open */
|
|
for (i--; i; i--) {
|
|
if (quote) {
|
|
if (str[i] == quote)
|
|
quote = 0;
|
|
continue;
|
|
}
|
|
switch (str[i]) {
|
|
case '(':
|
|
if (level == open) {
|
|
*err = i;
|
|
return TOO_MANY_OPEN;
|
|
}
|
|
level--;
|
|
break;
|
|
case ')':
|
|
level++;
|
|
break;
|
|
case '\'':
|
|
case '"':
|
|
quote = str[i];
|
|
break;
|
|
}
|
|
}
|
|
/* First character is the '(' with missing ')' */
|
|
*err = 0;
|
|
return TOO_MANY_OPEN;
|
|
}
|
|
|
|
/* Set the size of the required stacks */
|
|
*parens = max_open;
|
|
*preds = nr_preds;
|
|
return 0;
|
|
}
|
|
|
|
static int process_preds(struct trace_event_call *call,
|
|
const char *filter_string,
|
|
struct event_filter *filter,
|
|
struct filter_parse_error *pe)
|
|
{
|
|
struct prog_entry *prog;
|
|
int nr_parens;
|
|
int nr_preds;
|
|
int index;
|
|
int ret;
|
|
|
|
ret = calc_stack(filter_string, &nr_parens, &nr_preds, &index);
|
|
if (ret < 0) {
|
|
switch (ret) {
|
|
case MISSING_QUOTE:
|
|
parse_error(pe, FILT_ERR_MISSING_QUOTE, index);
|
|
break;
|
|
case TOO_MANY_OPEN:
|
|
parse_error(pe, FILT_ERR_TOO_MANY_OPEN, index);
|
|
break;
|
|
default:
|
|
parse_error(pe, FILT_ERR_TOO_MANY_CLOSE, index);
|
|
}
|
|
return ret;
|
|
}
|
|
|
|
if (!nr_preds)
|
|
return -EINVAL;
|
|
|
|
prog = predicate_parse(filter_string, nr_parens, nr_preds,
|
|
parse_pred, call, pe);
|
|
if (IS_ERR(prog))
|
|
return PTR_ERR(prog);
|
|
|
|
rcu_assign_pointer(filter->prog, prog);
|
|
return 0;
|
|
}
|
|
|
|
static inline void event_set_filtered_flag(struct trace_event_file *file)
|
|
{
|
|
unsigned long old_flags = file->flags;
|
|
|
|
file->flags |= EVENT_FILE_FL_FILTERED;
|
|
|
|
if (old_flags != file->flags)
|
|
trace_buffered_event_enable();
|
|
}
|
|
|
|
static inline void event_set_filter(struct trace_event_file *file,
|
|
struct event_filter *filter)
|
|
{
|
|
rcu_assign_pointer(file->filter, filter);
|
|
}
|
|
|
|
static inline void event_clear_filter(struct trace_event_file *file)
|
|
{
|
|
RCU_INIT_POINTER(file->filter, NULL);
|
|
}
|
|
|
|
static inline void
|
|
event_set_no_set_filter_flag(struct trace_event_file *file)
|
|
{
|
|
file->flags |= EVENT_FILE_FL_NO_SET_FILTER;
|
|
}
|
|
|
|
static inline void
|
|
event_clear_no_set_filter_flag(struct trace_event_file *file)
|
|
{
|
|
file->flags &= ~EVENT_FILE_FL_NO_SET_FILTER;
|
|
}
|
|
|
|
static inline bool
|
|
event_no_set_filter_flag(struct trace_event_file *file)
|
|
{
|
|
if (file->flags & EVENT_FILE_FL_NO_SET_FILTER)
|
|
return true;
|
|
|
|
return false;
|
|
}
|
|
|
|
struct filter_list {
|
|
struct list_head list;
|
|
struct event_filter *filter;
|
|
};
|
|
|
|
static int process_system_preds(struct trace_subsystem_dir *dir,
|
|
struct trace_array *tr,
|
|
struct filter_parse_error *pe,
|
|
char *filter_string)
|
|
{
|
|
struct trace_event_file *file;
|
|
struct filter_list *filter_item;
|
|
struct event_filter *filter = NULL;
|
|
struct filter_list *tmp;
|
|
LIST_HEAD(filter_list);
|
|
bool fail = true;
|
|
int err;
|
|
|
|
list_for_each_entry(file, &tr->events, list) {
|
|
|
|
if (file->system != dir)
|
|
continue;
|
|
|
|
filter = kzalloc(sizeof(*filter), GFP_KERNEL);
|
|
if (!filter)
|
|
goto fail_mem;
|
|
|
|
filter->filter_string = kstrdup(filter_string, GFP_KERNEL);
|
|
if (!filter->filter_string)
|
|
goto fail_mem;
|
|
|
|
err = process_preds(file->event_call, filter_string, filter, pe);
|
|
if (err) {
|
|
filter_disable(file);
|
|
parse_error(pe, FILT_ERR_BAD_SUBSYS_FILTER, 0);
|
|
append_filter_err(pe, filter);
|
|
} else
|
|
event_set_filtered_flag(file);
|
|
|
|
|
|
filter_item = kzalloc(sizeof(*filter_item), GFP_KERNEL);
|
|
if (!filter_item)
|
|
goto fail_mem;
|
|
|
|
list_add_tail(&filter_item->list, &filter_list);
|
|
/*
|
|
* Regardless of if this returned an error, we still
|
|
* replace the filter for the call.
|
|
*/
|
|
filter_item->filter = event_filter(file);
|
|
event_set_filter(file, filter);
|
|
filter = NULL;
|
|
|
|
fail = false;
|
|
}
|
|
|
|
if (fail)
|
|
goto fail;
|
|
|
|
/*
|
|
* The calls can still be using the old filters.
|
|
* Do a synchronize_rcu() and to ensure all calls are
|
|
* done with them before we free them.
|
|
*/
|
|
tracepoint_synchronize_unregister();
|
|
list_for_each_entry_safe(filter_item, tmp, &filter_list, list) {
|
|
__free_filter(filter_item->filter);
|
|
list_del(&filter_item->list);
|
|
kfree(filter_item);
|
|
}
|
|
return 0;
|
|
fail:
|
|
/* No call succeeded */
|
|
list_for_each_entry_safe(filter_item, tmp, &filter_list, list) {
|
|
list_del(&filter_item->list);
|
|
kfree(filter_item);
|
|
}
|
|
parse_error(pe, FILT_ERR_BAD_SUBSYS_FILTER, 0);
|
|
return -EINVAL;
|
|
fail_mem:
|
|
kfree(filter);
|
|
/* If any call succeeded, we still need to sync */
|
|
if (!fail)
|
|
tracepoint_synchronize_unregister();
|
|
list_for_each_entry_safe(filter_item, tmp, &filter_list, list) {
|
|
__free_filter(filter_item->filter);
|
|
list_del(&filter_item->list);
|
|
kfree(filter_item);
|
|
}
|
|
return -ENOMEM;
|
|
}
|
|
|
|
static int create_filter_start(char *filter_string, bool set_str,
|
|
struct filter_parse_error **pse,
|
|
struct event_filter **filterp)
|
|
{
|
|
struct event_filter *filter;
|
|
struct filter_parse_error *pe = NULL;
|
|
int err = 0;
|
|
|
|
if (WARN_ON_ONCE(*pse || *filterp))
|
|
return -EINVAL;
|
|
|
|
filter = kzalloc(sizeof(*filter), GFP_KERNEL);
|
|
if (filter && set_str) {
|
|
filter->filter_string = kstrdup(filter_string, GFP_KERNEL);
|
|
if (!filter->filter_string)
|
|
err = -ENOMEM;
|
|
}
|
|
|
|
pe = kzalloc(sizeof(*pe), GFP_KERNEL);
|
|
|
|
if (!filter || !pe || err) {
|
|
kfree(pe);
|
|
__free_filter(filter);
|
|
return -ENOMEM;
|
|
}
|
|
|
|
/* we're committed to creating a new filter */
|
|
*filterp = filter;
|
|
*pse = pe;
|
|
|
|
return 0;
|
|
}
|
|
|
|
static void create_filter_finish(struct filter_parse_error *pe)
|
|
{
|
|
kfree(pe);
|
|
}
|
|
|
|
/**
|
|
* create_filter - create a filter for a trace_event_call
|
|
* @call: trace_event_call to create a filter for
|
|
* @filter_str: filter string
|
|
* @set_str: remember @filter_str and enable detailed error in filter
|
|
* @filterp: out param for created filter (always updated on return)
|
|
* Must be a pointer that references a NULL pointer.
|
|
*
|
|
* Creates a filter for @call with @filter_str. If @set_str is %true,
|
|
* @filter_str is copied and recorded in the new filter.
|
|
*
|
|
* On success, returns 0 and *@filterp points to the new filter. On
|
|
* failure, returns -errno and *@filterp may point to %NULL or to a new
|
|
* filter. In the latter case, the returned filter contains error
|
|
* information if @set_str is %true and the caller is responsible for
|
|
* freeing it.
|
|
*/
|
|
static int create_filter(struct trace_event_call *call,
|
|
char *filter_string, bool set_str,
|
|
struct event_filter **filterp)
|
|
{
|
|
struct filter_parse_error *pe = NULL;
|
|
int err;
|
|
|
|
/* filterp must point to NULL */
|
|
if (WARN_ON(*filterp))
|
|
*filterp = NULL;
|
|
|
|
err = create_filter_start(filter_string, set_str, &pe, filterp);
|
|
if (err)
|
|
return err;
|
|
|
|
err = process_preds(call, filter_string, *filterp, pe);
|
|
if (err && set_str)
|
|
append_filter_err(pe, *filterp);
|
|
create_filter_finish(pe);
|
|
|
|
return err;
|
|
}
|
|
|
|
int create_event_filter(struct trace_event_call *call,
|
|
char *filter_str, bool set_str,
|
|
struct event_filter **filterp)
|
|
{
|
|
return create_filter(call, filter_str, set_str, filterp);
|
|
}
|
|
|
|
/**
|
|
* create_system_filter - create a filter for an event_subsystem
|
|
* @system: event_subsystem to create a filter for
|
|
* @filter_str: filter string
|
|
* @filterp: out param for created filter (always updated on return)
|
|
*
|
|
* Identical to create_filter() except that it creates a subsystem filter
|
|
* and always remembers @filter_str.
|
|
*/
|
|
static int create_system_filter(struct trace_subsystem_dir *dir,
|
|
struct trace_array *tr,
|
|
char *filter_str, struct event_filter **filterp)
|
|
{
|
|
struct filter_parse_error *pe = NULL;
|
|
int err;
|
|
|
|
err = create_filter_start(filter_str, true, &pe, filterp);
|
|
if (!err) {
|
|
err = process_system_preds(dir, tr, pe, filter_str);
|
|
if (!err) {
|
|
/* System filters just show a default message */
|
|
kfree((*filterp)->filter_string);
|
|
(*filterp)->filter_string = NULL;
|
|
} else {
|
|
append_filter_err(pe, *filterp);
|
|
}
|
|
}
|
|
create_filter_finish(pe);
|
|
|
|
return err;
|
|
}
|
|
|
|
/* caller must hold event_mutex */
|
|
int apply_event_filter(struct trace_event_file *file, char *filter_string)
|
|
{
|
|
struct trace_event_call *call = file->event_call;
|
|
struct event_filter *filter = NULL;
|
|
int err;
|
|
|
|
if (!strcmp(strstrip(filter_string), "0")) {
|
|
filter_disable(file);
|
|
filter = event_filter(file);
|
|
|
|
if (!filter)
|
|
return 0;
|
|
|
|
event_clear_filter(file);
|
|
|
|
/* Make sure the filter is not being used */
|
|
tracepoint_synchronize_unregister();
|
|
__free_filter(filter);
|
|
|
|
return 0;
|
|
}
|
|
|
|
err = create_filter(call, filter_string, true, &filter);
|
|
|
|
/*
|
|
* Always swap the call filter with the new filter
|
|
* even if there was an error. If there was an error
|
|
* in the filter, we disable the filter and show the error
|
|
* string
|
|
*/
|
|
if (filter) {
|
|
struct event_filter *tmp;
|
|
|
|
tmp = event_filter(file);
|
|
if (!err)
|
|
event_set_filtered_flag(file);
|
|
else
|
|
filter_disable(file);
|
|
|
|
event_set_filter(file, filter);
|
|
|
|
if (tmp) {
|
|
/* Make sure the call is done with the filter */
|
|
tracepoint_synchronize_unregister();
|
|
__free_filter(tmp);
|
|
}
|
|
}
|
|
|
|
return err;
|
|
}
|
|
|
|
int apply_subsystem_event_filter(struct trace_subsystem_dir *dir,
|
|
char *filter_string)
|
|
{
|
|
struct event_subsystem *system = dir->subsystem;
|
|
struct trace_array *tr = dir->tr;
|
|
struct event_filter *filter = NULL;
|
|
int err = 0;
|
|
|
|
mutex_lock(&event_mutex);
|
|
|
|
/* Make sure the system still has events */
|
|
if (!dir->nr_events) {
|
|
err = -ENODEV;
|
|
goto out_unlock;
|
|
}
|
|
|
|
if (!strcmp(strstrip(filter_string), "0")) {
|
|
filter_free_subsystem_preds(dir, tr);
|
|
remove_filter_string(system->filter);
|
|
filter = system->filter;
|
|
system->filter = NULL;
|
|
/* Ensure all filters are no longer used */
|
|
tracepoint_synchronize_unregister();
|
|
filter_free_subsystem_filters(dir, tr);
|
|
__free_filter(filter);
|
|
goto out_unlock;
|
|
}
|
|
|
|
err = create_system_filter(dir, tr, filter_string, &filter);
|
|
if (filter) {
|
|
/*
|
|
* No event actually uses the system filter
|
|
* we can free it without synchronize_rcu().
|
|
*/
|
|
__free_filter(system->filter);
|
|
system->filter = filter;
|
|
}
|
|
out_unlock:
|
|
mutex_unlock(&event_mutex);
|
|
|
|
return err;
|
|
}
|
|
|
|
#ifdef CONFIG_PERF_EVENTS
|
|
|
|
void ftrace_profile_free_filter(struct perf_event *event)
|
|
{
|
|
struct event_filter *filter = event->filter;
|
|
|
|
event->filter = NULL;
|
|
__free_filter(filter);
|
|
}
|
|
|
|
struct function_filter_data {
|
|
struct ftrace_ops *ops;
|
|
int first_filter;
|
|
int first_notrace;
|
|
};
|
|
|
|
#ifdef CONFIG_FUNCTION_TRACER
|
|
static char **
|
|
ftrace_function_filter_re(char *buf, int len, int *count)
|
|
{
|
|
char *str, **re;
|
|
|
|
str = kstrndup(buf, len, GFP_KERNEL);
|
|
if (!str)
|
|
return NULL;
|
|
|
|
/*
|
|
* The argv_split function takes white space
|
|
* as a separator, so convert ',' into spaces.
|
|
*/
|
|
strreplace(str, ',', ' ');
|
|
|
|
re = argv_split(GFP_KERNEL, str, count);
|
|
kfree(str);
|
|
return re;
|
|
}
|
|
|
|
static int ftrace_function_set_regexp(struct ftrace_ops *ops, int filter,
|
|
int reset, char *re, int len)
|
|
{
|
|
int ret;
|
|
|
|
if (filter)
|
|
ret = ftrace_set_filter(ops, re, len, reset);
|
|
else
|
|
ret = ftrace_set_notrace(ops, re, len, reset);
|
|
|
|
return ret;
|
|
}
|
|
|
|
static int __ftrace_function_set_filter(int filter, char *buf, int len,
|
|
struct function_filter_data *data)
|
|
{
|
|
int i, re_cnt, ret = -EINVAL;
|
|
int *reset;
|
|
char **re;
|
|
|
|
reset = filter ? &data->first_filter : &data->first_notrace;
|
|
|
|
/*
|
|
* The 'ip' field could have multiple filters set, separated
|
|
* either by space or comma. We first cut the filter and apply
|
|
* all pieces separatelly.
|
|
*/
|
|
re = ftrace_function_filter_re(buf, len, &re_cnt);
|
|
if (!re)
|
|
return -EINVAL;
|
|
|
|
for (i = 0; i < re_cnt; i++) {
|
|
ret = ftrace_function_set_regexp(data->ops, filter, *reset,
|
|
re[i], strlen(re[i]));
|
|
if (ret)
|
|
break;
|
|
|
|
if (*reset)
|
|
*reset = 0;
|
|
}
|
|
|
|
argv_free(re);
|
|
return ret;
|
|
}
|
|
|
|
static int ftrace_function_check_pred(struct filter_pred *pred)
|
|
{
|
|
struct ftrace_event_field *field = pred->field;
|
|
|
|
/*
|
|
* Check the predicate for function trace, verify:
|
|
* - only '==' and '!=' is used
|
|
* - the 'ip' field is used
|
|
*/
|
|
if ((pred->op != OP_EQ) && (pred->op != OP_NE))
|
|
return -EINVAL;
|
|
|
|
if (strcmp(field->name, "ip"))
|
|
return -EINVAL;
|
|
|
|
return 0;
|
|
}
|
|
|
|
static int ftrace_function_set_filter_pred(struct filter_pred *pred,
|
|
struct function_filter_data *data)
|
|
{
|
|
int ret;
|
|
|
|
/* Checking the node is valid for function trace. */
|
|
ret = ftrace_function_check_pred(pred);
|
|
if (ret)
|
|
return ret;
|
|
|
|
return __ftrace_function_set_filter(pred->op == OP_EQ,
|
|
pred->regex.pattern,
|
|
pred->regex.len,
|
|
data);
|
|
}
|
|
|
|
static bool is_or(struct prog_entry *prog, int i)
|
|
{
|
|
int target;
|
|
|
|
/*
|
|
* Only "||" is allowed for function events, thus,
|
|
* all true branches should jump to true, and any
|
|
* false branch should jump to false.
|
|
*/
|
|
target = prog[i].target + 1;
|
|
/* True and false have NULL preds (all prog entries should jump to one */
|
|
if (prog[target].pred)
|
|
return false;
|
|
|
|
/* prog[target].target is 1 for TRUE, 0 for FALSE */
|
|
return prog[i].when_to_branch == prog[target].target;
|
|
}
|
|
|
|
static int ftrace_function_set_filter(struct perf_event *event,
|
|
struct event_filter *filter)
|
|
{
|
|
struct prog_entry *prog = rcu_dereference_protected(filter->prog,
|
|
lockdep_is_held(&event_mutex));
|
|
struct function_filter_data data = {
|
|
.first_filter = 1,
|
|
.first_notrace = 1,
|
|
.ops = &event->ftrace_ops,
|
|
};
|
|
int i;
|
|
|
|
for (i = 0; prog[i].pred; i++) {
|
|
struct filter_pred *pred = prog[i].pred;
|
|
|
|
if (!is_or(prog, i))
|
|
return -EINVAL;
|
|
|
|
if (ftrace_function_set_filter_pred(pred, &data) < 0)
|
|
return -EINVAL;
|
|
}
|
|
return 0;
|
|
}
|
|
#else
|
|
static int ftrace_function_set_filter(struct perf_event *event,
|
|
struct event_filter *filter)
|
|
{
|
|
return -ENODEV;
|
|
}
|
|
#endif /* CONFIG_FUNCTION_TRACER */
|
|
|
|
int ftrace_profile_set_filter(struct perf_event *event, int event_id,
|
|
char *filter_str)
|
|
{
|
|
int err;
|
|
struct event_filter *filter = NULL;
|
|
struct trace_event_call *call;
|
|
|
|
mutex_lock(&event_mutex);
|
|
|
|
call = event->tp_event;
|
|
|
|
err = -EINVAL;
|
|
if (!call)
|
|
goto out_unlock;
|
|
|
|
err = -EEXIST;
|
|
if (event->filter)
|
|
goto out_unlock;
|
|
|
|
err = create_filter(call, filter_str, false, &filter);
|
|
if (err)
|
|
goto free_filter;
|
|
|
|
if (ftrace_event_is_function(call))
|
|
err = ftrace_function_set_filter(event, filter);
|
|
else
|
|
event->filter = filter;
|
|
|
|
free_filter:
|
|
if (err || ftrace_event_is_function(call))
|
|
__free_filter(filter);
|
|
|
|
out_unlock:
|
|
mutex_unlock(&event_mutex);
|
|
|
|
return err;
|
|
}
|
|
|
|
#endif /* CONFIG_PERF_EVENTS */
|
|
|
|
#ifdef CONFIG_FTRACE_STARTUP_TEST
|
|
|
|
#include <linux/types.h>
|
|
#include <linux/tracepoint.h>
|
|
|
|
#define CREATE_TRACE_POINTS
|
|
#include "trace_events_filter_test.h"
|
|
|
|
#define DATA_REC(m, va, vb, vc, vd, ve, vf, vg, vh, nvisit) \
|
|
{ \
|
|
.filter = FILTER, \
|
|
.rec = { .a = va, .b = vb, .c = vc, .d = vd, \
|
|
.e = ve, .f = vf, .g = vg, .h = vh }, \
|
|
.match = m, \
|
|
.not_visited = nvisit, \
|
|
}
|
|
#define YES 1
|
|
#define NO 0
|
|
|
|
static struct test_filter_data_t {
|
|
char *filter;
|
|
struct trace_event_raw_ftrace_test_filter rec;
|
|
int match;
|
|
char *not_visited;
|
|
} test_filter_data[] = {
|
|
#define FILTER "a == 1 && b == 1 && c == 1 && d == 1 && " \
|
|
"e == 1 && f == 1 && g == 1 && h == 1"
|
|
DATA_REC(YES, 1, 1, 1, 1, 1, 1, 1, 1, ""),
|
|
DATA_REC(NO, 0, 1, 1, 1, 1, 1, 1, 1, "bcdefgh"),
|
|
DATA_REC(NO, 1, 1, 1, 1, 1, 1, 1, 0, ""),
|
|
#undef FILTER
|
|
#define FILTER "a == 1 || b == 1 || c == 1 || d == 1 || " \
|
|
"e == 1 || f == 1 || g == 1 || h == 1"
|
|
DATA_REC(NO, 0, 0, 0, 0, 0, 0, 0, 0, ""),
|
|
DATA_REC(YES, 0, 0, 0, 0, 0, 0, 0, 1, ""),
|
|
DATA_REC(YES, 1, 0, 0, 0, 0, 0, 0, 0, "bcdefgh"),
|
|
#undef FILTER
|
|
#define FILTER "(a == 1 || b == 1) && (c == 1 || d == 1) && " \
|
|
"(e == 1 || f == 1) && (g == 1 || h == 1)"
|
|
DATA_REC(NO, 0, 0, 1, 1, 1, 1, 1, 1, "dfh"),
|
|
DATA_REC(YES, 0, 1, 0, 1, 0, 1, 0, 1, ""),
|
|
DATA_REC(YES, 1, 0, 1, 0, 0, 1, 0, 1, "bd"),
|
|
DATA_REC(NO, 1, 0, 1, 0, 0, 1, 0, 0, "bd"),
|
|
#undef FILTER
|
|
#define FILTER "(a == 1 && b == 1) || (c == 1 && d == 1) || " \
|
|
"(e == 1 && f == 1) || (g == 1 && h == 1)"
|
|
DATA_REC(YES, 1, 0, 1, 1, 1, 1, 1, 1, "efgh"),
|
|
DATA_REC(YES, 0, 0, 0, 0, 0, 0, 1, 1, ""),
|
|
DATA_REC(NO, 0, 0, 0, 0, 0, 0, 0, 1, ""),
|
|
#undef FILTER
|
|
#define FILTER "(a == 1 && b == 1) && (c == 1 && d == 1) && " \
|
|
"(e == 1 && f == 1) || (g == 1 && h == 1)"
|
|
DATA_REC(YES, 1, 1, 1, 1, 1, 1, 0, 0, "gh"),
|
|
DATA_REC(NO, 0, 0, 0, 0, 0, 0, 0, 1, ""),
|
|
DATA_REC(YES, 1, 1, 1, 1, 1, 0, 1, 1, ""),
|
|
#undef FILTER
|
|
#define FILTER "((a == 1 || b == 1) || (c == 1 || d == 1) || " \
|
|
"(e == 1 || f == 1)) && (g == 1 || h == 1)"
|
|
DATA_REC(YES, 1, 1, 1, 1, 1, 1, 0, 1, "bcdef"),
|
|
DATA_REC(NO, 0, 0, 0, 0, 0, 0, 0, 0, ""),
|
|
DATA_REC(YES, 1, 1, 1, 1, 1, 0, 1, 1, "h"),
|
|
#undef FILTER
|
|
#define FILTER "((((((((a == 1) && (b == 1)) || (c == 1)) && (d == 1)) || " \
|
|
"(e == 1)) && (f == 1)) || (g == 1)) && (h == 1))"
|
|
DATA_REC(YES, 1, 1, 1, 1, 1, 1, 1, 1, "ceg"),
|
|
DATA_REC(NO, 0, 1, 0, 1, 0, 1, 0, 1, ""),
|
|
DATA_REC(NO, 1, 0, 1, 0, 1, 0, 1, 0, ""),
|
|
#undef FILTER
|
|
#define FILTER "((((((((a == 1) || (b == 1)) && (c == 1)) || (d == 1)) && " \
|
|
"(e == 1)) || (f == 1)) && (g == 1)) || (h == 1))"
|
|
DATA_REC(YES, 1, 1, 1, 1, 1, 1, 1, 1, "bdfh"),
|
|
DATA_REC(YES, 0, 1, 0, 1, 0, 1, 0, 1, ""),
|
|
DATA_REC(YES, 1, 0, 1, 0, 1, 0, 1, 0, "bdfh"),
|
|
};
|
|
|
|
#undef DATA_REC
|
|
#undef FILTER
|
|
#undef YES
|
|
#undef NO
|
|
|
|
#define DATA_CNT ARRAY_SIZE(test_filter_data)
|
|
|
|
static int test_pred_visited;
|
|
|
|
static int test_pred_visited_fn(struct filter_pred *pred, void *event)
|
|
{
|
|
struct ftrace_event_field *field = pred->field;
|
|
|
|
test_pred_visited = 1;
|
|
printk(KERN_INFO "\npred visited %s\n", field->name);
|
|
return 1;
|
|
}
|
|
|
|
static void update_pred_fn(struct event_filter *filter, char *fields)
|
|
{
|
|
struct prog_entry *prog = rcu_dereference_protected(filter->prog,
|
|
lockdep_is_held(&event_mutex));
|
|
int i;
|
|
|
|
for (i = 0; prog[i].pred; i++) {
|
|
struct filter_pred *pred = prog[i].pred;
|
|
struct ftrace_event_field *field = pred->field;
|
|
|
|
WARN_ON_ONCE(!pred->fn);
|
|
|
|
if (!field) {
|
|
WARN_ONCE(1, "all leafs should have field defined %d", i);
|
|
continue;
|
|
}
|
|
|
|
if (!strchr(fields, *field->name))
|
|
continue;
|
|
|
|
pred->fn = test_pred_visited_fn;
|
|
}
|
|
}
|
|
|
|
static __init int ftrace_test_event_filter(void)
|
|
{
|
|
int i;
|
|
|
|
printk(KERN_INFO "Testing ftrace filter: ");
|
|
|
|
for (i = 0; i < DATA_CNT; i++) {
|
|
struct event_filter *filter = NULL;
|
|
struct test_filter_data_t *d = &test_filter_data[i];
|
|
int err;
|
|
|
|
err = create_filter(&event_ftrace_test_filter, d->filter,
|
|
false, &filter);
|
|
if (err) {
|
|
printk(KERN_INFO
|
|
"Failed to get filter for '%s', err %d\n",
|
|
d->filter, err);
|
|
__free_filter(filter);
|
|
break;
|
|
}
|
|
|
|
/* Needed to dereference filter->prog */
|
|
mutex_lock(&event_mutex);
|
|
/*
|
|
* The preemption disabling is not really needed for self
|
|
* tests, but the rcu dereference will complain without it.
|
|
*/
|
|
preempt_disable();
|
|
if (*d->not_visited)
|
|
update_pred_fn(filter, d->not_visited);
|
|
|
|
test_pred_visited = 0;
|
|
err = filter_match_preds(filter, &d->rec);
|
|
preempt_enable();
|
|
|
|
mutex_unlock(&event_mutex);
|
|
|
|
__free_filter(filter);
|
|
|
|
if (test_pred_visited) {
|
|
printk(KERN_INFO
|
|
"Failed, unwanted pred visited for filter %s\n",
|
|
d->filter);
|
|
break;
|
|
}
|
|
|
|
if (err != d->match) {
|
|
printk(KERN_INFO
|
|
"Failed to match filter '%s', expected %d\n",
|
|
d->filter, d->match);
|
|
break;
|
|
}
|
|
}
|
|
|
|
if (i == DATA_CNT)
|
|
printk(KERN_CONT "OK\n");
|
|
|
|
return 0;
|
|
}
|
|
|
|
late_initcall(ftrace_test_event_filter);
|
|
|
|
#endif /* CONFIG_FTRACE_STARTUP_TEST */
|