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