SAFE public projects git trees. - safe/jmp/linux-2.6/blob - kernel/trace/trace_ksym.c

   1 /*
   2  * trace_ksym.c - Kernel Symbol Tracer
   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) IBM Corporation, 2009
  19  */
  20
  21 #include <linux/kallsyms.h>
  22 #include <linux/uaccess.h>
  23 #include <linux/debugfs.h>
  24 #include <linux/ftrace.h>
  25 #include <linux/module.h>
  26 #include <linux/fs.h>
  27
  28 #include "trace_output.h"
  29 #include "trace_stat.h"
  30 #include "trace.h"
  31
  32 /* For now, let us restrict the no. of symbols traced simultaneously to number
  33  * of available hardware breakpoint registers.
  34  */
  35 #define KSYM_TRACER_MAX HBP_NUM
  36
  37 #define KSYM_TRACER_OP_LEN 3 /* rw- */
  38 #define KSYM_FILTER_ENTRY_LEN (KSYM_NAME_LEN + KSYM_TRACER_OP_LEN + 1)
  39
  40 static struct trace_array *ksym_trace_array;
  41
  42 static unsigned int ksym_filter_entry_count;
  43 static unsigned int ksym_tracing_enabled;
  44
  45 static HLIST_HEAD(ksym_filter_head);
  46
  47 #ifdef CONFIG_PROFILE_KSYM_TRACER
  48
  49 #define MAX_UL_INT 0xffffffff
  50
  51 static DEFINE_MUTEX(ksym_tracer_mutex);
  52
  53 void ksym_collect_stats(unsigned long hbp_hit_addr)
  54 {
  55         struct hlist_node *node;
  56         struct trace_ksym *entry;
  57
  58         rcu_read_lock();
  59         hlist_for_each_entry_rcu(entry, node, &ksym_filter_head, ksym_hlist) {
  60                 if ((entry->ksym_addr == hbp_hit_addr) &&
  61                     (entry->counter <= MAX_UL_INT)) {
  62                         entry->counter++;
  63                         break;
  64                 }
  65         }
  66         rcu_read_unlock();
  67 }
  68 #endif /* CONFIG_PROFILE_KSYM_TRACER */
  69
  70 void ksym_hbp_handler(struct hw_breakpoint *hbp, struct pt_regs *regs)
  71 {
  72         struct ring_buffer_event *event;
  73         struct trace_array *tr;
  74         struct trace_ksym *entry;
  75         int pc;
  76
  77         if (!ksym_tracing_enabled)
  78                 return;
  79
  80         tr = ksym_trace_array;
  81         pc = preempt_count();
  82
  83         event = trace_buffer_lock_reserve(tr, TRACE_KSYM,
  84                                                         sizeof(*entry), 0, pc);
  85         if (!event)
  86                 return;
  87
  88         entry = ring_buffer_event_data(event);
  89         strlcpy(entry->ksym_name, hbp->info.name, KSYM_SYMBOL_LEN);
  90         entry->ksym_hbp = hbp;
  91         entry->ip = instruction_pointer(regs);
  92         strlcpy(entry->p_name, current->comm, TASK_COMM_LEN);
  93 #ifdef CONFIG_PROFILE_KSYM_TRACER
  94         ksym_collect_stats(hbp->info.address);
  95 #endif /* CONFIG_PROFILE_KSYM_TRACER */
  96
  97         trace_buffer_unlock_commit(tr, event, 0, pc);
  98 }
  99
 100 /* Valid access types are represented as
 101  *
 102  * rw- : Set Read/Write Access Breakpoint
 103  * -w- : Set Write Access Breakpoint
 104  * --- : Clear Breakpoints
 105  * --x : Set Execution Break points (Not available yet)
 106  *
 107  */
 108 static int ksym_trace_get_access_type(char *access_str)
 109 {
 110         int pos, access = 0;
 111
 112         for (pos = 0; pos < KSYM_TRACER_OP_LEN; pos++) {
 113                 switch (access_str[pos]) {
 114                 case 'r':
 115                         access += (pos == 0) ? 4 : -1;
 116                         break;
 117                 case 'w':
 118                         access += (pos == 1) ? 2 : -1;
 119                         break;
 120                 case '-':
 121                         break;
 122                 default:
 123                         return -EINVAL;
 124                 }
 125         }
 126
 127         switch (access) {
 128         case 6:
 129                 access = HW_BREAKPOINT_RW;
 130                 break;
 131         case 2:
 132                 access = HW_BREAKPOINT_WRITE;
 133                 break;
 134         case 0:
 135                 access = 0;
 136         }
 137
 138         return access;
 139 }
 140
 141 /*
 142  * There can be several possible malformed requests and we attempt to capture
 143  * all of them. We enumerate some of the rules
 144  * 1. We will not allow kernel symbols with ':' since it is used as a delimiter.
 145  *    i.e. multiple ':' symbols disallowed. Possible uses are of the form
 146  *    <module>:<ksym_name>:<op>.
 147  * 2. No delimiter symbol ':' in the input string
 148  * 3. Spurious operator symbols or symbols not in their respective positions
 149  * 4. <ksym_name>:--- i.e. clear breakpoint request when ksym_name not in file
 150  * 5. Kernel symbol not a part of /proc/kallsyms
 151  * 6. Duplicate requests
 152  */
 153 static int parse_ksym_trace_str(char *input_string, char **ksymname,
 154                                                         unsigned long *addr)
 155 {
 156         char *delimiter = ":";
 157         int ret;
 158
 159         ret = -EINVAL;
 160         *ksymname = strsep(&input_string, delimiter);
 161         *addr = kallsyms_lookup_name(*ksymname);
 162
 163         /* Check for malformed request: (2), (1) and (5) */
 164         if ((!input_string) ||
 165                 (strlen(input_string) != (KSYM_TRACER_OP_LEN + 1)) ||
 166                         (*addr == 0))
 167                 goto return_code;
 168         ret = ksym_trace_get_access_type(input_string);
 169
 170 return_code:
 171         return ret;
 172 }
 173
 174 int process_new_ksym_entry(char *ksymname, int op, unsigned long addr)
 175 {
 176         struct trace_ksym *entry;
 177         int ret;
 178
 179         if (ksym_filter_entry_count >= KSYM_TRACER_MAX) {
 180                 printk(KERN_ERR "ksym_tracer: Maximum limit:(%d) reached. No"
 181                 " new requests for tracing can be accepted now.\n",
 182                         KSYM_TRACER_MAX);
 183                 return -ENOSPC;
 184         }
 185
 186         entry = kzalloc(sizeof(struct trace_ksym), GFP_KERNEL);
 187         if (!entry)
 188                 return -ENOMEM;
 189
 190         entry->ksym_hbp = kzalloc(sizeof(struct hw_breakpoint), GFP_KERNEL);
 191         if (!entry->ksym_hbp) {
 192                 kfree(entry);
 193                 return -ENOMEM;
 194         }
 195
 196         entry->ksym_hbp->info.name = ksymname;
 197         entry->ksym_hbp->info.type = op;
 198         entry->ksym_addr = entry->ksym_hbp->info.address = addr;
 199 #ifdef CONFIG_X86
 200         entry->ksym_hbp->info.len = HW_BREAKPOINT_LEN_4;
 201 #endif
 202         entry->ksym_hbp->triggered = (void *)ksym_hbp_handler;
 203
 204         ret = register_kernel_hw_breakpoint(entry->ksym_hbp);
 205         if (ret < 0) {
 206                 printk(KERN_INFO "ksym_tracer request failed. Try again"
 207                                         " later!!\n");
 208                 kfree(entry->ksym_hbp);
 209                 kfree(entry);
 210                 return -EAGAIN;
 211         }
 212         hlist_add_head_rcu(&(entry->ksym_hlist), &ksym_filter_head);
 213         ksym_filter_entry_count++;
 214
 215         return 0;
 216 }
 217
 218 static ssize_t ksym_trace_filter_read(struct file *filp, char __user *ubuf,
 219                                                 size_t count, loff_t *ppos)
 220 {
 221         struct trace_ksym *entry;
 222         struct hlist_node *node;
 223         char buf[KSYM_FILTER_ENTRY_LEN * KSYM_TRACER_MAX];
 224         ssize_t ret, cnt = 0;
 225
 226         mutex_lock(&ksym_tracer_mutex);
 227
 228         hlist_for_each_entry(entry, node, &ksym_filter_head, ksym_hlist) {
 229                 cnt += snprintf(&buf[cnt], KSYM_FILTER_ENTRY_LEN - cnt, "%s:",
 230                                 entry->ksym_hbp->info.name);
 231                 if (entry->ksym_hbp->info.type == HW_BREAKPOINT_WRITE)
 232                         cnt += snprintf(&buf[cnt], KSYM_FILTER_ENTRY_LEN - cnt,
 233                                                                 "-w-\n");
 234                 else if (entry->ksym_hbp->info.type == HW_BREAKPOINT_RW)
 235                         cnt += snprintf(&buf[cnt], KSYM_FILTER_ENTRY_LEN - cnt,
 236                                                                 "rw-\n");
 237         }
 238         ret = simple_read_from_buffer(ubuf, count, ppos, buf, strlen(buf));
 239         mutex_unlock(&ksym_tracer_mutex);
 240
 241         return ret;
 242 }
 243
 244 static ssize_t ksym_trace_filter_write(struct file *file,
 245                                         const char __user *buffer,
 246                                                 size_t count, loff_t *ppos)
 247 {
 248         struct trace_ksym *entry;
 249         struct hlist_node *node;
 250         char *input_string, *ksymname = NULL;
 251         unsigned long ksym_addr = 0;
 252         int ret, op, changed = 0;
 253
 254         /* Ignore echo "" > ksym_trace_filter */
 255         if (count == 0)
 256                 return 0;
 257
 258         input_string = kzalloc(count, GFP_KERNEL);
 259         if (!input_string)
 260                 return -ENOMEM;
 261
 262         if (copy_from_user(input_string, buffer, count)) {
 263                 kfree(input_string);
 264                 return -EFAULT;
 265         }
 266
 267         ret = op = parse_ksym_trace_str(input_string, &ksymname, &ksym_addr);
 268         if (ret < 0) {
 269                 kfree(input_string);
 270                 return ret;
 271         }
 272
 273         mutex_lock(&ksym_tracer_mutex);
 274
 275         ret = -EINVAL;
 276         hlist_for_each_entry(entry, node, &ksym_filter_head, ksym_hlist) {
 277                 if (entry->ksym_addr == ksym_addr) {
 278                         /* Check for malformed request: (6) */
 279                         if (entry->ksym_hbp->info.type != op)
 280                                 changed = 1;
 281                         else
 282                                 goto err_ret;
 283                         break;
 284                 }
 285         }
 286         if (changed) {
 287                 unregister_kernel_hw_breakpoint(entry->ksym_hbp);
 288                 entry->ksym_hbp->info.type = op;
 289                 if (op > 0) {
 290                         ret = register_kernel_hw_breakpoint(entry->ksym_hbp);
 291                         if (ret == 0) {
 292                                 ret = count;
 293                                 goto unlock_ret_path;
 294                         }
 295                 }
 296                 ksym_filter_entry_count--;
 297                 hlist_del_rcu(&(entry->ksym_hlist));
 298                 synchronize_rcu();
 299                 kfree(entry->ksym_hbp);
 300                 kfree(entry);
 301                 ret = count;
 302                 goto err_ret;
 303         } else {
 304                 /* Check for malformed request: (4) */
 305                 if (op == 0)
 306                         goto err_ret;
 307                 ret = process_new_ksym_entry(ksymname, op, ksym_addr);
 308                 if (ret)
 309                         goto err_ret;
 310         }
 311         ret = count;
 312         goto unlock_ret_path;
 313
 314 err_ret:
 315         kfree(input_string);
 316
 317 unlock_ret_path:
 318         mutex_unlock(&ksym_tracer_mutex);
 319         return ret;
 320 }
 321
 322 static const struct file_operations ksym_tracing_fops = {
 323         .open           = tracing_open_generic,
 324         .read           = ksym_trace_filter_read,
 325         .write          = ksym_trace_filter_write,
 326 };
 327
 328 static void ksym_trace_reset(struct trace_array *tr)
 329 {
 330         struct trace_ksym *entry;
 331         struct hlist_node *node, *node1;
 332
 333         ksym_tracing_enabled = 0;
 334
 335         mutex_lock(&ksym_tracer_mutex);
 336         hlist_for_each_entry_safe(entry, node, node1, &ksym_filter_head,
 337                                                                 ksym_hlist) {
 338                 unregister_kernel_hw_breakpoint(entry->ksym_hbp);
 339                 ksym_filter_entry_count--;
 340                 hlist_del_rcu(&(entry->ksym_hlist));
 341                 synchronize_rcu();
 342                 /* Free the 'input_string' only if reset
 343                  * after startup self-test
 344                  */
 345 #ifdef CONFIG_FTRACE_SELFTEST
 346                 if (strncmp(entry->ksym_hbp->info.name, KSYM_SELFTEST_ENTRY,
 347                                         strlen(KSYM_SELFTEST_ENTRY)) != 0)
 348 #endif /* CONFIG_FTRACE_SELFTEST*/
 349                         kfree(entry->ksym_hbp->info.name);
 350                 kfree(entry->ksym_hbp);
 351                 kfree(entry);
 352         }
 353         mutex_unlock(&ksym_tracer_mutex);
 354 }
 355
 356 static int ksym_trace_init(struct trace_array *tr)
 357 {
 358         int cpu, ret = 0;
 359
 360         for_each_online_cpu(cpu)
 361                 tracing_reset(tr, cpu);
 362         ksym_tracing_enabled = 1;
 363         ksym_trace_array = tr;
 364
 365         return ret;
 366 }
 367
 368 static void ksym_trace_print_header(struct seq_file *m)
 369 {
 370
 371         seq_puts(m,
 372                  "#       TASK-PID      CPU#      Symbol         Type    "
 373                  "Function         \n");
 374         seq_puts(m,
 375                  "#          |           |          |              |         "
 376                  "|            \n");
 377 }
 378
 379 static enum print_line_t ksym_trace_output(struct trace_iterator *iter)
 380 {
 381         struct trace_entry *entry = iter->ent;
 382         struct trace_seq *s = &iter->seq;
 383         struct trace_ksym *field;
 384         char str[KSYM_SYMBOL_LEN];
 385         int ret;
 386
 387         if (entry->type != TRACE_KSYM)
 388                 return TRACE_TYPE_UNHANDLED;
 389
 390         trace_assign_type(field, entry);
 391
 392         ret = trace_seq_printf(s, "%-15s %-5d %-3d %-20s ", field->p_name,
 393                                 entry->pid, iter->cpu, field->ksym_name);
 394         if (!ret)
 395                 return TRACE_TYPE_PARTIAL_LINE;
 396
 397         switch (field->ksym_hbp->info.type) {
 398         case HW_BREAKPOINT_WRITE:
 399                 ret = trace_seq_printf(s, " W  ");
 400                 break;
 401         case HW_BREAKPOINT_RW:
 402                 ret = trace_seq_printf(s, " RW ");
 403                 break;
 404         default:
 405                 return TRACE_TYPE_PARTIAL_LINE;
 406         }
 407
 408         if (!ret)
 409                 return TRACE_TYPE_PARTIAL_LINE;
 410
 411         sprint_symbol(str, field->ip);
 412         ret = trace_seq_printf(s, "%-20s\n", str);
 413         if (!ret)
 414                 return TRACE_TYPE_PARTIAL_LINE;
 415
 416         return TRACE_TYPE_HANDLED;
 417 }
 418
 419 struct tracer ksym_tracer __read_mostly =
 420 {
 421         .name           = "ksym_tracer",
 422         .init           = ksym_trace_init,
 423         .reset          = ksym_trace_reset,
 424 #ifdef CONFIG_FTRACE_SELFTEST
 425         .selftest       = trace_selftest_startup_ksym,
 426 #endif
 427         .print_header   = ksym_trace_print_header,
 428         .print_line     = ksym_trace_output
 429 };
 430
 431 __init static int init_ksym_trace(void)
 432 {
 433         struct dentry *d_tracer;
 434         struct dentry *entry;
 435
 436         d_tracer = tracing_init_dentry();
 437         ksym_filter_entry_count = 0;
 438
 439         entry = debugfs_create_file("ksym_trace_filter", 0644, d_tracer,
 440                                     NULL, &ksym_tracing_fops);
 441         if (!entry)
 442                 pr_warning("Could not create debugfs "
 443                            "'ksym_trace_filter' file\n");
 444
 445         return register_tracer(&ksym_tracer);
 446 }
 447 device_initcall(init_ksym_trace);
 448
 449
 450 #ifdef CONFIG_PROFILE_KSYM_TRACER
 451 static int ksym_tracer_stat_headers(struct seq_file *m)
 452 {
 453         seq_printf(m, "   Access type    ");
 454         seq_printf(m, "            Symbol                     Counter     \n");
 455         return 0;
 456 }
 457
 458 static int ksym_tracer_stat_show(struct seq_file *m, void *v)
 459 {
 460         struct hlist_node *stat = v;
 461         struct trace_ksym *entry;
 462         int access_type = 0;
 463         char fn_name[KSYM_NAME_LEN];
 464
 465         entry = hlist_entry(stat, struct trace_ksym, ksym_hlist);
 466
 467         if (entry->ksym_hbp)
 468                 access_type = entry->ksym_hbp->info.type;
 469
 470         switch (access_type) {
 471         case HW_BREAKPOINT_WRITE:
 472                 seq_printf(m, "     W     ");
 473                 break;
 474         case HW_BREAKPOINT_RW:
 475                 seq_printf(m, "     RW    ");
 476                 break;
 477         default:
 478                 seq_printf(m, "     NA    ");
 479         }
 480
 481         if (lookup_symbol_name(entry->ksym_addr, fn_name) >= 0)
 482                 seq_printf(m, "               %s                 ", fn_name);
 483         else
 484                 seq_printf(m, "               <NA>                ");
 485
 486         seq_printf(m, "%15lu\n", entry->counter);
 487         return 0;
 488 }
 489
 490 static void *ksym_tracer_stat_start(struct tracer_stat *trace)
 491 {
 492         return &(ksym_filter_head.first);
 493 }
 494
 495 static void *
 496 ksym_tracer_stat_next(void *v, int idx)
 497 {
 498         struct hlist_node *stat = v;
 499
 500         return stat->next;
 501 }
 502
 503 static struct tracer_stat ksym_tracer_stats = {
 504         .name = "ksym_tracer",
 505         .stat_start = ksym_tracer_stat_start,
 506         .stat_next = ksym_tracer_stat_next,
 507         .stat_headers = ksym_tracer_stat_headers,
 508         .stat_show = ksym_tracer_stat_show
 509 };
 510
 511 __init static int ksym_tracer_stat_init(void)
 512 {
 513         int ret;
 514
 515         ret = register_stat_tracer(&ksym_tracer_stats);
 516         if (ret) {
 517                 printk(KERN_WARNING "Warning: could not register "
 518                                     "ksym tracer stats\n");
 519                 return 1;
 520         }
 521
 522         return 0;
 523 }
 524 fs_initcall(ksym_tracer_stat_init);
 525 #endif /* CONFIG_PROFILE_KSYM_TRACER */