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