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