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) 1986, 1988, 1989, 1990, 1991, 1992, 1993, 1994, 1995, 1996,
   5    1998, 1999, 2000, 2001, 2003, 2004, 2005, 2006, 2007, 2008
   6    Free Software Foundation, Inc.
   7
   8    This file is part of GDB.
   9
  10    This program is free software; you can redistribute it and/or modify
  11    it under the terms of the GNU General Public License as published by
  12    the Free Software Foundation; either version 3 of the License, or
  13    (at your option) any later version.
  14
  15    This program is distributed in the hope that it will be useful,
  16    but WITHOUT ANY WARRANTY; without even the implied warranty of
  17    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  18    GNU General Public License for more details.
  19
  20    You should have received a copy of the GNU General Public License
  21    along with this program.  If not, see <http://www.gnu.org/licenses/>.  */
  22
  23 #include "defs.h"
  24 #include "gdbtypes.h"
  25 #include "xml-support.h"
  26 #include "xml-syscall.h"
  27
  28 /* For the struct syscall definition.  */
  29 #include "target.h"
  30
  31 #include "filenames.h"
  32
  33 #include "gdb_assert.h"
  34
  35 #ifndef HAVE_LIBEXPAT
  36
  37 /* Dummy functions to indicate that there's no support for fetching
  38    syscalls information.  */
  39
  40 static void
  41 syscall_warn_user (void)
  42 {
  43   static int have_warned = 0;
  44   if (!have_warned)
  45     {
  46       have_warned = 1;
  47       warning (_("Can not parse XML syscalls information; XML support was "
  48                  "disabled at compile time."));
  49     }
  50 }
  51
  52 void
  53 set_xml_syscall_file_name (const char *name)
  54 {
  55   syscall_warn_user ();
  56 }
  57
  58 void
  59 get_syscall_by_number (int syscall_number,
  60                        struct syscall *s)
  61 {
  62   syscall_warn_user ();
  63   s->number = syscall_number;
  64   s->name = NULL;
  65 }
  66
  67 void
  68 get_syscall_by_name (const char *syscall_name,
  69                      struct syscall *s)
  70 {
  71   syscall_warn_user ();
  72   s->number = UNKNOWN_SYSCALL;
  73   s->name = syscall_name;
  74 }
  75
  76 const char **
  77 get_syscall_names (void)
  78 {
  79   syscall_warn_user ();
  80   return NULL;
  81 }
  82
  83
  84 #else /* ! HAVE_LIBEXPAT */
  85
  86 /* Structure which describes a syscall.  */
  87 typedef struct syscall_desc
  88 {
  89   /* The syscall number.  */
  90
  91   int number;
  92
  93   /* The syscall name.  */
  94
  95   char *name;
  96 } *syscall_desc_p;
  97 DEF_VEC_P(syscall_desc_p);
  98
  99 /* Structure that represents syscalls information.  */
 100 struct syscalls_info
 101 {
 102   /* The syscalls.  */
 103
 104   VEC(syscall_desc_p) *syscalls;
 105 };
 106
 107 /* Callback data for syscall information parsing.  */
 108 struct syscall_parsing_data
 109 {
 110   /* The syscalls_info we are building.  */
 111
 112   struct syscalls_info *sysinfo;
 113 };
 114
 115 /* Structure used to store information about the available syscalls in
 116    the system.  */
 117 static const struct syscalls_info *_sysinfo = NULL;
 118
 119 /* A flag to tell if we already initialized the structure above.  */
 120 static int have_initialized_sysinfo = 0;
 121
 122 /* The filename of the syscall's XML.  */
 123 static const char *xml_syscall_file = NULL;
 124
 125 static struct syscalls_info *
 126 allocate_syscalls_info (void)
 127 {
 128   return XZALLOC (struct syscalls_info);
 129 }
 130
 131 static void
 132 sysinfo_free_syscalls_desc (struct syscall_desc *sd)
 133 {
 134   xfree (sd->name);
 135 }
 136
 137 static void
 138 free_syscalls_info (void *arg)
 139 {
 140   struct syscalls_info *sysinfo = arg;
 141   struct syscall_desc *sysdesc;
 142   int i;
 143
 144   for (i = 0;
 145        VEC_iterate (syscall_desc_p, sysinfo->syscalls, i, sysdesc);
 146        i++)
 147     sysinfo_free_syscalls_desc (sysdesc);
 148   VEC_free (syscall_desc_p, sysinfo->syscalls);
 149
 150   xfree (sysinfo);
 151 }
 152
 153 struct cleanup *
 154 make_cleanup_free_syscalls_info (struct syscalls_info *sysinfo)
 155 {
 156   return make_cleanup (free_syscalls_info, sysinfo);
 157 }
 158
 159 static void
 160 syscall_create_syscall_desc (struct syscalls_info *sysinfo,
 161                              const char *name, int number)
 162 {
 163   struct syscall_desc *sysdesc = XZALLOC (struct syscall_desc);
 164
 165   sysdesc->name = xstrdup (name);
 166   sysdesc->number = number;
 167
 168   VEC_safe_push (syscall_desc_p, sysinfo->syscalls, sysdesc);
 169 }
 170
 171 /* Handle the start of a <syscalls_info> element.  */
 172 static void
 173 syscall_start_syscalls_info (struct gdb_xml_parser *parser,
 174                              const struct gdb_xml_element *element,
 175                              void *user_data,
 176                              VEC(gdb_xml_value_s) *attributes)
 177 {
 178   struct syscall_parsing_data *data = user_data;
 179   struct syscalls_info *sysinfo = data->sysinfo;
 180 }
 181
 182 /* Handle the start of a <syscall> element.  */
 183 static void
 184 syscall_start_syscall (struct gdb_xml_parser *parser,
 185                        const struct gdb_xml_element *element,
 186                        void *user_data, VEC(gdb_xml_value_s) *attributes)
 187 {
 188   struct syscall_parsing_data *data = user_data;
 189   struct gdb_xml_value *attrs = VEC_address (gdb_xml_value_s, attributes);
 190   int len, i;
 191   /* syscall info.  */
 192   char *name = NULL;
 193   int number = 0;
 194
 195   len = VEC_length (gdb_xml_value_s, attributes);
 196
 197   for (i = 0; i < len; i++)
 198     {
 199       if (strcmp (attrs[i].name, "name") == 0)
 200         name = attrs[i].value;
 201       else if (strcmp (attrs[i].name, "number") == 0)
 202         number = * (ULONGEST *) attrs[i].value;
 203       else
 204         internal_error (__FILE__, __LINE__,
 205                         _("Unknown attribute name '%s'."), attrs[i].name);
 206     }
 207
 208   syscall_create_syscall_desc (data->sysinfo, name, number);
 209 }
 210
 211
 212 /* The elements and attributes of an XML syscall document.  */
 213 static const struct gdb_xml_attribute syscall_attr[] = {
 214   { "number", GDB_XML_AF_NONE, gdb_xml_parse_attr_ulongest, NULL },
 215   { "name", GDB_XML_AF_NONE, NULL, NULL },
 216   { NULL, GDB_XML_AF_NONE, NULL, NULL }
 217 };
 218
 219 static const struct gdb_xml_element syscalls_info_children[] = {
 220   { "syscall", syscall_attr, NULL,
 221     GDB_XML_EF_OPTIONAL | GDB_XML_EF_REPEATABLE,
 222     syscall_start_syscall, NULL },
 223   { NULL, NULL, NULL, GDB_XML_EF_NONE, NULL, NULL }
 224 };
 225
 226 static const struct gdb_xml_element syselements[] = {
 227   { "syscalls_info", NULL, syscalls_info_children,
 228     GDB_XML_EF_NONE, syscall_start_syscalls_info, NULL },
 229   { NULL, NULL, NULL, GDB_XML_EF_NONE, NULL, NULL }
 230 };
 231
 232 static struct syscalls_info *
 233 syscall_parse_xml (const char *document, xml_fetch_another fetcher,
 234                    void *fetcher_baton)
 235 {
 236   struct cleanup *result_cleanup;
 237   struct gdb_xml_parser *parser;
 238   struct syscall_parsing_data data;
 239   char *expanded_text;
 240   int i;
 241
 242   parser = gdb_xml_create_parser_and_cleanup (_("syscalls info"),
 243                                               syselements, &data);
 244
 245   memset (&data, 0, sizeof (struct syscall_parsing_data));
 246   data.sysinfo = allocate_syscalls_info ();
 247   result_cleanup = make_cleanup_free_syscalls_info (data.sysinfo);
 248
 249   if (gdb_xml_parse (parser, document) == 0)
 250     {
 251       /* Parsed successfully.  */
 252       discard_cleanups (result_cleanup);
 253       return data.sysinfo;
 254     }
 255   else
 256     {
 257       warning (_("Could not load XML syscalls info; ignoring"));
 258       do_cleanups (result_cleanup);
 259       return NULL;
 260     }
 261 }
 262
 263 /* Function responsible for initializing the information
 264    about the syscalls.  It reads the XML file and fills the
 265    struct syscalls_info with the values.
 266
 267    Returns the struct syscalls_info if the file is valid, NULL otherwise.  */
 268 static const struct syscalls_info *
 269 xml_init_syscalls_info (const char *filename)
 270 {
 271   char *full_file;
 272   char *dirname;
 273   struct syscalls_info *sysinfo;
 274   struct cleanup *back_to;
 275
 276   full_file = xml_fetch_content_from_file (filename, gdb_datadir);
 277   if (full_file == NULL)
 278     {
 279       warning (_("Could not open \"%s\""), filename);
 280       return NULL;
 281     }
 282
 283   back_to = make_cleanup (xfree, full_file);
 284
 285   dirname = ldirname (filename);
 286   if (dirname != NULL)
 287     make_cleanup (xfree, dirname);
 288
 289   sysinfo = syscall_parse_xml (full_file, xml_fetch_content_from_file, dirname);
 290   do_cleanups (back_to);
 291
 292   return sysinfo;
 293 }
 294
 295 /* Initializes the syscalls_info structure according to the
 296    architecture.  */
 297 static void
 298 init_sysinfo (void)
 299 {
 300   /* Did we already try to initialize the structure?  */
 301   if (have_initialized_sysinfo)
 302     return;
 303 /*  if (xml_syscall_file == NULL)
 304     internal_error (__FILE__, __LINE__,
 305                     _("This architecture has not set the XML syscall file "
 306                       "name.  This is a bug and should not happen; please "
 307                       "report it.")); */
 308
 309   _sysinfo = xml_init_syscalls_info (xml_syscall_file);
 310
 311   have_initialized_sysinfo = 1;
 312
 313   if (_sysinfo == NULL)
 314     {
 315       if (xml_syscall_file)
 316         /* The initialization failed.  Let's show a warning
 317            message to the user (just this time) and leave.  */
 318         warning (_("Could not load the syscall XML file `%s'.\n\
 319 GDB will not be able to display syscall names."), xml_syscall_file);
 320       else
 321         /* There's no file to open.  Let's warn the user.  */
 322         warning (_("There is no XML file to open.\n\
 323 GDB will not be able to display syscall names."));
 324     }
 325 }
 326
 327 static int
 328 xml_get_syscall_number (const struct syscalls_info *sysinfo,
 329                         const char *syscall_name)
 330 {
 331   struct syscall_desc *sysdesc;
 332   int i;
 333
 334   if (sysinfo == NULL
 335       || syscall_name == NULL)
 336     return UNKNOWN_SYSCALL;
 337
 338   for (i = 0;
 339        VEC_iterate(syscall_desc_p, sysinfo->syscalls, i, sysdesc);
 340        i++)
 341     if (strcmp (sysdesc->name, syscall_name) == 0)
 342       return sysdesc->number;
 343
 344   return UNKNOWN_SYSCALL;
 345 }
 346
 347 static const char *
 348 xml_get_syscall_name (const struct syscalls_info *sysinfo,
 349                       int syscall_number)
 350 {
 351   struct syscall_desc *sysdesc;
 352   int i;
 353
 354   if (sysinfo == NULL
 355       || syscall_number < 0)
 356     return NULL;
 357
 358   for (i = 0;
 359        VEC_iterate(syscall_desc_p, sysinfo->syscalls, i, sysdesc);
 360        i++)
 361     if (sysdesc->number == syscall_number)
 362       return sysdesc->name;
 363
 364   return NULL;
 365 }
 366
 367 static int
 368 xml_number_of_syscalls (const struct syscalls_info *sysinfo)
 369 {
 370   return (sysinfo == NULL ? 0 : VEC_length (syscall_desc_p,
 371                                             sysinfo->syscalls));
 372 }
 373
 374 static const char **
 375 xml_list_of_syscalls (const struct syscalls_info *sysinfo)
 376 {
 377   struct syscall_desc *sysdesc;
 378   const char **names = NULL;
 379   int nsyscalls;
 380   int i;
 381
 382   if (sysinfo == NULL)
 383     return NULL;
 384
 385   nsyscalls = VEC_length (syscall_desc_p, sysinfo->syscalls);
 386   names = xmalloc ((nsyscalls + 1) * sizeof (char *));
 387
 388   for (i = 0;
 389        VEC_iterate (syscall_desc_p, sysinfo->syscalls, i, sysdesc);
 390        i++)
 391     names[i] = sysdesc->name;
 392
 393   names[i] = NULL;
 394
 395   return names;
 396 }
 397
 398 void
 399 set_xml_syscall_file_name (const char *name)
 400 {
 401   xml_syscall_file = name;
 402 }
 403
 404 void
 405 get_syscall_by_number (int syscall_number,
 406                        struct syscall *s)
 407 {
 408   init_sysinfo ();
 409
 410   s->number = syscall_number;
 411   s->name = xml_get_syscall_name (_sysinfo, syscall_number);
 412 }
 413
 414 void
 415 get_syscall_by_name (const char *syscall_name,
 416                      struct syscall *s)
 417 {
 418   init_sysinfo ();
 419
 420   s->number = xml_get_syscall_number (_sysinfo, syscall_name);
 421   s->name = syscall_name;
 422 }
 423
 424 const char **
 425 get_syscall_names (void)
 426 {
 427   init_sysinfo ();
 428
 429   return xml_list_of_syscalls (_sysinfo);
 430 }
 431
 432 #endif /* ! HAVE_LIBEXPAT */