git.oblomov.eu Git - linux-2.6/blob - kernel/trace/trace_events_filter.c

   1 /*
   2  * trace_events_filter - generic event filtering
   3  *
   4  * This program is free software; you can redistribute it and/or modify
   5  * it under the terms of the GNU General Public License as published by
   6  * the Free Software Foundation; either version 2 of the License, or
   7  * (at your option) any later version.
   8  *
   9  * This program is distributed in the hope that it will be useful,
  10  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  11  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  12  * GNU General Public License for more details.
  13  *
  14  * You should have received a copy of the GNU General Public License
  15  * along with this program; if not, write to the Free Software
  16  * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
  17  *
  18  * Copyright (C) 2009 Tom Zanussi <tzanussi@gmail.com>
  19  */
  20
  21 #include <linux/debugfs.h>
  22 #include <linux/uaccess.h>
  23 #include <linux/module.h>
  24 #include <linux/ctype.h>
  25
  26 #include "trace.h"
  27 #include "trace_output.h"
  28
  29 static int filter_pred_64(struct filter_pred *pred, void *event)
  30 {
  31         u64 *addr = (u64 *)(event + pred->offset);
  32         u64 val = (u64)pred->val;
  33         int match;
  34
  35         match = (val == *addr) ^ pred->not;
  36
  37         return match;
  38 }
  39
  40 static int filter_pred_32(struct filter_pred *pred, void *event)
  41 {
  42         u32 *addr = (u32 *)(event + pred->offset);
  43         u32 val = (u32)pred->val;
  44         int match;
  45
  46         match = (val == *addr) ^ pred->not;
  47
  48         return match;
  49 }
  50
  51 static int filter_pred_16(struct filter_pred *pred, void *event)
  52 {
  53         u16 *addr = (u16 *)(event + pred->offset);
  54         u16 val = (u16)pred->val;
  55         int match;
  56
  57         match = (val == *addr) ^ pred->not;
  58
  59         return match;
  60 }
  61
  62 static int filter_pred_8(struct filter_pred *pred, void *event)
  63 {
  64         u8 *addr = (u8 *)(event + pred->offset);
  65         u8 val = (u8)pred->val;
  66         int match;
  67
  68         match = (val == *addr) ^ pred->not;
  69
  70         return match;
  71 }
  72
  73 static int filter_pred_string(struct filter_pred *pred, void *event)
  74 {
  75         char *addr = (char *)(event + pred->offset);
  76         int cmp, match;
  77
  78         cmp = strncmp(addr, pred->str_val, pred->str_len);
  79
  80         match = (!cmp) ^ pred->not;
  81
  82         return match;
  83 }
  84
  85 static int filter_pred_none(struct filter_pred *pred, void *event)
  86 {
  87         return 0;
  88 }
  89
  90 /* return 1 if event matches, 0 otherwise (discard) */
  91 int filter_match_preds(struct ftrace_event_call *call, void *rec)
  92 {
  93         int i, matched, and_failed = 0;
  94         struct filter_pred *pred;
  95
  96         for (i = 0; i < call->n_preds; i++) {
  97                 pred = call->preds[i];
  98                 if (and_failed && !pred->or)
  99                         continue;
 100                 matched = pred->fn(pred, rec);
 101                 if (!matched && !pred->or) {
 102                         and_failed = 1;
 103                         continue;
 104                 } else if (matched && pred->or)
 105                         return 1;
 106         }
 107
 108         if (and_failed)
 109                 return 0;
 110
 111         return 1;
 112 }
 113
 114 void filter_print_preds(struct filter_pred **preds, int n_preds,
 115                         struct trace_seq *s)
 116 {
 117         char *field_name;
 118         struct filter_pred *pred;
 119         int i;
 120
 121         if (!n_preds) {
 122                 trace_seq_printf(s, "none\n");
 123                 return;
 124         }
 125
 126         for (i = 0; i < n_preds; i++) {
 127                 pred = preds[i];
 128                 field_name = pred->field_name;
 129                 if (i)
 130                         trace_seq_printf(s, pred->or ? "|| " : "&& ");
 131                 trace_seq_printf(s, "%s ", field_name);
 132                 trace_seq_printf(s, pred->not ? "!= " : "== ");
 133                 if (pred->str_len)
 134                         trace_seq_printf(s, "%s\n", pred->str_val);
 135                 else
 136                         trace_seq_printf(s, "%llu\n", pred->val);
 137         }
 138 }
 139
 140 static struct ftrace_event_field *
 141 find_event_field(struct ftrace_event_call *call, char *name)
 142 {
 143         struct ftrace_event_field *field;
 144
 145         list_for_each_entry(field, &call->fields, link) {
 146                 if (!strcmp(field->name, name))
 147                         return field;
 148         }
 149
 150         return NULL;
 151 }
 152
 153 void filter_free_pred(struct filter_pred *pred)
 154 {
 155         if (!pred)
 156                 return;
 157
 158         kfree(pred->field_name);
 159         kfree(pred);
 160 }
 161
 162 static void filter_clear_pred(struct filter_pred *pred)
 163 {
 164         kfree(pred->field_name);
 165         pred->field_name = NULL;
 166         pred->str_len = 0;
 167 }
 168
 169 static int filter_set_pred(struct filter_pred *dest,
 170                            struct filter_pred *src,
 171                            filter_pred_fn_t fn)
 172 {
 173         *dest = *src;
 174         dest->field_name = kstrdup(src->field_name, GFP_KERNEL);
 175         if (!dest->field_name)
 176                 return -ENOMEM;
 177         dest->fn = fn;
 178
 179         return 0;
 180 }
 181
 182 void filter_disable_preds(struct ftrace_event_call *call)
 183 {
 184         int i;
 185
 186         call->n_preds = 0;
 187
 188         for (i = 0; i < MAX_FILTER_PRED; i++)
 189                 call->preds[i]->fn = filter_pred_none;
 190 }
 191
 192 int init_preds(struct ftrace_event_call *call)
 193 {
 194         struct filter_pred *pred;
 195         int i;
 196
 197         call->n_preds = 0;
 198
 199         call->preds = kzalloc(MAX_FILTER_PRED * sizeof(pred), GFP_KERNEL);
 200         if (!call->preds)
 201                 return -ENOMEM;
 202
 203         for (i = 0; i < MAX_FILTER_PRED; i++) {
 204                 pred = kzalloc(sizeof(*pred), GFP_KERNEL);
 205                 if (!pred)
 206                         goto oom;
 207                 pred->fn = filter_pred_none;
 208                 call->preds[i] = pred;
 209         }
 210
 211         return 0;
 212
 213 oom:
 214         for (i = 0; i < MAX_FILTER_PRED; i++) {
 215                 if (call->preds[i])
 216                         filter_free_pred(call->preds[i]);
 217         }
 218         kfree(call->preds);
 219         call->preds = NULL;
 220
 221         return -ENOMEM;
 222 }
 223
 224 void filter_free_subsystem_preds(struct event_subsystem *system)
 225 {
 226         struct ftrace_event_call *call;
 227         int i;
 228
 229         if (system->n_preds) {
 230                 for (i = 0; i < system->n_preds; i++)
 231                         filter_free_pred(system->preds[i]);
 232                 kfree(system->preds);
 233                 system->preds = NULL;
 234                 system->n_preds = 0;
 235         }
 236
 237         list_for_each_entry(call, &ftrace_events, list) {
 238                 if (!call->define_fields)
 239                         continue;
 240
 241                 if (!strcmp(call->system, system->name))
 242                         filter_disable_preds(call);
 243         }
 244 }
 245
 246 static int __filter_add_pred(struct ftrace_event_call *call,
 247                              struct filter_pred *pred,
 248                              filter_pred_fn_t fn)
 249 {
 250         int idx, err;
 251
 252         if (call->n_preds && !pred->compound)
 253                 filter_disable_preds(call);
 254
 255         if (call->n_preds == MAX_FILTER_PRED)
 256                 return -ENOSPC;
 257
 258         idx = call->n_preds;
 259         filter_clear_pred(call->preds[idx]);
 260         err = filter_set_pred(call->preds[idx], pred, fn);
 261         if (err)
 262                 return err;
 263
 264         call->n_preds++;
 265
 266         return 0;
 267 }
 268
 269 static int is_string_field(const char *type)
 270 {
 271         if (strchr(type, '[') && strstr(type, "char"))
 272                 return 1;
 273
 274         return 0;
 275 }
 276
 277 int filter_add_pred(struct ftrace_event_call *call, struct filter_pred *pred)
 278 {
 279         struct ftrace_event_field *field;
 280         filter_pred_fn_t fn;
 281
 282         field = find_event_field(call, pred->field_name);
 283         if (!field)
 284                 return -EINVAL;
 285
 286         pred->fn = filter_pred_none;
 287         pred->offset = field->offset;
 288
 289         if (is_string_field(field->type)) {
 290                 if (!pred->str_len)
 291                         return -EINVAL;
 292                 fn = filter_pred_string;
 293                 pred->str_len = field->size;
 294                 return __filter_add_pred(call, pred, fn);
 295         } else {
 296                 if (pred->str_len)
 297                         return -EINVAL;
 298         }
 299
 300         switch (field->size) {
 301         case 8:
 302                 fn = filter_pred_64;
 303                 break;
 304         case 4:
 305                 fn = filter_pred_32;
 306                 break;
 307         case 2:
 308                 fn = filter_pred_16;
 309                 break;
 310         case 1:
 311                 fn = filter_pred_8;
 312                 break;
 313         default:
 314                 return -EINVAL;
 315         }
 316
 317         return __filter_add_pred(call, pred, fn);
 318 }
 319
 320 int filter_add_subsystem_pred(struct event_subsystem *system,
 321                               struct filter_pred *pred)
 322 {
 323         struct ftrace_event_call *call;
 324
 325         if (system->n_preds && !pred->compound)
 326                 filter_free_subsystem_preds(system);
 327
 328         if (!system->n_preds) {
 329                 system->preds = kzalloc(MAX_FILTER_PRED * sizeof(pred),
 330                                         GFP_KERNEL);
 331                 if (!system->preds)
 332                         return -ENOMEM;
 333         }
 334
 335         if (system->n_preds == MAX_FILTER_PRED)
 336                 return -ENOSPC;
 337
 338         system->preds[system->n_preds] = pred;
 339
 340         list_for_each_entry(call, &ftrace_events, list) {
 341                 int err;
 342
 343                 if (!call->define_fields)
 344                         continue;
 345
 346                 if (strcmp(call->system, system->name))
 347                         continue;
 348
 349                 if (!find_event_field(call, pred->field_name))
 350                         continue;
 351
 352                 err = filter_add_pred(call, pred);
 353                 if (err == -ENOMEM) {
 354                         system->preds[system->n_preds] = NULL;
 355                         return err;
 356                 }
 357         }
 358
 359         system->n_preds++;
 360
 361         return 0;
 362 }
 363
 364 int filter_parse(char **pbuf, struct filter_pred *pred)
 365 {
 366         char *tmp, *tok, *val_str = NULL;
 367         int tok_n = 0;
 368
 369         /* field ==/!= number, or/and field ==/!= number, number */
 370         while ((tok = strsep(pbuf, " \n"))) {
 371                 if (tok_n == 0) {
 372                         if (!strcmp(tok, "0")) {
 373                                 pred->clear = 1;
 374                                 return 0;
 375                         } else if (!strcmp(tok, "&&")) {
 376                                 pred->or = 0;
 377                                 pred->compound = 1;
 378                         } else if (!strcmp(tok, "||")) {
 379                                 pred->or = 1;
 380                                 pred->compound = 1;
 381                         } else
 382                                 pred->field_name = tok;
 383                         tok_n = 1;
 384                         continue;
 385                 }
 386                 if (tok_n == 1) {
 387                         if (!pred->field_name)
 388                                 pred->field_name = tok;
 389                         else if (!strcmp(tok, "!="))
 390                                 pred->not = 1;
 391                         else if (!strcmp(tok, "=="))
 392                                 pred->not = 0;
 393                         else {
 394                                 pred->field_name = NULL;
 395                                 return -EINVAL;
 396                         }
 397                         tok_n = 2;
 398                         continue;
 399                 }
 400                 if (tok_n == 2) {
 401                         if (pred->compound) {
 402                                 if (!strcmp(tok, "!="))
 403                                         pred->not = 1;
 404                                 else if (!strcmp(tok, "=="))
 405                                         pred->not = 0;
 406                                 else {
 407                                         pred->field_name = NULL;
 408                                         return -EINVAL;
 409                                 }
 410                         } else {
 411                                 val_str = tok;
 412                                 break; /* done */
 413                         }
 414                         tok_n = 3;
 415                         continue;
 416                 }
 417                 if (tok_n == 3) {
 418                         val_str = tok;
 419                         break; /* done */
 420                 }
 421         }
 422
 423         if (!val_str || !strlen(val_str)
 424             || strlen(val_str) >= MAX_FILTER_STR_VAL) {
 425                 pred->field_name = NULL;
 426                 return -EINVAL;
 427         }
 428
 429         pred->field_name = kstrdup(pred->field_name, GFP_KERNEL);
 430         if (!pred->field_name)
 431                 return -ENOMEM;
 432
 433         pred->str_len = 0;
 434         pred->val = simple_strtoull(val_str, &tmp, 0);
 435         if (tmp == val_str) {
 436                 strncpy(pred->str_val, val_str, MAX_FILTER_STR_VAL);
 437                 pred->str_len = strlen(val_str);
 438                 pred->str_val[pred->str_len] = '\0';
 439         } else if (*tmp != '\0')
 440                 return -EINVAL;
 441
 442         return 0;
 443 }
 444
 445