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-2017 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, VEC(gdb_xml_value_s) *attributes)
 231 {
 232   struct syscall_parsing_data *data = (struct syscall_parsing_data *) user_data;
 233   struct gdb_xml_value *attrs = VEC_address (gdb_xml_value_s, attributes);
 234   int len, i;
 235   /* syscall info.  */
 236   char *name = NULL;
 237   int number = 0;
 238   char *groups = NULL;
 239
 240   len = VEC_length (gdb_xml_value_s, attributes);
 241
 242   for (i = 0; i < len; i++)
 243     {
 244       if (strcmp (attrs[i].name, "name") == 0)
 245         name = (char *) attrs[i].value;
 246       else if (strcmp (attrs[i].name, "number") == 0)
 247         number = * (ULONGEST *) attrs[i].value;
 248       else if (strcmp (attrs[i].name, "groups") == 0)
 249         groups = (char *) attrs[i].value;
 250       else
 251         internal_error (__FILE__, __LINE__,
 252                         _("Unknown attribute name '%s'."), attrs[i].name);
 253     }
 254
 255   gdb_assert (name);
 256   syscall_create_syscall_desc (data->syscalls_info, name, number, groups);
 257 }
 258
 259
 260 /* The elements and attributes of an XML syscall document.  */
 261 static const struct gdb_xml_attribute syscall_attr[] = {
 262   { "number", GDB_XML_AF_NONE, gdb_xml_parse_attr_ulongest, NULL },
 263   { "name", GDB_XML_AF_NONE, NULL, NULL },
 264   { "groups", GDB_XML_AF_OPTIONAL, NULL, NULL },
 265   { NULL, GDB_XML_AF_NONE, NULL, NULL }
 266 };
 267
 268 static const struct gdb_xml_element syscalls_info_children[] = {
 269   { "syscall", syscall_attr, NULL,
 270     GDB_XML_EF_OPTIONAL | GDB_XML_EF_REPEATABLE,
 271     syscall_start_syscall, NULL },
 272   { NULL, NULL, NULL, GDB_XML_EF_NONE, NULL, NULL }
 273 };
 274
 275 static const struct gdb_xml_element syselements[] = {
 276   { "syscalls_info", NULL, syscalls_info_children,
 277     GDB_XML_EF_NONE, NULL, NULL },
 278   { NULL, NULL, NULL, GDB_XML_EF_NONE, NULL, NULL }
 279 };
 280
 281 static struct syscalls_info *
 282 syscall_parse_xml (const char *document, xml_fetch_another fetcher,
 283                    void *fetcher_baton)
 284 {
 285   struct syscall_parsing_data data;
 286   syscalls_info_up sysinfo (new syscalls_info ());
 287
 288   data.syscalls_info = sysinfo.get ();
 289
 290   if (gdb_xml_parse_quick (_("syscalls info"), NULL,
 291                            syselements, document, &data) == 0)
 292     {
 293       /* Parsed successfully.  */
 294       return sysinfo.release ();
 295     }
 296   else
 297     {
 298       warning (_("Could not load XML syscalls info; ignoring"));
 299       return NULL;
 300     }
 301 }
 302
 303 /* Function responsible for initializing the information
 304    about the syscalls.  It reads the XML file and fills the
 305    struct syscalls_info with the values.
 306
 307    Returns the struct syscalls_info if the file is valid, NULL otherwise.  */
 308 static struct syscalls_info *
 309 xml_init_syscalls_info (const char *filename)
 310 {
 311   gdb::unique_xmalloc_ptr<char> full_file
 312     = xml_fetch_content_from_file (filename, gdb_datadir);
 313   if (full_file == NULL)
 314     return NULL;
 315
 316   return syscall_parse_xml (full_file.get (),
 317                             xml_fetch_content_from_file,
 318                             (void *) ldirname (filename).c_str ());
 319 }
 320
 321 /* Initializes the syscalls_info structure according to the
 322    architecture.  */
 323 static void
 324 init_syscalls_info (struct gdbarch *gdbarch)
 325 {
 326   struct syscalls_info *syscalls_info = gdbarch_syscalls_info (gdbarch);
 327   const char *xml_syscall_file = gdbarch_xml_syscall_file (gdbarch);
 328
 329   /* Should we re-read the XML info for this target?  */
 330   if (syscalls_info != NULL && !syscalls_info->my_gdb_datadir.empty ()
 331       && filename_cmp (syscalls_info->my_gdb_datadir.c_str (),
 332                        gdb_datadir) != 0)
 333     {
 334       /* The data-directory changed from the last time we used it.
 335          It means that we have to re-read the XML info.  */
 336       delete syscalls_info;
 337       syscalls_info = NULL;
 338       set_gdbarch_syscalls_info (gdbarch, NULL);
 339     }
 340
 341   /* Did we succeed at initializing this?  */
 342   if (syscalls_info != NULL)
 343     return;
 344
 345   syscalls_info = xml_init_syscalls_info (xml_syscall_file);
 346
 347   /* If there was some error reading the XML file, we initialize
 348      gdbarch->syscalls_info anyway, in order to store information
 349      about our attempt.  */
 350   if (syscalls_info == NULL)
 351     syscalls_info = new struct syscalls_info ();
 352
 353   if (syscalls_info->syscalls.empty ())
 354     {
 355       if (xml_syscall_file != NULL)
 356         warning (_("Could not load the syscall XML file `%s/%s'."),
 357                  gdb_datadir, xml_syscall_file);
 358       else
 359         warning (_("There is no XML file to open."));
 360
 361       warning (_("GDB will not be able to display "
 362                  "syscall names nor to verify if\n"
 363                  "any provided syscall numbers are valid."));
 364     }
 365
 366   /* Saving the data-directory used to read this XML info.  */
 367   syscalls_info->my_gdb_datadir.assign (gdb_datadir);
 368
 369   set_gdbarch_syscalls_info (gdbarch, syscalls_info);
 370 }
 371
 372 /* Search for a syscall group by its name.  Return syscall_group_desc
 373    structure for the group if found or NULL otherwise.  */
 374
 375 static struct syscall_group_desc *
 376 syscall_group_get_group_by_name (const struct syscalls_info *syscalls_info,
 377                                  const char *group)
 378 {
 379   if (syscalls_info == NULL)
 380     return NULL;
 381
 382   if (group == NULL)
 383     return NULL;
 384
 385   /* Search for existing group.  */
 386   for (const syscall_group_desc_up &groupdesc : syscalls_info->groups)
 387     {
 388       if (groupdesc->name == group)
 389         return groupdesc.get ();
 390     }
 391
 392   return NULL;
 393 }
 394
 395 static int
 396 xml_get_syscall_number (struct gdbarch *gdbarch,
 397                         const char *syscall_name)
 398 {
 399   struct syscalls_info *syscalls_info = gdbarch_syscalls_info (gdbarch);
 400
 401   if (syscalls_info == NULL
 402       || syscall_name == NULL)
 403     return UNKNOWN_SYSCALL;
 404
 405   for (const syscall_desc_up &sysdesc : syscalls_info->syscalls)
 406     if (sysdesc->name == syscall_name)
 407       return sysdesc->number;
 408
 409   return UNKNOWN_SYSCALL;
 410 }
 411
 412 static const char *
 413 xml_get_syscall_name (struct gdbarch *gdbarch,
 414                       int syscall_number)
 415 {
 416   struct syscalls_info *syscalls_info = gdbarch_syscalls_info (gdbarch);
 417
 418   if (syscalls_info == NULL
 419       || syscall_number < 0)
 420     return NULL;
 421
 422   for (const syscall_desc_up &sysdesc : syscalls_info->syscalls)
 423     if (sysdesc->number == syscall_number)
 424       return sysdesc->name.c_str ();
 425
 426   return NULL;
 427 }
 428
 429 static const char **
 430 xml_list_of_syscalls (struct gdbarch *gdbarch)
 431 {
 432   struct syscalls_info *syscalls_info = gdbarch_syscalls_info (gdbarch);
 433
 434   if (syscalls_info == NULL)
 435     return NULL;
 436
 437   int nsyscalls = syscalls_info->syscalls.size ();
 438   const char **names = XNEWVEC (const char *, nsyscalls + 1);
 439
 440   int i;
 441   for (i = 0; i < syscalls_info->syscalls.size (); i++)
 442     names[i] = syscalls_info->syscalls[i]->name.c_str ();
 443
 444   names[i] = NULL;
 445
 446   return names;
 447 }
 448
 449 /* Iterate over the syscall_group_desc element to return a list of
 450    syscalls that are part of the given group, terminated by an empty
 451    element.  If the syscall group doesn't exist, return NULL.  */
 452
 453 static struct syscall *
 454 xml_list_syscalls_by_group (struct gdbarch *gdbarch, const char *group)
 455 {
 456   struct syscalls_info *syscalls_info = gdbarch_syscalls_info (gdbarch);
 457   struct syscall_group_desc *groupdesc;
 458   struct syscall *syscalls = NULL;
 459   int nsyscalls;
 460   int i;
 461
 462   if (syscalls_info == NULL)
 463     return NULL;
 464
 465   groupdesc = syscall_group_get_group_by_name (syscalls_info, group);
 466   if (groupdesc == NULL)
 467     return NULL;
 468
 469   nsyscalls = groupdesc->syscalls.size ();
 470   syscalls = (struct syscall*) xmalloc ((nsyscalls + 1)
 471                                         * sizeof (struct syscall));
 472
 473   for (i = 0; i < groupdesc->syscalls.size (); i++)
 474     {
 475       syscalls[i].name = groupdesc->syscalls[i]->name.c_str ();
 476       syscalls[i].number = groupdesc->syscalls[i]->number;
 477     }
 478
 479   /* Add final element marker.  */
 480   syscalls[i].name = NULL;
 481   syscalls[i].number = 0;
 482
 483   return syscalls;
 484 }
 485
 486 /* Return a NULL terminated list of syscall groups or an empty list, if
 487    no syscall group is available.  Return NULL, if there is no syscall
 488    information available.  */
 489
 490 static const char **
 491 xml_list_of_groups (struct gdbarch *gdbarch)
 492 {
 493   struct syscalls_info *syscalls_info = gdbarch_syscalls_info (gdbarch);
 494   const char **names = NULL;
 495   int ngroups;
 496   int i;
 497
 498   if (syscalls_info == NULL)
 499     return NULL;
 500
 501   ngroups = syscalls_info->groups.size ();
 502   names = (const char**) xmalloc ((ngroups + 1) * sizeof (char *));
 503
 504   for (i = 0; i < syscalls_info->groups.size (); i++)
 505     names[i] = syscalls_info->groups[i]->name.c_str ();
 506
 507   names[i] = NULL;
 508
 509   return names;
 510 }
 511
 512 void
 513 set_xml_syscall_file_name (struct gdbarch *gdbarch, const char *name)
 514 {
 515   set_gdbarch_xml_syscall_file (gdbarch, name);
 516 }
 517
 518 void
 519 get_syscall_by_number (struct gdbarch *gdbarch,
 520                        int syscall_number, struct syscall *s)
 521 {
 522   init_syscalls_info (gdbarch);
 523
 524   s->number = syscall_number;
 525   s->name = xml_get_syscall_name (gdbarch, syscall_number);
 526 }
 527
 528 void
 529 get_syscall_by_name (struct gdbarch *gdbarch,
 530                      const char *syscall_name, struct syscall *s)
 531 {
 532   init_syscalls_info (gdbarch);
 533
 534   s->number = xml_get_syscall_number (gdbarch, syscall_name);
 535   s->name = syscall_name;
 536 }
 537
 538 const char **
 539 get_syscall_names (struct gdbarch *gdbarch)
 540 {
 541   init_syscalls_info (gdbarch);
 542
 543   return xml_list_of_syscalls (gdbarch);
 544 }
 545
 546 /* See comment in xml-syscall.h.  */
 547
 548 struct syscall *
 549 get_syscalls_by_group (struct gdbarch *gdbarch, const char *group)
 550 {
 551   init_syscalls_info (gdbarch);
 552
 553   return xml_list_syscalls_by_group (gdbarch, group);
 554 }
 555
 556 /* See comment in xml-syscall.h.  */
 557
 558 const char **
 559 get_syscall_group_names (struct gdbarch *gdbarch)
 560 {
 561   init_syscalls_info (gdbarch);
 562
 563   return xml_list_of_groups (gdbarch);
 564 }
 565
 566 #endif /* ! HAVE_LIBEXPAT */