kernel/debug/kdb/kdb_support.c

   1 /*
   2  * Kernel Debugger Architecture Independent Support Functions
   3  *
   4  * This file is subject to the terms and conditions of the GNU General Public
   5  * License.  See the file "COPYING" in the main directory of this archive
   6  * for more details.
   7  *
   8  * Copyright (c) 1999-2004 Silicon Graphics, Inc.  All Rights Reserved.
   9  * Copyright (c) 2009 Wind River Systems, Inc.  All Rights Reserved.
  10  * 03/02/13    added new 2.5 kallsyms <xavier.bru@bull.net>
  11  */
  12
  13 #include <linux/types.h>
  14 #include <linux/sched.h>
  15 #include <linux/mm.h>
  16 #include <linux/kallsyms.h>
  17 #include <linux/stddef.h>
  18 #include <linux/vmalloc.h>
  19 #include <linux/ptrace.h>
  20 #include <linux/module.h>
  21 #include <linux/highmem.h>
  22 #include <linux/hardirq.h>
  23 #include <linux/delay.h>
  24 #include <linux/uaccess.h>
  25 #include <linux/kdb.h>
  26 #include <linux/slab.h>
  27 #include "kdb_private.h"
  28
  29 /*
  30  * kdbgetsymval - Return the address of the given symbol.
  31  *
  32  * Parameters:
  33  *      symname Character string containing symbol name
  34  *      symtab  Structure to receive results
  35  * Returns:
  36  *      0       Symbol not found, symtab zero filled
  37  *      1       Symbol mapped to module/symbol/section, data in symtab
  38  */
  39 int kdbgetsymval(const char *symname, kdb_symtab_t *symtab)
  40 {
  41         kdb_dbg_printf(AR, "symname=%s, symtab=%px\n", symname, symtab);
  42         memset(symtab, 0, sizeof(*symtab));
  43         symtab->sym_start = kallsyms_lookup_name(symname);
  44         if (symtab->sym_start) {
  45                 kdb_dbg_printf(AR, "returns 1, symtab->sym_start=0x%lx\n",
  46                                symtab->sym_start);
  47                 return 1;
  48         }
  49         kdb_dbg_printf(AR, "returns 0\n");
  50         return 0;
  51 }
  52 EXPORT_SYMBOL(kdbgetsymval);
  53
  54 /**
  55  * kdbnearsym() - Return the name of the symbol with the nearest address
  56  *                less than @addr.
  57  * @addr: Address to check for near symbol
  58  * @symtab: Structure to receive results
  59  *
  60  * WARNING: This function may return a pointer to a single statically
  61  * allocated buffer (namebuf). kdb's unusual calling context (single
  62  * threaded, all other CPUs halted) provides us sufficient locking for
  63  * this to be safe. The only constraint imposed by the static buffer is
  64  * that the caller must consume any previous reply prior to another call
  65  * to lookup a new symbol.
  66  *
  67  * Note that, strictly speaking, some architectures may re-enter the kdb
  68  * trap if the system turns out to be very badly damaged and this breaks
  69  * the single-threaded assumption above. In these circumstances successful
  70  * continuation and exit from the inner trap is unlikely to work and any
  71  * user attempting this receives a prominent warning before being allowed
  72  * to progress. In these circumstances we remain memory safe because
  73  * namebuf[KSYM_NAME_LEN-1] will never change from '\0' although we do
  74  * tolerate the possibility of garbled symbol display from the outer kdb
  75  * trap.
  76  *
  77  * Return:
  78  * * 0 - No sections contain this address, symtab zero filled
  79  * * 1 - Address mapped to module/symbol/section, data in symtab
  80  */
  81 int kdbnearsym(unsigned long addr, kdb_symtab_t *symtab)
  82 {
  83         int ret = 0;
  84         unsigned long symbolsize = 0;
  85         unsigned long offset = 0;
  86         static char namebuf[KSYM_NAME_LEN];
  87
  88         kdb_dbg_printf(AR, "addr=0x%lx, symtab=%px\n", addr, symtab);
  89         memset(symtab, 0, sizeof(*symtab));
  90
  91         if (addr < 4096)
  92                 goto out;
  93
  94         symtab->sym_name = kallsyms_lookup(addr, &symbolsize , &offset,
  95                                 (char **)(&symtab->mod_name), namebuf);
  96         if (offset > 8*1024*1024) {
  97                 symtab->sym_name = NULL;
  98                 addr = offset = symbolsize = 0;
  99         }
 100         symtab->sym_start = addr - offset;
 101         symtab->sym_end = symtab->sym_start + symbolsize;
 102         ret = symtab->sym_name != NULL && *(symtab->sym_name) != '\0';
 103
 104         if (symtab->mod_name == NULL)
 105                 symtab->mod_name = "kernel";
 106         kdb_dbg_printf(AR, "returns %d symtab->sym_start=0x%lx, symtab->mod_name=%px, symtab->sym_name=%px (%s)\n",
 107                        ret, symtab->sym_start, symtab->mod_name, symtab->sym_name, symtab->sym_name);
 108 out:
 109         return ret;
 110 }
 111
 112 static char ks_namebuf[KSYM_NAME_LEN+1], ks_namebuf_prev[KSYM_NAME_LEN+1];
 113
 114 /*
 115  * kallsyms_symbol_complete
 116  *
 117  * Parameters:
 118  *      prefix_name     prefix of a symbol name to lookup
 119  *      max_len         maximum length that can be returned
 120  * Returns:
 121  *      Number of symbols which match the given prefix.
 122  * Notes:
 123  *      prefix_name is changed to contain the longest unique prefix that
 124  *      starts with this prefix (tab completion).
 125  */
 126 int kallsyms_symbol_complete(char *prefix_name, int max_len)
 127 {
 128         loff_t pos = 0;
 129         int prefix_len = strlen(prefix_name), prev_len = 0;
 130         int i, number = 0;
 131         const char *name;
 132
 133         while ((name = kdb_walk_kallsyms(&pos))) {
 134                 if (strncmp(name, prefix_name, prefix_len) == 0) {
 135                         strscpy(ks_namebuf, name, sizeof(ks_namebuf));
 136                         /* Work out the longest name that matches the prefix */
 137                         if (++number == 1) {
 138                                 prev_len = min_t(int, max_len-1,
 139                                                  strlen(ks_namebuf));
 140                                 memcpy(ks_namebuf_prev, ks_namebuf, prev_len);
 141                                 ks_namebuf_prev[prev_len] = '\0';
 142                                 continue;
 143                         }
 144                         for (i = 0; i < prev_len; i++) {
 145                                 if (ks_namebuf[i] != ks_namebuf_prev[i]) {
 146                                         prev_len = i;
 147                                         ks_namebuf_prev[i] = '\0';
 148                                         break;
 149                                 }
 150                         }
 151                 }
 152         }
 153         if (prev_len > prefix_len)
 154                 memcpy(prefix_name, ks_namebuf_prev, prev_len+1);
 155         return number;
 156 }
 157
 158 /*
 159  * kallsyms_symbol_next
 160  *
 161  * Parameters:
 162  *      prefix_name     prefix of a symbol name to lookup
 163  *      flag    0 means search from the head, 1 means continue search.
 164  *      buf_size        maximum length that can be written to prefix_name
 165  *                      buffer
 166  * Returns:
 167  *      1 if a symbol matches the given prefix.
 168  *      0 if no string found
 169  */
 170 int kallsyms_symbol_next(char *prefix_name, int flag, int buf_size)
 171 {
 172         int prefix_len = strlen(prefix_name);
 173         static loff_t pos;
 174         const char *name;
 175
 176         if (!flag)
 177                 pos = 0;
 178
 179         while ((name = kdb_walk_kallsyms(&pos))) {
 180                 if (!strncmp(name, prefix_name, prefix_len))
 181                         return strscpy(prefix_name, name, buf_size);
 182         }
 183         return 0;
 184 }
 185
 186 /*
 187  * kdb_symbol_print - Standard method for printing a symbol name and offset.
 188  * Inputs:
 189  *      addr    Address to be printed.
 190  *      symtab  Address of symbol data, if NULL this routine does its
 191  *              own lookup.
 192  *      punc    Punctuation for string, bit field.
 193  * Remarks:
 194  *      The string and its punctuation is only printed if the address
 195  *      is inside the kernel, except that the value is always printed
 196  *      when requested.
 197  */
 198 void kdb_symbol_print(unsigned long addr, const kdb_symtab_t *symtab_p,
 199                       unsigned int punc)
 200 {
 201         kdb_symtab_t symtab, *symtab_p2;
 202         if (symtab_p) {
 203                 symtab_p2 = (kdb_symtab_t *)symtab_p;
 204         } else {
 205                 symtab_p2 = &symtab;
 206                 kdbnearsym(addr, symtab_p2);
 207         }
 208         if (!(symtab_p2->sym_name || (punc & KDB_SP_VALUE)))
 209                 return;
 210         if (punc & KDB_SP_SPACEB)
 211                 kdb_printf(" ");
 212         if (punc & KDB_SP_VALUE)
 213                 kdb_printf(kdb_machreg_fmt0, addr);
 214         if (symtab_p2->sym_name) {
 215                 if (punc & KDB_SP_VALUE)
 216                         kdb_printf(" ");
 217                 if (punc & KDB_SP_PAREN)
 218                         kdb_printf("(");
 219                 if (strcmp(symtab_p2->mod_name, "kernel"))
 220                         kdb_printf("[%s]", symtab_p2->mod_name);
 221                 kdb_printf("%s", symtab_p2->sym_name);
 222                 if (addr != symtab_p2->sym_start)
 223                         kdb_printf("+0x%lx", addr - symtab_p2->sym_start);
 224                 if (punc & KDB_SP_SYMSIZE)
 225                         kdb_printf("/0x%lx",
 226                                    symtab_p2->sym_end - symtab_p2->sym_start);
 227                 if (punc & KDB_SP_PAREN)
 228                         kdb_printf(")");
 229         }
 230         if (punc & KDB_SP_SPACEA)
 231                 kdb_printf(" ");
 232         if (punc & KDB_SP_NEWLINE)
 233                 kdb_printf("\n");
 234 }
 235
 236 /*
 237  * kdb_strdup - kdb equivalent of strdup, for disasm code.
 238  * Inputs:
 239  *      str     The string to duplicate.
 240  *      type    Flags to kmalloc for the new string.
 241  * Returns:
 242  *      Address of the new string, NULL if storage could not be allocated.
 243  * Remarks:
 244  *      This is not in lib/string.c because it uses kmalloc which is not
 245  *      available when string.o is used in boot loaders.
 246  */
 247 char *kdb_strdup(const char *str, gfp_t type)
 248 {
 249         int n = strlen(str)+1;
 250         char *s = kmalloc(n, type);
 251         if (!s)
 252                 return NULL;
 253         return strcpy(s, str);
 254 }
 255
 256 /*
 257  * kdb_getarea_size - Read an area of data.  The kdb equivalent of
 258  *      copy_from_user, with kdb messages for invalid addresses.
 259  * Inputs:
 260  *      res     Pointer to the area to receive the result.
 261  *      addr    Address of the area to copy.
 262  *      size    Size of the area.
 263  * Returns:
 264  *      0 for success, < 0 for error.
 265  */
 266 int kdb_getarea_size(void *res, unsigned long addr, size_t size)
 267 {
 268         int ret = copy_from_kernel_nofault((char *)res, (char *)addr, size);
 269         if (ret) {
 270                 if (!KDB_STATE(SUPPRESS)) {
 271                         kdb_func_printf("Bad address 0x%lx\n", addr);
 272                         KDB_STATE_SET(SUPPRESS);
 273                 }
 274                 ret = KDB_BADADDR;
 275         } else {
 276                 KDB_STATE_CLEAR(SUPPRESS);
 277         }
 278         return ret;
 279 }
 280
 281 /*
 282  * kdb_putarea_size - Write an area of data.  The kdb equivalent of
 283  *      copy_to_user, with kdb messages for invalid addresses.
 284  * Inputs:
 285  *      addr    Address of the area to write to.
 286  *      res     Pointer to the area holding the data.
 287  *      size    Size of the area.
 288  * Returns:
 289  *      0 for success, < 0 for error.
 290  */
 291 int kdb_putarea_size(unsigned long addr, void *res, size_t size)
 292 {
 293         int ret = copy_from_kernel_nofault((char *)addr, (char *)res, size);
 294         if (ret) {
 295                 if (!KDB_STATE(SUPPRESS)) {
 296                         kdb_func_printf("Bad address 0x%lx\n", addr);
 297                         KDB_STATE_SET(SUPPRESS);
 298                 }
 299                 ret = KDB_BADADDR;
 300         } else {
 301                 KDB_STATE_CLEAR(SUPPRESS);
 302         }
 303         return ret;
 304 }
 305
 306 /*
 307  * kdb_getphys - Read data from a physical address. Validate the
 308  *      address is in range, use kmap_atomic() to get data
 309  *      similar to kdb_getarea() - but for phys addresses
 310  * Inputs:
 311  *      res     Pointer to the word to receive the result
 312  *      addr    Physical address of the area to copy
 313  *      size    Size of the area
 314  * Returns:
 315  *      0 for success, < 0 for error.
 316  */
 317 static int kdb_getphys(void *res, unsigned long addr, size_t size)
 318 {
 319         unsigned long pfn;
 320         void *vaddr;
 321         struct page *page;
 322
 323         pfn = (addr >> PAGE_SHIFT);
 324         if (!pfn_valid(pfn))
 325                 return 1;
 326         page = pfn_to_page(pfn);
 327         vaddr = kmap_atomic(page);
 328         memcpy(res, vaddr + (addr & (PAGE_SIZE - 1)), size);
 329         kunmap_atomic(vaddr);
 330
 331         return 0;
 332 }
 333
 334 /*
 335  * kdb_getphysword
 336  * Inputs:
 337  *      word    Pointer to the word to receive the result.
 338  *      addr    Address of the area to copy.
 339  *      size    Size of the area.
 340  * Returns:
 341  *      0 for success, < 0 for error.
 342  */
 343 int kdb_getphysword(unsigned long *word, unsigned long addr, size_t size)
 344 {
 345         int diag;
 346         __u8  w1;
 347         __u16 w2;
 348         __u32 w4;
 349         __u64 w8;
 350         *word = 0;      /* Default value if addr or size is invalid */
 351
 352         switch (size) {
 353         case 1:
 354                 diag = kdb_getphys(&w1, addr, sizeof(w1));
 355                 if (!diag)
 356                         *word = w1;
 357                 break;
 358         case 2:
 359                 diag = kdb_getphys(&w2, addr, sizeof(w2));
 360                 if (!diag)
 361                         *word = w2;
 362                 break;
 363         case 4:
 364                 diag = kdb_getphys(&w4, addr, sizeof(w4));
 365                 if (!diag)
 366                         *word = w4;
 367                 break;
 368         case 8:
 369                 if (size <= sizeof(*word)) {
 370                         diag = kdb_getphys(&w8, addr, sizeof(w8));
 371                         if (!diag)
 372                                 *word = w8;
 373                         break;
 374                 }
 375                 fallthrough;
 376         default:
 377                 diag = KDB_BADWIDTH;
 378                 kdb_func_printf("bad width %zu\n", size);
 379         }
 380         return diag;
 381 }
 382
 383 /*
 384  * kdb_getword - Read a binary value.  Unlike kdb_getarea, this treats
 385  *      data as numbers.
 386  * Inputs:
 387  *      word    Pointer to the word to receive the result.
 388  *      addr    Address of the area to copy.
 389  *      size    Size of the area.
 390  * Returns:
 391  *      0 for success, < 0 for error.
 392  */
 393 int kdb_getword(unsigned long *word, unsigned long addr, size_t size)
 394 {
 395         int diag;
 396         __u8  w1;
 397         __u16 w2;
 398         __u32 w4;
 399         __u64 w8;
 400         *word = 0;      /* Default value if addr or size is invalid */
 401         switch (size) {
 402         case 1:
 403                 diag = kdb_getarea(w1, addr);
 404                 if (!diag)
 405                         *word = w1;
 406                 break;
 407         case 2:
 408                 diag = kdb_getarea(w2, addr);
 409                 if (!diag)
 410                         *word = w2;
 411                 break;
 412         case 4:
 413                 diag = kdb_getarea(w4, addr);
 414                 if (!diag)
 415                         *word = w4;
 416                 break;
 417         case 8:
 418                 if (size <= sizeof(*word)) {
 419                         diag = kdb_getarea(w8, addr);
 420                         if (!diag)
 421                                 *word = w8;
 422                         break;
 423                 }
 424                 fallthrough;
 425         default:
 426                 diag = KDB_BADWIDTH;
 427                 kdb_func_printf("bad width %zu\n", size);
 428         }
 429         return diag;
 430 }
 431
 432 /*
 433  * kdb_putword - Write a binary value.  Unlike kdb_putarea, this
 434  *      treats data as numbers.
 435  * Inputs:
 436  *      addr    Address of the area to write to..
 437  *      word    The value to set.
 438  *      size    Size of the area.
 439  * Returns:
 440  *      0 for success, < 0 for error.
 441  */
 442 int kdb_putword(unsigned long addr, unsigned long word, size_t size)
 443 {
 444         int diag;
 445         __u8  w1;
 446         __u16 w2;
 447         __u32 w4;
 448         __u64 w8;
 449         switch (size) {
 450         case 1:
 451                 w1 = word;
 452                 diag = kdb_putarea(addr, w1);
 453                 break;
 454         case 2:
 455                 w2 = word;
 456                 diag = kdb_putarea(addr, w2);
 457                 break;
 458         case 4:
 459                 w4 = word;
 460                 diag = kdb_putarea(addr, w4);
 461                 break;
 462         case 8:
 463                 if (size <= sizeof(word)) {
 464                         w8 = word;
 465                         diag = kdb_putarea(addr, w8);
 466                         break;
 467                 }
 468                 fallthrough;
 469         default:
 470                 diag = KDB_BADWIDTH;
 471                 kdb_func_printf("bad width %zu\n", size);
 472         }
 473         return diag;
 474 }
 475
 476 /*
 477  * kdb_task_state_string - Convert a string containing any of the
 478  *      letters DRSTCZEUIMA to a mask for the process state field and
 479  *      return the value.  If no argument is supplied, return the mask
 480  *      that corresponds to environment variable PS, DRSTCZEU by
 481  *      default.
 482  * Inputs:
 483  *      s       String to convert
 484  * Returns:
 485  *      Mask for process state.
 486  * Notes:
 487  *      The mask folds data from several sources into a single long value, so
 488  *      be careful not to overlap the bits.  TASK_* bits are in the LSB,
 489  *      special cases like UNRUNNABLE are in the MSB.  As of 2.6.10-rc1 there
 490  *      is no overlap between TASK_* and EXIT_* but that may not always be
 491  *      true, so EXIT_* bits are shifted left 16 bits before being stored in
 492  *      the mask.
 493  */
 494
 495 /* unrunnable is < 0 */
 496 #define UNRUNNABLE      (1UL << (8*sizeof(unsigned long) - 1))
 497 #define RUNNING         (1UL << (8*sizeof(unsigned long) - 2))
 498 #define IDLE            (1UL << (8*sizeof(unsigned long) - 3))
 499 #define DAEMON          (1UL << (8*sizeof(unsigned long) - 4))
 500
 501 unsigned long kdb_task_state_string(const char *s)
 502 {
 503         long res = 0;
 504         if (!s) {
 505                 s = kdbgetenv("PS");
 506                 if (!s)
 507                         s = "DRSTCZEU"; /* default value for ps */
 508         }
 509         while (*s) {
 510                 switch (*s) {
 511                 case 'D':
 512                         res |= TASK_UNINTERRUPTIBLE;
 513                         break;
 514                 case 'R':
 515                         res |= RUNNING;
 516                         break;
 517                 case 'S':
 518                         res |= TASK_INTERRUPTIBLE;
 519                         break;
 520                 case 'T':
 521                         res |= TASK_STOPPED;
 522                         break;
 523                 case 'C':
 524                         res |= TASK_TRACED;
 525                         break;
 526                 case 'Z':
 527                         res |= EXIT_ZOMBIE << 16;
 528                         break;
 529                 case 'E':
 530                         res |= EXIT_DEAD << 16;
 531                         break;
 532                 case 'U':
 533                         res |= UNRUNNABLE;
 534                         break;
 535                 case 'I':
 536                         res |= IDLE;
 537                         break;
 538                 case 'M':
 539                         res |= DAEMON;
 540                         break;
 541                 case 'A':
 542                         res = ~0UL;
 543                         break;
 544                 default:
 545                           kdb_func_printf("unknown flag '%c' ignored\n", *s);
 546                           break;
 547                 }
 548                 ++s;
 549         }
 550         return res;
 551 }
 552
 553 /*
 554  * kdb_task_state_char - Return the character that represents the task state.
 555  * Inputs:
 556  *      p       struct task for the process
 557  * Returns:
 558  *      One character to represent the task state.
 559  */
 560 char kdb_task_state_char (const struct task_struct *p)
 561 {
 562         unsigned int p_state;
 563         unsigned long tmp;
 564         char state;
 565         int cpu;
 566
 567         if (!p ||
 568             copy_from_kernel_nofault(&tmp, (char *)p, sizeof(unsigned long)))
 569                 return 'E';
 570
 571         cpu = kdb_process_cpu(p);
 572         p_state = READ_ONCE(p->__state);
 573         state = (p_state == 0) ? 'R' :
 574                 (p_state < 0) ? 'U' :
 575                 (p_state & TASK_UNINTERRUPTIBLE) ? 'D' :
 576                 (p_state & TASK_STOPPED) ? 'T' :
 577                 (p_state & TASK_TRACED) ? 'C' :
 578                 (p->exit_state & EXIT_ZOMBIE) ? 'Z' :
 579                 (p->exit_state & EXIT_DEAD) ? 'E' :
 580                 (p_state & TASK_INTERRUPTIBLE) ? 'S' : '?';
 581         if (is_idle_task(p)) {
 582                 /* Idle task.  Is it really idle, apart from the kdb
 583                  * interrupt? */
 584                 if (!kdb_task_has_cpu(p) || kgdb_info[cpu].irq_depth == 1) {
 585                         if (cpu != kdb_initial_cpu)
 586                                 state = 'I';    /* idle task */
 587                 }
 588         } else if (!p->mm && state == 'S') {
 589                 state = 'M';    /* sleeping system daemon */
 590         }
 591         return state;
 592 }
 593
 594 /*
 595  * kdb_task_state - Return true if a process has the desired state
 596  *      given by the mask.
 597  * Inputs:
 598  *      p       struct task for the process
 599  *      mask    mask from kdb_task_state_string to select processes
 600  * Returns:
 601  *      True if the process matches at least one criteria defined by the mask.
 602  */
 603 unsigned long kdb_task_state(const struct task_struct *p, unsigned long mask)
 604 {
 605         char state[] = { kdb_task_state_char(p), '\0' };
 606         return (mask & kdb_task_state_string(state)) != 0;
 607 }
 608
 609 /* Maintain a small stack of kdb_flags to allow recursion without disturbing
 610  * the global kdb state.
 611  */
 612
 613 static int kdb_flags_stack[4], kdb_flags_index;
 614
 615 void kdb_save_flags(void)
 616 {
 617         BUG_ON(kdb_flags_index >= ARRAY_SIZE(kdb_flags_stack));
 618         kdb_flags_stack[kdb_flags_index++] = kdb_flags;
 619 }
 620
 621 void kdb_restore_flags(void)
 622 {
 623         BUG_ON(kdb_flags_index <= 0);
 624         kdb_flags = kdb_flags_stack[--kdb_flags_index];
 625 }