gdb/break-catch-syscall.c

   1 /* Everything about syscall catchpoints, for GDB.
   2
   3    Copyright (C) 2009-2017 Free Software Foundation, Inc.
   4
   5    This file is part of GDB.
   6
   7    This program is free software; you can redistribute it and/or modify
   8    it under the terms of the GNU General Public License as published by
   9    the Free Software Foundation; either version 3 of the License, or
  10    (at your option) any later version.
  11
  12    This program is distributed in the hope that it will be useful,
  13    but WITHOUT ANY WARRANTY; without even the implied warranty of
  14    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  15    GNU General Public License for more details.
  16
  17    You should have received a copy of the GNU General Public License
  18    along with this program.  If not, see <http://www.gnu.org/licenses/>.  */
  19
  20 #include "defs.h"
  21 #include <ctype.h>
  22 #include "breakpoint.h"
  23 #include "gdbcmd.h"
  24 #include "inferior.h"
  25 #include "cli/cli-utils.h"
  26 #include "annotate.h"
  27 #include "mi/mi-common.h"
  28 #include "valprint.h"
  29 #include "arch-utils.h"
  30 #include "observer.h"
  31 #include "xml-syscall.h"
  32
  33 /* An instance of this type is used to represent a syscall catchpoint.
  34    A breakpoint is really of this type iff its ops pointer points to
  35    CATCH_SYSCALL_BREAKPOINT_OPS.  */
  36
  37 struct syscall_catchpoint : public breakpoint
  38 {
  39   /* Syscall numbers used for the 'catch syscall' feature.  If no
  40      syscall has been specified for filtering, it is empty.
  41      Otherwise, it holds a list of all syscalls to be caught.  */
  42   std::vector<int> syscalls_to_be_caught;
  43 };
  44
  45 static const struct inferior_data *catch_syscall_inferior_data = NULL;
  46
  47 struct catch_syscall_inferior_data
  48 {
  49   /* We keep a count of the number of times the user has requested a
  50      particular syscall to be tracked, and pass this information to the
  51      target.  This lets capable targets implement filtering directly.  */
  52
  53   /* Number of times that "any" syscall is requested.  */
  54   int any_syscall_count;
  55
  56   /* Count of each system call.  */
  57   std::vector<int> syscalls_counts;
  58
  59   /* This counts all syscall catch requests, so we can readily determine
  60      if any catching is necessary.  */
  61   int total_syscalls_count;
  62 };
  63
  64 static struct catch_syscall_inferior_data *
  65 get_catch_syscall_inferior_data (struct inferior *inf)
  66 {
  67   struct catch_syscall_inferior_data *inf_data;
  68
  69   inf_data = ((struct catch_syscall_inferior_data *)
  70               inferior_data (inf, catch_syscall_inferior_data));
  71   if (inf_data == NULL)
  72     {
  73       inf_data = new struct catch_syscall_inferior_data ();
  74       set_inferior_data (inf, catch_syscall_inferior_data, inf_data);
  75     }
  76
  77   return inf_data;
  78 }
  79
  80 static void
  81 catch_syscall_inferior_data_cleanup (struct inferior *inf, void *arg)
  82 {
  83   struct catch_syscall_inferior_data *inf_data
  84     = (struct catch_syscall_inferior_data *) arg;
  85   delete inf_data;
  86 }
  87
  88
  89 /* Implement the "insert" breakpoint_ops method for syscall
  90    catchpoints.  */
  91
  92 static int
  93 insert_catch_syscall (struct bp_location *bl)
  94 {
  95   struct syscall_catchpoint *c = (struct syscall_catchpoint *) bl->owner;
  96   struct inferior *inf = current_inferior ();
  97   struct catch_syscall_inferior_data *inf_data
  98     = get_catch_syscall_inferior_data (inf);
  99
 100   ++inf_data->total_syscalls_count;
 101   if (c->syscalls_to_be_caught.empty ())
 102     ++inf_data->any_syscall_count;
 103   else
 104     {
 105       for (int iter : c->syscalls_to_be_caught)
 106         {
 107           int elem;
 108
 109           if (iter >= inf_data->syscalls_counts.size ())
 110             inf_data->syscalls_counts.resize (iter + 1);
 111           ++inf_data->syscalls_counts[iter];
 112         }
 113     }
 114
 115   return target_set_syscall_catchpoint (ptid_get_pid (inferior_ptid),
 116                                         inf_data->total_syscalls_count != 0,
 117                                         inf_data->any_syscall_count,
 118                                         inf_data->syscalls_counts.size (),
 119                                         inf_data->syscalls_counts.data ());
 120 }
 121
 122 /* Implement the "remove" breakpoint_ops method for syscall
 123    catchpoints.  */
 124
 125 static int
 126 remove_catch_syscall (struct bp_location *bl, enum remove_bp_reason reason)
 127 {
 128   struct syscall_catchpoint *c = (struct syscall_catchpoint *) bl->owner;
 129   struct inferior *inf = current_inferior ();
 130   struct catch_syscall_inferior_data *inf_data
 131     = get_catch_syscall_inferior_data (inf);
 132
 133   --inf_data->total_syscalls_count;
 134   if (c->syscalls_to_be_caught.empty ())
 135     --inf_data->any_syscall_count;
 136   else
 137     {
 138       for (int iter : c->syscalls_to_be_caught)
 139         {
 140           int elem;
 141           if (iter >= inf_data->syscalls_counts.size ())
 142             /* Shouldn't happen.  */
 143             continue;
 144           --inf_data->syscalls_counts[iter];
 145         }
 146     }
 147
 148   return target_set_syscall_catchpoint (ptid_get_pid (inferior_ptid),
 149                                         inf_data->total_syscalls_count != 0,
 150                                         inf_data->any_syscall_count,
 151                                         inf_data->syscalls_counts.size (),
 152                                         inf_data->syscalls_counts.data ());
 153 }
 154
 155 /* Implement the "breakpoint_hit" breakpoint_ops method for syscall
 156    catchpoints.  */
 157
 158 static int
 159 breakpoint_hit_catch_syscall (const struct bp_location *bl,
 160                               struct address_space *aspace, CORE_ADDR bp_addr,
 161                               const struct target_waitstatus *ws)
 162 {
 163   /* We must check if we are catching specific syscalls in this
 164      breakpoint.  If we are, then we must guarantee that the called
 165      syscall is the same syscall we are catching.  */
 166   int syscall_number = 0;
 167   const struct syscall_catchpoint *c
 168     = (const struct syscall_catchpoint *) bl->owner;
 169
 170   if (ws->kind != TARGET_WAITKIND_SYSCALL_ENTRY
 171       && ws->kind != TARGET_WAITKIND_SYSCALL_RETURN)
 172     return 0;
 173
 174   syscall_number = ws->value.syscall_number;
 175
 176   /* Now, checking if the syscall is the same.  */
 177   if (!c->syscalls_to_be_caught.empty ())
 178     {
 179       for (int iter : c->syscalls_to_be_caught)
 180         if (syscall_number == iter)
 181           return 1;
 182
 183       return 0;
 184     }
 185
 186   return 1;
 187 }
 188
 189 /* Implement the "print_it" breakpoint_ops method for syscall
 190    catchpoints.  */
 191
 192 static enum print_stop_action
 193 print_it_catch_syscall (bpstat bs)
 194 {
 195   struct ui_out *uiout = current_uiout;
 196   struct breakpoint *b = bs->breakpoint_at;
 197   /* These are needed because we want to know in which state a
 198      syscall is.  It can be in the TARGET_WAITKIND_SYSCALL_ENTRY
 199      or TARGET_WAITKIND_SYSCALL_RETURN, and depending on it we
 200      must print "called syscall" or "returned from syscall".  */
 201   ptid_t ptid;
 202   struct target_waitstatus last;
 203   struct syscall s;
 204   struct gdbarch *gdbarch = bs->bp_location_at->gdbarch;
 205
 206   get_last_target_status (&ptid, &last);
 207
 208   get_syscall_by_number (gdbarch, last.value.syscall_number, &s);
 209
 210   annotate_catchpoint (b->number);
 211   maybe_print_thread_hit_breakpoint (uiout);
 212
 213   if (b->disposition == disp_del)
 214     uiout->text ("Temporary catchpoint ");
 215   else
 216     uiout->text ("Catchpoint ");
 217   if (uiout->is_mi_like_p ())
 218     {
 219       uiout->field_string ("reason",
 220                            async_reason_lookup (last.kind == TARGET_WAITKIND_SYSCALL_ENTRY
 221                                                 ? EXEC_ASYNC_SYSCALL_ENTRY
 222                                                 : EXEC_ASYNC_SYSCALL_RETURN));
 223       uiout->field_string ("disp", bpdisp_text (b->disposition));
 224     }
 225   uiout->field_int ("bkptno", b->number);
 226
 227   if (last.kind == TARGET_WAITKIND_SYSCALL_ENTRY)
 228     uiout->text (" (call to syscall ");
 229   else
 230     uiout->text (" (returned from syscall ");
 231
 232   if (s.name == NULL || uiout->is_mi_like_p ())
 233     uiout->field_int ("syscall-number", last.value.syscall_number);
 234   if (s.name != NULL)
 235     uiout->field_string ("syscall-name", s.name);
 236
 237   uiout->text ("), ");
 238
 239   return PRINT_SRC_AND_LOC;
 240 }
 241
 242 /* Implement the "print_one" breakpoint_ops method for syscall
 243    catchpoints.  */
 244
 245 static void
 246 print_one_catch_syscall (struct breakpoint *b,
 247                          struct bp_location **last_loc)
 248 {
 249   struct syscall_catchpoint *c = (struct syscall_catchpoint *) b;
 250   struct value_print_options opts;
 251   struct ui_out *uiout = current_uiout;
 252   struct gdbarch *gdbarch = b->loc->gdbarch;
 253
 254   get_user_print_options (&opts);
 255   /* Field 4, the address, is omitted (which makes the columns not
 256      line up too nicely with the headers, but the effect is relatively
 257      readable).  */
 258   if (opts.addressprint)
 259     uiout->field_skip ("addr");
 260   annotate_field (5);
 261
 262   if (c->syscalls_to_be_caught.size () > 1)
 263     uiout->text ("syscalls \"");
 264   else
 265     uiout->text ("syscall \"");
 266
 267   if (!c->syscalls_to_be_caught.empty ())
 268     {
 269       char *text = xstrprintf ("%s", "");
 270
 271       for (int iter : c->syscalls_to_be_caught)
 272         {
 273           char *x = text;
 274           struct syscall s;
 275           get_syscall_by_number (gdbarch, iter, &s);
 276
 277           if (s.name != NULL)
 278             text = xstrprintf ("%s%s, ", text, s.name);
 279           else
 280             text = xstrprintf ("%s%d, ", text, iter);
 281
 282           /* We have to xfree the last 'text' (now stored at 'x')
 283              because xstrprintf dynamically allocates new space for it
 284              on every call.  */
 285           xfree (x);
 286         }
 287       /* Remove the last comma.  */
 288       text[strlen (text) - 2] = '\0';
 289       uiout->field_string ("what", text);
 290     }
 291   else
 292     uiout->field_string ("what", "<any syscall>");
 293   uiout->text ("\" ");
 294
 295   if (uiout->is_mi_like_p ())
 296     uiout->field_string ("catch-type", "syscall");
 297 }
 298
 299 /* Implement the "print_mention" breakpoint_ops method for syscall
 300    catchpoints.  */
 301
 302 static void
 303 print_mention_catch_syscall (struct breakpoint *b)
 304 {
 305   struct syscall_catchpoint *c = (struct syscall_catchpoint *) b;
 306   struct gdbarch *gdbarch = b->loc->gdbarch;
 307
 308   if (!c->syscalls_to_be_caught.empty ())
 309     {
 310       if (c->syscalls_to_be_caught.size () > 1)
 311         printf_filtered (_("Catchpoint %d (syscalls"), b->number);
 312       else
 313         printf_filtered (_("Catchpoint %d (syscall"), b->number);
 314
 315       for (int iter : c->syscalls_to_be_caught)
 316         {
 317           struct syscall s;
 318           get_syscall_by_number (gdbarch, iter, &s);
 319
 320           if (s.name != NULL)
 321             printf_filtered (" '%s' [%d]", s.name, s.number);
 322           else
 323             printf_filtered (" %d", s.number);
 324         }
 325       printf_filtered (")");
 326     }
 327   else
 328     printf_filtered (_("Catchpoint %d (any syscall)"),
 329                      b->number);
 330 }
 331
 332 /* Implement the "print_recreate" breakpoint_ops method for syscall
 333    catchpoints.  */
 334
 335 static void
 336 print_recreate_catch_syscall (struct breakpoint *b, struct ui_file *fp)
 337 {
 338   struct syscall_catchpoint *c = (struct syscall_catchpoint *) b;
 339   struct gdbarch *gdbarch = b->loc->gdbarch;
 340
 341   fprintf_unfiltered (fp, "catch syscall");
 342
 343   for (int iter : c->syscalls_to_be_caught)
 344     {
 345       struct syscall s;
 346
 347       get_syscall_by_number (gdbarch, iter, &s);
 348       if (s.name != NULL)
 349         fprintf_unfiltered (fp, " %s", s.name);
 350       else
 351         fprintf_unfiltered (fp, " %d", s.number);
 352     }
 353
 354   print_recreate_thread (b, fp);
 355 }
 356
 357 /* The breakpoint_ops structure to be used in syscall catchpoints.  */
 358
 359 static struct breakpoint_ops catch_syscall_breakpoint_ops;
 360
 361 /* Returns non-zero if 'b' is a syscall catchpoint.  */
 362
 363 static int
 364 syscall_catchpoint_p (struct breakpoint *b)
 365 {
 366   return (b->ops == &catch_syscall_breakpoint_ops);
 367 }
 368
 369 static void
 370 create_syscall_event_catchpoint (int tempflag, std::vector<int> &&filter,
 371                                  const struct breakpoint_ops *ops)
 372 {
 373   struct syscall_catchpoint *c;
 374   struct gdbarch *gdbarch = get_current_arch ();
 375
 376   c = new syscall_catchpoint ();
 377   init_catchpoint (c, gdbarch, tempflag, NULL, ops);
 378   c->syscalls_to_be_caught = filter;
 379
 380   install_breakpoint (0, c, 1);
 381 }
 382
 383 /* Splits the argument using space as delimiter.  */
 384
 385 static std::vector<int>
 386 catch_syscall_split_args (char *arg)
 387 {
 388   std::vector<int> result;
 389   struct gdbarch *gdbarch = target_gdbarch ();
 390
 391   while (*arg != '\0')
 392     {
 393       int i, syscall_number;
 394       char *endptr;
 395       char cur_name[128];
 396       struct syscall s;
 397
 398       /* Skip whitespace.  */
 399       arg = skip_spaces (arg);
 400
 401       for (i = 0; i < 127 && arg[i] && !isspace (arg[i]); ++i)
 402         cur_name[i] = arg[i];
 403       cur_name[i] = '\0';
 404       arg += i;
 405
 406       /* Check if the user provided a syscall name, group, or a number.  */
 407       syscall_number = (int) strtol (cur_name, &endptr, 0);
 408       if (*endptr == '\0')
 409         {
 410           get_syscall_by_number (gdbarch, syscall_number, &s);
 411           result.push_back (s.number);
 412         }
 413       else if (startswith (cur_name, "g:")
 414                || startswith (cur_name, "group:"))
 415         {
 416           /* We have a syscall group.  Let's expand it into a syscall
 417              list before inserting.  */
 418           struct syscall *syscall_list;
 419           const char *group_name;
 420
 421           /* Skip over "g:" and "group:" prefix strings.  */
 422           group_name = strchr (cur_name, ':') + 1;
 423
 424           syscall_list = get_syscalls_by_group (gdbarch, group_name);
 425
 426           if (syscall_list == NULL)
 427             error (_("Unknown syscall group '%s'."), group_name);
 428
 429           for (i = 0; syscall_list[i].name != NULL; i++)
 430             {
 431               /* Insert each syscall that are part of the group.  No
 432                  need to check if it is valid.  */
 433               result.push_back (syscall_list[i].number);
 434             }
 435
 436           xfree (syscall_list);
 437         }
 438       else
 439         {
 440           /* We have a name.  Let's check if it's valid and convert it
 441              to a number.  */
 442           get_syscall_by_name (gdbarch, cur_name, &s);
 443
 444           if (s.number == UNKNOWN_SYSCALL)
 445             /* Here we have to issue an error instead of a warning,
 446                because GDB cannot do anything useful if there's no
 447                syscall number to be caught.  */
 448             error (_("Unknown syscall name '%s'."), cur_name);
 449
 450           /* Ok, it's valid.  */
 451           result.push_back (s.number);
 452         }
 453     }
 454
 455   return result;
 456 }
 457
 458 /* Implement the "catch syscall" command.  */
 459
 460 static void
 461 catch_syscall_command_1 (char *arg, int from_tty,
 462                          struct cmd_list_element *command)
 463 {
 464   int tempflag;
 465   std::vector<int> filter;
 466   struct syscall s;
 467   struct gdbarch *gdbarch = get_current_arch ();
 468
 469   /* Checking if the feature if supported.  */
 470   if (gdbarch_get_syscall_number_p (gdbarch) == 0)
 471     error (_("The feature 'catch syscall' is not supported on \
 472 this architecture yet."));
 473
 474   tempflag = get_cmd_context (command) == CATCH_TEMPORARY;
 475
 476   arg = skip_spaces (arg);
 477
 478   /* We need to do this first "dummy" translation in order
 479      to get the syscall XML file loaded or, most important,
 480      to display a warning to the user if there's no XML file
 481      for his/her architecture.  */
 482   get_syscall_by_number (gdbarch, 0, &s);
 483
 484   /* The allowed syntax is:
 485      catch syscall
 486      catch syscall <name | number> [<name | number> ... <name | number>]
 487
 488      Let's check if there's a syscall name.  */
 489
 490   if (arg != NULL)
 491     filter = catch_syscall_split_args (arg);
 492
 493   create_syscall_event_catchpoint (tempflag, std::move (filter),
 494                                    &catch_syscall_breakpoint_ops);
 495 }
 496
 497
 498 /* Returns 0 if 'bp' is NOT a syscall catchpoint,
 499    non-zero otherwise.  */
 500 static int
 501 is_syscall_catchpoint_enabled (struct breakpoint *bp)
 502 {
 503   if (syscall_catchpoint_p (bp)
 504       && bp->enable_state != bp_disabled
 505       && bp->enable_state != bp_call_disabled)
 506     return 1;
 507   else
 508     return 0;
 509 }
 510
 511 int
 512 catch_syscall_enabled (void)
 513 {
 514   struct catch_syscall_inferior_data *inf_data
 515     = get_catch_syscall_inferior_data (current_inferior ());
 516
 517   return inf_data->total_syscalls_count != 0;
 518 }
 519
 520 /* Helper function for catching_syscall_number.  If B is a syscall
 521    catchpoint for SYSCALL_NUMBER, return 1 (which will make
 522    'breakpoint_find_if' return).  Otherwise, return 0.  */
 523
 524 static int
 525 catching_syscall_number_1 (struct breakpoint *b,
 526                            void *data)
 527 {
 528   int syscall_number = (int) (uintptr_t) data;
 529
 530   if (is_syscall_catchpoint_enabled (b))
 531     {
 532       struct syscall_catchpoint *c = (struct syscall_catchpoint *) b;
 533
 534       if (!c->syscalls_to_be_caught.empty ())
 535         {
 536           for (int iter : c->syscalls_to_be_caught)
 537             if (syscall_number == iter)
 538               return 1;
 539         }
 540       else
 541         return 1;
 542     }
 543
 544   return 0;
 545 }
 546
 547 int
 548 catching_syscall_number (int syscall_number)
 549 {
 550   struct breakpoint *b = breakpoint_find_if (catching_syscall_number_1,
 551                                          (void *) (uintptr_t) syscall_number);
 552
 553   return b != NULL;
 554 }
 555
 556 /* Complete syscall names.  Used by "catch syscall".  */
 557
 558 static void
 559 catch_syscall_completer (struct cmd_list_element *cmd,
 560                          completion_tracker &tracker,
 561                          const char *text, const char *word)
 562 {
 563   struct gdbarch *gdbarch = get_current_arch ();
 564   struct cleanup *cleanups = make_cleanup (null_cleanup, NULL);
 565   const char **group_list = NULL;
 566   const char **syscall_list = NULL;
 567   const char *prefix;
 568   int i;
 569
 570   /* Completion considers ':' to be a word separator, so we use this to
 571      verify whether the previous word was a group prefix.  If so, we
 572      build the completion list using group names only.  */
 573   for (prefix = word; prefix != text && prefix[-1] != ' '; prefix--)
 574     ;
 575
 576   if (startswith (prefix, "g:") || startswith (prefix, "group:"))
 577     {
 578       /* Perform completion inside 'group:' namespace only.  */
 579       group_list = get_syscall_group_names (gdbarch);
 580       if (group_list != NULL)
 581         complete_on_enum (tracker, group_list, word, word);
 582     }
 583   else
 584     {
 585       /* Complete with both, syscall names and groups.  */
 586       syscall_list = get_syscall_names (gdbarch);
 587       group_list = get_syscall_group_names (gdbarch);
 588
 589       /* Append "group:" prefix to syscall groups.  */
 590       for (i = 0; group_list[i] != NULL; i++)
 591         {
 592           char *prefixed_group = xstrprintf ("group:%s", group_list[i]);
 593
 594           group_list[i] = prefixed_group;
 595           make_cleanup (xfree, prefixed_group);
 596         }
 597
 598       if (syscall_list != NULL)
 599         complete_on_enum (tracker, syscall_list, word, word);
 600       if (group_list != NULL)
 601         complete_on_enum (tracker, group_list, word, word);
 602     }
 603
 604   xfree (syscall_list);
 605   xfree (group_list);
 606   do_cleanups (cleanups);
 607 }
 608
 609 static void
 610 clear_syscall_counts (struct inferior *inf)
 611 {
 612   struct catch_syscall_inferior_data *inf_data
 613     = get_catch_syscall_inferior_data (inf);
 614
 615   inf_data->total_syscalls_count = 0;
 616   inf_data->any_syscall_count = 0;
 617   inf_data->syscalls_counts.clear ();
 618 }
 619
 620 static void
 621 initialize_syscall_catchpoint_ops (void)
 622 {
 623   struct breakpoint_ops *ops;
 624
 625   initialize_breakpoint_ops ();
 626
 627   /* Syscall catchpoints.  */
 628   ops = &catch_syscall_breakpoint_ops;
 629   *ops = base_breakpoint_ops;
 630   ops->insert_location = insert_catch_syscall;
 631   ops->remove_location = remove_catch_syscall;
 632   ops->breakpoint_hit = breakpoint_hit_catch_syscall;
 633   ops->print_it = print_it_catch_syscall;
 634   ops->print_one = print_one_catch_syscall;
 635   ops->print_mention = print_mention_catch_syscall;
 636   ops->print_recreate = print_recreate_catch_syscall;
 637 }
 638
 639 initialize_file_ftype _initialize_break_catch_syscall;
 640
 641 void
 642 _initialize_break_catch_syscall (void)
 643 {
 644   initialize_syscall_catchpoint_ops ();
 645
 646   observer_attach_inferior_exit (clear_syscall_counts);
 647   catch_syscall_inferior_data
 648     = register_inferior_data_with_cleanup (NULL,
 649                                            catch_syscall_inferior_data_cleanup);
 650
 651   add_catch_command ("syscall", _("\
 652 Catch system calls by their names, groups and/or numbers.\n\
 653 Arguments say which system calls to catch.  If no arguments are given,\n\
 654 every system call will be caught.  Arguments, if given, should be one\n\
 655 or more system call names (if your system supports that), system call\n\
 656 groups or system call numbers."),
 657                      catch_syscall_command_1,
 658                      catch_syscall_completer,
 659                      CATCH_PERMANENT,
 660                      CATCH_TEMPORARY);
 661 }