gdb/xml-syscall.c

   1 /* Functions that provide the mechanism to parse a syscall XML file
   2    and get its values.
   3
   4    Copyright (C) 2009-2018 Free Software Foundation, Inc.
   5
   6    This file is part of GDB.
   7
   8    This program is free software; you can redistribute it and/or modify
   9    it under the terms of the GNU General Public License as published by
  10    the Free Software Foundation; either version 3 of the License, or
  11    (at your option) any later version.
  12
  13    This program is distributed in the hope that it will be useful,
  14    but WITHOUT ANY WARRANTY; without even the implied warranty of
  15    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  16    GNU General Public License for more details.
  17
  18    You should have received a copy of the GNU General Public License
  19    along with this program.  If not, see <http://www.gnu.org/licenses/>.  */
  20
  21 #include "defs.h"
  22 #include "gdbtypes.h"
  23 #include "xml-support.h"
  24 #include "xml-syscall.h"
  25 #include "gdbarch.h"
  26
  27 /* For the struct syscall definition.  */
  28 #include "target.h"
  29
  30 #include "filenames.h"
  31
  32 #ifndef HAVE_LIBEXPAT
  33
  34 /* Dummy functions to indicate that there's no support for fetching
  35    syscalls information.  */
  36
  37 static void
  38 syscall_warn_user (void)
  39 {
  40   static int have_warned = 0;
  41   if (!have_warned)
  42     {
  43       have_warned = 1;
  44       warning (_("Can not parse XML syscalls information; XML support was "
  45                  "disabled at compile time."));
  46     }
  47 }
  48
  49 void
  50 set_xml_syscall_file_name (struct gdbarch *gdbarch, const char *name)
  51 {
  52   return;
  53 }
  54
  55 void
  56 get_syscall_by_number (struct gdbarch *gdbarch,
  57                        int syscall_number, struct syscall *s)
  58 {
  59   syscall_warn_user ();
  60   s->number = syscall_number;
  61   s->name = NULL;
  62 }
  63
  64 void
  65 get_syscall_by_name (struct gdbarch *gdbarch, const char *syscall_name,
  66                      struct syscall *s)
  67 {
  68   syscall_warn_user ();
  69   s->number = UNKNOWN_SYSCALL;
  70   s->name = syscall_name;
  71 }
  72
  73 const char **
  74 get_syscall_names (struct gdbarch *gdbarch)
  75 {
  76   syscall_warn_user ();
  77   return NULL;
  78 }
  79
  80 struct syscall *
  81 get_syscalls_by_group (struct gdbarch *gdbarch, const char *group)
  82 {
  83   syscall_warn_user ();
  84   return NULL;
  85 }
  86
  87 const char **
  88 get_syscall_group_names (struct gdbarch *gdbarch)
  89 {
  90   syscall_warn_user ();
  91   return NULL;
  92 }
  93
  94 #else /* ! HAVE_LIBEXPAT */
  95
  96 /* Structure which describes a syscall.  */
  97 struct syscall_desc
  98 {
  99   syscall_desc (int number_, std::string name_)
 100   : number (number_), name (name_)
 101   {}
 102
 103   /* The syscall number.  */
 104
 105   int number;
 106
 107   /* The syscall name.  */
 108
 109   std::string name;
 110 };
 111
 112 typedef std::unique_ptr<syscall_desc> syscall_desc_up;
 113
 114 /* Structure of a syscall group.  */
 115 struct syscall_group_desc
 116 {
 117   syscall_group_desc (const std::string &name_)
 118   : name (name_)
 119   {}
 120
 121   /* The group name.  */
 122
 123   std::string name;
 124
 125   /* The syscalls that are part of the group.  This is a non-owning
 126      reference.  */
 127
 128   std::vector<syscall_desc *> syscalls;
 129 };
 130
 131 typedef std::unique_ptr<syscall_group_desc> syscall_group_desc_up;
 132
 133 /* Structure that represents syscalls information.  */
 134 struct syscalls_info
 135 {
 136   /* The syscalls.  */
 137
 138   std::vector<syscall_desc_up> syscalls;
 139
 140   /* The syscall groups.  */
 141
 142   std::vector<syscall_group_desc_up> groups;
 143
 144   /* Variable that will hold the last known data-directory.  This is
 145      useful to know whether we should re-read the XML info for the
 146      target.  */
 147
 148   std::string my_gdb_datadir;
 149 };
 150
 151 typedef std::unique_ptr<syscalls_info> syscalls_info_up;
 152
 153 /* Callback data for syscall information parsing.  */
 154 struct syscall_parsing_data
 155 {
 156   /* The syscalls_info we are building.  */
 157
 158   struct syscalls_info *syscalls_info;
 159 };
 160
 161 /* Create a new syscall group.  Return pointer to the
 162    syscall_group_desc structure that represents the new group.  */
 163
 164 static struct syscall_group_desc *
 165 syscall_group_create_syscall_group_desc (struct syscalls_info *syscalls_info,
 166                                          const char *group)
 167 {
 168   syscall_group_desc *groupdesc = new syscall_group_desc (group);
 169
 170   syscalls_info->groups.emplace_back (groupdesc);
 171
 172   return groupdesc;
 173 }
 174
 175 /* Add a syscall to the group.  If group doesn't exist, create it.  */
 176
 177 static void
 178 syscall_group_add_syscall (struct syscalls_info *syscalls_info,
 179                            struct syscall_desc *syscall,
 180                            const char *group)
 181 {
 182   /* Search for an existing group.  */
 183   std::vector<syscall_group_desc_up>::iterator it
 184     = syscalls_info->groups.begin ();
 185
 186   for (; it != syscalls_info->groups.end (); it++)
 187     {
 188       if ((*it)->name == group)
 189         break;
 190     }
 191
 192   syscall_group_desc *groupdesc;
 193
 194   if (it != syscalls_info->groups.end ())
 195     groupdesc = it->get ();
 196   else
 197     {
 198       /* No group was found with this name.  We must create a new
 199          one.  */
 200       groupdesc = syscall_group_create_syscall_group_desc (syscalls_info,
 201                                                            group);
 202     }
 203
 204   groupdesc->syscalls.push_back (syscall);
 205 }
 206
 207 static void
 208 syscall_create_syscall_desc (struct syscalls_info *syscalls_info,
 209                              const char *name, int number,
 210                              char *groups)
 211 {
 212   syscall_desc *sysdesc = new syscall_desc (number, name);
 213
 214   syscalls_info->syscalls.emplace_back (sysdesc);
 215
 216   /*  Add syscall to its groups.  */
 217   if (groups != NULL)
 218     {
 219       for (char *group = strtok (groups, ",");
 220            group != NULL;
 221            group = strtok (NULL, ","))
 222         syscall_group_add_syscall (syscalls_info, sysdesc, group);
 223     }
 224 }
 225
 226 /* Handle the start of a <syscall> element.  */
 227 static void
 228 syscall_start_syscall (struct gdb_xml_parser *parser,
 229                        const struct gdb_xml_element *element,
 230                        void *user_data,
 231                        std::vector<gdb_xml_value> &attributes)
 232 {
 233   struct syscall_parsing_data *data = (struct syscall_parsing_data *) user_data;
 234   /* syscall info.  */
 235   char *name = NULL;
 236   int number = 0;
 237   char *groups = NULL;
 238
 239   for (const gdb_xml_value &attr : attributes)
 240     {
 241       if (strcmp (attr.name, "name") == 0)
 242         name = (char *) attr.value.get ();
 243       else if (strcmp (attr.name, "number") == 0)
 244         number = * (ULONGEST *) attr.value.get ();
 245       else if (strcmp (attr.name, "groups") == 0)
 246         groups = (char *) attr.value.get ();
 247       else
 248         internal_error (__FILE__, __LINE__,
 249                         _("Unknown attribute name '%s'."), attr.name);
 250     }
 251
 252   gdb_assert (name);
 253   syscall_create_syscall_desc (data->syscalls_info, name, number, groups);
 254 }
 255
 256
 257 /* The elements and attributes of an XML syscall document.  */
 258 static const struct gdb_xml_attribute syscall_attr[] = {
 259   { "number", GDB_XML_AF_NONE, gdb_xml_parse_attr_ulongest, NULL },
 260   { "name", GDB_XML_AF_NONE, NULL, NULL },
 261   { "groups", GDB_XML_AF_OPTIONAL, NULL, NULL },
 262   { NULL, GDB_XML_AF_NONE, NULL, NULL }
 263 };
 264
 265 static const struct gdb_xml_element syscalls_info_children[] = {
 266   { "syscall", syscall_attr, NULL,
 267     GDB_XML_EF_OPTIONAL | GDB_XML_EF_REPEATABLE,
 268     syscall_start_syscall, NULL },
 269   { NULL, NULL, NULL, GDB_XML_EF_NONE, NULL, NULL }
 270 };
 271
 272 static const struct gdb_xml_element syselements[] = {
 273   { "syscalls_info", NULL, syscalls_info_children,
 274     GDB_XML_EF_NONE, NULL, NULL },
 275   { NULL, NULL, NULL, GDB_XML_EF_NONE, NULL, NULL }
 276 };
 277
 278 static struct syscalls_info *
 279 syscall_parse_xml (const char *document, xml_fetch_another fetcher,
 280                    void *fetcher_baton)
 281 {
 282   struct syscall_parsing_data data;
 283   syscalls_info_up sysinfo (new syscalls_info ());
 284
 285   data.syscalls_info = sysinfo.get ();
 286
 287   if (gdb_xml_parse_quick (_("syscalls info"), NULL,
 288                            syselements, document, &data) == 0)
 289     {
 290       /* Parsed successfully.  */
 291       return sysinfo.release ();
 292     }
 293   else
 294     {
 295       warning (_("Could not load XML syscalls info; ignoring"));
 296       return NULL;
 297     }
 298 }
 299
 300 /* Function responsible for initializing the information
 301    about the syscalls.  It reads the XML file and fills the
 302    struct syscalls_info with the values.
 303
 304    Returns the struct syscalls_info if the file is valid, NULL otherwise.  */
 305 static struct syscalls_info *
 306 xml_init_syscalls_info (const char *filename)
 307 {
 308   gdb::optional<gdb::char_vector> full_file
 309     = xml_fetch_content_from_file (filename, gdb_datadir);
 310   if (!full_file)
 311     return NULL;
 312
 313   return syscall_parse_xml (full_file->data (),
 314                             xml_fetch_content_from_file,
 315                             (void *) ldirname (filename).c_str ());
 316 }
 317
 318 /* Initializes the syscalls_info structure according to the
 319    architecture.  */
 320 static void
 321 init_syscalls_info (struct gdbarch *gdbarch)
 322 {
 323   struct syscalls_info *syscalls_info = gdbarch_syscalls_info (gdbarch);
 324   const char *xml_syscall_file = gdbarch_xml_syscall_file (gdbarch);
 325
 326   /* Should we re-read the XML info for this target?  */
 327   if (syscalls_info != NULL && !syscalls_info->my_gdb_datadir.empty ()
 328       && filename_cmp (syscalls_info->my_gdb_datadir.c_str (),
 329                        gdb_datadir) != 0)
 330     {
 331       /* The data-directory changed from the last time we used it.
 332          It means that we have to re-read the XML info.  */
 333       delete syscalls_info;
 334       syscalls_info = NULL;
 335       set_gdbarch_syscalls_info (gdbarch, NULL);
 336     }
 337
 338   /* Did we succeed at initializing this?  */
 339   if (syscalls_info != NULL)
 340     return;
 341
 342   syscalls_info = xml_init_syscalls_info (xml_syscall_file);
 343
 344   /* If there was some error reading the XML file, we initialize
 345      gdbarch->syscalls_info anyway, in order to store information
 346      about our attempt.  */
 347   if (syscalls_info == NULL)
 348     syscalls_info = new struct syscalls_info ();
 349
 350   if (syscalls_info->syscalls.empty ())
 351     {
 352       if (xml_syscall_file != NULL)
 353         warning (_("Could not load the syscall XML file `%s/%s'."),
 354                  gdb_datadir, xml_syscall_file);
 355       else
 356         warning (_("There is no XML file to open."));
 357
 358       warning (_("GDB will not be able to display "
 359                  "syscall names nor to verify if\n"
 360                  "any provided syscall numbers are valid."));
 361     }
 362
 363   /* Saving the data-directory used to read this XML info.  */
 364   syscalls_info->my_gdb_datadir.assign (gdb_datadir);
 365
 366   set_gdbarch_syscalls_info (gdbarch, syscalls_info);
 367 }
 368
 369 /* Search for a syscall group by its name.  Return syscall_group_desc
 370    structure for the group if found or NULL otherwise.  */
 371
 372 static struct syscall_group_desc *
 373 syscall_group_get_group_by_name (const struct syscalls_info *syscalls_info,
 374                                  const char *group)
 375 {
 376   if (syscalls_info == NULL)
 377     return NULL;
 378
 379   if (group == NULL)
 380     return NULL;
 381
 382   /* Search for existing group.  */
 383   for (const syscall_group_desc_up &groupdesc : syscalls_info->groups)
 384     {
 385       if (groupdesc->name == group)
 386         return groupdesc.get ();
 387     }
 388
 389   return NULL;
 390 }
 391
 392 static int
 393 xml_get_syscall_number (struct gdbarch *gdbarch,
 394                         const char *syscall_name)
 395 {
 396   struct syscalls_info *syscalls_info = gdbarch_syscalls_info (gdbarch);
 397
 398   if (syscalls_info == NULL
 399       || syscall_name == NULL)
 400     return UNKNOWN_SYSCALL;
 401
 402   for (const syscall_desc_up &sysdesc : syscalls_info->syscalls)
 403     if (sysdesc->name == syscall_name)
 404       return sysdesc->number;
 405
 406   return UNKNOWN_SYSCALL;
 407 }
 408
 409 static const char *
 410 xml_get_syscall_name (struct gdbarch *gdbarch,
 411                       int syscall_number)
 412 {
 413   struct syscalls_info *syscalls_info = gdbarch_syscalls_info (gdbarch);
 414
 415   if (syscalls_info == NULL
 416       || syscall_number < 0)
 417     return NULL;
 418
 419   for (const syscall_desc_up &sysdesc : syscalls_info->syscalls)
 420     if (sysdesc->number == syscall_number)
 421       return sysdesc->name.c_str ();
 422
 423   return NULL;
 424 }
 425
 426 static const char **
 427 xml_list_of_syscalls (struct gdbarch *gdbarch)
 428 {
 429   struct syscalls_info *syscalls_info = gdbarch_syscalls_info (gdbarch);
 430
 431   if (syscalls_info == NULL)
 432     return NULL;
 433
 434   int nsyscalls = syscalls_info->syscalls.size ();
 435   const char **names = XNEWVEC (const char *, nsyscalls + 1);
 436
 437   int i;
 438   for (i = 0; i < syscalls_info->syscalls.size (); i++)
 439     names[i] = syscalls_info->syscalls[i]->name.c_str ();
 440
 441   names[i] = NULL;
 442
 443   return names;
 444 }
 445
 446 /* Iterate over the syscall_group_desc element to return a list of
 447    syscalls that are part of the given group, terminated by an empty
 448    element.  If the syscall group doesn't exist, return NULL.  */
 449
 450 static struct syscall *
 451 xml_list_syscalls_by_group (struct gdbarch *gdbarch, const char *group)
 452 {
 453   struct syscalls_info *syscalls_info = gdbarch_syscalls_info (gdbarch);
 454   struct syscall_group_desc *groupdesc;
 455   struct syscall *syscalls = NULL;
 456   int nsyscalls;
 457   int i;
 458
 459   if (syscalls_info == NULL)
 460     return NULL;
 461
 462   groupdesc = syscall_group_get_group_by_name (syscalls_info, group);
 463   if (groupdesc == NULL)
 464     return NULL;
 465
 466   nsyscalls = groupdesc->syscalls.size ();
 467   syscalls = (struct syscall*) xmalloc ((nsyscalls + 1)
 468                                         * sizeof (struct syscall));
 469
 470   for (i = 0; i < groupdesc->syscalls.size (); i++)
 471     {
 472       syscalls[i].name = groupdesc->syscalls[i]->name.c_str ();
 473       syscalls[i].number = groupdesc->syscalls[i]->number;
 474     }
 475
 476   /* Add final element marker.  */
 477   syscalls[i].name = NULL;
 478   syscalls[i].number = 0;
 479
 480   return syscalls;
 481 }
 482
 483 /* Return a NULL terminated list of syscall groups or an empty list, if
 484    no syscall group is available.  Return NULL, if there is no syscall
 485    information available.  */
 486
 487 static const char **
 488 xml_list_of_groups (struct gdbarch *gdbarch)
 489 {
 490   struct syscalls_info *syscalls_info = gdbarch_syscalls_info (gdbarch);
 491   const char **names = NULL;
 492   int ngroups;
 493   int i;
 494
 495   if (syscalls_info == NULL)
 496     return NULL;
 497
 498   ngroups = syscalls_info->groups.size ();
 499   names = (const char**) xmalloc ((ngroups + 1) * sizeof (char *));
 500
 501   for (i = 0; i < syscalls_info->groups.size (); i++)
 502     names[i] = syscalls_info->groups[i]->name.c_str ();
 503
 504   names[i] = NULL;
 505
 506   return names;
 507 }
 508
 509 void
 510 set_xml_syscall_file_name (struct gdbarch *gdbarch, const char *name)
 511 {
 512   set_gdbarch_xml_syscall_file (gdbarch, name);
 513 }
 514
 515 void
 516 get_syscall_by_number (struct gdbarch *gdbarch,
 517                        int syscall_number, struct syscall *s)
 518 {
 519   init_syscalls_info (gdbarch);
 520
 521   s->number = syscall_number;
 522   s->name = xml_get_syscall_name (gdbarch, syscall_number);
 523 }
 524
 525 void
 526 get_syscall_by_name (struct gdbarch *gdbarch,
 527                      const char *syscall_name, struct syscall *s)
 528 {
 529   init_syscalls_info (gdbarch);
 530
 531   s->number = xml_get_syscall_number (gdbarch, syscall_name);
 532   s->name = syscall_name;
 533 }
 534
 535 const char **
 536 get_syscall_names (struct gdbarch *gdbarch)
 537 {
 538   init_syscalls_info (gdbarch);
 539
 540   return xml_list_of_syscalls (gdbarch);
 541 }
 542
 543 /* See comment in xml-syscall.h.  */
 544
 545 struct syscall *
 546 get_syscalls_by_group (struct gdbarch *gdbarch, const char *group)
 547 {
 548   init_syscalls_info (gdbarch);
 549
 550   return xml_list_syscalls_by_group (gdbarch, group);
 551 }
 552
 553 /* See comment in xml-syscall.h.  */
 554
 555 const char **
 556 get_syscall_group_names (struct gdbarch *gdbarch)
 557 {
 558   init_syscalls_info (gdbarch);
 559
 560   return xml_list_of_groups (gdbarch);
 561 }
 562
 563 #endif /* ! HAVE_LIBEXPAT */